intel_i2c.c 13.9 KB
Newer Older
1
2
/*
 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
3
 * Copyright © 2006-2008,2010 Intel Corporation
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 *   Jesse Barnes <jesse.barnes@intel.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *	Eric Anholt <eric@anholt.net>
27
 *	Chris Wilson <chris@chris-wilson.co.uk>
28
29
30
 */
#include <linux/i2c.h>
#include <linux/i2c-algo-bit.h>
31
#include <linux/export.h>
32
33
34
35
36
37
#include "drmP.h"
#include "drm.h"
#include "intel_drv.h"
#include "i915_drm.h"
#include "i915_drv.h"

38
39
40
41
42
43
44
45
46
47
48
49
50
51
struct gmbus_port {
	const char *name;
	int reg;
};

static const struct gmbus_port gmbus_ports[] = {
	{ "ssc", GPIOB },
	{ "vga", GPIOA },
	{ "panel", GPIOC },
	{ "dpc", GPIOD },
	{ "dpb", GPIOE },
	{ "dpd", GPIOF },
};

52
53
/* Intel GPIO access functions */

Jean Delvare's avatar
Jean Delvare committed
54
#define I2C_RISEFALL_TIME 10
55

56
57
58
59
60
61
static inline struct intel_gmbus *
to_intel_gmbus(struct i2c_adapter *i2c)
{
	return container_of(i2c, struct intel_gmbus, adapter);
}

62
63
void
intel_i2c_reset(struct drm_device *dev)
64
65
{
	struct drm_i915_private *dev_priv = dev->dev_private;
66
	I915_WRITE(dev_priv->gpio_mmio_base + GMBUS0, 0);
67
68
69
70
}

static void intel_i2c_quirk_set(struct drm_i915_private *dev_priv, bool enable)
{
71
	u32 val;
72
73

	/* When using bit bashing for I2C, this bit needs to be set to 1 */
74
	if (!IS_PINEVIEW(dev_priv->dev))
75
		return;
76
77

	val = I915_READ(DSPCLK_GATE_D);
78
	if (enable)
79
		val |= DPCUNIT_CLOCK_GATE_DISABLE;
80
	else
81
82
		val &= ~DPCUNIT_CLOCK_GATE_DISABLE;
	I915_WRITE(DSPCLK_GATE_D, val);
83
84
}

85
static u32 get_reserved(struct intel_gmbus *bus)
86
{
87
	struct drm_i915_private *dev_priv = bus->dev_priv;
88
89
90
91
92
	struct drm_device *dev = dev_priv->dev;
	u32 reserved = 0;

	/* On most chips, these bits must be preserved in software. */
	if (!IS_I830(dev) && !IS_845G(dev))
93
		reserved = I915_READ_NOTRACE(bus->gpio_reg) &
94
95
					     (GPIO_DATA_PULLUP_DISABLE |
					      GPIO_CLOCK_PULLUP_DISABLE);
96
97
98
99

	return reserved;
}

100
101
static int get_clock(void *data)
{
102
103
104
105
106
107
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | GPIO_CLOCK_DIR_MASK);
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved);
	return (I915_READ_NOTRACE(bus->gpio_reg) & GPIO_CLOCK_VAL_IN) != 0;
108
109
110
111
}

static int get_data(void *data)
{
112
113
114
115
116
117
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | GPIO_DATA_DIR_MASK);
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved);
	return (I915_READ_NOTRACE(bus->gpio_reg) & GPIO_DATA_VAL_IN) != 0;
118
119
120
121
}

static void set_clock(void *data, int state_high)
{
122
123
124
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
125
	u32 clock_bits;
126
127
128
129
130
131

	if (state_high)
		clock_bits = GPIO_CLOCK_DIR_IN | GPIO_CLOCK_DIR_MASK;
	else
		clock_bits = GPIO_CLOCK_DIR_OUT | GPIO_CLOCK_DIR_MASK |
			GPIO_CLOCK_VAL_MASK;
132

133
134
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | clock_bits);
	POSTING_READ(bus->gpio_reg);
