sys/bus/smbus/ichiic/ig4_iic.c

   1 /*
   2  * Copyright (c) 2014 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 /*
  35  * Intel 4th generation mobile cpus integrated I2C device, smbus driver.
  36  *
  37  * See ig4_reg.h for datasheet reference and notes.
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/kernel.h>
  43 #include <sys/module.h>
  44 #include <sys/errno.h>
  45 #include <sys/lock.h>
  46 #include <sys/syslog.h>
  47 #include <sys/bus.h>
  48 #include <sys/sysctl.h>
  49
  50 #include <sys/rman.h>
  51
  52 #include <bus/pci/pcivar.h>
  53 #include <bus/pci/pcireg.h>
  54 #include <bus/smbus/smbconf.h>
  55
  56 #include "smbus_if.h"
  57
  58 #include "ig4_reg.h"
  59 #include "ig4_var.h"
  60
  61 #define TRANS_NORMAL    1
  62 #define TRANS_PCALL     2
  63 #define TRANS_BLOCK     3
  64
  65 static void ig4iic_intr(void *cookie);
  66 static void ig4iic_dump(ig4iic_softc_t *sc);
  67
  68 static int ig4_dump;
  69 SYSCTL_INT(_debug, OID_AUTO, ig4_dump, CTLTYPE_INT | CTLFLAG_RW,
  70            &ig4_dump, 0, "");
  71
  72 /*
  73  * Low-level inline support functions
  74  */
  75 static __inline
  76 void
  77 reg_write(ig4iic_softc_t *sc, uint32_t reg, uint32_t value)
  78 {
  79         bus_space_write_4(sc->regs_t, sc->regs_h, reg, value);
  80         bus_space_barrier(sc->regs_t, sc->regs_h, reg, 4,
  81                           BUS_SPACE_BARRIER_WRITE);
  82 }
  83
  84 static __inline
  85 uint32_t
  86 reg_read(ig4iic_softc_t *sc, uint32_t reg)
  87 {
  88         uint32_t value;
  89
  90         bus_space_barrier(sc->regs_t, sc->regs_h, reg, 4,
  91                           BUS_SPACE_BARRIER_READ);
  92         value = bus_space_read_4(sc->regs_t, sc->regs_h, reg);
  93         return value;
  94 }
  95
  96 /*
  97  * Enable or disable the controller and wait for the controller to acknowledge
  98  * the state change.
  99  */
 100 static
 101 int
 102 set_controller(ig4iic_softc_t *sc, uint32_t ctl)
 103 {
 104         int retry;
 105         int error;
 106         uint32_t v;
 107
 108         if (ctl & IG4_I2C_ENABLE) {
 109                 reg_write(sc, IG4_REG_INTR_MASK, IG4_INTR_STOP_DET |
 110                                                  IG4_INTR_RX_FULL);
 111                 reg_read(sc, IG4_REG_CLR_INTR);
 112         } else {
 113                 reg_write(sc, IG4_REG_INTR_MASK, 0);
 114         }
 115         reg_write(sc, IG4_REG_I2C_EN, ctl);
 116         error = SMB_ETIMEOUT;
 117
 118         for (retry = 100; retry > 0; --retry) {
 119                 v = reg_read(sc, IG4_REG_ENABLE_STATUS);
 120                 if (((v ^ ctl) & IG4_I2C_ENABLE) == 0) {
 121                         error = 0;
 122                         break;
 123                 }
 124                 tsleep(sc, 0, "i2cslv", 1);
 125         }
 126         return error;
 127 }
 128
 129 /*
 130  * Wait up to 25ms for the requested status using a 25uS polling loop.
 131  */
 132 static
 133 int
 134 wait_status(ig4iic_softc_t *sc, uint32_t status)
 135 {
 136         uint32_t v;
 137         int error;
 138         int txlvl = -1;
 139         sysclock_t count;
 140         sysclock_t limit;
 141
 142         error = SMB_ETIMEOUT;
 143         count = sys_cputimer->count();
 144         limit = sys_cputimer->freq / 40;
 145
 146         for (;;) {
 147                 /*
 148                  * Check requested status
 149                  */
 150                 v = reg_read(sc, IG4_REG_I2C_STA);
 151                 if (v & status) {
 152                         error = 0;
 153                         break;
 154                 }
 155
 156                 /*
 157                  * When waiting for receive data break-out if the interrupt
 158                  * loaded data into the FIFO.
 159                  */
 160                 if (status & IG4_STATUS_RX_NOTEMPTY) {
 161                         if (sc->rpos != sc->rnext) {
 162                                 error = 0;
 163                                 break;
 164                         }
 165                 }
 166
 167                 /*
 168                  * When waiting for the transmit FIFO to become empty,
 169                  * reset the timeout if we see a change in the transmit
 170                  * FIFO level as progress is being made.
 171                  */
 172                 if (status & IG4_STATUS_TX_EMPTY) {
 173                         v = reg_read(sc, IG4_REG_TXFLR) & IG4_FIFOLVL_MASK;
 174                         if (txlvl != v) {
 175                                 txlvl = v;
 176                                 count = sys_cputimer->count();
 177                         }
 178                 }
 179
 180                 /*
 181                  * Stop if we've run out of time.
 182                  */
 183                 if (sys_cputimer->count() - count > limit)
 184                         break;
 185
 186                 /*
 187                  * When waiting for receive data let the interrupt do its
 188                  * work, otherwise poll with the lock held.
 189                  */
 190                 if (status & IG4_STATUS_RX_NOTEMPTY) {
 191                         lksleep(sc, &sc->lk, 0, "i2cwait", (hz + 99) / 100);
 192                 } else {
 193                         DELAY(25);
 194                 }
 195         }
 196
 197         return error;
 198 }
 199
 200 /*
 201  * Read I2C data.  The data might have already been read by
 202  * the interrupt code, otherwise it is sitting in the data
 203  * register.
 204  */
 205 static
 206 uint8_t
 207 data_read(ig4iic_softc_t *sc)
 208 {
 209         uint8_t c;
 210
 211         if (sc->rpos == sc->rnext) {
 212                 c = (uint8_t)reg_read(sc, IG4_REG_DATA_CMD);
 213         } else {
 214                 c = sc->rbuf[sc->rpos & IG4_RBUFMASK];
 215                 ++sc->rpos;
 216         }
 217         return c;
 218 }
 219
 220 /*
 221  * Set the slave address.  The controller must be disabled when
 222  * changing the address.
 223  *
 224  * This operation does not issue anything to the I2C bus but sets
 225  * the target address for when the controller later issues a START.
 226  */
 227 static
 228 void
 229 set_slave_addr(ig4iic_softc_t *sc, uint8_t slave, int trans_op)
 230 {
 231         uint32_t tar;
 232         uint32_t ctl;
 233         int use_10bit;
 234
 235         use_10bit = sc->use_10bit;
 236         if (trans_op & SMB_TRANS_7BIT)
 237                 use_10bit = 0;
 238         if (trans_op & SMB_TRANS_10BIT)
 239                 use_10bit = 1;
 240
 241         if (sc->slave_valid && sc->last_slave == slave &&
 242             sc->use_10bit == use_10bit) {
 243                 return;
 244         }
 245         sc->use_10bit = use_10bit;
 246
 247         /*
 248          * Wait for TXFIFO to drain before disabling the controller.
 249          *
 250          * If a write message has not been completed it's really a
 251          * programming error, but for now in that case issue an extra
 252          * byte + STOP.
 253          *
 254          * If a read message has not been completed it's also a programming
 255          * error, for now just ignore it.
 256          */
 257         wait_status(sc, IG4_STATUS_TX_NOTFULL);
 258         if (sc->write_started) {
 259                 reg_write(sc, IG4_REG_DATA_CMD, IG4_DATA_STOP);
 260                 sc->write_started = 0;
 261         }
 262         if (sc->read_started)
 263                 sc->read_started = 0;
 264         wait_status(sc, IG4_STATUS_TX_EMPTY);
 265
 266         set_controller(sc, 0);
 267         ctl = reg_read(sc, IG4_REG_CTL);
 268         ctl &= ~IG4_CTL_10BIT;
 269         ctl |= IG4_CTL_RESTARTEN;
 270
 271         tar = slave;
 272         if (sc->use_10bit) {
 273                 tar |= IG4_TAR_10BIT;
 274                 ctl |= IG4_CTL_10BIT;
 275         }
 276         reg_write(sc, IG4_REG_CTL, ctl);
 277         reg_write(sc, IG4_REG_TAR_ADD, tar);
 278         set_controller(sc, IG4_I2C_ENABLE);
 279         sc->slave_valid = 1;
 280         sc->last_slave = slave;
 281 }
 282
 283 /*
 284  * Issue START with byte command, possible count, and a variable length
 285  * read or write buffer, then possible turn-around read.  The read also
 286  * has a possible count received.
 287  *
 288  * For SMBUS -
 289  *
 290  * Quick:               START+ADDR+RD/WR STOP
 291  *
 292  * Normal:              START+ADDR+WR CMD DATA..DATA STOP
 293  *
 294  *                      START+ADDR+RD CMD
 295  *                      RESTART+ADDR RDATA..RDATA STOP
 296  *                      (can also be used for I2C transactions)
 297  *
 298  * Process Call:        START+ADDR+WR CMD DATAL DATAH
 299  *                      RESTART+ADDR+RD RDATAL RDATAH STOP
 300  *
 301  * Block:               START+ADDR+RD CMD
 302  *                      RESTART+ADDR+RD RCOUNT DATA... STOP
 303  *
 304  *                      START+ADDR+WR CMD
 305  *                      RESTART+ADDR+WR WCOUNT DATA... STOP
 306  *
 307  * For I2C - basically, no *COUNT fields, possibly no *CMD field.  If the
 308  *           sender needs to issue a 2-byte command it will incorporate it
 309  *           into the write buffer and also set NOCMD.
 310  *
 311  * Generally speaking, the START+ADDR / RESTART+ADDR is handled automatically
 312  * by the controller at the beginning of a command sequence or on a data
 313  * direction turn-around, and we only need to tell it when to issue the STOP.
 314  */
 315 static int
 316 smb_transaction(ig4iic_softc_t *sc, char cmd, int op,
 317                 char *wbuf, int wcount, char *rbuf, int rcount, int *actualp)
 318 {
 319         int error;
 320         int unit;
 321         uint32_t last;
 322
 323         /*
 324          * Debugging - dump registers
 325          */
 326         if (ig4_dump) {
 327                 unit = device_get_unit(sc->dev);
 328                 if (ig4_dump & (1 << unit)) {
 329                         ig4_dump &= ~(1 << unit);
 330                         ig4iic_dump(sc);
 331                 }
 332         }
 333
 334         /*
 335          * Issue START or RESTART with next data byte, clear any previous
 336          * abort condition that may have been holding the txfifo in reset.
 337          */
 338         last = IG4_DATA_RESTART;
 339         reg_read(sc, IG4_REG_CLR_TX_ABORT);
 340         if (actualp)
 341                 *actualp = 0;
 342
 343         /*
 344          * Issue command if not told otherwise (smbus).
 345          */
 346         if ((op & SMB_TRANS_NOCMD) == 0) {
 347                 error = wait_status(sc, IG4_STATUS_TX_NOTFULL);
 348                 if (error)
 349                         goto done;
 350                 last |= (u_char)cmd;
 351                 if (wcount == 0 && rcount == 0 && (op & SMB_TRANS_NOSTOP) == 0)
 352                         last |= IG4_DATA_STOP;
 353                 reg_write(sc, IG4_REG_DATA_CMD, last);
 354                 last = 0;
 355         }
 356
 357         /*
 358          * Clean out any previously received data.
 359          */
 360         if (sc->rpos != sc->rnext &&
 361             (op & SMB_TRANS_NOREPORT) == 0) {
 362                 device_printf(sc->dev,
 363                               "discarding %d bytes of spurious data\n",
 364                               sc->rnext - sc->rpos);
 365         }
 366         sc->rpos = 0;
 367         sc->rnext = 0;
 368
 369         /*
 370          * If writing and not told otherwise, issue the write count (smbus).
 371          */
 372         if (wcount && (op & SMB_TRANS_NOCNT) == 0) {
 373                 error = wait_status(sc, IG4_STATUS_TX_NOTFULL);
 374                 if (error)
 375                         goto done;
 376                 last |= (u_char)cmd;
 377                 reg_write(sc, IG4_REG_DATA_CMD, last);
 378                 last = 0;
 379         }
 380
 381         /*
 382          * Bulk write (i2c)
 383          */
 384         while (wcount) {
 385                 error = wait_status(sc, IG4_STATUS_TX_NOTFULL);
 386                 if (error)
 387                         goto done;
 388                 last |= (u_char)*wbuf;
 389                 if (wcount == 1 && rcount == 0 && (op & SMB_TRANS_NOSTOP) == 0)
 390                         last |= IG4_DATA_STOP;
 391                 reg_write(sc, IG4_REG_DATA_CMD, last);
 392                 --wcount;
 393                 ++wbuf;
 394                 last = 0;
 395         }
 396
 397         /*
 398          * Issue reads to xmit FIFO (strange, I know) to tell the controller
 399          * to clock in data.  At the moment just issue one read ahead to
 400          * pipeline the incoming data.
 401          *
 402          * NOTE: In the case of NOCMD and wcount == 0 we still issue a
 403          *       RESTART here, even if the data direction has not changed
 404          *       from the previous CHAINing call.  This we force the RESTART.
 405          *       (A new START is issued automatically by the controller in
 406          *       the other nominal cases such as a data direction change or
 407          *       a previous STOP was issued).
 408          *
 409          * If this will be the last byte read we must also issue the STOP
 410          * at the end of the read.
 411          */
 412         if (rcount) {
 413                 last = IG4_DATA_RESTART | IG4_DATA_COMMAND_RD;
 414                 if (rcount == 1 &&
 415                     (op & (SMB_TRANS_NOSTOP | SMB_TRANS_NOCNT)) ==
 416                     SMB_TRANS_NOCNT) {
 417                         last |= IG4_DATA_STOP;
 418                 }
 419                 reg_write(sc, IG4_REG_DATA_CMD, last);
 420                 last = IG4_DATA_COMMAND_RD;
 421         }
 422
 423         /*
 424          * Bulk read (i2c) and count field handling (smbus)
 425          */
 426         while (rcount) {
 427                 /*
 428                  * Maintain a pipeline by queueing the allowance for the next
 429                  * read before waiting for the current read.
 430                  */
 431                 if (rcount > 1) {
 432                         if (op & SMB_TRANS_NOCNT)
 433                                 last = (rcount == 2) ? IG4_DATA_STOP : 0;
 434                         else
 435                                 last = 0;
 436                         reg_write(sc, IG4_REG_DATA_CMD, IG4_DATA_COMMAND_RD |
 437                                                         last);
 438                 }
 439                 error = wait_status(sc, IG4_STATUS_RX_NOTEMPTY);
 440                 if (error) {
 441                         if ((op & SMB_TRANS_NOREPORT) == 0) {
 442                                 device_printf(sc->dev,
 443                                               "rx timeout addr 0x%02x\n",
 444                                               sc->last_slave);
 445                         }
 446                         goto done;
 447                 }
 448                 last = data_read(sc);
 449
 450                 if (op & SMB_TRANS_NOCNT) {
 451                         *rbuf = (u_char)last;
 452                         ++rbuf;
 453                         --rcount;
 454                         if (actualp)
 455                                 ++*actualp;
 456                 } else {
 457                         /*
 458                          * Handle count field (smbus), which is not part of
 459                          * the rcount'ed buffer.  The first read data in a
 460                          * bulk transfer is the count.
 461                          *
 462                          * XXX if rcount is loaded as 0 how do I generate a
 463                          *     STOP now without issuing another RD or WR?
 464                          */
 465                         if (rcount > (u_char)last)
 466                                 rcount = (u_char)last;
 467                         op |= SMB_TRANS_NOCNT;
 468                 }
 469         }
 470         error = 0;
 471 done:
 472         /* XXX wait for xmit buffer to become empty */
 473         last = reg_read(sc, IG4_REG_TX_ABRT_SOURCE);
 474
 475         return error;
 476 }
 477
 478 /*
 479  *                              SMBUS API FUNCTIONS
 480  *
 481  * Called from ig4iic_pci_attach/detach()
 482  */
 483 int
 484 ig4iic_attach(ig4iic_softc_t *sc)
 485 {
 486         int error;
 487         uint32_t v;
 488
 489         lockmgr(&sc->lk, LK_EXCLUSIVE);
 490
 491         v = reg_read(sc, IG4_REG_COMP_TYPE);
 492         kprintf("type %08x", v);
 493         v = reg_read(sc, IG4_REG_COMP_PARAM1);
 494         kprintf(" params %08x", v);
 495         v = reg_read(sc, IG4_REG_GENERAL);
 496         kprintf(" general %08x", v);
 497         if ((v & IG4_GENERAL_SWMODE) == 0) {
 498                 v |= IG4_GENERAL_SWMODE;
 499                 reg_write(sc, IG4_REG_GENERAL, v);
 500                 v = reg_read(sc, IG4_REG_GENERAL);
 501                 kprintf(" (updated %08x)", v);
 502         }
 503
 504         v = reg_read(sc, IG4_REG_SW_LTR_VALUE);
 505         kprintf(" swltr %08x", v);
 506         v = reg_read(sc, IG4_REG_AUTO_LTR_VALUE);
 507         kprintf(" autoltr %08x", v);
 508
 509         v = reg_read(sc, IG4_REG_COMP_VER);
 510         kprintf(" version %08x\n", v);
 511         if (v != IG4_COMP_VER) {
 512                 error = ENXIO;
 513                 goto done;
 514         }
 515 #if 1
 516         v = reg_read(sc, IG4_REG_SS_SCL_HCNT);
 517         kprintf("SS_SCL_HCNT=%08x", v);
 518         v = reg_read(sc, IG4_REG_SS_SCL_LCNT);
 519         kprintf(" LCNT=%08x", v);
 520         v = reg_read(sc, IG4_REG_FS_SCL_HCNT);
 521         kprintf(" FS_SCL_HCNT=%08x", v);
 522         v = reg_read(sc, IG4_REG_FS_SCL_LCNT);
 523         kprintf(" LCNT=%08x\n", v);
 524         v = reg_read(sc, IG4_REG_SDA_HOLD);
 525         kprintf("HOLD        %08x\n", v);
 526
 527         v = reg_read(sc, IG4_REG_SS_SCL_HCNT);
 528         reg_write(sc, IG4_REG_FS_SCL_HCNT, v);
 529         v = reg_read(sc, IG4_REG_SS_SCL_LCNT);
 530         reg_write(sc, IG4_REG_FS_SCL_LCNT, v);
 531 #endif
 532         /*
 533          * Program based on a 25000 Hz clock.  This is a bit of a
 534          * hack (obviously).  The defaults are 400 and 470 for standard
 535          * and 60 and 130 for fast.  The defaults for standard fail
 536          * utterly (presumably cause an abort) because the clock time
 537          * is ~18.8ms by default.  This brings it down to ~4ms (for now).
 538          */
 539         reg_write(sc, IG4_REG_SS_SCL_HCNT, 100);
 540         reg_write(sc, IG4_REG_SS_SCL_LCNT, 125);
 541         reg_write(sc, IG4_REG_FS_SCL_HCNT, 100);
 542         reg_write(sc, IG4_REG_FS_SCL_LCNT, 125);
 543
 544         /*
 545          * Use a threshold of 1 so we get interrupted on each character,
 546          * allowing us to use lksleep() in our poll code.  Not perfect
 547          * but this is better than using DELAY() for receiving data.
 548          */
 549         reg_write(sc, IG4_REG_RX_TL, 1);
 550
 551         reg_write(sc, IG4_REG_CTL,
 552                   IG4_CTL_MASTER |
 553                   IG4_CTL_SLAVE_DISABLE |
 554                   IG4_CTL_RESTARTEN |
 555                   IG4_CTL_SPEED_STD);
 556         /*
 557          * When ig4 is attached via ACPI, (child) devices should access the
 558          * smbus via I2cSerialBus ACPI resources instead.
 559          */
 560         if (strcmp("acpi", device_get_name(device_get_parent(sc->dev))) != 0) {
 561                 sc->smb = device_add_child(sc->dev, "smbus", -1);
 562                 if (sc->smb == NULL) {
 563                         device_printf(sc->dev, "smbus driver not found\n");
 564                         error = ENXIO;
 565                         goto done;
 566                 }
 567         }
 568
 569         sc->acpismb = device_add_child(sc->dev, "smbacpi", -1);
 570         if (sc->acpismb == NULL) {
 571                 device_printf(sc->dev, "smbacpi driver not found\n");
 572                 if (sc->smb == NULL) {
 573                         error = ENXIO;
 574                         goto done;
 575                 }
 576         }
 577
 578 #if 0
 579         /*
 580          * Don't do this, it blows up the PCI config
 581          */
 582         reg_write(sc, IG4_REG_RESETS, IG4_RESETS_ASSERT);
 583         reg_write(sc, IG4_REG_RESETS, IG4_RESETS_DEASSERT);
 584 #endif
 585
 586         /*
 587          * Interrupt on STOP detect or receive character ready
 588          */
 589         if (set_controller(sc, 0))
 590                 device_printf(sc->dev, "controller error during attach-1\n");
 591         if (set_controller(sc, IG4_I2C_ENABLE))
 592                 device_printf(sc->dev, "controller error during attach-2\n");
 593         error = bus_setup_intr(sc->dev, sc->intr_res, 0,
 594                                ig4iic_intr, sc, &sc->intr_handle, NULL);
 595         if (error) {
 596                 device_printf(sc->dev,
 597                               "Unable to setup irq: error %d\n", error);
 598                 goto done;
 599         }
 600
 601         /* Attach us to the smbus */
 602         lockmgr(&sc->lk, LK_RELEASE);
 603         error = bus_generic_attach(sc->dev);
 604         lockmgr(&sc->lk, LK_EXCLUSIVE);
 605         if (error) {
 606                 device_printf(sc->dev,
 607                               "failed to attach child: error %d\n", error);
 608                 goto done;
 609         }
 610         sc->generic_attached = 1;
 611
 612 done:
 613         lockmgr(&sc->lk, LK_RELEASE);
 614         return error;
 615 }
 616
 617 int
 618 ig4iic_detach(ig4iic_softc_t *sc)
 619 {
 620         int error;
 621
 622         lockmgr(&sc->lk, LK_EXCLUSIVE);
 623
 624         reg_write(sc, IG4_REG_INTR_MASK, 0);
 625         set_controller(sc, 0);
 626
 627         if (sc->generic_attached) {
 628                 error = bus_generic_detach(sc->dev);
 629                 if (error)
 630                         goto done;
 631                 sc->generic_attached = 0;
 632         }
 633         if (sc->smb) {
 634                 device_delete_child(sc->dev, sc->smb);
 635                 sc->smb = NULL;
 636         }
 637         if (sc->acpismb) {
 638                 device_delete_child(sc->dev, sc->acpismb);
 639                 sc->acpismb = NULL;
 640         }
 641         if (sc->intr_handle) {
 642                 bus_teardown_intr(sc->dev, sc->intr_res, sc->intr_handle);
 643                 sc->intr_handle = NULL;
 644         }
 645
 646         error = 0;
 647 done:
 648         lockmgr(&sc->lk, LK_RELEASE);
 649         return error;
 650 }
 651
 652 int
 653 ig4iic_smb_callback(device_t dev, int index, void *data)
 654 {
 655         ig4iic_softc_t *sc = device_get_softc(dev);
 656         int error;
 657
 658         lockmgr(&sc->lk, LK_EXCLUSIVE);
 659
 660         switch (index) {
 661         case SMB_REQUEST_BUS:
 662                 error = 0;
 663                 break;
 664         case SMB_RELEASE_BUS:
 665                 error = 0;
 666                 break;
 667         default:
 668                 error = SMB_EABORT;
 669                 break;
 670         }
 671
 672         lockmgr(&sc->lk, LK_RELEASE);
 673
 674         return error;
 675 }
 676
 677 /*
 678  * Quick command.  i.e. START + cmd + R/W + STOP and no data.  It is
 679  * unclear to me how I could implement this with the intel i2c controller
 680  * because the controler sends STARTs and STOPs automatically with data.
 681  */
 682 int
 683 ig4iic_smb_quick(device_t dev, u_char slave, int how)
 684 {
 685         ig4iic_softc_t *sc = device_get_softc(dev);
 686         int error;
 687
 688         lockmgr(&sc->lk, LK_EXCLUSIVE);
 689
 690         switch (how) {
 691         case SMB_QREAD:
 692                 error = SMB_ENOTSUPP;
 693                 break;
 694         case SMB_QWRITE:
 695                 error = SMB_ENOTSUPP;
 696                 break;
 697         default:
 698                 error = SMB_ENOTSUPP;
 699                 break;
 700         }
 701         lockmgr(&sc->lk, LK_RELEASE);
 702
 703         return error;
 704 }
 705
 706 /*
 707  * Incremental send byte without stop (?).  It is unclear why the slave
 708  * address is specified if this presumably is used in combination with
 709  * ig4iic_smb_quick().
 710  *
 711  * (Also, how would this work anyway?  Issue the last byte with writeb()?)
 712  */
 713 int
 714 ig4iic_smb_sendb(device_t dev, u_char slave, char byte)
 715 {
 716         ig4iic_softc_t *sc = device_get_softc(dev);
 717         uint32_t cmd;
 718         int error;
 719
 720         lockmgr(&sc->lk, LK_EXCLUSIVE);
 721
 722         set_slave_addr(sc, slave, 0);
 723         cmd = byte;
 724         if (wait_status(sc, IG4_STATUS_TX_NOTFULL) == 0) {
 725                 reg_write(sc, IG4_REG_DATA_CMD, cmd);
 726                 error = 0;
 727         } else {
 728                 error = SMB_ETIMEOUT;
 729         }
 730
 731         lockmgr(&sc->lk, LK_RELEASE);
 732         return error;
 733 }
 734
 735 /*
 736  * Incremental receive byte without stop (?).  It is unclear why the slave
 737  * address is specified if this presumably is used in combination with
 738  * ig4iic_smb_quick().
 739  */
 740 int
 741 ig4iic_smb_recvb(device_t dev, u_char slave, char *byte)
 742 {
 743         ig4iic_softc_t *sc = device_get_softc(dev);
 744         int error;
 745
 746         lockmgr(&sc->lk, LK_EXCLUSIVE);
 747
 748         set_slave_addr(sc, slave, 0);
 749         reg_write(sc, IG4_REG_DATA_CMD, IG4_DATA_COMMAND_RD);
 750         if (wait_status(sc, IG4_STATUS_RX_NOTEMPTY) == 0) {
 751                 *byte = data_read(sc);
 752                 error = 0;
 753         } else {
 754                 *byte = 0;
 755                 error = SMB_ETIMEOUT;
 756         }
 757
 758         lockmgr(&sc->lk, LK_RELEASE);
 759         return error;
 760 }
 761
 762 /*
 763  * Write command and single byte in transaction.
 764  */
 765 int
 766 ig4iic_smb_writeb(device_t dev, u_char slave, char cmd, char byte)
 767 {
 768         ig4iic_softc_t *sc = device_get_softc(dev);
 769         int error;
 770
 771         lockmgr(&sc->lk, LK_EXCLUSIVE);
 772
 773         set_slave_addr(sc, slave, 0);
 774         error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT,
 775                                 &byte, 1, NULL, 0, NULL);
 776
 777         lockmgr(&sc->lk, LK_RELEASE);
 778         return error;
 779 }
 780
 781 /*
 782  * Write command and single word in transaction.
 783  */
 784 int
 785 ig4iic_smb_writew(device_t dev, u_char slave, char cmd, short word)
 786 {
 787         ig4iic_softc_t *sc = device_get_softc(dev);
 788         char buf[2];
 789         int error;
 790
 791         lockmgr(&sc->lk, LK_EXCLUSIVE);
 792
 793         set_slave_addr(sc, slave, 0);
 794         buf[0] = word & 0xFF;
 795         buf[1] = word >> 8;
 796         error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT,
 797                                 buf, 2, NULL, 0, NULL);
 798
 799         lockmgr(&sc->lk, LK_RELEASE);
 800         return error;
 801 }
 802
 803 /*
 804  * write command and read single byte in transaction.
 805  */
 806 int
 807 ig4iic_smb_readb(device_t dev, u_char slave, char cmd, char *byte)
 808 {
 809         ig4iic_softc_t *sc = device_get_softc(dev);
 810         int error;
 811
 812         lockmgr(&sc->lk, LK_EXCLUSIVE);
 813
 814         set_slave_addr(sc, slave, 0);
 815         error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT,
 816                                 NULL, 0, byte, 1, NULL);
 817
 818         lockmgr(&sc->lk, LK_RELEASE);
 819         return error;
 820 }
 821
 822 /*
 823  * write command and read word in transaction.
 824  */
 825 int
 826 ig4iic_smb_readw(device_t dev, u_char slave, char cmd, short *word)
 827 {
 828         ig4iic_softc_t *sc = device_get_softc(dev);
 829         char buf[2];
 830         int error;
 831
 832         lockmgr(&sc->lk, LK_EXCLUSIVE);
 833
 834         set_slave_addr(sc, slave, 0);
 835         if ((error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT,
 836                                      NULL, 0, buf, 2, NULL)) == 0) {
 837                 *word = (u_char)buf[0] | ((u_char)buf[1] << 8);
 838         }
 839
 840         lockmgr(&sc->lk, LK_RELEASE);
 841         return error;
 842 }
 843
 844 /*
 845  * write command and word and read word in transaction
 846  */
 847 int
 848 ig4iic_smb_pcall(device_t dev, u_char slave, char cmd,
 849                  short sdata, short *rdata)
 850 {
 851         ig4iic_softc_t *sc = device_get_softc(dev);
 852         char rbuf[2];
 853         char wbuf[2];
 854         int error;
 855
 856         lockmgr(&sc->lk, LK_EXCLUSIVE);
 857
 858         set_slave_addr(sc, slave, 0);
 859         wbuf[0] = sdata & 0xFF;
 860         wbuf[1] = sdata >> 8;
 861         if ((error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT,
 862                                      wbuf, 2, rbuf, 2, NULL)) == 0) {
 863                 *rdata = (u_char)rbuf[0] | ((u_char)rbuf[1] << 8);
 864         }
 865
 866         lockmgr(&sc->lk, LK_RELEASE);
 867         return error;
 868 }
 869
 870 int
 871 ig4iic_smb_bwrite(device_t dev, u_char slave, char cmd,
 872                   u_char wcount, char *buf)
 873 {
 874         ig4iic_softc_t *sc = device_get_softc(dev);
 875         int error;
 876
 877         lockmgr(&sc->lk, LK_EXCLUSIVE);
 878
 879         set_slave_addr(sc, slave, 0);
 880         error = smb_transaction(sc, cmd, 0,
 881                                 buf, wcount, NULL, 0, NULL);
 882
 883         lockmgr(&sc->lk, LK_RELEASE);
 884         return error;
 885 }
 886
 887 int
 888 ig4iic_smb_bread(device_t dev, u_char slave, char cmd,
 889                  u_char *countp_char, char *buf)
 890 {
 891         ig4iic_softc_t *sc = device_get_softc(dev);
 892         int rcount = *countp_char;
 893         int error;
 894
 895         lockmgr(&sc->lk, LK_EXCLUSIVE);
 896
 897         set_slave_addr(sc, slave, 0);
 898         error = smb_transaction(sc, cmd, 0,
 899                                 NULL, 0, buf, rcount, &rcount);
 900         *countp_char = rcount;
 901
 902         lockmgr(&sc->lk, LK_RELEASE);
 903         return error;
 904 }
 905
 906 int
 907 ig4iic_smb_trans(device_t dev, int slave, char cmd, int op,
 908                  char *wbuf, int wcount, char *rbuf, int rcount,
 909                  int *actualp)
 910 {
 911         ig4iic_softc_t *sc = device_get_softc(dev);
 912         int error;
 913
 914         lockmgr(&sc->lk, LK_EXCLUSIVE);
 915
 916         set_slave_addr(sc, slave, op);
 917         error = smb_transaction(sc, cmd, op,
 918                                 wbuf, wcount, rbuf, rcount, actualp);
 919
 920         lockmgr(&sc->lk, LK_RELEASE);
 921         return error;
 922 }
 923
 924 /*
 925  * Interrupt Operation
 926  */
 927 static
 928 void
 929 ig4iic_intr(void *cookie)
 930 {
 931         ig4iic_softc_t *sc = cookie;
 932         uint32_t status;
 933
 934         lockmgr(&sc->lk, LK_EXCLUSIVE);
 935 /*      reg_write(sc, IG4_REG_INTR_MASK, IG4_INTR_STOP_DET);*/
 936         reg_read(sc, IG4_REG_CLR_INTR);
 937         status = reg_read(sc, IG4_REG_I2C_STA);
 938         while (status & IG4_STATUS_RX_NOTEMPTY) {
 939                 sc->rbuf[sc->rnext & IG4_RBUFMASK] =
 940                     (uint8_t)reg_read(sc, IG4_REG_DATA_CMD);
 941                 ++sc->rnext;
 942                 status = reg_read(sc, IG4_REG_I2C_STA);
 943         }
 944         wakeup(sc);
 945         lockmgr(&sc->lk, LK_RELEASE);
 946 }
 947
 948 #define REGDUMP(sc, reg)        \
 949         device_printf(sc->dev, "  %-23s %08x\n", #reg, reg_read(sc, reg))
 950
 951 static
 952 void
 953 ig4iic_dump(ig4iic_softc_t *sc)
 954 {
 955         device_printf(sc->dev, "ig4iic register dump:\n");
 956         REGDUMP(sc, IG4_REG_CTL);
 957         REGDUMP(sc, IG4_REG_TAR_ADD);
 958         REGDUMP(sc, IG4_REG_SS_SCL_HCNT);
 959         REGDUMP(sc, IG4_REG_SS_SCL_LCNT);
 960         REGDUMP(sc, IG4_REG_FS_SCL_HCNT);
 961         REGDUMP(sc, IG4_REG_FS_SCL_LCNT);
 962         REGDUMP(sc, IG4_REG_INTR_STAT);
 963         REGDUMP(sc, IG4_REG_INTR_MASK);
 964         REGDUMP(sc, IG4_REG_RAW_INTR_STAT);
 965         REGDUMP(sc, IG4_REG_RX_TL);
 966         REGDUMP(sc, IG4_REG_TX_TL);
 967         REGDUMP(sc, IG4_REG_I2C_EN);
 968         REGDUMP(sc, IG4_REG_I2C_STA);
 969         REGDUMP(sc, IG4_REG_TXFLR);
 970         REGDUMP(sc, IG4_REG_RXFLR);
 971         REGDUMP(sc, IG4_REG_SDA_HOLD);
 972         REGDUMP(sc, IG4_REG_TX_ABRT_SOURCE);
 973         REGDUMP(sc, IG4_REG_SLV_DATA_NACK);
 974         REGDUMP(sc, IG4_REG_DMA_CTRL);
 975         REGDUMP(sc, IG4_REG_DMA_TDLR);
 976         REGDUMP(sc, IG4_REG_DMA_RDLR);
 977         REGDUMP(sc, IG4_REG_SDA_SETUP);
 978         REGDUMP(sc, IG4_REG_ENABLE_STATUS);
 979         REGDUMP(sc, IG4_REG_COMP_PARAM1);
 980         REGDUMP(sc, IG4_REG_COMP_VER);
 981         REGDUMP(sc, IG4_REG_COMP_TYPE);
 982         REGDUMP(sc, IG4_REG_CLK_PARMS);
 983         REGDUMP(sc, IG4_REG_RESETS);
 984         REGDUMP(sc, IG4_REG_GENERAL);
 985         REGDUMP(sc, IG4_REG_SW_LTR_VALUE);
 986         REGDUMP(sc, IG4_REG_AUTO_LTR_VALUE);
 987 }
 988 #undef REGDUMP
 989
 990 DRIVER_MODULE(smbus, ig4iic, smbus_driver, smbus_devclass, NULL, NULL);