intel_i2c.c 15.7 KB
Newer Older
J
Jesse Barnes 已提交
1 2
/*
 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
3
 * Copyright © 2006-2008,2010 Intel Corporation
J
Jesse Barnes 已提交
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>
J
Jesse Barnes 已提交
28 29 30
 */
#include <linux/i2c.h>
#include <linux/i2c-algo-bit.h>
31
#include <linux/export.h>
32
#include <drm/drmP.h>
J
Jesse Barnes 已提交
33
#include "intel_drv.h"
34
#include <drm/i915_drm.h>
J
Jesse Barnes 已提交
35 36
#include "i915_drv.h"

37 38 39 40 41 42 43 44 45 46 47 48 49 50
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 },
};

51 52
/* Intel GPIO access functions */

J
Jean Delvare 已提交
53
#define I2C_RISEFALL_TIME 10
54

C
Chris Wilson 已提交
55 56 57 58 59 60
static inline struct intel_gmbus *
to_intel_gmbus(struct i2c_adapter *i2c)
{
	return container_of(i2c, struct intel_gmbus, adapter);
}

61 62
void
intel_i2c_reset(struct drm_device *dev)
63 64
{
	struct drm_i915_private *dev_priv = dev->dev_private;
65

66
	I915_WRITE(dev_priv->gpio_mmio_base + GMBUS0, 0);
67
	I915_WRITE(dev_priv->gpio_mmio_base + GMBUS4, 0);
68 69 70 71
}

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

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

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

86
static u32 get_reserved(struct intel_gmbus *bus)
C
Chris Wilson 已提交
87
{
88
	struct drm_i915_private *dev_priv = bus->dev_priv;
C
Chris Wilson 已提交
89 90 91 92 93
	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))
94
		reserved = I915_READ_NOTRACE(bus->gpio_reg) &
95 96
					     (GPIO_DATA_PULLUP_DISABLE |
					      GPIO_CLOCK_PULLUP_DISABLE);
C
Chris Wilson 已提交
97 98 99 100

	return reserved;
}

J
Jesse Barnes 已提交
101 102
static int get_clock(void *data)
{
103 104 105 106 107 108
	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;
J
Jesse Barnes 已提交
109 110 111 112
}

static int get_data(void *data)
{
113 114 115 116 117 118
	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;
J
Jesse Barnes 已提交
119 120 121 122
}

static void set_clock(void *data, int state_high)
{
123 124 125
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
C
Chris Wilson 已提交
126
	u32 clock_bits;
J
Jesse Barnes 已提交
127 128 129 130 131 132

	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;
133

134 135
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | clock_bits);
	POSTING_READ(bus->gpio_reg);
J
Jesse Barnes 已提交
136 137 138 139
}

static void set_data(void *data, int state_high)
{
140 141 142
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
C
Chris Wilson 已提交
143
	u32 data_bits;
J
Jesse Barnes 已提交
144 145 146 147 148 149 150

	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;

151 152
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | data_bits);
	POSTING_READ(bus->gpio_reg);
J
Jesse Barnes 已提交
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 183
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);
}

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

190
	algo = &bus->bit_algo;
191

192 193
	/* -1 to map pin pair to gmbus index */
	bus->gpio_reg = dev_priv->gpio_mmio_base + gmbus_ports[pin - 1].reg;
J
Jesse Barnes 已提交
194

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

207 208
static int
gmbus_wait_hw_status(struct drm_i915_private *dev_priv,
209 210
		     u32 gmbus2_status,
		     u32 gmbus4_irq_en)
211
{
212
	int i;
213
	int reg_offset = dev_priv->gpio_mmio_base;
214 215 216
	u32 gmbus2 = 0;
	DEFINE_WAIT(wait);

217 218 219
	if (!HAS_GMBUS_IRQ(dev_priv->dev))
		gmbus4_irq_en = 0;

220 221 222 223 224
	/* Important: The hw handles only the first bit, so set only one! Since
	 * we also need to check for NAKs besides the hw ready/idle signal, we
	 * need to wake up periodically and check that ourselves. */
	I915_WRITE(GMBUS4 + reg_offset, gmbus4_irq_en);

225
	for (i = 0; i < msecs_to_jiffies_timeout(50); i++) {
226 227 228
		prepare_to_wait(&dev_priv->gmbus_wait_queue, &wait,
				TASK_UNINTERRUPTIBLE);

229
		gmbus2 = I915_READ_NOTRACE(GMBUS2 + reg_offset);
230 231
		if (gmbus2 & (GMBUS_SATOER | gmbus2_status))
			break;
232

233 234 235 236 237
		schedule_timeout(1);
	}
	finish_wait(&dev_priv->gmbus_wait_queue, &wait);

	I915_WRITE(GMBUS4 + reg_offset, 0);
238 239 240

	if (gmbus2 & GMBUS_SATOER)
		return -ENXIO;
241 242 243
	if (gmbus2 & gmbus2_status)
		return 0;
	return -ETIMEDOUT;
244 245
}

