intel_i2c.c 17.1 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 38 39 40 41
enum disp_clk {
	CDCLK,
	CZCLK
};

42 43 44 45 46 47 48 49 50 51 52 53 54 55
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 },
};

56 57
/* Intel GPIO access functions */

58
#define I2C_RISEFALL_TIME 10
59

60 61 62 63 64 65
static inline struct intel_gmbus *
to_intel_gmbus(struct i2c_adapter *i2c)
{
	return container_of(i2c, struct intel_gmbus, adapter);
}

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
static int get_disp_clk_div(struct drm_i915_private *dev_priv,
			    enum disp_clk clk)
{
	u32 reg_val;
	int clk_ratio;

	reg_val = I915_READ(CZCLK_CDCLK_FREQ_RATIO);

	if (clk == CDCLK)
		clk_ratio =
			((reg_val & CDCLK_FREQ_MASK) >> CDCLK_FREQ_SHIFT) + 1;
	else
		clk_ratio = (reg_val & CZCLK_FREQ_MASK) + 1;

	return clk_ratio;
}

static void gmbus_set_freq(struct drm_i915_private *dev_priv)
{
85
	int vco, gmbus_freq = 0, cdclk_div;
86 87 88

	BUG_ON(!IS_VALLEYVIEW(dev_priv->dev));

89
	vco = valleyview_get_vco(dev_priv);
90 91 92 93 94 95 96 97 98 99

	/* Get the CDCLK divide ratio */
	cdclk_div = get_disp_clk_div(dev_priv, CDCLK);

	/*
	 * Program the gmbus_freq based on the cdclk frequency.
	 * BSpec erroneously claims we should aim for 4MHz, but
	 * in fact 1MHz is the correct frequency.
	 */
	if (cdclk_div)
100
		gmbus_freq = (vco << 1) / cdclk_div;
101 102 103 104 105 106 107

	if (WARN_ON(gmbus_freq == 0))
		return;

	I915_WRITE(GMBUSFREQ_VLV, gmbus_freq);
}

108 109
void
intel_i2c_reset(struct drm_device *dev)
110 111
{
	struct drm_i915_private *dev_priv = dev->dev_private;
112 113 114 115 116 117 118 119

	/*
	 * In BIOS-less system, program the correct gmbus frequency
	 * before reading edid.
	 */
	if (IS_VALLEYVIEW(dev))
		gmbus_set_freq(dev_priv);

120
	I915_WRITE(dev_priv->gpio_mmio_base + GMBUS0, 0);
121
	I915_WRITE(dev_priv->gpio_mmio_base + GMBUS4, 0);
122 123 124 125
}

static void intel_i2c_quirk_set(struct drm_i915_private *dev_priv, bool enable)
{
126
	u32 val;
127 128

	/* When using bit bashing for I2C, this bit needs to be set to 1 */
129
	if (!IS_PINEVIEW(dev_priv->dev))
130
		return;
131 132

	val = I915_READ(DSPCLK_GATE_D);
133
	if (enable)
134
		val |= DPCUNIT_CLOCK_GATE_DISABLE;
135
	else
136 137
		val &= ~DPCUNIT_CLOCK_GATE_DISABLE;
	I915_WRITE(DSPCLK_GATE_D, val);
138 139
}

140
static u32 get_reserved(struct intel_gmbus *bus)
141
{
142
	struct drm_i915_private *dev_priv = bus->dev_priv;
143 144 145 146 147
	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))
148
		reserved = I915_READ_NOTRACE(bus->gpio_reg) &
149 150
					     (GPIO_DATA_PULLUP_DISABLE |
					      GPIO_CLOCK_PULLUP_DISABLE);
151 152 153 154

	return reserved;
}

155 156
static int get_clock(void *data)
{
157 158 159 160 161 162
	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;
163 164 165 166
}

static int get_data(void *data)
{
167 168 169 170 171 172
	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;
173 174 175 176
}

