intel_i2c.c 15.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
#include <drm/drmP.h>
33
#include "intel_drv.h"
34
#include <drm/i915_drm.h>
35 36
#include "i915_drv.h"

37
struct gmbus_pin {
38 39 40 41
	const char *name;
	int reg;
};

42 43 44 45 46 47 48 49
/* Map gmbus pin pairs to names and registers. */
static const struct gmbus_pin gmbus_pins[] = {
	[GMBUS_PIN_SSC] = { "ssc", GPIOB },
	[GMBUS_PIN_VGADDC] = { "vga", GPIOA },
	[GMBUS_PIN_PANEL] = { "panel", GPIOC },
	[GMBUS_PIN_DPC] = { "dpc", GPIOD },
	[GMBUS_PIN_DPB] = { "dpb", GPIOE },
	[GMBUS_PIN_DPD] = { "dpd", GPIOF },
50 51
};

52 53
/* Intel GPIO access functions */

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

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

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

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

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

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

	return reserved;
}

102 103
static int get_clock(void *data)
{
104 105 106 107 108 109
	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;
110 111 112 113
}

static int get_data(void *data)
{
114 115 116 117 118 119
	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;
120 121 122 123
}

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

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

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

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

	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;

152 153
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | data_bits);
	POSTING_READ(bus->gpio_reg);
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 184
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);
}

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

191
	algo = &bus->bit_algo;
192

193
	bus->gpio_reg = dev_priv->gpio_mmio_base + gmbus_pins[pin].reg;
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;
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

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

513
/**
514 515
 * intel_gmbus_setup - instantiate all Intel i2c GMBuses
 * @dev: DRM device
516
 */
517 518 519
int intel_setup_gmbus(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
520 521 522
	struct intel_gmbus *bus;
	unsigned int pin;
	int ret;
523

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

533
	mutex_init(&dev_priv->gmbus_mutex);
534
	init_waitqueue_head(&dev_priv->gmbus_wait_queue);
535

536 537 538 539 540
	for (pin = 0; pin < ARRAY_SIZE(dev_priv->gmbus); pin++) {
		if (!intel_gmbus_is_valid_pin(pin))
			continue;

		bus = &dev_priv->gmbus[pin];
541 542 543 544

		bus->adapter.owner = THIS_MODULE;
		bus->adapter.class = I2C_CLASS_DDC;
		snprintf(bus->adapter.name,
545 546
			 sizeof(bus->adapter.name),
			 "i915 gmbus %s",
547
			 gmbus_pins[pin].name);
548 549

		bus->adapter.dev.parent = &dev->pdev->dev;
550
		bus->dev_priv = dev_priv;
551 552 553

		bus->adapter.algo = &gmbus_algorithm;

554
		/* By default use a conservative clock rate */
555
		bus->reg0 = pin | GMBUS_RATE_100KHZ;
556

557 558
		/* gmbus seems to be broken on i830 */
		if (IS_I830(dev))
559
			bus->force_bit = 1;
560

561
		intel_gpio_setup(bus, pin);
562 563 564 565

		ret = i2c_add_adapter(&bus->adapter);
		if (ret)
			goto err;
566 567 568 569 570 571 572
	}

	intel_i2c_reset(dev_priv->dev);

	return 0;

err:
573 574 575 576 577
	while (--pin) {
		if (!intel_gmbus_is_valid_pin(pin))
			continue;

		bus = &dev_priv->gmbus[pin];
578 579 580 581 582
		i2c_del_adapter(&bus->adapter);
	}
	return ret;
}

583
struct i2c_adapter *intel_gmbus_get_adapter(struct drm_i915_private *dev_priv,
584
					    unsigned int pin)
585
{
586 587 588 589
	if (WARN_ON(!intel_gmbus_is_valid_pin(pin)))
		return NULL;

	return &dev_priv->gmbus[pin].adapter;
590 591
}

592 593 594 595
void intel_gmbus_set_speed(struct i2c_adapter *adapter, int speed)
{
	struct intel_gmbus *bus = to_intel_gmbus(adapter);

596
	bus->reg0 = (bus->reg0 & ~(0x3 << 8)) | speed;
597 598 599 600 601 602
}

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

603 604 605 606
	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);
607 608
}

609
void intel_teardown_gmbus(struct drm_device *dev)
610
{
611
	struct drm_i915_private *dev_priv = dev->dev_private;
612 613 614 615 616 617
	struct intel_gmbus *bus;
	unsigned int pin;

	for (pin = 0; pin < ARRAY_SIZE(dev_priv->gmbus); pin++) {
		if (!intel_gmbus_is_valid_pin(pin))
			continue;
618

619
		bus = &dev_priv->gmbus[pin];
620 621
		i2c_del_adapter(&bus->adapter);
	}
622
}
新手
引导
客服 返回
顶部