246 247 248 249 250 251
static int
gmbus_wait_idle(struct drm_i915_private *dev_priv)
{
	int ret;
	int reg_offset = dev_priv->gpio_mmio_base;

252
#define C ((I915_READ_NOTRACE(GMBUS2 + reg_offset) & GMBUS_ACTIVE) == 0)
253 254 255 256 257 258 259

	if (!HAS_GMBUS_IRQ(dev_priv->dev))
		return wait_for(C, 10);

	/* Important: The hw handles only the first bit, so set only one! */
	I915_WRITE(GMBUS4 + reg_offset, GMBUS_IDLE_EN);

260 261
	ret = wait_event_timeout(dev_priv->gmbus_wait_queue, C,
				 msecs_to_jiffies_timeout(10));
262 263 264 265 266 267 268 269 270 271

	I915_WRITE(GMBUS4 + reg_offset, 0);

	if (ret)
		return 0;
	else
		return -ETIMEDOUT;
#undef C
}

272
static int
273 274
gmbus_xfer_read(struct drm_i915_private *dev_priv, struct i2c_msg *msg,
		u32 gmbus1_index)
275 276 277 278 279 280
{
	int reg_offset = dev_priv->gpio_mmio_base;
	u16 len = msg->len;
	u8 *buf = msg->buf;

	I915_WRITE(GMBUS1 + reg_offset,
281
		   gmbus1_index |
282 283 284 285
		   GMBUS_CYCLE_WAIT |
		   (len << GMBUS_BYTE_COUNT_SHIFT) |
		   (msg->addr << GMBUS_SLAVE_ADDR_SHIFT) |
		   GMBUS_SLAVE_READ | GMBUS_SW_RDY);
286
	while (len) {
287
		int ret;
288 289
		u32 val, loop = 0;

290 291
		ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_RDY,
					   GMBUS_HW_RDY_EN);
292
		if (ret)
293
			return ret;
294 295 296 297 298 299

		val = I915_READ(GMBUS3 + reg_offset);
		do {
			*buf++ = val & 0xff;
			val >>= 8;
		} while (--len && ++loop < 4);
300
	}
301 302 303 304 305

	return 0;
}

static int
306
gmbus_xfer_write(struct drm_i915_private *dev_priv, struct i2c_msg *msg)
307 308 309 310 311 312 313
{
	int reg_offset = dev_priv->gpio_mmio_base;
	u16 len = msg->len;
	u8 *buf = msg->buf;
	u32 val, loop;

	val = loop = 0;
314 315 316 317
	while (len && loop < 4) {
		val |= *buf++ << (8 * loop++);
		len -= 1;
	}
318 319 320 321 322 323 324 325

	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) {
326 327
		int ret;

328 329 330 331 332 333
		val = loop = 0;
		do {
			val |= *buf++ << (8 * loop);
		} while (--len && ++loop < 4);

		I915_WRITE(GMBUS3 + reg_offset, val);
334

335 336
		ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_RDY,
					   GMBUS_HW_RDY_EN);
337
		if (ret)
338
			return ret;
339 340 341 342
	}
	return 0;
}

343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
/*
 * 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;
}

383 384 385 386 387 388 389 390
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);
391
	struct drm_i915_private *dev_priv = bus->dev_priv;
392 393
	int i, reg_offset;
	int ret = 0;
394

395
	intel_aux_display_runtime_get(dev_priv);
396 397 398
	mutex_lock(&dev_priv->gmbus_mutex);

	if (bus->force_bit) {
399
		ret = i2c_bit_algo.master_xfer(adapter, msgs, num);
400 401
		goto out;
	}
402

403
	reg_offset = dev_priv->gpio_mmio_base;
404

C
Chris Wilson 已提交
405
	I915_WRITE(GMBUS0 + reg_offset, bus->reg0);
406 407

	for (i = 0; i < num; i++) {
408 409 410 411 412 413
		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 {
414
			ret = gmbus_xfer_write(dev_priv, &msgs[i]);
415
		}
416 417 418 419 420 421

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

422 423
		ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_WAIT_PHASE,
					   GMBUS_HW_WAIT_EN);
424 425
		if (ret == -ENXIO)
			goto clear_err;
426
		if (ret)
427 428 429
			goto timeout;
	}

430 431 432 433 434 435
	/* 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);

436 437 438 439
	/* 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.
	 */
440
	if (gmbus_wait_idle(dev_priv)) {
441
		DRM_DEBUG_KMS("GMBUS [%s] timed out waiting for idle\n",
442
			 adapter->name);
443 444
		ret = -ETIMEDOUT;
	}
445
	I915_WRITE(GMBUS0 + reg_offset, 0);
446
	ret = ret ?: i;
447
	goto out;
448 449

clear_err:
450 451 452 453
	/*
	 * 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.
454 455 456 457 458 459 460 461
	 *
	 * 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. But we have to be careful to not return
	 * spurious -ENXIO because that will prevent i2c and drm edid functions
	 * from retrying. So return -ENXIO only when gmbus properly quiescents -
	 * timing out seems to happen when there _is_ a ddc chip present, but
	 * it's slow responding and only answers on the 2nd retry.
462
	 */
463
	ret = -ENXIO;