135
136
137
138
}

static void set_data(void *data, int state_high)
{
139
140
141
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
142
	u32 data_bits;
143
144
145
146
147
148
149

	if (state_high)
		data_bits = GPIO_DATA_DIR_IN | GPIO_DATA_DIR_MASK;
	else
		data_bits = GPIO_DATA_DIR_OUT | GPIO_DATA_DIR_MASK |
			GPIO_DATA_VAL_MASK;

150
151
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | data_bits);
	POSTING_READ(bus->gpio_reg);
152
153
}

154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
static int
intel_gpio_pre_xfer(struct i2c_adapter *adapter)
{
	struct intel_gmbus *bus = container_of(adapter,
					       struct intel_gmbus,
					       adapter);
	struct drm_i915_private *dev_priv = bus->dev_priv;

	intel_i2c_reset(dev_priv->dev);
	intel_i2c_quirk_set(dev_priv, true);
	set_data(bus, 1);
	set_clock(bus, 1);
	udelay(I2C_RISEFALL_TIME);
	return 0;
}

static void
intel_gpio_post_xfer(struct i2c_adapter *adapter)
{
	struct intel_gmbus *bus = container_of(adapter,
					       struct intel_gmbus,
					       adapter);
	struct drm_i915_private *dev_priv = bus->dev_priv;

	set_data(bus, 1);
	set_clock(bus, 1);
	intel_i2c_quirk_set(dev_priv, false);
}

183
static void
184
intel_gpio_setup(struct intel_gmbus *bus, u32 pin)
185
{
186
187
	struct drm_i915_private *dev_priv = bus->dev_priv;
	struct i2c_algo_bit_data *algo;
188

189
	algo = &bus->bit_algo;
190

191
192
	/* -1 to map pin pair to gmbus index */
	bus->gpio_reg = dev_priv->gpio_mmio_base + gmbus_ports[pin - 1].reg;
193

194
	bus->adapter.algo_data = algo;
195
196
197
198
	algo->setsda = set_data;
	algo->setscl = set_clock;
	algo->getsda = get_data;
	algo->getscl = get_clock;
199
200
	algo->pre_xfer = intel_gpio_pre_xfer;
	algo->post_xfer = intel_gpio_post_xfer;
201
202
203
	algo->udelay = I2C_RISEFALL_TIME;
	algo->timeout = usecs_to_jiffies(2200);
	algo->data = bus;
204
205
}

206
static int
207
208
gmbus_xfer_read(struct drm_i915_private *dev_priv, struct i2c_msg *msg,
		u32 gmbus1_index)
209
210
211
212
213
214
{
	int reg_offset = dev_priv->gpio_mmio_base;
	u16 len = msg->len;
	u8 *buf = msg->buf;

	I915_WRITE(GMBUS1 + reg_offset,
215
		   gmbus1_index |
216
217
218
219
		   GMBUS_CYCLE_WAIT |
		   (len << GMBUS_BYTE_COUNT_SHIFT) |
		   (msg->addr << GMBUS_SLAVE_ADDR_SHIFT) |
		   GMBUS_SLAVE_READ | GMBUS_SW_RDY);
220
	while (len) {
221
		int ret;
222
		u32 val, loop = 0;
223
		u32 gmbus2;
224

225
226
227
228
		ret = wait_for((gmbus2 = I915_READ(GMBUS2 + reg_offset)) &
			       (GMBUS_SATOER | GMBUS_HW_RDY),
			       50);
		if (ret)
229
			return -ETIMEDOUT;
230
		if (gmbus2 & GMBUS_SATOER)
231
232
233
234
235
236
237
			return -ENXIO;

		val = I915_READ(GMBUS3 + reg_offset);
		do {
			*buf++ = val & 0xff;
			val >>= 8;
		} while (--len && ++loop < 4);
238
	}
239
240
241
242
243

	return 0;
}