static void set_clock(void *data, int state_high)
{
177 178 179
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
180
	u32 clock_bits;
181 182 183 184 185 186

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

188 189
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | clock_bits);
	POSTING_READ(bus->gpio_reg);
190 191 192 193
}

static void set_data(void *data, int state_high)
{
194 195 196
	struct intel_gmbus *bus = data;
	struct drm_i915_private *dev_priv = bus->dev_priv;
	u32 reserved = get_reserved(bus);
197
	u32 data_bits;
198 199 200 201 202 203 204

	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;

205 206
	I915_WRITE_NOTRACE(bus->gpio_reg, reserved | data_bits);
	POSTING_READ(bus->gpio_reg);
207 208
}

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
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);
}

238
static void
239
intel_gpio_setup(struct intel_gmbus *bus, u32 pin)
240
{
241 242
	struct drm_i915_private *dev_priv = bus->dev_priv;
	struct i2c_algo_bit_data *algo;
243

244
	algo = &bus->bit_algo;
245

246 247
	/* -1 to map pin pair to gmbus index */
	bus->gpio_reg = dev_priv->gpio_mmio_base + gmbus_ports[pin - 1].reg;
248

249
	bus->adapter.algo_data = algo;
250 251 252 253
	algo->setsda = set_data;
	algo->setscl = set_clock;
	algo->getsda = get_data;
	algo->getscl = get_clock;
254 255
	algo->pre_xfer = intel_gpio_pre_xfer;
	algo->post_xfer = intel_gpio_post_xfer;
256 257 258
	algo->udelay = I2C_RISEFALL_TIME;
	algo->timeout = usecs_to_jiffies(2200);
	algo->data = bus;
259 260
}

261 262 263 264 265 266 267
/*
 * gmbus on gen4 seems to be able to generate legacy interrupts even when in MSI
 * mode. This results in spurious interrupt warnings if the legacy irq no. is
 * shared with another device. The kernel then disables that interrupt source
 * and so prevents the other device from working properly.
 */
#define HAS_GMBUS_IRQ(dev) (INTEL_INFO(dev)->gen >= 5)
268 269
static int
gmbus_wait_hw_status(struct drm_i915_private *dev_priv,
270 271
		     u32 gmbus2_status,
		     u32 gmbus4_irq_en)