464
	if (gmbus_wait_idle(dev_priv)) {
465 466
		DRM_DEBUG_KMS("GMBUS [%s] timed out after NAK\n",
			      adapter->name);
467 468
		ret = -ETIMEDOUT;
	}
469

470 471 472 473 474 475
	/* 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);
476
	I915_WRITE(GMBUS0 + reg_offset, 0);
477

478
	DRM_DEBUG_KMS("GMBUS [%s] NAK for addr: %04x %c(%d)\n",
479 480 481
			 adapter->name, msgs[i].addr,
			 (msgs[i].flags & I2C_M_RD) ? 'r' : 'w', msgs[i].len);

482
	goto out;
483 484

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

489
	/* Hardware may not support GMBUS over these pins? Try GPIO bitbanging instead. */
490
	bus->force_bit = 1;
491
	ret = i2c_bit_algo.master_xfer(adapter, msgs, num);
492

493 494
out:
	mutex_unlock(&dev_priv->gmbus_mutex);
495
	intel_aux_display_runtime_put(dev_priv);
496
	return ret;
497 498 499 500
}

static u32 gmbus_func(struct i2c_adapter *adapter)
{
501 502
	return i2c_bit_algo.functionality(adapter) &
		(I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
503 504 505 506 507 508 509 510 511 512
		/* 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
};

J
Jesse Barnes 已提交
513
/**
514 515
 * intel_gmbus_setup - instantiate all Intel i2c GMBuses
 * @dev: DRM device
J
Jesse Barnes 已提交
516
 */
517 518 519 520 521
int intel_setup_gmbus(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	int ret, i;

522 523 524
	if (HAS_PCH_NOP(dev))
		return 0;
	else if (HAS_PCH_SPLIT(dev))
525
		dev_priv->gpio_mmio_base = PCH_GPIOA - GPIOA;
526 527
	else if (IS_VALLEYVIEW(dev))
		dev_priv->gpio_mmio_base = VLV_DISPLAY_BASE;
528 529 530
	else
		dev_priv->gpio_mmio_base = 0;

531
	mutex_init(&dev_priv->gmbus_mutex);
532
	init_waitqueue_head(&dev_priv->gmbus_wait_queue);
533

534 535
	for (i = 0; i < GMBUS_NUM_PORTS; i++) {
		struct intel_gmbus *bus = &dev_priv->gmbus[i];
536
		u32 port = i + 1; /* +1 to map gmbus index to pin pair */
537 538 539 540

		bus->adapter.owner = THIS_MODULE;
		bus->adapter.class = I2C_CLASS_DDC;
		snprintf(bus->adapter.name,
541 542
			 sizeof(bus->adapter.name),
			 "i915 gmbus %s",
543
			 gmbus_ports[i].name);
544 545

		bus->adapter.dev.parent = &dev->pdev->dev;
546
		bus->dev_priv = dev_priv;
547 548 549

		bus->adapter.algo = &gmbus_algorithm;

C
Chris Wilson 已提交
550
		/* By default use a conservative clock rate */
551
		bus->reg0 = port | GMBUS_RATE_100KHZ;
552

D
Daniel Vetter 已提交
553 554
		/* gmbus seems to be broken on i830 */
		if (IS_I830(dev))
555
			bus->force_bit = 1;
D
Daniel Vetter 已提交
556

557
		intel_gpio_setup(bus, port);
558 559 560 561

		ret = i2c_add_adapter(&bus->adapter);
		if (ret)
			goto err;
562 563 564 565 566 567 568 569 570 571 572 573 574 575
	}

	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;
}

576
struct i2c_adapter *intel_gmbus_get_adapter(struct drm_i915_private *dev_priv,
577
					    unsigned int pin)
578
{
579
	WARN_ON(!intel_gmbus_is_valid_pin(pin));
580
	/* -1 to map pin pair to gmbus index */
581 582
	return (intel_gmbus_is_valid_pin(pin)) ?
		&dev_priv->gmbus[pin - 1].adapter : NULL;
583 584
}

C
Chris Wilson 已提交
585 586 587 588
void intel_gmbus_set_speed(struct i2c_adapter *adapter, int speed)
{
	struct intel_gmbus *bus = to_intel_gmbus(adapter);

589
	bus->reg0 = (bus->reg0 & ~(0x3 << 8)) | speed;
C
Chris Wilson 已提交
590 591 592 593 594 595
}

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

596 597 598 599
	bus->force_bit += force_bit ? 1 : -1;
	DRM_DEBUG_KMS("%sabling bit-banging on %s. force bit now %d\n",
		      force_bit ? "en" : "dis", adapter->name,
		      bus->force_bit);
C
Chris Wilson 已提交
600 601
}

602
void intel_teardown_gmbus(struct drm_device *dev)
J
Jesse Barnes 已提交
603
{
604 605
	struct drm_i915_private *dev_priv = dev->dev_private;
	int i;
606

607 608 609 610
	for (i = 0; i < GMBUS_NUM_PORTS; i++) {
		struct intel_gmbus *bus = &dev_priv->gmbus[i];
		i2c_del_adapter(&bus->adapter);
	}
J
Jesse Barnes 已提交
611
}