static int
244
gmbus_xfer_write(struct drm_i915_private *dev_priv, struct i2c_msg *msg)
245
246
247
248
249
250
251
{
	int reg_offset = dev_priv->gpio_mmio_base;
	u16 len = msg->len;
	u8 *buf = msg->buf;
	u32 val, loop;

	val = loop = 0;
252
253
254
255
	while (len && loop < 4) {
		val |= *buf++ << (8 * loop++);
		len -= 1;
	}
256
257
258
259
260
261
262
263

	I915_WRITE(GMBUS3 + reg_offset, val);
	I915_WRITE(GMBUS1 + reg_offset,
		   GMBUS_CYCLE_WAIT |
		   (msg->len << GMBUS_BYTE_COUNT_SHIFT) |
		   (msg->addr << GMBUS_SLAVE_ADDR_SHIFT) |
		   GMBUS_SLAVE_WRITE | GMBUS_SW_RDY);
	while (len) {
264
265
266
		int ret;
		u32 gmbus2;

267
268
269
270
271
272
		val = loop = 0;
		do {
			val |= *buf++ << (8 * loop);
		} while (--len && ++loop < 4);

		I915_WRITE(GMBUS3 + reg_offset, val);
273

274
275
276
277
		ret = wait_for((gmbus2 = I915_READ(GMBUS2 + reg_offset)) &
			       (GMBUS_SATOER | GMBUS_HW_RDY),
			       50);
		if (ret)
278
			return -ETIMEDOUT;
279
		if (gmbus2 & GMBUS_SATOER)
280
			return -ENXIO;
281
282
283
284
	}
	return 0;
}

285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
/*
 * The gmbus controller can combine a 1 or 2 byte write with a read that
 * immediately follows it by using an "INDEX" cycle.
 */
static bool
gmbus_is_index_read(struct i2c_msg *msgs, int i, int num)
{
	return (i + 1 < num &&
		!(msgs[i].flags & I2C_M_RD) && msgs[i].len <= 2 &&
		(msgs[i + 1].flags & I2C_M_RD));
}

static int
gmbus_xfer_index_read(struct drm_i915_private *dev_priv, struct i2c_msg *msgs)
{
	int reg_offset = dev_priv->gpio_mmio_base;
	u32 gmbus1_index = 0;
	u32 gmbus5 = 0;
	int ret;

	if (msgs[0].len == 2)
		gmbus5 = GMBUS_2BYTE_INDEX_EN |
			 msgs[0].buf[1] | (msgs[0].buf[0] << 8);
	if (msgs[0].len == 1)
		gmbus1_index = GMBUS_CYCLE_INDEX |
			       (msgs[0].buf[0] << GMBUS_SLAVE_INDEX_SHIFT);

	/* GMBUS5 holds 16-bit index */
	if (gmbus5)
		I915_WRITE(GMBUS5 + reg_offset, gmbus5);

	ret = gmbus_xfer_read(dev_priv, &msgs[1], gmbus1_index);

	/* Clear GMBUS5 after each index transfer */
	if (gmbus5)
		I915_WRITE(GMBUS5 + reg_offset, 0);

	return ret;
}