272
{
273
	int i;
274
	int reg_offset = dev_priv->gpio_mmio_base;
275 276 277
	u32 gmbus2 = 0;
	DEFINE_WAIT(wait);

278 279 280
	if (!HAS_GMBUS_IRQ(dev_priv->dev))
		gmbus4_irq_en = 0;

281 282 283 284 285
	/* 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);

286
	for (i = 0; i < msecs_to_jiffies_timeout(50); i++) {
287 288 289
		prepare_to_wait(&dev_priv->gmbus_wait_queue, &wait,
				TASK_UNINTERRUPTIBLE);

290
		gmbus2 = I915_READ_NOTRACE(GMBUS2 + reg_offset);
291 292
		if (gmbus2 & (GMBUS_SATOER | gmbus2_status))
			break;
293

294 295 296 297 298
		schedule_timeout(1);
	}
	finish_wait(&dev_priv->gmbus_wait_queue, &wait);

	I915_WRITE(GMBUS4 + reg_offset, 0);
299 300 301

	if (gmbus2 & GMBUS_SATOER)
		return -ENXIO;
302 303 304
	if (gmbus2 & gmbus2_status)
		return 0;
	return -ETIMEDOUT;
305 306
}

307 308 309 310 311 312
static int
gmbus_wait_idle(struct drm_i915_private *dev_priv)
{
	int ret;
	int reg_offset = dev_priv->gpio_mmio_base;

313
#define C ((I915_READ_NOTRACE(GMBUS2 + reg_offset) & GMBUS_ACTIVE) == 0)
314 315 316 317 318 319 320

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

321 322
	ret = wait_event_timeout(dev_priv->gmbus_wait_queue, C,
				 msecs_to_jiffies_timeout(10));
323 324 325 326 327 328 329 330 331 332

	I915_WRITE(GMBUS4 + reg_offset, 0);

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

333
static int
334 335
gmbus_xfer_read(struct drm_i915_private *dev_priv, struct i2c_msg *msg,
		u32 gmbus1_index)
336 337 338 339 340 341
{
	int reg_offset = dev_priv->gpio_mmio_base;
	u16 len = msg->len;
	u8 *buf = msg->buf;

	I915_WRITE(GMBUS1 + reg_offset,
342
		   gmbus1_index |
343 344 345 346
		   GMBUS_CYCLE_WAIT |
		   (len << GMBUS_BYTE_COUNT_SHIFT) |
		   (msg->addr << GMBUS_SLAVE_ADDR_SHIFT) |
		   GMBUS_SLAVE_READ | GMBUS_SW_RDY);
347
	while (len) {
348
		int ret;
349 350
		u32 val, loop = 0;

351 352
		ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_RDY,
					   GMBUS_HW_RDY_EN);
353
		if (ret)
354
			return ret;
355 356 357 358 359 360

		val = I915_READ(GMBUS3 + reg_offset);
		do {
			*buf++ = val & 0xff;
			val >>= 8;
		} while (--len && ++loop < 4);
361
	}
362 363 364 365 366

	return 0;
}

static int
367
gmbus_xfer_write(struct drm_i915_private *dev_priv, struct i2c_msg *msg)
368 369 370 371 372 373 374
{
	int reg_offset = dev_priv->gpio_mmio_base;
	u16 len = msg->len;
	u8 *buf = msg->buf;
	u32 val, loop;

	val = loop = 0;
375 376 377 378
	while (len && loop < 4) {
		val |= *buf++ << (8 * loop++);
		len -= 1;
	}
379 380 381 382 383 384 385 386

	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) {
387 388
		int ret;

389 390 391 392 393 394
		val = loop = 0;
		do {
			val |= *buf++ << (8 * loop);
		} while (--len && ++loop < 4);

		I915_WRITE(GMBUS3 + reg_offset, val);
395

396 397
		ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_RDY,
					   GMBUS_HW_RDY_EN);
398
		if (ret)
399
			return ret;
400 401 402 403
	}
	return 0;
}

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
/*
 * 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;
}

444 445 446 447 448 449 450 451
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);
452
	struct drm_i915_private *dev_priv = bus->dev_priv;
453 454
	int i, reg_offset;
	int ret = 0;
455

456
	intel_aux_display_runtime_get(dev_priv);
457 458 459
	mutex_lock(&dev_priv->gmbus_mutex);

	if (bus->force_bit) {
460
		ret = i2c_bit_algo.master_xfer(adapter, msgs, num);
461 462
		goto out;
	}
463

464
	reg_offset = dev_priv->gpio_mmio_base;
465

466
	I915_WRITE(GMBUS0 + reg_offset, bus->reg0);
467 468

	for (i = 0; i < num; i++) {
469 470 471 472 473 474
		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 {
475
			ret = gmbus_xfer_write(dev_priv, &msgs[i]);
476
		}
477 478 479 480 481 482

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

483 484
		ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_WAIT_PHASE,
					   GMBUS_HW_WAIT_EN);
485 486
		if (ret == -ENXIO)
			goto clear_err;
487
		if (ret)
488 489 490
			goto timeout;
	}

491 492 493 494 495 496
	/* 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);

497 498 499 500
	/* 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.
	 */
501
	if (gmbus_wait_idle(dev_priv)) {
502
		DRM_DEBUG_KMS("GMBUS [%s] timed out waiting for idle\n",
503
			 adapter->name);
504 505
		ret = -ETIMEDOUT;
	}
506
	I915_WRITE(GMBUS0 + reg_offset, 0);
507
	ret = ret ?: i;
508
	goto out;
509 510

clear_err:
511 512 513 514
	/*
	 * 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.
515 516 517 518 519 520 521 522
	 *
	 * 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.
523
	 */
524
	ret = -ENXIO;
525
	if (gmbus_wait_idle(dev_priv)) {
526 527
		DRM_DEBUG_KMS("GMBUS [%s] timed out after NAK\n",
			      adapter->name);
528 529
		ret = -ETIMEDOUT;
	}
530

531 532 533 534 535 536
	/* 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);
537
	I915_WRITE(GMBUS0 + reg_offset, 0);
538

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

543
	goto out;
544 545

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

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

554 555
out:
	mutex_unlock(&dev_priv->gmbus_mutex);
556
	intel_aux_display_runtime_put(dev_priv);
557
	return ret;
558 559 560 561
}

static u32 gmbus_func(struct i2c_adapter *adapter)
{
562 563
	return i2c_bit_algo.functionality(adapter) &
		(I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
564 565 566 567 568 569 570 571 572 573
		/* 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
};

574
/**
575 576
 * intel_gmbus_setup - instantiate all Intel i2c GMBuses
 * @dev: DRM device
577
 */
578 579 580 581 582
int intel_setup_gmbus(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	int ret, i;

583 584 585
	if (HAS_PCH_NOP(dev))
		return 0;
	else if (HAS_PCH_SPLIT(dev))
586
		dev_priv->gpio_mmio_base = PCH_GPIOA - GPIOA;
587 588
	else if (IS_VALLEYVIEW(dev))
		dev_priv->gpio_mmio_base = VLV_DISPLAY_BASE;
589 590 591
	else
		dev_priv->gpio_mmio_base = 0;

592
	mutex_init(&dev_priv->gmbus_mutex);
593
	init_waitqueue_head(&dev_priv->gmbus_wait_queue);
594

595 596
	for (i = 0; i < GMBUS_NUM_PORTS; i++) {
		struct intel_gmbus *bus = &dev_priv->gmbus[i];
597
		u32 port = i + 1; /* +1 to map gmbus index to pin pair */
598 599 600 601

		bus->adapter.owner = THIS_MODULE;
		bus->adapter.class = I2C_CLASS_DDC;
		snprintf(bus->adapter.name,
602 603
			 sizeof(bus->adapter.name),
			 "i915 gmbus %s",
604
			 gmbus_ports[i].name);
605 606

		bus->adapter.dev.parent = &dev->pdev->dev;
607
		bus->dev_priv = dev_priv;
608 609 610

		bus->adapter.algo = &gmbus_algorithm;

611
		/* By default use a conservative clock rate */
612
		bus->reg0 = port | GMBUS_RATE_100KHZ;
613

614 615
		/* gmbus seems to be broken on i830 */
		if (IS_I830(dev))
616
			bus->force_bit = 1;
617

618
		intel_gpio_setup(bus, port);
619 620 621 622

		ret = i2c_add_adapter(&bus->adapter);
		if (ret)
			goto err;
623 624 625 626 627 628 629 630 631 632 633 634 635 636
	}

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

637 638 639 640
struct i2c_adapter *intel_gmbus_get_adapter(struct drm_i915_private *dev_priv,
					    unsigned port)
{
	WARN_ON(!intel_gmbus_is_port_valid(port));
641
	/* -1 to map pin pair to gmbus index */
642
	return (intel_gmbus_is_port_valid(port)) ?
643
		&dev_priv->gmbus[port - 1].adapter : NULL;
644 645
}

646 647 648 649
void intel_gmbus_set_speed(struct i2c_adapter *adapter, int speed)
{
	struct intel_gmbus *bus = to_intel_gmbus(adapter);

650
	bus->reg0 = (bus->reg0 & ~(0x3 << 8)) | speed;
651 652 653 654 655 656
}

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

657 658 659 660
	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);
661 662
}

663
void intel_teardown_gmbus(struct drm_device *dev)
664
{
665 666
	struct drm_i915_private *dev_priv = dev->dev_private;
	int i;
667

668 669 670 671
	for (i = 0; i < GMBUS_NUM_PORTS; i++) {
		struct intel_gmbus *bus = &dev_priv->gmbus[i];
		i2c_del_adapter(&bus->adapter);
	}
672
}