sys/dev/powermng/alpm/alpm.c

   1 /*-
   2  * Copyright (c) 1998, 1999, 2001 Nicolas Souchu
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/pci/alpm.c,v 1.26 2007/01/11 19:56:24 jhb Exp $
  27  *
  28  */
  29
  30 /*
  31  * Power Management support for the Acer M15x3 chipsets
  32  */
  33 #include <sys/param.h>
  34 #include <sys/bus.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/module.h>
  38 #include <sys/rman.h>
  39 #include <sys/systm.h>
  40
  41 #include <bus/pci/pcivar.h>
  42 #include <bus/pci/pcireg.h>
  43
  44 #include <bus/smbus/smbconf.h>
  45 #include "smbus_if.h"
  46
  47 #define ALPM_DEBUG(x)   if (alpm_debug) (x)
  48
  49 #ifdef DEBUG
  50 static int alpm_debug = 1;
  51 #else
  52 static int alpm_debug = 0;
  53 #endif
  54
  55 #define ACER_M1543_PMU_ID       0x710110b9
  56
  57 /*
  58  * I/O registers offsets - the base address is programmed via the
  59  * SMBBA PCI configuration register
  60  */
  61 #define SMBSTS          0x0     /* SMBus host/slave status register */
  62 #define SMBCMD          0x1     /* SMBus host/slave command register */
  63 #define SMBSTART        0x2     /* start to generate programmed cycle */
  64 #define SMBHADDR        0x3     /* host address register */
  65 #define SMBHDATA        0x4     /* data A register for host controller */
  66 #define SMBHDATB        0x5     /* data B register for host controller */
  67 #define SMBHBLOCK       0x6     /* block register for host controller */
  68 #define SMBHCMD         0x7     /* command register for host controller */
  69
  70 /* SMBHADDR mask. */
  71 #define LSB             0x1     /* XXX: Better name: Read/Write? */
  72
  73 /* SMBSTS masks */
  74 #define TERMINATE       0x80
  75 #define BUS_COLLI       0x40
  76 #define DEVICE_ERR      0x20
  77 #define SMI_I_STS       0x10
  78 #define HST_BSY         0x08
  79 #define IDL_STS         0x04
  80 #define HSTSLV_STS      0x02
  81 #define HSTSLV_BSY      0x01
  82
  83 /* SMBCMD masks */
  84 #define SMB_BLK_CLR     0x80
  85 #define T_OUT_CMD       0x08
  86 #define ABORT_HOST      0x04
  87
  88 /* SMBus commands */
  89 #define SMBQUICK        0x00
  90 #define SMBSRBYTE       0x10            /* send/receive byte */
  91 #define SMBWRBYTE       0x20            /* write/read byte */
  92 #define SMBWRWORD       0x30            /* write/read word */
  93 #define SMBWRBLOCK      0x40            /* write/read block */
  94
  95 /* PCI configuration registers and masks
  96  */
  97 #define COM             0x4
  98 #define COM_ENABLE_IO   0x1
  99
 100 #define SMBBA           PCIR_BAR(1)
 101
 102 #define ATPC            0x5b
 103 #define ATPC_SMBCTRL    0x04            /* XX linux has this as 0x6 */
 104
 105 #define SMBHSI          0xe0
 106 #define SMBHSI_SLAVE    0x2
 107 #define SMBHSI_HOST     0x1
 108
 109 #define SMBHCBC         0xe2
 110 #define SMBHCBC_CLOCK   0x70
 111
 112 #define SMBCLOCK_149K   0x0
 113 #define SMBCLOCK_74K    0x20
 114 #define SMBCLOCK_37K    0x40
 115 #define SMBCLOCK_223K   0x80
 116 #define SMBCLOCK_111K   0xa0
 117 #define SMBCLOCK_55K    0xc0
 118
 119 struct alpm_softc {
 120         int base;
 121         struct resource *res;
 122         bus_space_tag_t smbst;
 123         bus_space_handle_t smbsh;
 124         device_t smbus;
 125         struct lock lock;
 126 };
 127
 128 #define ALPM_LOCK(alpm)         lockmgr(&(alpm)->lock, LK_EXCLUSIVE)
 129 #define ALPM_UNLOCK(alpm)       lockmgr(&(alpm)->lock, LK_RELEASE)
 130 #define ALPM_LOCK_ASSERT(alpm)  KKASSERT(lockstatus(&(alpm)->lock, curthread) != 0)
 131
 132 #define ALPM_SMBINB(alpm,register) \
 133         (bus_space_read_1(alpm->smbst, alpm->smbsh, register))
 134 #define ALPM_SMBOUTB(alpm,register,value) \
 135         (bus_space_write_1(alpm->smbst, alpm->smbsh, register, value))
 136
 137 static int      alpm_detach(device_t dev);
 138
 139 static int
 140 alpm_probe(device_t dev)
 141 {
 142
 143         if (pci_get_devid(dev) == ACER_M1543_PMU_ID) {
 144                 device_set_desc(dev, "AcerLabs M15x3 Power Management Unit");
 145
 146                 return (BUS_PROBE_DEFAULT);
 147         }
 148
 149         return (ENXIO);
 150 }
 151
 152 static int
 153 alpm_attach(device_t dev)
 154 {
 155         int rid;
 156         u_int32_t l;
 157         struct alpm_softc *alpm;
 158
 159         alpm = device_get_softc(dev);
 160
 161         /* Unlock SMBIO base register access */
 162         l = pci_read_config(dev, ATPC, 1);
 163         pci_write_config(dev, ATPC, l & ~ATPC_SMBCTRL, 1);
 164
 165         /*
 166          * XX linux sets clock to 74k, should we?
 167         l = pci_read_config(dev, SMBHCBC, 1);
 168         l &= 0x1f;
 169         l |= SMBCLOCK_74K;
 170         pci_write_config(dev, SMBHCBC, l, 1);
 171          */
 172
 173         if (bootverbose || alpm_debug) {
 174                 l = pci_read_config(dev, SMBHSI, 1);
 175                 device_printf(dev, "%s/%s",
 176                         (l & SMBHSI_HOST) ? "host":"nohost",
 177                         (l & SMBHSI_SLAVE) ? "slave":"noslave");
 178
 179                 l = pci_read_config(dev, SMBHCBC, 1);
 180                 switch (l & SMBHCBC_CLOCK) {
 181                 case SMBCLOCK_149K:
 182                         kprintf(" 149K");
 183                         break;
 184                 case SMBCLOCK_74K:
 185                         kprintf(" 74K");
 186                         break;
 187                 case SMBCLOCK_37K:
 188                         kprintf(" 37K");
 189                         break;
 190                 case SMBCLOCK_223K:
 191                         kprintf(" 223K");
 192                         break;
 193                 case SMBCLOCK_111K:
 194                         kprintf(" 111K");
 195                         break;
 196                 case SMBCLOCK_55K:
 197                         kprintf(" 55K");
 198                         break;
 199                 default:
 200                         kprintf("unknown");
 201                         break;
 202                 }
 203                 kprintf("\n");
 204         }
 205
 206         rid = SMBBA;
 207         alpm->res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
 208             RF_ACTIVE);
 209
 210         if (alpm->res == NULL) {
 211                 device_printf(dev, "Could not allocate Bus space\n");
 212                 return (ENXIO);
 213         }
 214         alpm->smbst = rman_get_bustag(alpm->res);
 215         alpm->smbsh = rman_get_bushandle(alpm->res);
 216         lockinit(&alpm->lock, "alpm", 0, LK_CANRECURSE);
 217
 218         /* attach the smbus */
 219         alpm->smbus = device_add_child(dev, "smbus", -1);
 220         if (alpm->smbus == NULL) {
 221                 alpm_detach(dev);
 222                 return (EINVAL);
 223         }
 224         bus_generic_attach(dev);
 225
 226         return (0);
 227 }
 228
 229 static int
 230 alpm_detach(device_t dev)
 231 {
 232         struct alpm_softc *alpm = device_get_softc(dev);
 233
 234         if (alpm->smbus) {
 235                 device_delete_child(dev, alpm->smbus);
 236                 alpm->smbus = NULL;
 237         }
 238         lockuninit(&alpm->lock);
 239
 240         if (alpm->res)
 241                 bus_release_resource(dev, SYS_RES_IOPORT, SMBBA, alpm->res);
 242
 243         return (0);
 244 }
 245
 246 static int
 247 alpm_callback(device_t dev, int index, void *data)
 248 {
 249         int error = 0;
 250
 251         switch (index) {
 252         case SMB_REQUEST_BUS:
 253         case SMB_RELEASE_BUS:
 254                 /* ok, bus allocation accepted */
 255                 break;
 256         default:
 257                 error = EINVAL;
 258         }
 259
 260         return (error);
 261 }
 262
 263 static int
 264 alpm_clear(struct alpm_softc *sc)
 265 {
 266         ALPM_SMBOUTB(sc, SMBSTS, 0xff);
 267         DELAY(10);
 268
 269         return (0);
 270 }
 271
 272 #if 0
 273 static int
 274 alpm_abort(struct alpm_softc *sc)
 275 {
 276         ALPM_SMBOUTB(sc, SMBCMD, T_OUT_CMD | ABORT_HOST);
 277
 278         return (0);
 279 }
 280 #endif
 281
 282 static int
 283 alpm_idle(struct alpm_softc *sc)
 284 {
 285         u_char sts;
 286
 287         sts = ALPM_SMBINB(sc, SMBSTS);
 288
 289         ALPM_DEBUG(kprintf("alpm: idle? STS=0x%x\n", sts));
 290
 291         return (sts & IDL_STS);
 292 }
 293
 294 /*
 295  * Poll the SMBus controller
 296  */
 297 static int
 298 alpm_wait(struct alpm_softc *sc)
 299 {
 300         int count = 10000;
 301         u_char sts = 0;
 302         int error;
 303
 304         /* wait for command to complete and SMBus controller is idle */
 305         while (count--) {
 306                 DELAY(10);
 307                 sts = ALPM_SMBINB(sc, SMBSTS);
 308                 if (sts & SMI_I_STS)
 309                         break;
 310         }
 311
 312         ALPM_DEBUG(kprintf("alpm: STS=0x%x\n", sts));
 313
 314         error = SMB_ENOERR;
 315
 316         if (!count)
 317                 error |= SMB_ETIMEOUT;
 318
 319         if (sts & TERMINATE)
 320                 error |= SMB_EABORT;
 321
 322         if (sts & BUS_COLLI)
 323                 error |= SMB_ENOACK;
 324
 325         if (sts & DEVICE_ERR)
 326                 error |= SMB_EBUSERR;
 327
 328         if (error != SMB_ENOERR)
 329                 alpm_clear(sc);
 330
 331         return (error);
 332 }
 333
 334 static int
 335 alpm_quick(device_t dev, u_char slave, int how)
 336 {
 337         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 338         int error;
 339
 340         ALPM_LOCK(sc);
 341         alpm_clear(sc);
 342         if (!alpm_idle(sc)) {
 343                 ALPM_UNLOCK(sc);
 344                 return (EBUSY);
 345         }
 346
 347         switch (how) {
 348         case SMB_QWRITE:
 349                 ALPM_DEBUG(kprintf("alpm: QWRITE to 0x%x", slave));
 350                 ALPM_SMBOUTB(sc, SMBHADDR, slave & ~LSB);
 351                 break;
 352         case SMB_QREAD:
 353                 ALPM_DEBUG(kprintf("alpm: QREAD to 0x%x", slave));
 354                 ALPM_SMBOUTB(sc, SMBHADDR, slave | LSB);
 355                 break;
 356         default:
 357                 panic("%s: unknown QUICK command (%x)!", __func__, how);
 358         }
 359         ALPM_SMBOUTB(sc, SMBCMD, SMBQUICK);
 360         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 361
 362         error = alpm_wait(sc);
 363
 364         ALPM_DEBUG(kprintf(", error=0x%x\n", error));
 365         ALPM_UNLOCK(sc);
 366
 367         return (error);
 368 }
 369
 370 static int
 371 alpm_sendb(device_t dev, u_char slave, char byte)
 372 {
 373         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 374         int error;
 375
 376         ALPM_LOCK(sc);
 377         alpm_clear(sc);
 378         if (!alpm_idle(sc)) {
 379                 ALPM_UNLOCK(sc);
 380                 return (SMB_EBUSY);
 381         }
 382
 383         ALPM_SMBOUTB(sc, SMBHADDR, slave & ~LSB);
 384         ALPM_SMBOUTB(sc, SMBCMD, SMBSRBYTE);
 385         ALPM_SMBOUTB(sc, SMBHDATA, byte);
 386         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 387
 388         error = alpm_wait(sc);
 389
 390         ALPM_DEBUG(kprintf("alpm: SENDB to 0x%x, byte=0x%x, error=0x%x\n", slave, byte, error));
 391         ALPM_UNLOCK(sc);
 392
 393         return (error);
 394 }
 395
 396 static int
 397 alpm_recvb(device_t dev, u_char slave, char *byte)
 398 {
 399         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 400         int error;
 401
 402         ALPM_LOCK(sc);
 403         alpm_clear(sc);
 404         if (!alpm_idle(sc)) {
 405                 ALPM_UNLOCK(sc);
 406                 return (SMB_EBUSY);
 407         }
 408
 409         ALPM_SMBOUTB(sc, SMBHADDR, slave | LSB);
 410         ALPM_SMBOUTB(sc, SMBCMD, SMBSRBYTE);
 411         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 412
 413         if ((error = alpm_wait(sc)) == SMB_ENOERR)
 414                 *byte = ALPM_SMBINB(sc, SMBHDATA);
 415
 416         ALPM_DEBUG(kprintf("alpm: RECVB from 0x%x, byte=0x%x, error=0x%x\n", slave, *byte, error));
 417         ALPM_UNLOCK(sc);
 418
 419         return (error);
 420 }
 421
 422 static int
 423 alpm_writeb(device_t dev, u_char slave, char cmd, char byte)
 424 {
 425         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 426         int error;
 427
 428         ALPM_LOCK(sc);
 429         alpm_clear(sc);
 430         if (!alpm_idle(sc)) {
 431                 ALPM_UNLOCK(sc);
 432                 return (SMB_EBUSY);
 433         }
 434
 435         ALPM_SMBOUTB(sc, SMBHADDR, slave & ~LSB);
 436         ALPM_SMBOUTB(sc, SMBCMD, SMBWRBYTE);
 437         ALPM_SMBOUTB(sc, SMBHDATA, byte);
 438         ALPM_SMBOUTB(sc, SMBHCMD, cmd);
 439         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 440
 441         error = alpm_wait(sc);
 442
 443         ALPM_DEBUG(kprintf("alpm: WRITEB to 0x%x, cmd=0x%x, byte=0x%x, error=0x%x\n", slave, cmd, byte, error));
 444         ALPM_UNLOCK(sc);
 445
 446         return (error);
 447 }
 448
 449 static int
 450 alpm_readb(device_t dev, u_char slave, char cmd, char *byte)
 451 {
 452         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 453         int error;
 454
 455         ALPM_LOCK(sc);
 456         alpm_clear(sc);
 457         if (!alpm_idle(sc)) {
 458                 ALPM_UNLOCK(sc);
 459                 return (SMB_EBUSY);
 460         }
 461
 462         ALPM_SMBOUTB(sc, SMBHADDR, slave | LSB);
 463         ALPM_SMBOUTB(sc, SMBCMD, SMBWRBYTE);
 464         ALPM_SMBOUTB(sc, SMBHCMD, cmd);
 465         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 466
 467         if ((error = alpm_wait(sc)) == SMB_ENOERR)
 468                 *byte = ALPM_SMBINB(sc, SMBHDATA);
 469
 470         ALPM_DEBUG(kprintf("alpm: READB from 0x%x, cmd=0x%x, byte=0x%x, error=0x%x\n", slave, cmd, *byte, error));
 471         ALPM_UNLOCK(sc);
 472
 473         return (error);
 474 }
 475
 476 static int
 477 alpm_writew(device_t dev, u_char slave, char cmd, short word)
 478 {
 479         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 480         int error;
 481
 482         ALPM_LOCK(sc);
 483         alpm_clear(sc);
 484         if (!alpm_idle(sc)) {
 485                 ALPM_UNLOCK(sc);
 486                 return (SMB_EBUSY);
 487         }
 488
 489         ALPM_SMBOUTB(sc, SMBHADDR, slave & ~LSB);
 490         ALPM_SMBOUTB(sc, SMBCMD, SMBWRWORD);
 491         ALPM_SMBOUTB(sc, SMBHDATA, word & 0x00ff);
 492         ALPM_SMBOUTB(sc, SMBHDATB, (word & 0xff00) >> 8);
 493         ALPM_SMBOUTB(sc, SMBHCMD, cmd);
 494         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 495
 496         error = alpm_wait(sc);
 497
 498         ALPM_DEBUG(kprintf("alpm: WRITEW to 0x%x, cmd=0x%x, word=0x%x, error=0x%x\n", slave, cmd, word, error));
 499         ALPM_UNLOCK(sc);
 500
 501         return (error);
 502 }
 503
 504 static int
 505 alpm_readw(device_t dev, u_char slave, char cmd, short *word)
 506 {
 507         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 508         int error;
 509         u_char high, low;
 510
 511         ALPM_LOCK(sc);
 512         alpm_clear(sc);
 513         if (!alpm_idle(sc)) {
 514                 ALPM_UNLOCK(sc);
 515                 return (SMB_EBUSY);
 516         }
 517
 518         ALPM_SMBOUTB(sc, SMBHADDR, slave | LSB);
 519         ALPM_SMBOUTB(sc, SMBCMD, SMBWRWORD);
 520         ALPM_SMBOUTB(sc, SMBHCMD, cmd);
 521         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 522
 523         if ((error = alpm_wait(sc)) == SMB_ENOERR) {
 524                 low = ALPM_SMBINB(sc, SMBHDATA);
 525                 high = ALPM_SMBINB(sc, SMBHDATB);
 526
 527                 *word = ((high & 0xff) << 8) | (low & 0xff);
 528         }
 529
 530         ALPM_DEBUG(kprintf("alpm: READW from 0x%x, cmd=0x%x, word=0x%x, error=0x%x\n", slave, cmd, *word, error));
 531         ALPM_UNLOCK(sc);
 532
 533         return (error);
 534 }
 535
 536 static int
 537 alpm_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
 538 {
 539         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 540         u_char i;
 541         int error;
 542
 543         if (count < 1 || count > 32)
 544                 return (SMB_EINVAL);
 545
 546         ALPM_LOCK(sc);
 547         alpm_clear(sc);
 548         if(!alpm_idle(sc)) {
 549                 ALPM_UNLOCK(sc);
 550                 return (SMB_EBUSY);
 551         }
 552
 553         ALPM_SMBOUTB(sc, SMBHADDR, slave & ~LSB);
 554
 555         /* set the cmd and reset the
 556          * 32-byte long internal buffer */
 557         ALPM_SMBOUTB(sc, SMBCMD, SMBWRBLOCK | SMB_BLK_CLR);
 558
 559         ALPM_SMBOUTB(sc, SMBHDATA, count);
 560
 561         /* fill the 32-byte internal buffer */
 562         for (i = 0; i < count; i++) {
 563                 ALPM_SMBOUTB(sc, SMBHBLOCK, buf[i]);
 564                 DELAY(2);
 565         }
 566         ALPM_SMBOUTB(sc, SMBHCMD, cmd);
 567         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 568
 569         error = alpm_wait(sc);
 570
 571         ALPM_DEBUG(kprintf("alpm: WRITEBLK to 0x%x, count=0x%x, cmd=0x%x, error=0x%x", slave, count, cmd, error));
 572         ALPM_UNLOCK(sc);
 573
 574         return (error);
 575 }
 576
 577 static int
 578 alpm_bread(device_t dev, u_char slave, char cmd, u_char *count, char *buf)
 579 {
 580         struct alpm_softc *sc = (struct alpm_softc *)device_get_softc(dev);
 581         u_char data, len, i;
 582         int error;
 583
 584         if (*count < 1 || *count > 32)
 585                 return (SMB_EINVAL);
 586
 587         ALPM_LOCK(sc);
 588         alpm_clear(sc);
 589         if (!alpm_idle(sc)) {
 590                 ALPM_UNLOCK(sc);
 591                 return (SMB_EBUSY);
 592         }
 593
 594         ALPM_SMBOUTB(sc, SMBHADDR, slave | LSB);
 595
 596         /* set the cmd and reset the
 597          * 32-byte long internal buffer */
 598         ALPM_SMBOUTB(sc, SMBCMD, SMBWRBLOCK | SMB_BLK_CLR);
 599
 600         ALPM_SMBOUTB(sc, SMBHCMD, cmd);
 601         ALPM_SMBOUTB(sc, SMBSTART, 0xff);
 602
 603         if ((error = alpm_wait(sc)) != SMB_ENOERR)
 604                 goto error;
 605
 606         len = ALPM_SMBINB(sc, SMBHDATA);
 607
 608         /* read the 32-byte internal buffer */
 609         for (i = 0; i < len; i++) {
 610                 data = ALPM_SMBINB(sc, SMBHBLOCK);
 611                 if (i < *count)
 612                         buf[i] = data;
 613                 DELAY(2);
 614         }
 615         *count = len;
 616
 617 error:
 618         ALPM_DEBUG(kprintf("alpm: READBLK to 0x%x, count=0x%x, cmd=0x%x, error=0x%x", slave, *count, cmd, error));
 619         ALPM_UNLOCK(sc);
 620
 621         return (error);
 622 }
 623
 624 static devclass_t alpm_devclass;
 625
 626 static device_method_t alpm_methods[] = {
 627         /* device interface */
 628         DEVMETHOD(device_probe,         alpm_probe),
 629         DEVMETHOD(device_attach,        alpm_attach),
 630         DEVMETHOD(device_detach,        alpm_detach),
 631
 632         /* smbus interface */
 633         DEVMETHOD(smbus_callback,       alpm_callback),
 634         DEVMETHOD(smbus_quick,          alpm_quick),
 635         DEVMETHOD(smbus_sendb,          alpm_sendb),
 636         DEVMETHOD(smbus_recvb,          alpm_recvb),
 637         DEVMETHOD(smbus_writeb,         alpm_writeb),
 638         DEVMETHOD(smbus_readb,          alpm_readb),
 639         DEVMETHOD(smbus_writew,         alpm_writew),
 640         DEVMETHOD(smbus_readw,          alpm_readw),
 641         DEVMETHOD(smbus_bwrite,         alpm_bwrite),
 642         DEVMETHOD(smbus_bread,          alpm_bread),
 643
 644         DEVMETHOD_END
 645 };
 646
 647 static driver_t alpm_driver = {
 648         "alpm",
 649         alpm_methods,
 650         sizeof(struct alpm_softc)
 651 };
 652
 653 DRIVER_MODULE(alpm, pci, alpm_driver, alpm_devclass, NULL, NULL);
 654 DRIVER_MODULE(smbus, alpm, smbus_driver, smbus_devclass, NULL, NULL);
 655 MODULE_DEPEND(alpm, pci, 1, 1, 1);
 656 MODULE_DEPEND(alpm, smbus, SMBUS_MINVER, SMBUS_PREFVER, SMBUS_MAXVER);
 657 MODULE_VERSION(alpm, 1);