325
326
327
328
329
330
331
332
static int
gmbus_xfer(struct i2c_adapter *adapter,
	   struct i2c_msg *msgs,
	   int num)
{
	struct intel_gmbus *bus = container_of(adapter,
					       struct intel_gmbus,
					       adapter);
333
	struct drm_i915_private *dev_priv = bus->dev_priv;
334
335
	int i, reg_offset;
	int ret = 0;
336

337
338
339
	mutex_lock(&dev_priv->gmbus_mutex);

	if (bus->force_bit) {
340
		ret = i2c_bit_algo.master_xfer(adapter, msgs, num);
341
342
		goto out;
	}
343

344
	reg_offset = dev_priv->gpio_mmio_base;
345

346
	I915_WRITE(GMBUS0 + reg_offset, bus->reg0);
347
348

	for (i = 0; i < num; i++) {
349
350
		u32 gmbus2;

351
352
353
354
355
356
		if (gmbus_is_index_read(msgs, i, num)) {
			ret = gmbus_xfer_index_read(dev_priv, &msgs[i]);
			i += 1;  /* set i to the index of the read xfer */
		} else if (msgs[i].flags & I2C_M_RD) {
			ret = gmbus_xfer_read(dev_priv, &msgs[i], 0);
		} else {
357
			ret = gmbus_xfer_write(dev_priv, &msgs[i]);
358
		}
359
360
361
362
363
364

		if (ret == -ETIMEDOUT)
			goto timeout;
		if (ret == -ENXIO)
			goto clear_err;

365
366
367
368
		ret = wait_for((gmbus2 = I915_READ(GMBUS2 + reg_offset)) &
			       (GMBUS_SATOER | GMBUS_HW_WAIT_PHASE),
			       50);
		if (ret)
369
			goto timeout;
370
		if (gmbus2 & GMBUS_SATOER)
371
			goto clear_err;
372
373
	}

374
375
376
377
378
379
	/* Generate a STOP condition on the bus. Note that gmbus can't generata
	 * a STOP on the very first cycle. To simplify the code we
	 * unconditionally generate the STOP condition with an additional gmbus
	 * cycle. */
	I915_WRITE(GMBUS1 + reg_offset, GMBUS_CYCLE_STOP | GMBUS_SW_RDY);

380
381
382
383
	/* Mark the GMBUS interface as disabled after waiting for idle.
	 * We will re-enable it at the start of the next xfer,
	 * till then let it sleep.
	 */
384
385
	if (wait_for((I915_READ(GMBUS2 + reg_offset) & GMBUS_ACTIVE) == 0,
		     10)) {
386
		DRM_DEBUG_KMS("GMBUS [%s] timed out waiting for idle\n",
387
			 adapter->name);
388
389
		ret = -ETIMEDOUT;
	}
390
	I915_WRITE(GMBUS0 + reg_offset, 0);
391
	ret = ret ?: i;
392
	goto out;
393
394

clear_err:
395
396
397
398
399
400
401
	/*
	 * Wait for bus to IDLE before clearing NAK.
	 * If we clear the NAK while bus is still active, then it will stay
	 * active and the next transaction may fail.
	 */
	if (wait_for((I915_READ(GMBUS2 + reg_offset) & GMBUS_ACTIVE) == 0,
		     10))
402
403
		DRM_DEBUG_KMS("GMBUS [%s] timed out after NAK\n",
			      adapter->name);
404

405
406
407
408
409
410
	/* Toggle the Software Clear Interrupt bit. This has the effect
	 * of resetting the GMBUS controller and so clearing the
	 * BUS_ERROR raised by the slave's NAK.
	 */
	I915_WRITE(GMBUS1 + reg_offset, GMBUS_SW_CLR_INT);
	I915_WRITE(GMBUS1 + reg_offset, 0);
411
	I915_WRITE(GMBUS0 + reg_offset, 0);
412

413
	DRM_DEBUG_KMS("GMBUS [%s] NAK for addr: %04x %c(%d)\n",
414
415
416
417
418
419
420
421
422
			 adapter->name, msgs[i].addr,
			 (msgs[i].flags & I2C_M_RD) ? 'r' : 'w', msgs[i].len);

	/*
	 * If no ACK is received during the address phase of a transaction,
	 * the adapter must report -ENXIO.
	 * It is not clear what to return if no ACK is received at other times.
	 * So, we always return -ENXIO in all NAK cases, to ensure we send
	 * it at least during the one case that is specified.
423
	 */
424
	ret = -ENXIO;
425
	goto out;
426
427

timeout:
428
429
	DRM_INFO("GMBUS [%s] timed out, falling back to bit banging on pin %d\n",
		 bus->adapter.name, bus->reg0 & 0xff);
430
431
	I915_WRITE(GMBUS0 + reg_offset, 0);

432
433
434
	/* Hardware may not support GMBUS over these pins? Try GPIO bitbanging instead. */
	bus->force_bit = true;
	ret = i2c_bit_algo.master_xfer(adapter, msgs, num);
435

436
437
438
out:
	mutex_unlock(&dev_priv->gmbus_mutex);
	return ret;
439
440
441
442
}

