sys/dev/drm/i915/intel_i2c.c

   1 /*
   2  * Copyright (c) 2006 Dave Airlie <airlied@linux.ie>
   3  * Copyright © 2006-2008,2010 Intel Corporation
   4  *   Jesse Barnes <jesse.barnes@intel.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  *
  25  * Authors:
  26  *      Eric Anholt <eric@anholt.net>
  27  *      Chris Wilson <chris@chris-wilson.co.uk>
  28  *
  29  * Copyright (c) 2011 The FreeBSD Foundation
  30  * All rights reserved.
  31  *
  32  * This software was developed by Konstantin Belousov under sponsorship from
  33  * the FreeBSD Foundation.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  * 1. Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  * 2. Redistributions in binary form must reproduce the above copyright
  41  *    notice, this list of conditions and the following disclaimer in the
  42  *    documentation and/or other materials provided with the distribution.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  */
  56
  57 #include <sys/mplock2.h>
  58
  59 #include <linux/i2c.h>
  60 #include <linux/export.h>
  61 #include <drm/drmP.h>
  62 #include "intel_drv.h"
  63 #include <drm/i915_drm.h>
  64 #include "i915_drv.h"
  65
  66 #include <bus/iicbus/iic.h>
  67 #include <bus/iicbus/iiconf.h>
  68 #include <bus/iicbus/iicbus.h>
  69 #include "iicbus_if.h"
  70 #include "iicbb_if.h"
  71
  72 enum disp_clk {
  73         CDCLK,
  74         CZCLK
  75 };
  76
  77 struct gmbus_port {
  78         const char *name;
  79         int reg;
  80 };
  81
  82 static const struct gmbus_port gmbus_ports[] = {
  83         { "ssc", GPIOB },
  84         { "vga", GPIOA },
  85         { "panel", GPIOC },
  86         { "dpc", GPIOD },
  87         { "dpb", GPIOE },
  88         { "dpd", GPIOF },
  89 };
  90
  91 /* Intel GPIO access functions */
  92
  93 #define I2C_RISEFALL_TIME 10
  94
  95 static int get_disp_clk_div(struct drm_i915_private *dev_priv,
  96                             enum disp_clk clk)
  97 {
  98         u32 reg_val;
  99         int clk_ratio;
 100
 101         reg_val = I915_READ(CZCLK_CDCLK_FREQ_RATIO);
 102
 103         if (clk == CDCLK)
 104                 clk_ratio =
 105                         ((reg_val & CDCLK_FREQ_MASK) >> CDCLK_FREQ_SHIFT) + 1;
 106         else
 107                 clk_ratio = (reg_val & CZCLK_FREQ_MASK) + 1;
 108
 109         return clk_ratio;
 110 }
 111
 112 static void gmbus_set_freq(struct drm_i915_private *dev_priv)
 113 {
 114         int vco, gmbus_freq = 0, cdclk_div;
 115
 116         BUG_ON(!IS_VALLEYVIEW(dev_priv->dev));
 117
 118         vco = valleyview_get_vco(dev_priv);
 119
 120         /* Get the CDCLK divide ratio */
 121         cdclk_div = get_disp_clk_div(dev_priv, CDCLK);
 122
 123         /*
 124          * Program the gmbus_freq based on the cdclk frequency.
 125          * BSpec erroneously claims we should aim for 4MHz, but
 126          * in fact 1MHz is the correct frequency.
 127          */
 128         if (cdclk_div)
 129                 gmbus_freq = (vco << 1) / cdclk_div;
 130
 131         if (WARN_ON(gmbus_freq == 0))
 132                 return;
 133
 134         I915_WRITE(GMBUSFREQ_VLV, gmbus_freq);
 135 }
 136
 137 void
 138 intel_i2c_reset(struct drm_device *dev)
 139 {
 140         struct drm_i915_private *dev_priv = dev->dev_private;
 141
 142         /*
 143          * In BIOS-less system, program the correct gmbus frequency
 144          * before reading edid.
 145          */
 146         if (IS_VALLEYVIEW(dev))
 147                 gmbus_set_freq(dev_priv);
 148
 149         I915_WRITE(dev_priv->gpio_mmio_base + GMBUS0, 0);
 150         I915_WRITE(dev_priv->gpio_mmio_base + GMBUS4, 0);
 151 }
 152
 153 static void intel_i2c_quirk_set(struct drm_i915_private *dev_priv, bool enable)
 154 {
 155         u32 val;
 156
 157         /* When using bit bashing for I2C, this bit needs to be set to 1 */
 158         if (!IS_PINEVIEW(dev_priv->dev))
 159                 return;
 160
 161         val = I915_READ(DSPCLK_GATE_D);
 162         if (enable)
 163                 val |= DPCUNIT_CLOCK_GATE_DISABLE;
 164         else
 165                 val &= ~DPCUNIT_CLOCK_GATE_DISABLE;
 166         I915_WRITE(DSPCLK_GATE_D, val);
 167 }
 168
 169 static u32 get_reserved(device_t idev)
 170 {
 171         struct intel_iic_softc *sc = device_get_softc(idev);
 172         struct drm_device *dev = sc->drm_dev;
 173         struct drm_i915_private *dev_priv;
 174         u32 reserved = 0;
 175
 176         dev_priv = dev->dev_private;
 177
 178         /* On most chips, these bits must be preserved in software. */
 179         if (!IS_I830(dev) && !IS_845G(dev))
 180                 reserved = I915_READ_NOTRACE(sc->reg) &
 181                                              (GPIO_DATA_PULLUP_DISABLE |
 182                                               GPIO_CLOCK_PULLUP_DISABLE);
 183
 184         return reserved;
 185 }
 186
 187 static int get_clock(device_t idev)
 188 {
 189         struct intel_iic_softc *sc;
 190         struct drm_i915_private *dev_priv;
 191         u32 reserved;
 192
 193         sc = device_get_softc(idev);
 194         dev_priv = sc->drm_dev->dev_private;
 195
 196         reserved = get_reserved(idev);
 197
 198         I915_WRITE_NOTRACE(sc->reg, reserved | GPIO_CLOCK_DIR_MASK);
 199         I915_WRITE_NOTRACE(sc->reg, reserved);
 200         return ((I915_READ_NOTRACE(sc->reg) & GPIO_CLOCK_VAL_IN) != 0);
 201 }
 202
 203 static int get_data(device_t idev)
 204 {
 205         struct intel_iic_softc *sc;
 206         struct drm_i915_private *dev_priv;
 207         u32 reserved;
 208
 209         sc = device_get_softc(idev);
 210         dev_priv = sc->drm_dev->dev_private;
 211
 212         reserved = get_reserved(idev);
 213
 214         I915_WRITE_NOTRACE(sc->reg, reserved | GPIO_DATA_DIR_MASK);
 215         I915_WRITE_NOTRACE(sc->reg, reserved);
 216         return ((I915_READ_NOTRACE(sc->reg) & GPIO_DATA_VAL_IN) != 0);
 217 }
 218
 219 static int
 220 intel_iicbus_reset(device_t idev, u_char speed, u_char addr, u_char *oldaddr)
 221 {
 222         struct intel_iic_softc *sc;
 223         struct drm_device *dev;
 224
 225         sc = device_get_softc(idev);
 226         dev = sc->drm_dev;
 227
 228         intel_i2c_reset(dev);
 229         return (0);
 230 }
 231
 232 static void set_clock(device_t idev, int val)
 233 {
 234         struct intel_iic_softc *sc;
 235         struct drm_i915_private *dev_priv;
 236         u32 clock_bits, reserved;
 237
 238         sc = device_get_softc(idev);
 239         dev_priv = sc->drm_dev->dev_private;
 240
 241         reserved = get_reserved(idev);
 242         if (val)
 243                 clock_bits = GPIO_CLOCK_DIR_IN | GPIO_CLOCK_DIR_MASK;
 244         else
 245                 clock_bits = GPIO_CLOCK_DIR_OUT | GPIO_CLOCK_DIR_MASK |
 246                     GPIO_CLOCK_VAL_MASK;
 247
 248         I915_WRITE_NOTRACE(sc->reg, reserved | clock_bits);
 249         POSTING_READ(sc->reg);
 250 }
 251
 252 static void set_data(device_t idev, int val)
 253 {
 254         struct intel_iic_softc *sc;
 255         struct drm_i915_private *dev_priv;
 256         u32 reserved;
 257         u32 data_bits;
 258
 259         sc = device_get_softc(idev);
 260         dev_priv = sc->drm_dev->dev_private;
 261
 262         reserved = get_reserved(idev);
 263         if (val)
 264                 data_bits = GPIO_DATA_DIR_IN | GPIO_DATA_DIR_MASK;
 265         else
 266                 data_bits = GPIO_DATA_DIR_OUT | GPIO_DATA_DIR_MASK |
 267                     GPIO_DATA_VAL_MASK;
 268
 269         I915_WRITE_NOTRACE(sc->reg, reserved | data_bits);
 270         POSTING_READ(sc->reg);
 271 }
 272
 273 static const char *gpio_names[GMBUS_NUM_PORTS] = {
 274         "ssc",
 275         "vga",
 276         "panel",
 277         "dpc",
 278         "dpb",
 279         "dpd",
 280 };
 281
 282 static int
 283 intel_gpio_setup(device_t idev)
 284 {
 285         static const int map_pin_to_reg[] = {
 286                 0,
 287                 GPIOB,
 288                 GPIOA,
 289                 GPIOC,
 290                 GPIOD,
 291                 GPIOE,
 292                 GPIOF,
 293                 0
 294         };
 295
 296         struct intel_iic_softc *sc;
 297         struct drm_i915_private *dev_priv;
 298         int pin;
 299
 300         sc = device_get_softc(idev);
 301         sc->drm_dev = device_get_softc(device_get_parent(idev));
 302         dev_priv = sc->drm_dev->dev_private;
 303         pin = device_get_unit(idev);
 304
 305         ksnprintf(sc->name, sizeof(sc->name), "i915 iicbb %s", gpio_names[pin]);
 306         device_set_desc(idev, sc->name);
 307
 308         sc->reg0 = (pin + 1) | GMBUS_RATE_100KHZ;
 309         sc->reg = map_pin_to_reg[pin + 1];
 310         if (HAS_PCH_SPLIT(dev_priv->dev))
 311                 sc->reg += PCH_GPIOA - GPIOA;
 312
 313         /* add generic bit-banging code */
 314         sc->iic_dev = device_add_child(idev, "iicbb", -1);
 315         if (sc->iic_dev == NULL)
 316                 return (ENXIO);
 317         device_quiet(sc->iic_dev);
 318         bus_generic_attach(idev);
 319
 320         return (0);
 321 }
 322
 323 static int
 324 intel_i2c_quirk_xfer(device_t idev, struct iic_msg *msgs, int nmsgs)
 325 {
 326         device_t bridge_dev;
 327         struct intel_iic_softc *sc;
 328         struct drm_i915_private *dev_priv;
 329         int ret;
 330         int i;
 331
 332         bridge_dev = device_get_parent(device_get_parent(idev));
 333         sc = device_get_softc(bridge_dev);
 334         dev_priv = sc->drm_dev->dev_private;
 335
 336         intel_i2c_reset(sc->drm_dev);
 337         intel_i2c_quirk_set(dev_priv, true);
 338         IICBB_SETSDA(bridge_dev, 1);
 339         IICBB_SETSCL(bridge_dev, 1);
 340         DELAY(I2C_RISEFALL_TIME);
 341
 342         for (i = 0; i < nmsgs - 1; i++) {
 343                 /* force use of repeated start instead of default stop+start */
 344                 msgs[i].flags |= IIC_M_NOSTOP;
 345         }
 346         ret = iicbus_transfer(idev, msgs, nmsgs);
 347         IICBB_SETSDA(bridge_dev, 1);
 348         IICBB_SETSCL(bridge_dev, 1);
 349         intel_i2c_quirk_set(dev_priv, false);
 350
 351         return (ret);
 352 }
 353
 354 static int
 355 gmbus_wait_hw_status(struct drm_i915_private *dev_priv,
 356                      u32 gmbus2_status,
 357                      u32 gmbus4_irq_en)
 358 {
 359         int i;
 360         int reg_offset = dev_priv->gpio_mmio_base;
 361         u32 gmbus2 = 0;
 362         DEFINE_WAIT(wait);
 363
 364         if (!HAS_GMBUS_IRQ(dev_priv->dev))
 365                 gmbus4_irq_en = 0;
 366
 367         /* Important: The hw handles only the first bit, so set only one! Since
 368          * we also need to check for NAKs besides the hw ready/idle signal, we
 369          * need to wake up periodically and check that ourselves. */
 370         I915_WRITE(GMBUS4 + reg_offset, gmbus4_irq_en);
 371
 372         for (i = 0; i < msecs_to_jiffies_timeout(50); i++) {
 373                 prepare_to_wait(&dev_priv->gmbus_wait_queue, &wait,
 374                                 TASK_UNINTERRUPTIBLE);
 375
 376                 gmbus2 = I915_READ_NOTRACE(GMBUS2 + reg_offset);
 377                 if (gmbus2 & (GMBUS_SATOER | gmbus2_status))
 378                         break;
 379
 380                 schedule_timeout(1);
 381         }
 382         finish_wait(&dev_priv->gmbus_wait_queue, &wait);
 383
 384         I915_WRITE(GMBUS4 + reg_offset, 0);
 385
 386         if (gmbus2 & GMBUS_SATOER)
 387                 return -ENXIO;
 388         if (gmbus2 & gmbus2_status)
 389                 return 0;
 390         return -ETIMEDOUT;
 391 }
 392
 393 static int
 394 gmbus_wait_idle(struct drm_i915_private *dev_priv)
 395 {
 396         int ret;
 397         int reg_offset = dev_priv->gpio_mmio_base;
 398
 399 #define C ((I915_READ_NOTRACE(GMBUS2 + reg_offset) & GMBUS_ACTIVE) == 0)
 400
 401         if (!HAS_GMBUS_IRQ(dev_priv->dev))
 402                 return wait_for(C, 10);
 403
 404         /* Important: The hw handles only the first bit, so set only one! */
 405         I915_WRITE(GMBUS4 + reg_offset, GMBUS_IDLE_EN);
 406
 407         ret = wait_event_timeout(dev_priv->gmbus_wait_queue, C,
 408                                  msecs_to_jiffies_timeout(10));
 409
 410         I915_WRITE(GMBUS4 + reg_offset, 0);
 411
 412         if (ret)
 413                 return 0;
 414         else
 415                 return -ETIMEDOUT;
 416 #undef C
 417 }
 418
 419 static int
 420 gmbus_xfer_read(struct drm_i915_private *dev_priv, struct i2c_msg *msg,
 421                 u32 gmbus1_index)
 422 {
 423         int reg_offset = dev_priv->gpio_mmio_base;
 424         u16 len = msg->len;
 425         u8 *buf = msg->buf;
 426
 427         I915_WRITE(GMBUS1 + reg_offset,
 428                    gmbus1_index |
 429                    GMBUS_CYCLE_WAIT |
 430                    (len << GMBUS_BYTE_COUNT_SHIFT) |
 431                    (msg->slave << (GMBUS_SLAVE_ADDR_SHIFT - 1)) |
 432                    GMBUS_SLAVE_READ | GMBUS_SW_RDY);
 433         while (len) {
 434                 int ret;
 435                 u32 val, loop = 0;
 436
 437                 ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_RDY,
 438                                            GMBUS_HW_RDY_EN);
 439                 if (ret)
 440                         return ret;
 441
 442                 val = I915_READ(GMBUS3 + reg_offset);
 443                 do {
 444                         *buf++ = val & 0xff;
 445                         val >>= 8;
 446                 } while (--len && ++loop < 4);
 447         }
 448
 449         return 0;
 450 }
 451
 452 static int
 453 gmbus_xfer_write(struct drm_i915_private *dev_priv, struct i2c_msg *msg)
 454 {
 455         int reg_offset = dev_priv->gpio_mmio_base;
 456         u16 len = msg->len;
 457         u8 *buf = msg->buf;
 458         u32 val, loop;
 459
 460         val = loop = 0;
 461         while (len && loop < 4) {
 462                 val |= *buf++ << (8 * loop++);
 463                 len -= 1;
 464         }
 465
 466         I915_WRITE(GMBUS3 + reg_offset, val);
 467         I915_WRITE(GMBUS1 + reg_offset,
 468                    GMBUS_CYCLE_WAIT |
 469                    (msg->len << GMBUS_BYTE_COUNT_SHIFT) |
 470                    (msg->slave << (GMBUS_SLAVE_ADDR_SHIFT - 1)) |
 471                    GMBUS_SLAVE_WRITE | GMBUS_SW_RDY);
 472         while (len) {
 473                 int ret;
 474
 475                 val = loop = 0;
 476                 do {
 477                         val |= *buf++ << (8 * loop);
 478                 } while (--len && ++loop < 4);
 479
 480                 I915_WRITE(GMBUS3 + reg_offset, val);
 481
 482                 ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_RDY,
 483                                            GMBUS_HW_RDY_EN);
 484                 if (ret)
 485                         return ret;
 486         }
 487         return 0;
 488 }
 489
 490 /*
 491  * The gmbus controller can combine a 1 or 2 byte write with a read that
 492  * immediately follows it by using an "INDEX" cycle.
 493  */
 494 static bool
 495 gmbus_is_index_read(struct i2c_msg *msgs, int i, int num)
 496 {
 497         return (i + 1 < num &&
 498                 !(msgs[i].flags & I2C_M_RD) && msgs[i].len <= 2 &&
 499                 (msgs[i + 1].flags & I2C_M_RD));
 500 }
 501
 502 static int
 503 gmbus_xfer_index_read(struct drm_i915_private *dev_priv, struct i2c_msg *msgs)
 504 {
 505         int reg_offset = dev_priv->gpio_mmio_base;
 506         u32 gmbus1_index = 0;
 507         u32 gmbus5 = 0;
 508         int ret;
 509
 510         if (msgs[0].len == 2)
 511                 gmbus5 = GMBUS_2BYTE_INDEX_EN |
 512                          msgs[0].buf[1] | (msgs[0].buf[0] << 8);
 513         if (msgs[0].len == 1)
 514                 gmbus1_index = GMBUS_CYCLE_INDEX |
 515                                (msgs[0].buf[0] << GMBUS_SLAVE_INDEX_SHIFT);
 516
 517         /* GMBUS5 holds 16-bit index */
 518         if (gmbus5)
 519                 I915_WRITE(GMBUS5 + reg_offset, gmbus5);
 520
 521         ret = gmbus_xfer_read(dev_priv, &msgs[1], gmbus1_index);
 522
 523         /* Clear GMBUS5 after each index transfer */
 524         if (gmbus5)
 525                 I915_WRITE(GMBUS5 + reg_offset, 0);
 526
 527         return ret;
 528 }
 529
 530 static int
 531 gmbus_xfer(struct device *adapter,
 532            struct i2c_msg *msgs,
 533            int num)
 534 {
 535         struct intel_iic_softc *sc;
 536         struct drm_i915_private *dev_priv;
 537         int i, reg_offset, unit;
 538         int ret = 0;
 539
 540         sc = device_get_softc(adapter);
 541         dev_priv = sc->drm_dev->dev_private;
 542         unit = device_get_unit(adapter);
 543
 544         mutex_lock(&dev_priv->gmbus_mutex);
 545
 546         if (sc->force_bit_dev) {
 547                 ret = intel_i2c_quirk_xfer(dev_priv->bbbus[unit], msgs, num);
 548                 goto out;
 549         }
 550
 551         reg_offset = HAS_PCH_SPLIT(dev_priv->dev) ? PCH_GMBUS0 - GMBUS0 : 0;
 552
 553         I915_WRITE(GMBUS0 + reg_offset, sc->reg0);
 554
 555         for (i = 0; i < num; i++) {
 556                 if (gmbus_is_index_read(msgs, i, num)) {
 557                         ret = gmbus_xfer_index_read(dev_priv, &msgs[i]);
 558                         i += 1;  /* set i to the index of the read xfer */
 559                 } else if (msgs[i].flags & I2C_M_RD) {
 560                         ret = gmbus_xfer_read(dev_priv, &msgs[i], 0);
 561                 } else {
 562                         ret = gmbus_xfer_write(dev_priv, &msgs[i]);
 563                 }
 564
 565                 if (ret == -ETIMEDOUT)
 566                         goto timeout;
 567                 if (ret == -ENXIO)
 568                         goto clear_err;
 569
 570                 ret = gmbus_wait_hw_status(dev_priv, GMBUS_HW_WAIT_PHASE,
 571                                            GMBUS_HW_WAIT_EN);
 572                 if (ret == -ENXIO)
 573                         goto clear_err;
 574                 if (ret)
 575                         goto timeout;
 576         }
 577
 578         /* Generate a STOP condition on the bus. Note that gmbus can't generata
 579          * a STOP on the very first cycle. To simplify the code we
 580          * unconditionally generate the STOP condition with an additional gmbus
 581          * cycle. */
 582         I915_WRITE(GMBUS1 + reg_offset, GMBUS_CYCLE_STOP | GMBUS_SW_RDY);
 583
 584         /* Mark the GMBUS interface as disabled after waiting for idle.
 585          * We will re-enable it at the start of the next xfer,
 586          * till then let it sleep.
 587          */
 588         if (gmbus_wait_idle(dev_priv)) {
 589                 DRM_DEBUG_KMS("GMBUS [%s] timed out waiting for idle\n",
 590                          sc->name);
 591                 ret = -ETIMEDOUT;
 592         }
 593         I915_WRITE(GMBUS0 + reg_offset, 0);
 594         ret = ret ?: i;
 595         goto timeout;   /* XXX: should be out */
 596
 597 clear_err:
 598         /*
 599          * Wait for bus to IDLE before clearing NAK.
 600          * If we clear the NAK while bus is still active, then it will stay
 601          * active and the next transaction may fail.
 602          *
 603          * If no ACK is received during the address phase of a transaction, the
 604          * adapter must report -ENXIO. It is not clear what to return if no ACK
 605          * is received at other times. But we have to be careful to not return
 606          * spurious -ENXIO because that will prevent i2c and drm edid functions
 607          * from retrying. So return -ENXIO only when gmbus properly quiescents -
 608          * timing out seems to happen when there _is_ a ddc chip present, but
 609          * it's slow responding and only answers on the 2nd retry.
 610          */
 611         ret = -ENXIO;
 612         if (gmbus_wait_idle(dev_priv)) {
 613                 DRM_DEBUG_KMS("GMBUS [%s] timed out after NAK\n",
 614                               sc->name);
 615                 ret = -ETIMEDOUT;
 616         }
 617
 618         /* Toggle the Software Clear Interrupt bit. This has the effect
 619          * of resetting the GMBUS controller and so clearing the
 620          * BUS_ERROR raised by the slave's NAK.
 621          */
 622         I915_WRITE(GMBUS1 + reg_offset, GMBUS_SW_CLR_INT);
 623         I915_WRITE(GMBUS1 + reg_offset, 0);
 624         I915_WRITE(GMBUS0 + reg_offset, 0);
 625
 626         DRM_DEBUG_KMS("GMBUS [%s] NAK for addr: %04x %c(%d)\n",
 627                          sc->name, msgs[i].slave,
 628                          (msgs[i].flags & I2C_M_RD) ? 'r' : 'w', msgs[i].len);
 629
 630         goto out;
 631
 632 timeout:
 633         DRM_INFO("GMBUS [%s] timed out, falling back to bit banging on pin %d\n",
 634                  sc->name, sc->reg0 & 0xff);
 635         I915_WRITE(GMBUS0 + reg_offset, 0);
 636
 637         /* Hardware may not support GMBUS over these pins? Try GPIO bitbanging instead. */
 638         sc->force_bit_dev = true;
 639         ret = intel_i2c_quirk_xfer(dev_priv->bbbus[unit], msgs, num);
 640
 641 out:
 642         mutex_unlock(&dev_priv->gmbus_mutex);
 643         return ret;
 644 }
 645
 646 struct device *intel_gmbus_get_adapter(struct drm_i915_private *dev_priv,
 647                                             unsigned port)
 648 {
 649         WARN_ON(!intel_gmbus_is_port_valid(port));
 650         /* -1 to map pin pair to gmbus index */
 651         return (intel_gmbus_is_port_valid(port)) ?
 652                 dev_priv->gmbus[port-1] : NULL;
 653 }
 654
 655 void
 656 intel_gmbus_set_speed(device_t idev, int speed)
 657 {
 658         struct intel_iic_softc *sc;
 659
 660         sc = device_get_softc(device_get_parent(idev));
 661
 662         sc->reg0 = (sc->reg0 & ~(0x3 << 8)) | speed;
 663 }
 664
 665 void
 666 intel_gmbus_force_bit(device_t idev, bool force_bit)
 667 {
 668         struct intel_iic_softc *sc;
 669
 670         sc = device_get_softc(device_get_parent(idev));
 671         sc->force_bit_dev += force_bit ? 1 : -1;
 672         DRM_DEBUG_KMS("%sabling bit-banging on %s. force bit now %d\n",
 673                       force_bit ? "en" : "dis", sc->name,
 674                       sc->force_bit_dev);
 675 }
 676
 677 static int
 678 intel_gmbus_probe(device_t dev)
 679 {
 680
 681         return (BUS_PROBE_SPECIFIC);
 682 }
 683
 684 static int
 685 intel_gmbus_attach(device_t idev)
 686 {
 687         struct drm_i915_private *dev_priv;
 688         struct intel_iic_softc *sc;
 689         int pin;
 690
 691         sc = device_get_softc(idev);
 692         sc->drm_dev = device_get_softc(device_get_parent(idev));
 693         dev_priv = sc->drm_dev->dev_private;
 694         pin = device_get_unit(idev);
 695
 696         ksnprintf(sc->name, sizeof(sc->name), "gmbus bus %s", gpio_names[pin]);
 697         device_set_desc(idev, sc->name);
 698
 699         /* By default use a conservative clock rate */
 700         sc->reg0 = (pin + 1) | GMBUS_RATE_100KHZ;
 701
 702         /* XXX force bit banging until GMBUS is fully debugged */
 703         if (IS_GEN2(sc->drm_dev)) {
 704                 sc->force_bit_dev = true;
 705         }
 706
 707         /* add bus interface device */
 708         sc->iic_dev = device_add_child(idev, "iicbus", -1);
 709         if (sc->iic_dev == NULL)
 710                 return (ENXIO);
 711         device_quiet(sc->iic_dev);
 712         bus_generic_attach(idev);
 713
 714         return (0);
 715 }
 716
 717 static int
 718 intel_gmbus_detach(device_t idev)
 719 {
 720         struct intel_iic_softc *sc;
 721         struct drm_i915_private *dev_priv;
 722         device_t child;
 723         int u;
 724
 725         sc = device_get_softc(idev);
 726         u = device_get_unit(idev);
 727         dev_priv = sc->drm_dev->dev_private;
 728
 729         child = sc->iic_dev;
 730         bus_generic_detach(idev);
 731         if (child != NULL)
 732                 device_delete_child(idev, child);
 733
 734         return (0);
 735 }
 736
 737 static int
 738 intel_iicbb_probe(device_t dev)
 739 {
 740
 741         return (BUS_PROBE_DEFAULT);
 742 }
 743
 744 static int
 745 intel_iicbb_detach(device_t idev)
 746 {
 747         struct intel_iic_softc *sc;
 748         device_t child;
 749
 750         sc = device_get_softc(idev);
 751         child = sc->iic_dev;
 752         bus_generic_detach(idev);
 753         if (child)
 754                 device_delete_child(idev, child);
 755         return (0);
 756 }
 757
 758 static device_method_t intel_gmbus_methods[] = {
 759         DEVMETHOD(device_probe,         intel_gmbus_probe),
 760         DEVMETHOD(device_attach,        intel_gmbus_attach),
 761         DEVMETHOD(device_detach,        intel_gmbus_detach),
 762         DEVMETHOD(iicbus_reset,         intel_iicbus_reset),
 763         DEVMETHOD(iicbus_transfer,      gmbus_xfer),
 764         DEVMETHOD_END
 765 };
 766 static driver_t intel_gmbus_driver = {
 767         "intel_gmbus",
 768         intel_gmbus_methods,
 769         sizeof(struct intel_iic_softc)
 770 };
 771 static devclass_t intel_gmbus_devclass;
 772 DRIVER_MODULE_ORDERED(intel_gmbus, drm, intel_gmbus_driver,
 773     intel_gmbus_devclass, 0, 0, SI_ORDER_FIRST);
 774 DRIVER_MODULE(iicbus, intel_gmbus, iicbus_driver, iicbus_devclass, NULL, NULL);
 775
 776 static device_method_t intel_iicbb_methods[] =  {
 777         DEVMETHOD(device_probe,         intel_iicbb_probe),
 778         DEVMETHOD(device_attach,        intel_gpio_setup),
 779         DEVMETHOD(device_detach,        intel_iicbb_detach),
 780
 781         DEVMETHOD(bus_add_child,        bus_generic_add_child),
 782         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 783
 784         DEVMETHOD(iicbb_callback,       iicbus_null_callback),
 785         DEVMETHOD(iicbb_reset,          intel_iicbus_reset),
 786         DEVMETHOD(iicbb_setsda,         set_data),
 787         DEVMETHOD(iicbb_setscl,         set_clock),
 788         DEVMETHOD(iicbb_getsda,         get_data),
 789         DEVMETHOD(iicbb_getscl,         get_clock),
 790         DEVMETHOD_END
 791 };
 792 static driver_t intel_iicbb_driver = {
 793         "intel_iicbb",
 794         intel_iicbb_methods,
 795         sizeof(struct intel_iic_softc)
 796 };
 797 static devclass_t intel_iicbb_devclass;
 798 DRIVER_MODULE_ORDERED(intel_iicbb, drm, intel_iicbb_driver,
 799     intel_iicbb_devclass, 0, 0, SI_ORDER_FIRST);
 800 DRIVER_MODULE(iicbb, intel_iicbb, iicbb_driver, iicbb_devclass, NULL, NULL);
 801
 802 static void intel_teardown_gmbus_m(struct drm_device *dev, int m);
 803
 804 int
 805 intel_setup_gmbus(struct drm_device *dev)
 806 {
 807         struct drm_i915_private *dev_priv = dev->dev_private;
 808         device_t iic_dev;
 809         int i, ret;
 810
 811         if (HAS_PCH_NOP(dev))
 812                 return 0;
 813         else if (HAS_PCH_SPLIT(dev))
 814                 dev_priv->gpio_mmio_base = PCH_GPIOA - GPIOA;
 815         else if (IS_VALLEYVIEW(dev))
 816                 dev_priv->gpio_mmio_base = VLV_DISPLAY_BASE;
 817         else
 818                 dev_priv->gpio_mmio_base = 0;
 819
 820         lockinit(&dev_priv->gmbus_mutex, "gmbus", 0, LK_CANRECURSE);
 821         init_waitqueue_head(&dev_priv->gmbus_wait_queue);
 822
 823         dev_priv->gmbus_bridge = kmalloc(sizeof(device_t) * GMBUS_NUM_PORTS,
 824             M_DRM, M_WAITOK | M_ZERO);
 825         dev_priv->bbbus_bridge = kmalloc(sizeof(device_t) * GMBUS_NUM_PORTS,
 826             M_DRM, M_WAITOK | M_ZERO);
 827         dev_priv->gmbus = kmalloc(sizeof(device_t) * GMBUS_NUM_PORTS,
 828             M_DRM, M_WAITOK | M_ZERO);
 829         dev_priv->bbbus = kmalloc(sizeof(device_t) * GMBUS_NUM_PORTS,
 830             M_DRM, M_WAITOK | M_ZERO);
 831
 832         for (i = 0; i < GMBUS_NUM_PORTS; i++) {
 833                 /*
 834                  * Initialized bbbus_bridge before gmbus_bridge, since
 835                  * gmbus may decide to force quirk transfer in the
 836                  * attachment code.
 837                  */
 838                 dev_priv->bbbus_bridge[i] = device_add_child(dev->dev,
 839                     "intel_iicbb", i);
 840                 if (dev_priv->bbbus_bridge[i] == NULL) {
 841                         DRM_ERROR("bbbus bridge %d creation failed\n", i);
 842                         ret = ENXIO;
 843                         goto err;
 844                 }
 845                 device_quiet(dev_priv->bbbus_bridge[i]);
 846                 ret = device_probe_and_attach(dev_priv->bbbus_bridge[i]);
 847                 if (ret != 0) {
 848                         DRM_ERROR("bbbus bridge %d attach failed, %d\n", i,
 849                             ret);
 850                         goto err;
 851                 }
 852
 853                 iic_dev = device_find_child(dev_priv->bbbus_bridge[i], "iicbb",
 854                     -1);
 855                 if (iic_dev == NULL) {
 856                         DRM_ERROR("bbbus bridge doesn't have iicbb child\n");
 857                         goto err;
 858                 }
 859                 iic_dev = device_find_child(iic_dev, "iicbus", -1);
 860                 if (iic_dev == NULL) {
 861                         DRM_ERROR(
 862                 "bbbus bridge doesn't have iicbus grandchild\n");
 863                         goto err;
 864                 }
 865
 866                 dev_priv->bbbus[i] = iic_dev;
 867
 868                 dev_priv->gmbus_bridge[i] = device_add_child(dev->dev,
 869                     "intel_gmbus", i);
 870                 if (dev_priv->gmbus_bridge[i] == NULL) {
 871                         DRM_ERROR("gmbus bridge %d creation failed\n", i);
 872                         ret = ENXIO;
 873                         goto err;
 874                 }
 875                 device_quiet(dev_priv->gmbus_bridge[i]);
 876                 ret = device_probe_and_attach(dev_priv->gmbus_bridge[i]);
 877                 if (ret != 0) {
 878                         DRM_ERROR("gmbus bridge %d attach failed, %d\n", i,
 879                             ret);
 880                         ret = ENXIO;
 881                         goto err;
 882                 }
 883
 884                 iic_dev = device_find_child(dev_priv->gmbus_bridge[i],
 885                     "iicbus", -1);
 886                 if (iic_dev == NULL) {
 887                         DRM_ERROR("gmbus bridge doesn't have iicbus child\n");
 888                         goto err;
 889                 }
 890                 dev_priv->gmbus[i] = iic_dev;
 891
 892                 intel_i2c_reset(dev);
 893         }
 894
 895         return (0);
 896
 897 err:
 898         intel_teardown_gmbus_m(dev, i);
 899         return (ret);
 900 }
 901
 902 static void
 903 intel_teardown_gmbus_m(struct drm_device *dev, int m)
 904 {
 905         struct drm_i915_private *dev_priv;
 906
 907         dev_priv = dev->dev_private;
 908
 909         drm_free(dev_priv->gmbus, M_DRM);
 910         dev_priv->gmbus = NULL;
 911         drm_free(dev_priv->bbbus, M_DRM);
 912         dev_priv->bbbus = NULL;
 913         drm_free(dev_priv->gmbus_bridge, M_DRM);
 914         dev_priv->gmbus_bridge = NULL;
 915         drm_free(dev_priv->bbbus_bridge, M_DRM);
 916         dev_priv->bbbus_bridge = NULL;
 917         lockuninit(&dev_priv->gmbus_mutex);
 918 }
 919
 920 void
 921 intel_teardown_gmbus(struct drm_device *dev)
 922 {
 923
 924         get_mplock();
 925         intel_teardown_gmbus_m(dev, GMBUS_NUM_PORTS);
 926         rel_mplock();
 927 }