sys/dev/ichsmb/ichsmb.c

   1 /*-
   2  * ichsmb.c
   3  *
   4  * Author: Archie Cobbs <archie@freebsd.org>
   5  * Copyright (c) 2000 Whistle Communications, Inc.
   6  * All rights reserved.
   7  *
   8  * Subject to the following obligations and disclaimer of warranty, use and
   9  * redistribution of this software, in source or object code forms, with or
  10  * without modifications are expressly permitted by Whistle Communications;
  11  * provided, however, that:
  12  * 1. Any and all reproductions of the source or object code must include the
  13  *    copyright notice above and the following disclaimer of warranties; and
  14  * 2. No rights are granted, in any manner or form, to use Whistle
  15  *    Communications, Inc. trademarks, including the mark "WHISTLE
  16  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
  17  *    such appears in the above copyright notice or in the software.
  18  *
  19  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
  20  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
  21  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
  22  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
  24  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
  25  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
  26  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
  27  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
  28  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
  29  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
  30  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
  32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  34  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
  35  * OF SUCH DAMAGE.
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 /*
  42  * Support for the SMBus controller logical device which is part of the
  43  * Intel 81801AA (ICH) and 81801AB (ICH0) I/O controller hub chips.
  44  *
  45  * This driver assumes that the generic SMBus code will ensure that
  46  * at most one process at a time calls into the SMBus methods below.
  47  */
  48
  49 #include <sys/param.h>
  50 #include <sys/systm.h>
  51 #include <sys/kernel.h>
  52 #include <sys/errno.h>
  53 #include <sys/lock.h>
  54 #include <sys/module.h>
  55 #include <sys/mutex.h>
  56 #include <sys/syslog.h>
  57 #include <sys/bus.h>
  58
  59 #include <machine/bus.h>
  60 #include <sys/rman.h>
  61 #include <machine/resource.h>
  62
  63 #include <dev/smbus/smbconf.h>
  64
  65 #include <dev/ichsmb/ichsmb_var.h>
  66 #include <dev/ichsmb/ichsmb_reg.h>
  67
  68 /*
  69  * Enable debugging by defining ICHSMB_DEBUG to a non-zero value.
  70  */
  71 #define ICHSMB_DEBUG    0
  72 #if ICHSMB_DEBUG != 0 && defined(__CC_SUPPORTS___FUNC__)
  73 #define DBG(fmt, args...)       \
  74         do { printf("%s: " fmt, __func__ , ## args); } while (0)
  75 #else
  76 #define DBG(fmt, args...)       do { } while (0)
  77 #endif
  78
  79 /*
  80  * Our child device driver name
  81  */
  82 #define DRIVER_SMBUS    "smbus"
  83
  84 /*
  85  * Internal functions
  86  */
  87 static int ichsmb_wait(sc_p sc);
  88
  89 /********************************************************************
  90                 BUS-INDEPENDENT BUS METHODS
  91 ********************************************************************/
  92
  93 /*
  94  * Handle probe-time duties that are independent of the bus
  95  * our device lives on.
  96  */
  97 int
  98 ichsmb_probe(device_t dev)
  99 {
 100         return (BUS_PROBE_DEFAULT);
 101 }
 102
 103 /*
 104  * Handle attach-time duties that are independent of the bus
 105  * our device lives on.
 106  */
 107 int
 108 ichsmb_attach(device_t dev)
 109 {
 110         const sc_p sc = device_get_softc(dev);
 111         int error;
 112
 113         /* Create mutex */
 114         mtx_init(&sc->mutex, device_get_nameunit(dev), "ichsmb", MTX_DEF);
 115
 116         /* Add child: an instance of the "smbus" device */
 117         if ((sc->smb = device_add_child(dev, DRIVER_SMBUS, -1)) == NULL) {
 118                 device_printf(dev, "no \"%s\" child found\n", DRIVER_SMBUS);
 119                 error = ENXIO;
 120                 goto fail;
 121         }
 122
 123         /* Clear interrupt conditions */
 124         bus_write_1(sc->io_res, ICH_HST_STA, 0xff);
 125
 126         /* Set up interrupt handler */
 127         error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
 128             NULL, ichsmb_device_intr, sc, &sc->irq_handle);
 129         if (error != 0) {
 130                 device_printf(dev, "can't setup irq\n");
 131                 goto fail;
 132         }
 133
 134         /* Attach "smbus" child */
 135         if ((error = bus_generic_attach(dev)) != 0) {
 136                 device_printf(dev, "failed to attach child: %d\n", error);
 137                 goto fail;
 138         }
 139
 140         return (0);
 141
 142 fail:
 143         mtx_destroy(&sc->mutex);
 144         return (error);
 145 }
 146
 147 /********************************************************************
 148                         SMBUS METHODS
 149 ********************************************************************/
 150
 151 int
 152 ichsmb_callback(device_t dev, int index, void *data)
 153 {
 154         int smb_error = 0;
 155
 156         DBG("index=%d how=%d\n", index, data ? *(int *)data : -1);
 157         switch (index) {
 158         case SMB_REQUEST_BUS:
 159                 break;
 160         case SMB_RELEASE_BUS:
 161                 break;
 162         default:
 163                 smb_error = SMB_EABORT; /* XXX */
 164                 break;
 165         }
 166         DBG("smb_error=%d\n", smb_error);
 167         return (smb_error);
 168 }
 169
 170 int
 171 ichsmb_quick(device_t dev, u_char slave, int how)
 172 {
 173         const sc_p sc = device_get_softc(dev);
 174         int smb_error;
 175
 176         DBG("slave=0x%02x how=%d\n", slave, how);
 177         KASSERT(sc->ich_cmd == -1,
 178             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 179         switch (how) {
 180         case SMB_QREAD:
 181         case SMB_QWRITE:
 182                 mtx_lock(&sc->mutex);
 183                 sc->ich_cmd = ICH_HST_CNT_SMB_CMD_QUICK;
 184                 bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 185                     slave | (how == SMB_QREAD ?
 186                         ICH_XMIT_SLVA_READ : ICH_XMIT_SLVA_WRITE));
 187                 bus_write_1(sc->io_res, ICH_HST_CNT,
 188                     ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 189                 smb_error = ichsmb_wait(sc);
 190                 mtx_unlock(&sc->mutex);
 191                 break;
 192         default:
 193                 smb_error = SMB_ENOTSUPP;
 194         }
 195         DBG("smb_error=%d\n", smb_error);
 196         return (smb_error);
 197 }
 198
 199 int
 200 ichsmb_sendb(device_t dev, u_char slave, char byte)
 201 {
 202         const sc_p sc = device_get_softc(dev);
 203         int smb_error;
 204
 205         DBG("slave=0x%02x byte=0x%02x\n", slave, (u_char)byte);
 206         KASSERT(sc->ich_cmd == -1,
 207             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 208         mtx_lock(&sc->mutex);
 209         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE;
 210         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 211             slave | ICH_XMIT_SLVA_WRITE);
 212         bus_write_1(sc->io_res, ICH_HST_CMD, byte);
 213         bus_write_1(sc->io_res, ICH_HST_CNT,
 214             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 215         smb_error = ichsmb_wait(sc);
 216         mtx_unlock(&sc->mutex);
 217         DBG("smb_error=%d\n", smb_error);
 218         return (smb_error);
 219 }
 220
 221 int
 222 ichsmb_recvb(device_t dev, u_char slave, char *byte)
 223 {
 224         const sc_p sc = device_get_softc(dev);
 225         int smb_error;
 226
 227         DBG("slave=0x%02x\n", slave);
 228         KASSERT(sc->ich_cmd == -1,
 229             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 230         mtx_lock(&sc->mutex);
 231         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE;
 232         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 233             slave | ICH_XMIT_SLVA_READ);
 234         bus_write_1(sc->io_res, ICH_HST_CNT,
 235             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 236         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
 237                 *byte = bus_read_1(sc->io_res, ICH_D0);
 238         mtx_unlock(&sc->mutex);
 239         DBG("smb_error=%d byte=0x%02x\n", smb_error, (u_char)*byte);
 240         return (smb_error);
 241 }
 242
 243 int
 244 ichsmb_writeb(device_t dev, u_char slave, char cmd, char byte)
 245 {
 246         const sc_p sc = device_get_softc(dev);
 247         int smb_error;
 248
 249         DBG("slave=0x%02x cmd=0x%02x byte=0x%02x\n",
 250             slave, (u_char)cmd, (u_char)byte);
 251         KASSERT(sc->ich_cmd == -1,
 252             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 253         mtx_lock(&sc->mutex);
 254         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE_DATA;
 255         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 256             slave | ICH_XMIT_SLVA_WRITE);
 257         bus_write_1(sc->io_res, ICH_HST_CMD, cmd);
 258         bus_write_1(sc->io_res, ICH_D0, byte);
 259         bus_write_1(sc->io_res, ICH_HST_CNT,
 260             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 261         smb_error = ichsmb_wait(sc);
 262         mtx_unlock(&sc->mutex);
 263         DBG("smb_error=%d\n", smb_error);
 264         return (smb_error);
 265 }
 266
 267 int
 268 ichsmb_writew(device_t dev, u_char slave, char cmd, short word)
 269 {
 270         const sc_p sc = device_get_softc(dev);
 271         int smb_error;
 272
 273         DBG("slave=0x%02x cmd=0x%02x word=0x%04x\n",
 274             slave, (u_char)cmd, (u_int16_t)word);
 275         KASSERT(sc->ich_cmd == -1,
 276             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 277         mtx_lock(&sc->mutex);
 278         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_WORD_DATA;
 279         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 280             slave | ICH_XMIT_SLVA_WRITE);
 281         bus_write_1(sc->io_res, ICH_HST_CMD, cmd);
 282         bus_write_1(sc->io_res, ICH_D0, word & 0xff);
 283         bus_write_1(sc->io_res, ICH_D1, word >> 8);
 284         bus_write_1(sc->io_res, ICH_HST_CNT,
 285             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 286         smb_error = ichsmb_wait(sc);
 287         mtx_unlock(&sc->mutex);
 288         DBG("smb_error=%d\n", smb_error);
 289         return (smb_error);
 290 }
 291
 292 int
 293 ichsmb_readb(device_t dev, u_char slave, char cmd, char *byte)
 294 {
 295         const sc_p sc = device_get_softc(dev);
 296         int smb_error;
 297
 298         DBG("slave=0x%02x cmd=0x%02x\n", slave, (u_char)cmd);
 299         KASSERT(sc->ich_cmd == -1,
 300             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 301         mtx_lock(&sc->mutex);
 302         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE_DATA;
 303         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 304             slave | ICH_XMIT_SLVA_READ);
 305         bus_write_1(sc->io_res, ICH_HST_CMD, cmd);
 306         bus_write_1(sc->io_res, ICH_HST_CNT,
 307             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 308         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
 309                 *byte = bus_read_1(sc->io_res, ICH_D0);
 310         mtx_unlock(&sc->mutex);
 311         DBG("smb_error=%d byte=0x%02x\n", smb_error, (u_char)*byte);
 312         return (smb_error);
 313 }
 314
 315 int
 316 ichsmb_readw(device_t dev, u_char slave, char cmd, short *word)
 317 {
 318         const sc_p sc = device_get_softc(dev);
 319         int smb_error;
 320
 321         DBG("slave=0x%02x cmd=0x%02x\n", slave, (u_char)cmd);
 322         KASSERT(sc->ich_cmd == -1,
 323             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 324         mtx_lock(&sc->mutex);
 325         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_WORD_DATA;
 326         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 327             slave | ICH_XMIT_SLVA_READ);
 328         bus_write_1(sc->io_res, ICH_HST_CMD, cmd);
 329         bus_write_1(sc->io_res, ICH_HST_CNT,
 330             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 331         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR) {
 332                 *word = (bus_read_1(sc->io_res,
 333                         ICH_D0) & 0xff)
 334                   | (bus_read_1(sc->io_res,
 335                         ICH_D1) << 8);
 336         }
 337         mtx_unlock(&sc->mutex);
 338         DBG("smb_error=%d word=0x%04x\n", smb_error, (u_int16_t)*word);
 339         return (smb_error);
 340 }
 341
 342 int
 343 ichsmb_pcall(device_t dev, u_char slave, char cmd, short sdata, short *rdata)
 344 {
 345         const sc_p sc = device_get_softc(dev);
 346         int smb_error;
 347
 348         DBG("slave=0x%02x cmd=0x%02x sdata=0x%04x\n",
 349             slave, (u_char)cmd, (u_int16_t)sdata);
 350         KASSERT(sc->ich_cmd == -1,
 351             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 352         mtx_lock(&sc->mutex);
 353         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_PROC_CALL;
 354         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 355             slave | ICH_XMIT_SLVA_WRITE);
 356         bus_write_1(sc->io_res, ICH_HST_CMD, cmd);
 357         bus_write_1(sc->io_res, ICH_D0, sdata & 0xff);
 358         bus_write_1(sc->io_res, ICH_D1, sdata >> 8);
 359         bus_write_1(sc->io_res, ICH_HST_CNT,
 360             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 361         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR) {
 362                 *rdata = (bus_read_1(sc->io_res,
 363                         ICH_D0) & 0xff)
 364                   | (bus_read_1(sc->io_res,
 365                         ICH_D1) << 8);
 366         }
 367         mtx_unlock(&sc->mutex);
 368         DBG("smb_error=%d rdata=0x%04x\n", smb_error, (u_int16_t)*rdata);
 369         return (smb_error);
 370 }
 371
 372 int
 373 ichsmb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
 374 {
 375         const sc_p sc = device_get_softc(dev);
 376         int smb_error;
 377
 378         DBG("slave=0x%02x cmd=0x%02x count=%d\n", slave, (u_char)cmd, count);
 379 #if ICHSMB_DEBUG
 380 #define DISP(ch)        (((ch) < 0x20 || (ch) >= 0x7e) ? '.' : (ch))
 381         {
 382             u_char *p;
 383
 384             for (p = (u_char *)buf; p - (u_char *)buf < 32; p += 8) {
 385                 DBG("%02x: %02x %02x %02x %02x %02x %02x %02x %02x"
 386                     "  %c%c%c%c%c%c%c%c", (p - (u_char *)buf),
 387                     p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
 388                     DISP(p[0]), DISP(p[1]), DISP(p[2]), DISP(p[3]),
 389                     DISP(p[4]), DISP(p[5]), DISP(p[6]), DISP(p[7]));
 390             }
 391         }
 392 #undef DISP
 393 #endif
 394         KASSERT(sc->ich_cmd == -1,
 395             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 396         if (count < 1 || count > 32)
 397                 return (SMB_EINVAL);
 398         bcopy(buf, sc->block_data, count);
 399         sc->block_count = count;
 400         sc->block_index = 1;
 401         sc->block_write = 1;
 402
 403         mtx_lock(&sc->mutex);
 404         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BLOCK;
 405         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 406             slave | ICH_XMIT_SLVA_WRITE);
 407         bus_write_1(sc->io_res, ICH_HST_CMD, cmd);
 408         bus_write_1(sc->io_res, ICH_D0, count);
 409         bus_write_1(sc->io_res, ICH_BLOCK_DB, buf[0]);
 410         bus_write_1(sc->io_res, ICH_HST_CNT,
 411             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 412         smb_error = ichsmb_wait(sc);
 413         mtx_unlock(&sc->mutex);
 414         DBG("smb_error=%d\n", smb_error);
 415         return (smb_error);
 416 }
 417
 418 int
 419 ichsmb_bread(device_t dev, u_char slave, char cmd, u_char *count, char *buf)
 420 {
 421         const sc_p sc = device_get_softc(dev);
 422         int smb_error;
 423
 424         DBG("slave=0x%02x cmd=0x%02x count=%d\n", slave, (u_char)cmd, count);
 425         KASSERT(sc->ich_cmd == -1,
 426             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 427         if (*count < 1 || *count > 32)
 428                 return (SMB_EINVAL);
 429         bzero(sc->block_data, sizeof(sc->block_data));
 430         sc->block_count = 0;
 431         sc->block_index = 0;
 432         sc->block_write = 0;
 433
 434         mtx_lock(&sc->mutex);
 435         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BLOCK;
 436         bus_write_1(sc->io_res, ICH_XMIT_SLVA,
 437             slave | ICH_XMIT_SLVA_READ);
 438         bus_write_1(sc->io_res, ICH_HST_CMD, cmd);
 439         bus_write_1(sc->io_res, ICH_D0, *count); /* XXX? */
 440         bus_write_1(sc->io_res, ICH_HST_CNT,
 441             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 442         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR) {
 443                 bcopy(sc->block_data, buf, min(sc->block_count, *count));
 444                 *count = sc->block_count;
 445         }
 446         mtx_unlock(&sc->mutex);
 447         DBG("smb_error=%d\n", smb_error);
 448 #if ICHSMB_DEBUG
 449 #define DISP(ch)        (((ch) < 0x20 || (ch) >= 0x7e) ? '.' : (ch))
 450         {
 451             u_char *p;
 452
 453             for (p = (u_char *)buf; p - (u_char *)buf < 32; p += 8) {
 454                 DBG("%02x: %02x %02x %02x %02x %02x %02x %02x %02x"
 455                     "  %c%c%c%c%c%c%c%c", (p - (u_char *)buf),
 456                     p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
 457                     DISP(p[0]), DISP(p[1]), DISP(p[2]), DISP(p[3]),
 458                     DISP(p[4]), DISP(p[5]), DISP(p[6]), DISP(p[7]));
 459             }
 460         }
 461 #undef DISP
 462 #endif
 463         return (smb_error);
 464 }
 465
 466 /********************************************************************
 467                         OTHER FUNCTIONS
 468 ********************************************************************/
 469
 470 /*
 471  * This table describes what interrupts we should ever expect to
 472  * see after each ICH command, not including the SMBALERT interrupt.
 473  */
 474 static const u_int8_t ichsmb_state_irqs[] = {
 475         /* quick */
 476         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
 477         /* byte */
 478         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
 479         /* byte data */
 480         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
 481         /* word data */
 482         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
 483         /* process call */
 484         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
 485         /* block */
 486         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR
 487             | ICH_HST_STA_BYTE_DONE_STS),
 488         /* i2c read (not used) */
 489         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR
 490             | ICH_HST_STA_BYTE_DONE_STS)
 491 };
 492
 493 /*
 494  * Interrupt handler. This handler is bus-independent. Note that our
 495  * interrupt may be shared, so we must handle "false" interrupts.
 496  */
 497 void
 498 ichsmb_device_intr(void *cookie)
 499 {
 500         const sc_p sc = cookie;
 501         const device_t dev = sc->dev;
 502         const int maxloops = 16;
 503         u_int8_t status;
 504         u_int8_t ok_bits;
 505         int cmd_index;
 506         int count;
 507
 508         mtx_lock(&sc->mutex);
 509         for (count = 0; count < maxloops; count++) {
 510
 511                 /* Get and reset status bits */
 512                 status = bus_read_1(sc->io_res, ICH_HST_STA);
 513 #if ICHSMB_DEBUG
 514                 if ((status & ~(ICH_HST_STA_INUSE_STS | ICH_HST_STA_HOST_BUSY))
 515                     || count > 0) {
 516                         DBG("%d stat=0x%02x\n", count, status);
 517                 }
 518 #endif
 519                 status &= ~(ICH_HST_STA_INUSE_STS | ICH_HST_STA_HOST_BUSY);
 520                 if (status == 0)
 521                         break;
 522
 523                 /* Check for unexpected interrupt */
 524                 ok_bits = ICH_HST_STA_SMBALERT_STS;
 525                 cmd_index = sc->ich_cmd >> 2;
 526                 if (sc->ich_cmd != -1) {
 527                         KASSERT(cmd_index < sizeof(ichsmb_state_irqs),
 528                             ("%s: ich_cmd=%d", device_get_nameunit(dev),
 529                             sc->ich_cmd));
 530                         ok_bits |= ichsmb_state_irqs[cmd_index];
 531                 }
 532                 if ((status & ~ok_bits) != 0) {
 533                         device_printf(dev, "irq 0x%02x during %d\n", status,
 534                             cmd_index);
 535                         bus_write_1(sc->io_res,
 536                             ICH_HST_STA, (status & ~ok_bits));
 537                         continue;
 538                 }
 539
 540                 /* Handle SMBALERT interrupt */
 541                 if (status & ICH_HST_STA_SMBALERT_STS) {
 542                         static int smbalert_count = 16;
 543                         if (smbalert_count > 0) {
 544                                 device_printf(dev, "SMBALERT# rec'd\n");
 545                                 if (--smbalert_count == 0) {
 546                                         device_printf(dev,
 547                                             "not logging anymore\n");
 548                                 }
 549                         }
 550                 }
 551
 552                 /* Check for bus error */
 553                 if (status & ICH_HST_STA_BUS_ERR) {
 554                         sc->smb_error = SMB_ECOLLI;     /* XXX SMB_EBUSERR? */
 555                         goto finished;
 556                 }
 557
 558                 /* Check for device error */
 559                 if (status & ICH_HST_STA_DEV_ERR) {
 560                         sc->smb_error = SMB_ENOACK;     /* or SMB_ETIMEOUT? */
 561                         goto finished;
 562                 }
 563
 564                 /* Check for byte completion in block transfer */
 565                 if (status & ICH_HST_STA_BYTE_DONE_STS) {
 566                         if (sc->block_write) {
 567                                 if (sc->block_index < sc->block_count) {
 568
 569                                         /* Write next byte */
 570                                         bus_write_1(sc->io_res,
 571                                             ICH_BLOCK_DB,
 572                                             sc->block_data[sc->block_index++]);
 573                                 }
 574                         } else {
 575
 576                                 /* First interrupt, get the count also */
 577                                 if (sc->block_index == 0) {
 578                                         sc->block_count = bus_read_1(
 579                                             sc->io_res, ICH_D0);
 580                                 }
 581
 582                                 /* Get next byte, if any */
 583                                 if (sc->block_index < sc->block_count) {
 584
 585                                         /* Read next byte */
 586                                         sc->block_data[sc->block_index++] =
 587                                             bus_read_1(sc->io_res,
 588                                               ICH_BLOCK_DB);
 589
 590                                         /* Set "LAST_BYTE" bit before reading
 591                                            the last byte of block data */
 592                                         if (sc->block_index
 593                                             >= sc->block_count - 1) {
 594                                                 bus_write_1(sc->io_res,
 595                                                     ICH_HST_CNT,
 596                                                     ICH_HST_CNT_LAST_BYTE
 597                                                         | ICH_HST_CNT_INTREN
 598                                                         | sc->ich_cmd);
 599                                         }
 600                                 }
 601                         }
 602                 }
 603
 604                 /* Check command completion */
 605                 if (status & ICH_HST_STA_INTR) {
 606                         sc->smb_error = SMB_ENOERR;
 607 finished:
 608                         sc->ich_cmd = -1;
 609                         bus_write_1(sc->io_res,
 610                             ICH_HST_STA, status);
 611                         wakeup(sc);
 612                         break;
 613                 }
 614
 615                 /* Clear status bits and try again */
 616                 bus_write_1(sc->io_res, ICH_HST_STA, status);
 617         }
 618         mtx_unlock(&sc->mutex);
 619
 620         /* Too many loops? */
 621         if (count == maxloops) {
 622                 device_printf(dev, "interrupt loop, status=0x%02x\n",
 623                     bus_read_1(sc->io_res, ICH_HST_STA));
 624         }
 625 }
 626
 627 /*
 628  * Wait for command completion. Assumes mutex is held.
 629  * Returns an SMB_* error code.
 630  */
 631 static int
 632 ichsmb_wait(sc_p sc)
 633 {
 634         const device_t dev = sc->dev;
 635         int error, smb_error;
 636
 637         KASSERT(sc->ich_cmd != -1,
 638             ("%s: ich_cmd=%d\n", __func__ , sc->ich_cmd));
 639         mtx_assert(&sc->mutex, MA_OWNED);
 640         error = msleep(sc, &sc->mutex, PZERO, "ichsmb", hz / 4);
 641         DBG("msleep -> %d\n", error);
 642         switch (error) {
 643         case 0:
 644                 smb_error = sc->smb_error;
 645                 break;
 646         case EWOULDBLOCK:
 647                 device_printf(dev, "device timeout, status=0x%02x\n",
 648                     bus_read_1(sc->io_res, ICH_HST_STA));
 649                 sc->ich_cmd = -1;
 650                 smb_error = SMB_ETIMEOUT;
 651                 break;
 652         default:
 653                 smb_error = SMB_EABORT;
 654                 break;
 655         }
 656         return (smb_error);
 657 }
 658
 659 /*
 660  * Release resources associated with device.
 661  */
 662 void
 663 ichsmb_release_resources(sc_p sc)
 664 {
 665         const device_t dev = sc->dev;
 666
 667         if (sc->irq_handle != NULL) {
 668                 bus_teardown_intr(dev, sc->irq_res, sc->irq_handle);
 669                 sc->irq_handle = NULL;
 670         }
 671         if (sc->irq_res != NULL) {
 672                 bus_release_resource(dev,
 673                     SYS_RES_IRQ, sc->irq_rid, sc->irq_res);
 674                 sc->irq_res = NULL;
 675         }
 676         if (sc->io_res != NULL) {
 677                 bus_release_resource(dev,
 678                     SYS_RES_IOPORT, sc->io_rid, sc->io_res);
 679                 sc->io_res = NULL;
 680         }
 681 }
 682
 683 int
 684 ichsmb_detach(device_t dev)
 685 {
 686         const sc_p sc = device_get_softc(dev);
 687         int error;
 688
 689         error = bus_generic_detach(dev);
 690         if (error)
 691                 return (error);
 692         device_delete_child(dev, sc->smb);
 693         ichsmb_release_resources(sc);
 694         mtx_destroy(&sc->mutex);
 695
 696         return 0;
 697 }
 698
 699 DRIVER_MODULE(smbus, ichsmb, smbus_driver, smbus_devclass, 0, 0);