The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/pci/amdsmb.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 #include <sys/cdefs.h>
    2 __FBSDID("$FreeBSD$");
    3 
    4 #include <sys/param.h>
    5 #include <sys/kernel.h>
    6 #include <sys/systm.h>
    7 #include <sys/module.h>
    8 #include <sys/bus.h>
    9 #include <sys/uio.h>
   10 
   11 #include <machine/bus.h>
   12 #include <machine/resource.h>
   13 #include <sys/rman.h>
   14 
   15 #include <dev/pci/pcivar.h>
   16 #include <dev/pci/pcireg.h>
   17 
   18 #include <dev/iicbus/iiconf.h>
   19 #include <dev/smbus/smbconf.h>
   20 #include "smbus_if.h"
   21 
   22 #define AMDSMB_DEBUG(x) if (amdsmb_debug) (x)
   23 
   24 #ifdef DEBUG
   25 static int amdsmb_debug = 1;
   26 #else
   27 static int amdsmb_debug = 0;
   28 #endif
   29 
   30 #define AMDSMB_VENDORID_AMD             0x1022
   31 #define AMDSMB_DEVICEID_AMD8111_SMB2    0x746a
   32 
   33 /*
   34  * ACPI 3.0, Chapter 12, Embedded Controller Interface.
   35  */
   36 #define EC_DATA         0x00    /* data register */
   37 #define EC_SC           0x04    /* status of controller */
   38 #define EC_CMD          0x04    /* command register */
   39 
   40 #define EC_SC_IBF       0x02    /* data ready for embedded controller */
   41 #define EC_SC_OBF       0x01    /* data ready for host */
   42 #define EC_CMD_WR       0x81    /* write EC */
   43 #define EC_CMD_RD       0x80    /* read EC */
   44 
   45 /*
   46  * ACPI 3.0, Chapter 12, SMBus Host Controller Interface.
   47  */
   48 #define SMB_PRTCL       0x00    /* protocol */
   49 #define SMB_STS         0x01    /* status */
   50 #define SMB_ADDR        0x02    /* address */
   51 #define SMB_CMD         0x03    /* command */
   52 #define SMB_DATA        0x04    /* 32 data registers */
   53 #define SMB_BCNT        0x24    /* number of data bytes */
   54 #define SMB_ALRM_A      0x25    /* alarm address */
   55 #define SMB_ALRM_D      0x26    /* 2 bytes alarm data */
   56 
   57 #define SMB_STS_DONE    0x80
   58 #define SMB_STS_ALRM    0x40
   59 #define SMB_STS_RES     0x20
   60 #define SMB_STS_STATUS  0x1f
   61 #define SMB_STS_OK      0x00    /* OK */
   62 #define SMB_STS_UF      0x07    /* Unknown Failure */
   63 #define SMB_STS_DANA    0x10    /* Device Address Not Acknowledged */
   64 #define SMB_STS_DED     0x11    /* Device Error Detected */
   65 #define SMB_STS_DCAD    0x12    /* Device Command Access Denied */
   66 #define SMB_STS_UE      0x13    /* Unknown Error */
   67 #define SMB_STS_DAD     0x17    /* Device Access Denied */
   68 #define SMB_STS_T       0x18    /* Timeout */
   69 #define SMB_STS_HUP     0x19    /* Host Unsupported Protocol */
   70 #define SMB_STS_B       0x1a    /* Busy */
   71 #define SMB_STS_PEC     0x1f    /* PEC (CRC-8) Error */
   72 
   73 #define SMB_PRTCL_WRITE                 0x00
   74 #define SMB_PRTCL_READ                  0x01
   75 #define SMB_PRTCL_QUICK                 0x02
   76 #define SMB_PRTCL_BYTE                  0x04
   77 #define SMB_PRTCL_BYTE_DATA             0x06
   78 #define SMB_PRTCL_WORD_DATA             0x08
   79 #define SMB_PRTCL_BLOCK_DATA            0x0a
   80 #define SMB_PRTCL_PROC_CALL             0x0c
   81 #define SMB_PRTCL_BLOCK_PROC_CALL       0x0d
   82 #define SMB_PRTCL_PEC                   0x80
   83 
   84 struct amdsmb_softc {
   85         int rid;
   86         struct resource *res;
   87         bus_space_tag_t smbst;
   88         bus_space_handle_t smbsh;
   89 
   90         device_t smbus;
   91 };
   92 
   93 #define AMDSMB_ECINB(amdsmb, register) \
   94         (bus_space_read_1(amdsmb->smbst, amdsmb->smbsh, register))
   95 #define AMDSMB_ECOUTB(amdsmb, register, value) \
   96         (bus_space_write_1(amdsmb->smbst, amdsmb->smbsh, register, value))
   97 
   98 static int
   99 amdsmb_probe(device_t dev)
  100 {
  101         u_int16_t vid;
  102         u_int16_t did;
  103 
  104         vid = pci_get_vendor(dev);
  105         did = pci_get_device(dev);
  106 
  107         if (vid == AMDSMB_VENDORID_AMD) {
  108                 switch(did) {
  109                 case AMDSMB_DEVICEID_AMD8111_SMB2:
  110                         device_set_desc(dev, "AMD-8111 SMBus 2.0 Controller");
  111                         return (BUS_PROBE_DEFAULT);
  112                 }
  113         }
  114 
  115         return (ENXIO);
  116 }
  117 
  118 static int
  119 amdsmb_attach(device_t dev)
  120 {
  121         struct amdsmb_softc *amdsmb_sc = device_get_softc(dev);
  122 
  123         /* Allocate I/O space */
  124         amdsmb_sc->rid = PCIR_BAR(0);
  125         
  126         amdsmb_sc->res = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
  127                 &amdsmb_sc->rid, RF_ACTIVE);
  128 
  129         if (amdsmb_sc->res == NULL) {
  130                 device_printf(dev, "could not map i/o space\n");
  131                 return (ENXIO);
  132         }
  133 
  134         amdsmb_sc->smbst = rman_get_bustag(amdsmb_sc->res);
  135         amdsmb_sc->smbsh = rman_get_bushandle(amdsmb_sc->res);
  136 
  137         /* Allocate a new smbus device */
  138         amdsmb_sc->smbus = device_add_child(dev, "smbus", -1);
  139         if (!amdsmb_sc->smbus)
  140                 return (EINVAL);
  141 
  142         bus_generic_attach(dev);
  143 
  144         return (0);
  145 }
  146 
  147 static int
  148 amdsmb_detach(device_t dev)
  149 {
  150         struct amdsmb_softc *amdsmb_sc = device_get_softc(dev);
  151 
  152         if (amdsmb_sc->smbus) {
  153                 device_delete_child(dev, amdsmb_sc->smbus);
  154                 amdsmb_sc->smbus = NULL;
  155         }
  156 
  157         if (amdsmb_sc->res)
  158                 bus_release_resource(dev, SYS_RES_IOPORT, amdsmb_sc->rid,
  159                     amdsmb_sc->res);
  160 
  161         return (0);
  162 }
  163 
  164 static int
  165 amdsmb_callback(device_t dev, int index, void *data)
  166 {
  167         int error = 0;
  168 
  169         switch (index) {
  170         case SMB_REQUEST_BUS:
  171         case SMB_RELEASE_BUS:
  172                 break;
  173         default:
  174                 error = EINVAL;
  175         }
  176 
  177         return (error);
  178 }
  179 
  180 static int
  181 amdsmb_ec_wait_write(struct amdsmb_softc *sc)
  182 {
  183         int timeout = 500;
  184 
  185         while (timeout-- && AMDSMB_ECINB(sc, EC_SC) & EC_SC_IBF)
  186                 DELAY(1);
  187         if (timeout == 0) {
  188                 device_printf(sc->smbus, "timeout waiting for IBF to clear\n");
  189                 return (1);
  190         }
  191         return (0);
  192 }
  193 
  194 static int
  195 amdsmb_ec_wait_read(struct amdsmb_softc *sc)
  196 {
  197         int timeout = 500;
  198 
  199         while (timeout-- && ~AMDSMB_ECINB(sc, EC_SC) & EC_SC_OBF)
  200                 DELAY(1);
  201         if (timeout == 0) {
  202                 device_printf(sc->smbus, "timeout waiting for OBF to set\n");
  203                 return (1);
  204         }
  205         return (0);
  206 }
  207 
  208 static int
  209 amdsmb_ec_read(struct amdsmb_softc *sc, u_char addr, u_char *data)
  210 {
  211 
  212         if (amdsmb_ec_wait_write(sc))
  213                 return (1);
  214         AMDSMB_ECOUTB(sc, EC_CMD, EC_CMD_RD);
  215 
  216         if (amdsmb_ec_wait_write(sc))
  217                 return (1);
  218         AMDSMB_ECOUTB(sc, EC_DATA, addr);
  219 
  220         if (amdsmb_ec_wait_read(sc))
  221                 return (1);
  222         *data = AMDSMB_ECINB(sc, EC_DATA);
  223 
  224         return (0);
  225 }
  226 
  227 static int
  228 amdsmb_ec_write(struct amdsmb_softc *sc, u_char addr, u_char data)
  229 {
  230 
  231         if (amdsmb_ec_wait_write(sc))
  232                 return (1);
  233         AMDSMB_ECOUTB(sc, EC_CMD, EC_CMD_WR);
  234 
  235         if (amdsmb_ec_wait_write(sc))
  236                 return (1);
  237         AMDSMB_ECOUTB(sc, EC_DATA, addr);
  238 
  239         if (amdsmb_ec_wait_write(sc))
  240                 return (1);
  241         AMDSMB_ECOUTB(sc, EC_DATA, data);
  242 
  243         return (0);
  244 }
  245 
  246 static int
  247 amdsmb_wait(struct amdsmb_softc *sc)
  248 {
  249         u_char sts, temp;
  250         int error, count;
  251 
  252         amdsmb_ec_read(sc, SMB_PRTCL, &temp);
  253         if (temp != 0)
  254         {
  255                 count = 10000;
  256                 do {
  257                         DELAY(500);
  258                         amdsmb_ec_read(sc, SMB_PRTCL, &temp);
  259                 } while (temp != 0 && count--);
  260                 if (count == 0)
  261                         return (SMB_ETIMEOUT);
  262         }
  263 
  264         amdsmb_ec_read(sc, SMB_STS, &sts);
  265         sts &= SMB_STS_STATUS;
  266         AMDSMB_DEBUG(printf("amdsmb: STS=0x%x\n", sts));
  267 
  268         switch (sts) {
  269         case SMB_STS_OK:
  270                 error = SMB_ENOERR;
  271                 break;
  272         case SMB_STS_DANA:
  273                 error = SMB_ENOACK;
  274                 break;
  275         case SMB_STS_B:
  276                 error = SMB_EBUSY;
  277                 break;
  278         case SMB_STS_T:
  279                 error = SMB_ETIMEOUT;
  280                 break;
  281         case SMB_STS_DCAD:
  282         case SMB_STS_DAD:
  283         case SMB_STS_HUP:
  284                 error = SMB_ENOTSUPP;
  285                 break;
  286         default:
  287                 error = SMB_EBUSERR;
  288                 break;
  289         }
  290 
  291         return (error);
  292 }
  293 
  294 static int
  295 amdsmb_quick(device_t dev, u_char slave, int how)
  296 {
  297         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  298         u_char protocol;
  299         int error;
  300 
  301         protocol = SMB_PRTCL_QUICK;
  302 
  303         switch (how) {
  304         case SMB_QWRITE:
  305                 protocol |= SMB_PRTCL_WRITE;
  306                 AMDSMB_DEBUG(printf("amdsmb: QWRITE to 0x%x", slave));
  307                 break;
  308         case SMB_QREAD:
  309                 protocol |= SMB_PRTCL_READ;
  310                 AMDSMB_DEBUG(printf("amdsmb: QREAD to 0x%x", slave));
  311                 break;
  312         default:
  313                 panic("%s: unknown QUICK command (%x)!", __func__, how);
  314         }
  315 
  316         amdsmb_ec_write(sc, SMB_ADDR, slave);
  317         amdsmb_ec_write(sc, SMB_PRTCL, protocol);
  318 
  319         error = amdsmb_wait(sc);
  320 
  321         AMDSMB_DEBUG(printf(", error=0x%x\n", error));
  322 
  323         return (error);
  324 }
  325 
  326 static int
  327 amdsmb_sendb(device_t dev, u_char slave, char byte)
  328 {
  329         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  330         int error;
  331 
  332         amdsmb_ec_write(sc, SMB_CMD, byte);
  333         amdsmb_ec_write(sc, SMB_ADDR, slave);
  334         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_WRITE | SMB_PRTCL_BYTE);
  335 
  336         error = amdsmb_wait(sc);
  337 
  338         AMDSMB_DEBUG(printf("amdsmb: SENDB to 0x%x, byte=0x%x, error=0x%x\n",
  339            slave, byte, error));
  340 
  341         return (error);
  342 }
  343 
  344 static int
  345 amdsmb_recvb(device_t dev, u_char slave, char *byte)
  346 {
  347         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  348         int error;
  349 
  350         amdsmb_ec_write(sc, SMB_ADDR, slave);
  351         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_READ | SMB_PRTCL_BYTE);
  352 
  353         if ((error = amdsmb_wait(sc)) == SMB_ENOERR)
  354                 amdsmb_ec_read(sc, SMB_DATA, byte);
  355 
  356         AMDSMB_DEBUG(printf("amdsmb: RECVB from 0x%x, byte=0x%x, error=0x%x\n",
  357             slave, *byte, error));
  358 
  359         return (error);
  360 }
  361 
  362 static int
  363 amdsmb_writeb(device_t dev, u_char slave, char cmd, char byte)
  364 {
  365         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  366         int error;
  367 
  368         amdsmb_ec_write(sc, SMB_CMD, cmd);
  369         amdsmb_ec_write(sc, SMB_DATA, byte);
  370         amdsmb_ec_write(sc, SMB_ADDR, slave);
  371         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_WRITE | SMB_PRTCL_BYTE_DATA);
  372 
  373         error = amdsmb_wait(sc);
  374 
  375         AMDSMB_DEBUG(printf("amdsmb: WRITEB to 0x%x, cmd=0x%x, byte=0x%x, "
  376             "error=0x%x\n", slave, cmd, byte, error));
  377 
  378         return (error);
  379 }
  380 
  381 static int
  382 amdsmb_readb(device_t dev, u_char slave, char cmd, char *byte)
  383 {
  384         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  385         int error;
  386 
  387         amdsmb_ec_write(sc, SMB_CMD, cmd);
  388         amdsmb_ec_write(sc, SMB_ADDR, slave);
  389         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_READ | SMB_PRTCL_BYTE_DATA);
  390 
  391         if ((error = amdsmb_wait(sc)) == SMB_ENOERR)
  392                 amdsmb_ec_read(sc, SMB_DATA, byte);
  393 
  394         AMDSMB_DEBUG(printf("amdsmb: READB from 0x%x, cmd=0x%x, byte=0x%x, "
  395             "error=0x%x\n", slave, cmd, (unsigned char)*byte, error));
  396 
  397         return (error);
  398 }
  399 
  400 static int
  401 amdsmb_writew(device_t dev, u_char slave, char cmd, short word)
  402 {
  403         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  404         int error;
  405 
  406         amdsmb_ec_write(sc, SMB_CMD, cmd);
  407         amdsmb_ec_write(sc, SMB_DATA, word);
  408         amdsmb_ec_write(sc, SMB_DATA + 1, word >> 8);
  409         amdsmb_ec_write(sc, SMB_ADDR, slave);
  410         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_WRITE | SMB_PRTCL_WORD_DATA);
  411 
  412         error = amdsmb_wait(sc);
  413 
  414         AMDSMB_DEBUG(printf("amdsmb: WRITEW to 0x%x, cmd=0x%x, word=0x%x, "
  415             "error=0x%x\n", slave, cmd, word, error));
  416 
  417         return (error);
  418 }
  419 
  420 static int
  421 amdsmb_readw(device_t dev, u_char slave, char cmd, short *word)
  422 {
  423         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  424         u_char temp[2];
  425         int error;
  426 
  427         amdsmb_ec_write(sc, SMB_CMD, cmd);
  428         amdsmb_ec_write(sc, SMB_ADDR, slave);
  429         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_READ | SMB_PRTCL_WORD_DATA);
  430 
  431         if ((error = amdsmb_wait(sc)) == SMB_ENOERR) {
  432                 amdsmb_ec_read(sc, SMB_DATA + 0, &temp[0]);
  433                 amdsmb_ec_read(sc, SMB_DATA + 1, &temp[1]);
  434                 *word = temp[0] | (temp[1] << 8);
  435         }
  436 
  437         AMDSMB_DEBUG(printf("amdsmb: READW from 0x%x, cmd=0x%x, word=0x%x, "
  438             "error=0x%x\n", slave, cmd, (unsigned short)*word, error));
  439 
  440         return (error);
  441 }
  442 
  443 static int
  444 amdsmb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
  445 {
  446         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  447         u_char i;
  448         int error;
  449 
  450         if (count < 1 || count > 32)
  451                 return (SMB_EINVAL);
  452         amdsmb_ec_write(sc, SMB_CMD, cmd);
  453         amdsmb_ec_write(sc, SMB_BCNT, count);
  454         for (i = 0; i < count; i++)
  455                 amdsmb_ec_write(sc, SMB_DATA + i, buf[i]);
  456         amdsmb_ec_write(sc, SMB_ADDR, slave);
  457         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_WRITE | SMB_PRTCL_BLOCK_DATA);
  458 
  459         error = amdsmb_wait(sc);
  460 
  461         AMDSMB_DEBUG(printf("amdsmb: WRITEBLK to 0x%x, count=0x%x, cmd=0x%x, "
  462             "error=0x%x", slave, count, cmd, error));
  463 
  464         return (error);
  465 }
  466 
  467 static int
  468 amdsmb_bread(device_t dev, u_char slave, char cmd, u_char *count, char *buf)
  469 {
  470         struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
  471         u_char data, len, i;
  472         int error;
  473 
  474         if (*count < 1 || *count > 32)
  475                 return (SMB_EINVAL);
  476         amdsmb_ec_write(sc, SMB_CMD, cmd);
  477         amdsmb_ec_write(sc, SMB_ADDR, slave);
  478         amdsmb_ec_write(sc, SMB_PRTCL, SMB_PRTCL_READ | SMB_PRTCL_BLOCK_DATA);
  479 
  480         if ((error = amdsmb_wait(sc)) == SMB_ENOERR) {
  481                 amdsmb_ec_read(sc, SMB_BCNT, &len);
  482                 for (i = 0; i < len; i++) {
  483                         amdsmb_ec_read(sc, SMB_DATA + i, &data);
  484                         if (i < *count)
  485                                 buf[i] = data;
  486                 }
  487                 *count = len;
  488         }
  489 
  490         AMDSMB_DEBUG(printf("amdsmb: READBLK to 0x%x, count=0x%x, cmd=0x%x, "
  491             "error=0x%x", slave, *count, cmd, error));
  492 
  493         return (error);
  494 }
  495 
  496 static device_method_t amdsmb_methods[] = {
  497         /* Device interface */
  498         DEVMETHOD(device_probe,         amdsmb_probe),
  499         DEVMETHOD(device_attach,        amdsmb_attach),
  500         DEVMETHOD(device_detach,        amdsmb_detach),
  501 
  502         /* SMBus interface */
  503         DEVMETHOD(smbus_callback,       amdsmb_callback),
  504         DEVMETHOD(smbus_quick,          amdsmb_quick),
  505         DEVMETHOD(smbus_sendb,          amdsmb_sendb),
  506         DEVMETHOD(smbus_recvb,          amdsmb_recvb),
  507         DEVMETHOD(smbus_writeb,         amdsmb_writeb),
  508         DEVMETHOD(smbus_readb,          amdsmb_readb),
  509         DEVMETHOD(smbus_writew,         amdsmb_writew),
  510         DEVMETHOD(smbus_readw,          amdsmb_readw),
  511         DEVMETHOD(smbus_bwrite,         amdsmb_bwrite),
  512         DEVMETHOD(smbus_bread,          amdsmb_bread),
  513 
  514         { 0, 0 }
  515 };
  516 
  517 static devclass_t amdsmb_devclass;
  518 
  519 static driver_t amdsmb_driver = {
  520         "amdsmb",
  521         amdsmb_methods,
  522         sizeof(struct amdsmb_softc),
  523 };
  524 
  525 DRIVER_MODULE(amdsmb, pci, amdsmb_driver, amdsmb_devclass, 0, 0);
  526 DRIVER_MODULE(smbus, amdsmb, smbus_driver, smbus_devclass, 0, 0);
  527 
  528 MODULE_DEPEND(amdsmb, pci, 1, 1, 1);
  529 MODULE_DEPEND(amdsmb, smbus, SMBUS_MINVER, SMBUS_PREFVER, SMBUS_MAXVER);
  530 MODULE_VERSION(amdsmb, 1);

Cache object: 9d70dfbafa32e2955ec16e48a790d879


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.