static u32 gmbus_func(struct i2c_adapter *adapter)
{
443
444
	return i2c_bit_algo.functionality(adapter) &
		(I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
445
446
447
448
449
450
451
452
453
454
		/* I2C_FUNC_10BIT_ADDR | */
		I2C_FUNC_SMBUS_READ_BLOCK_DATA |
		I2C_FUNC_SMBUS_BLOCK_PROC_CALL);
}

static const struct i2c_algorithm gmbus_algorithm = {
	.master_xfer	= gmbus_xfer,
	.functionality	= gmbus_func
};

455
/**
456
457
 * intel_gmbus_setup - instantiate all Intel i2c GMBuses
 * @dev: DRM device
458
 */
459
460
461
462
463
int intel_setup_gmbus(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	int ret, i;

464
465
466
467
468
	if (HAS_PCH_SPLIT(dev))
		dev_priv->gpio_mmio_base = PCH_GPIOA - GPIOA;
	else
		dev_priv->gpio_mmio_base = 0;

469
470
	mutex_init(&dev_priv->gmbus_mutex);

471
472
	for (i = 0; i < GMBUS_NUM_PORTS; i++) {
		struct intel_gmbus *bus = &dev_priv->gmbus[i];
473
		u32 port = i + 1; /* +1 to map gmbus index to pin pair */
474
475
476
477

		bus->adapter.owner = THIS_MODULE;
		bus->adapter.class = I2C_CLASS_DDC;
		snprintf(bus->adapter.name,
478
479
			 sizeof(bus->adapter.name),
			 "i915 gmbus %s",
480
			 gmbus_ports[i].name);
481
482

		bus->adapter.dev.parent = &dev->pdev->dev;
483
		bus->dev_priv = dev_priv;
484
485
486
487
488
489

		bus->adapter.algo = &gmbus_algorithm;
		ret = i2c_add_adapter(&bus->adapter);
		if (ret)
			goto err;

490
		/* By default use a conservative clock rate */
491
		bus->reg0 = port | GMBUS_RATE_100KHZ;
492

493
494
495
496
		/* gmbus seems to be broken on i830 */
		if (IS_I830(dev))
			bus->force_bit = true;

497
		intel_gpio_setup(bus, port);
498
499
500
501
502
503
504
505
506
507
508
509
510
511
	}

	intel_i2c_reset(dev_priv->dev);

	return 0;

err:
	while (--i) {
		struct intel_gmbus *bus = &dev_priv->gmbus[i];
		i2c_del_adapter(&bus->adapter);
	}
	return ret;
}

512
513
514
515
struct i2c_adapter *intel_gmbus_get_adapter(struct drm_i915_private *dev_priv,
					    unsigned port)
{
	WARN_ON(!intel_gmbus_is_port_valid(port));
516
	/* -1 to map pin pair to gmbus index */
517
	return (intel_gmbus_is_port_valid(port)) ?
518
		&dev_priv->gmbus[port - 1].adapter : NULL;
519
520
}

521
522
523
524
void intel_gmbus_set_speed(struct i2c_adapter *adapter, int speed)
{
	struct intel_gmbus *bus = to_intel_gmbus(adapter);

525
	bus->reg0 = (bus->reg0 & ~(0x3 << 8)) | speed;
526
527
528
529
530
531
}

void intel_gmbus_force_bit(struct i2c_adapter *adapter, bool force_bit)
{
	struct intel_gmbus *bus = to_intel_gmbus(adapter);

532
	bus->force_bit = force_bit;
533
534
}

535
void intel_teardown_gmbus(struct drm_device *dev)
536
{
537
538
	struct drm_i915_private *dev_priv = dev->dev_private;
	int i;
539

540
	if (dev_priv->gmbus == NULL)
541
542
		return;

543
544
545
546
	for (i = 0; i < GMBUS_NUM_PORTS; i++) {
		struct intel_gmbus *bus = &dev_priv->gmbus[i];
		i2c_del_adapter(&bus->adapter);
	}
547
}