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