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/viapm.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 /*-
    2  * Copyright (c) 2001 Alcove - 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 
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD: releng/8.2/sys/pci/viapm.c 199583 2009-11-20 15:27:52Z jhb $");
   29 
   30 #include "opt_isa.h"
   31 
   32 #include <sys/param.h>
   33 #include <sys/bus.h>
   34 #include <sys/kernel.h>
   35 #include <sys/lock.h>
   36 #include <sys/module.h>
   37 #include <sys/mutex.h>
   38 #include <sys/systm.h>
   39 
   40 #include <machine/bus.h>
   41 #include <machine/resource.h>
   42 #include <sys/rman.h>
   43 
   44 #ifdef DEV_ISA
   45 #include <isa/isavar.h>
   46 #include <isa/isa_common.h>
   47 #endif
   48 #include <dev/pci/pcivar.h>
   49 #include <dev/pci/pcireg.h>
   50 
   51 #include <dev/iicbus/iiconf.h>
   52 
   53 #include <dev/smbus/smbconf.h>
   54 
   55 #include "iicbb_if.h"
   56 #include "smbus_if.h"
   57 
   58 #define VIAPM_DEBUG(x)  if (viapm_debug) (x)
   59 
   60 #ifdef DEBUG
   61 static int viapm_debug = 1;
   62 #else
   63 static int viapm_debug = 0;
   64 #endif
   65 
   66 #define VIA_586B_PMU_ID         0x30401106
   67 #define VIA_596A_PMU_ID         0x30501106
   68 #define VIA_596B_PMU_ID         0x30511106
   69 #define VIA_686A_PMU_ID         0x30571106
   70 #define VIA_8233_PMU_ID         0x30741106
   71 #define VIA_8233A_PMU_ID        0x31471106
   72 #define VIA_8235_PMU_ID         0x31771106
   73 #define VIA_8237_PMU_ID         0x32271106
   74 #define VIA_CX700_PMU_ID        0x83241106
   75 
   76 #define VIAPM_INB(port) \
   77         ((u_char)bus_read_1(viapm->iores, port))
   78 #define VIAPM_OUTB(port,val) \
   79         (bus_write_1(viapm->iores, port, (u_char)(val)))
   80 
   81 #define VIAPM_TYP_UNKNOWN       0
   82 #define VIAPM_TYP_586B_3040E    1
   83 #define VIAPM_TYP_586B_3040F    2
   84 #define VIAPM_TYP_596B          3
   85 #define VIAPM_TYP_686A          4
   86 #define VIAPM_TYP_8233          5
   87 
   88 #define VIAPM_LOCK(sc)          mtx_lock(&(sc)->lock)
   89 #define VIAPM_UNLOCK(sc)        mtx_unlock(&(sc)->lock)
   90 #define VIAPM_LOCK_ASSERT(sc)   mtx_assert(&(sc)->lock, MA_OWNED)
   91 
   92 struct viapm_softc {
   93         int type;
   94         u_int32_t base;
   95         int iorid;
   96         int irqrid;
   97         struct resource *iores;
   98         struct resource *irqres;
   99         void *irqih;
  100         device_t iicbb;
  101         device_t smbus;
  102         struct mtx lock;
  103 };
  104 
  105 static devclass_t viapm_devclass;
  106 static devclass_t viapropm_devclass;
  107 
  108 /*
  109  * VT82C586B definitions
  110  */
  111 
  112 #define VIAPM_586B_REVID        0x08
  113 
  114 #define VIAPM_586B_3040E_BASE   0x20
  115 #define VIAPM_586B_3040E_ACTIV  0x4             /* 16 bits */
  116 
  117 #define VIAPM_586B_3040F_BASE   0x48
  118 #define VIAPM_586B_3040F_ACTIV  0x41            /* 8 bits */
  119 
  120 #define VIAPM_586B_OEM_REV_E    0x00
  121 #define VIAPM_586B_OEM_REV_F    0x01
  122 #define VIAPM_586B_PROD_REV_A   0x10
  123 
  124 #define VIAPM_586B_BA_MASK      0x0000ff00
  125 
  126 #define GPIO_DIR        0x40
  127 #define GPIO_VAL        0x42
  128 #define EXTSMI_VAL      0x44
  129 
  130 #define VIAPM_SCL       0x02                    /* GPIO1_VAL */
  131 #define VIAPM_SDA       0x04                    /* GPIO2_VAL */
  132 
  133 /*
  134  * VIAPRO common definitions
  135  */
  136 
  137 #define VIAPM_PRO_BA_MASK       0x0000fff0
  138 #define VIAPM_PRO_SMBCTRL       0xd2
  139 #define VIAPM_PRO_REVID         0xd6
  140 
  141 /*
  142  * VT82C686A definitions
  143  */
  144 
  145 #define VIAPM_PRO_BASE          0x90
  146 
  147 #define SMBHST                  0x0
  148 #define SMBHSL                  0x1
  149 #define SMBHCTRL                0x2
  150 #define SMBHCMD                 0x3
  151 #define SMBHADDR                0x4
  152 #define SMBHDATA0               0x5
  153 #define SMBHDATA1               0x6
  154 #define SMBHBLOCK               0x7
  155 
  156 #define SMBSST                  0x1
  157 #define SMBSCTRL                0x8
  158 #define SMBSSDWCMD              0x9
  159 #define SMBSEVENT               0xa
  160 #define SMBSDATA                0xc
  161 
  162 #define SMBHST_RESERVED         0xef    /* reserved bits */
  163 #define SMBHST_FAILED           0x10    /* failed bus transaction */
  164 #define SMBHST_COLLID           0x08    /* bus collision */
  165 #define SMBHST_ERROR            0x04    /* device error */
  166 #define SMBHST_INTR             0x02    /* command completed */
  167 #define SMBHST_BUSY             0x01    /* host busy */
  168 
  169 #define SMBHCTRL_START          0x40    /* start command */
  170 #define SMBHCTRL_PROTO          0x1c    /* command protocol mask */
  171 #define SMBHCTRL_QUICK          0x00
  172 #define SMBHCTRL_SENDRECV       0x04
  173 #define SMBHCTRL_BYTE           0x08
  174 #define SMBHCTRL_WORD           0x0c
  175 #define SMBHCTRL_BLOCK          0x14
  176 #define SMBHCTRL_KILL           0x02    /* stop the current transaction */
  177 #define SMBHCTRL_ENABLE         0x01    /* enable interrupts */
  178 
  179 #define SMBSCTRL_ENABLE         0x01    /* enable slave */
  180 
  181 
  182 /*
  183  * VIA8233 definitions
  184  */
  185 
  186 #define VIAPM_8233_BASE         0xD0
  187 
  188 static int
  189 viapm_586b_probe(device_t dev)
  190 {
  191         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  192         u_int32_t l;
  193         u_int16_t s;
  194         u_int8_t c;
  195 
  196         switch (pci_get_devid(dev)) {
  197         case VIA_586B_PMU_ID:
  198 
  199                 bzero(viapm, sizeof(struct viapm_softc));
  200 
  201                 l = pci_read_config(dev, VIAPM_586B_REVID, 1);
  202                 switch (l) {
  203                 case VIAPM_586B_OEM_REV_E:
  204                         viapm->type = VIAPM_TYP_586B_3040E;
  205                         viapm->iorid = VIAPM_586B_3040E_BASE;
  206 
  207                         /* Activate IO block access */
  208                         s = pci_read_config(dev, VIAPM_586B_3040E_ACTIV, 2);
  209                         pci_write_config(dev, VIAPM_586B_3040E_ACTIV, s | 0x1, 2);
  210                         break;
  211 
  212                 case VIAPM_586B_OEM_REV_F:
  213                 case VIAPM_586B_PROD_REV_A:
  214                 default:
  215                         viapm->type = VIAPM_TYP_586B_3040F;
  216                         viapm->iorid = VIAPM_586B_3040F_BASE;
  217 
  218                         /* Activate IO block access */
  219                         c = pci_read_config(dev, VIAPM_586B_3040F_ACTIV, 1);
  220                         pci_write_config(dev, VIAPM_586B_3040F_ACTIV, c | 0x80, 1);
  221                         break;
  222                 }
  223 
  224                 viapm->base = pci_read_config(dev, viapm->iorid, 4) &
  225                                 VIAPM_586B_BA_MASK;
  226 
  227                 /*
  228                  * We have to set the I/O resources by hand because it is
  229                  * described outside the viapmope of the traditional maps
  230                  */
  231                 if (bus_set_resource(dev, SYS_RES_IOPORT, viapm->iorid,
  232                                                         viapm->base, 256)) {
  233                         device_printf(dev, "could not set bus resource\n");
  234                         return ENXIO;
  235                 }
  236                 device_set_desc(dev, "VIA VT82C586B Power Management Unit");
  237                 return (BUS_PROBE_DEFAULT);
  238 
  239         default:
  240                 break;
  241         }
  242 
  243         return ENXIO;
  244 }
  245 
  246 
  247 static int
  248 viapm_pro_probe(device_t dev)
  249 {
  250         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  251 #ifdef VIAPM_BASE_ADDR
  252         u_int32_t l;
  253 #endif
  254         u_int32_t base_cfgreg;
  255         char *desc;
  256 
  257         switch (pci_get_devid(dev)) {
  258         case VIA_596A_PMU_ID:
  259                 desc = "VIA VT82C596A Power Management Unit";
  260                 viapm->type = VIAPM_TYP_596B;
  261                 base_cfgreg = VIAPM_PRO_BASE;
  262                 goto viapro;
  263 
  264         case VIA_596B_PMU_ID:
  265                 desc = "VIA VT82C596B Power Management Unit";
  266                 viapm->type = VIAPM_TYP_596B;
  267                 base_cfgreg = VIAPM_PRO_BASE;
  268                 goto viapro;
  269 
  270         case VIA_686A_PMU_ID:
  271                 desc = "VIA VT82C686A Power Management Unit";
  272                 viapm->type = VIAPM_TYP_686A;
  273                 base_cfgreg = VIAPM_PRO_BASE;
  274                 goto viapro;
  275 
  276         case VIA_8233_PMU_ID:
  277         case VIA_8233A_PMU_ID:
  278                 desc = "VIA VT8233 Power Management Unit";
  279                 viapm->type = VIAPM_TYP_UNKNOWN;
  280                 base_cfgreg = VIAPM_8233_BASE;
  281                 goto viapro;
  282 
  283         case VIA_8235_PMU_ID:
  284                 desc = "VIA VT8235 Power Management Unit";
  285                 viapm->type = VIAPM_TYP_UNKNOWN;
  286                 base_cfgreg = VIAPM_8233_BASE;
  287                 goto viapro;
  288 
  289         case VIA_8237_PMU_ID:
  290                 desc = "VIA VT8237 Power Management Unit";
  291                 viapm->type = VIAPM_TYP_UNKNOWN;
  292                 base_cfgreg = VIAPM_8233_BASE;
  293                 goto viapro;
  294 
  295         case VIA_CX700_PMU_ID:
  296                 desc = "VIA CX700 Power Management Unit";
  297                 viapm->type = VIAPM_TYP_UNKNOWN;
  298                 base_cfgreg = VIAPM_8233_BASE;
  299                 goto viapro;
  300 
  301         viapro:
  302 
  303 #ifdef VIAPM_BASE_ADDR
  304                 /* force VIAPM I/O base address */
  305 
  306                 /* enable the SMBus controller function */
  307                 l = pci_read_config(dev, VIAPM_PRO_SMBCTRL, 1);
  308                 pci_write_config(dev, VIAPM_PRO_SMBCTRL, l | 1, 1);
  309 
  310                 /* write the base address */
  311                 pci_write_config(dev, base_cfgreg,
  312                                  VIAPM_BASE_ADDR & VIAPM_PRO_BA_MASK, 4);
  313 #endif
  314 
  315                 viapm->base = pci_read_config(dev, base_cfgreg, 4) & VIAPM_PRO_BA_MASK;
  316 
  317                 /*
  318                  * We have to set the I/O resources by hand because it is
  319                  * described outside the viapmope of the traditional maps
  320                  */
  321                 viapm->iorid = base_cfgreg;
  322                 if (bus_set_resource(dev, SYS_RES_IOPORT, viapm->iorid,
  323                                      viapm->base, 16)) {
  324                         device_printf(dev, "could not set bus resource 0x%x\n",
  325                                         viapm->base);
  326                         return ENXIO;
  327                 }
  328 
  329                 if (bootverbose) {
  330                         device_printf(dev, "SMBus I/O base at 0x%x\n", viapm->base);
  331                 }
  332 
  333                 device_set_desc(dev, desc);
  334                 return (BUS_PROBE_DEFAULT);
  335 
  336         default:
  337                 break;
  338         }
  339 
  340         return ENXIO;
  341 }
  342 
  343 static int
  344 viapm_pro_attach(device_t dev)
  345 {
  346         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  347         u_int32_t l;
  348 
  349         mtx_init(&viapm->lock, device_get_nameunit(dev), "viapm", MTX_DEF);
  350         if (!(viapm->iores = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
  351                 &viapm->iorid, RF_ACTIVE))) {
  352                 device_printf(dev, "could not allocate bus space\n");
  353                 goto error;
  354         }
  355 
  356 #ifdef notyet
  357         /* force irq 9 */
  358         l = pci_read_config(dev, VIAPM_PRO_SMBCTRL, 1);
  359         pci_write_config(dev, VIAPM_PRO_SMBCTRL, l | 0x80, 1);
  360 
  361         viapm->irqrid = 0;
  362         if (!(viapm->irqres = bus_alloc_resource(dev, SYS_RES_IRQ,
  363                                 &viapm->irqrid, 9, 9, 1,
  364                                 RF_SHAREABLE | RF_ACTIVE))) {
  365                 device_printf(dev, "could not allocate irq\n");
  366                 goto error;
  367         }
  368 
  369         if (bus_setup_intr(dev, viapm->irqres, INTR_TYPE_MISC | INTR_MPSAFE,
  370                         (driver_intr_t *) viasmb_intr, viapm, &viapm->irqih)) {
  371                 device_printf(dev, "could not setup irq\n");
  372                 goto error;
  373         }
  374 #endif
  375 
  376         if (bootverbose) {
  377                 l = pci_read_config(dev, VIAPM_PRO_REVID, 1);
  378                 device_printf(dev, "SMBus revision code 0x%x\n", l);
  379         }
  380 
  381         viapm->smbus = device_add_child(dev, "smbus", -1);
  382 
  383         /* probe and attach the smbus */
  384         bus_generic_attach(dev);
  385 
  386         /* disable slave function */
  387         VIAPM_OUTB(SMBSCTRL, VIAPM_INB(SMBSCTRL) & ~SMBSCTRL_ENABLE);
  388 
  389         /* enable the SMBus controller function */
  390         l = pci_read_config(dev, VIAPM_PRO_SMBCTRL, 1);
  391         pci_write_config(dev, VIAPM_PRO_SMBCTRL, l | 1, 1);
  392 
  393 #ifdef notyet
  394         /* enable interrupts */
  395         VIAPM_OUTB(SMBHCTRL, VIAPM_INB(SMBHCTRL) | SMBHCTRL_ENABLE);
  396 #endif
  397 
  398 #ifdef DEV_ISA
  399         /* If this device is a PCI-ISA bridge, then attach an ISA bus. */
  400         if ((pci_get_class(dev) == PCIC_BRIDGE) &&
  401             (pci_get_subclass(dev) == PCIS_BRIDGE_ISA))
  402                 isab_attach(dev);
  403 #endif
  404         return 0;
  405 
  406 error:
  407         if (viapm->iores)
  408                 bus_release_resource(dev, SYS_RES_IOPORT, viapm->iorid, viapm->iores);
  409 #ifdef notyet
  410         if (viapm->irqres)
  411                 bus_release_resource(dev, SYS_RES_IRQ, viapm->irqrid, viapm->irqres);
  412 #endif
  413         mtx_destroy(&viapm->lock);
  414 
  415         return ENXIO;
  416 }
  417 
  418 static int
  419 viapm_586b_attach(device_t dev)
  420 {
  421         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  422 
  423         mtx_init(&viapm->lock, device_get_nameunit(dev), "viapm", MTX_DEF);
  424         if (!(viapm->iores = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
  425                 &viapm->iorid, RF_ACTIVE | RF_SHAREABLE))) {
  426                 device_printf(dev, "could not allocate bus resource\n");
  427                 goto error;
  428         }
  429 
  430         VIAPM_OUTB(GPIO_DIR, VIAPM_INB(GPIO_DIR) | VIAPM_SCL | VIAPM_SDA);
  431 
  432         /* add generic bit-banging code */
  433         if (!(viapm->iicbb = device_add_child(dev, "iicbb", -1)))
  434                 goto error;
  435 
  436         bus_generic_attach(dev);
  437 
  438         return 0;
  439 
  440 error:
  441         if (viapm->iores)
  442                 bus_release_resource(dev, SYS_RES_IOPORT,
  443                                         viapm->iorid, viapm->iores);
  444         mtx_destroy(&viapm->lock);
  445         return ENXIO;
  446 }
  447 
  448 static int
  449 viapm_586b_detach(device_t dev)
  450 {
  451         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  452 
  453         bus_generic_detach(dev);
  454         if (viapm->iicbb) {
  455                 device_delete_child(dev, viapm->iicbb);
  456         }
  457 
  458         if (viapm->iores)
  459                 bus_release_resource(dev, SYS_RES_IOPORT, viapm->iorid,
  460                     viapm->iores);
  461         mtx_destroy(&viapm->lock);
  462 
  463         return 0;
  464 }
  465 
  466 static int
  467 viapm_pro_detach(device_t dev)
  468 {
  469         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  470 
  471         bus_generic_detach(dev);
  472         if (viapm->smbus) {
  473                 device_delete_child(dev, viapm->smbus);
  474         }
  475 
  476         bus_release_resource(dev, SYS_RES_IOPORT, viapm->iorid, viapm->iores);
  477 
  478 #ifdef notyet
  479         bus_release_resource(dev, SYS_RES_IRQ, viapm->irqrid, viapm->irqres);
  480 #endif
  481         mtx_destroy(&viapm->lock);
  482 
  483         return 0;
  484 }
  485 
  486 static int
  487 viabb_callback(device_t dev, int index, caddr_t data)
  488 {
  489         return 0;
  490 }
  491 
  492 static void
  493 viabb_setscl(device_t dev, int ctrl)
  494 {
  495         struct viapm_softc *viapm = device_get_softc(dev);
  496         u_char val;
  497 
  498         VIAPM_LOCK(viapm);
  499         val = VIAPM_INB(GPIO_VAL);
  500 
  501         if (ctrl)
  502                 val |= VIAPM_SCL;
  503         else
  504                 val &= ~VIAPM_SCL;
  505 
  506         VIAPM_OUTB(GPIO_VAL, val);
  507         VIAPM_UNLOCK(viapm);
  508 
  509         return;
  510 }
  511 
  512 static void
  513 viabb_setsda(device_t dev, int data)
  514 {
  515         struct viapm_softc *viapm = device_get_softc(dev);
  516         u_char val;
  517 
  518         VIAPM_LOCK(viapm);
  519         val = VIAPM_INB(GPIO_VAL);
  520 
  521         if (data)
  522                 val |= VIAPM_SDA;
  523         else
  524                 val &= ~VIAPM_SDA;
  525 
  526         VIAPM_OUTB(GPIO_VAL, val);
  527         VIAPM_UNLOCK(viapm);
  528 
  529         return;
  530 }
  531         
  532 static int
  533 viabb_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
  534 {
  535         /* reset bus */
  536         viabb_setsda(dev, 1);
  537         viabb_setscl(dev, 1);
  538 
  539         return (IIC_ENOADDR);
  540 }
  541 
  542 static int
  543 viabb_getscl(device_t dev)
  544 {
  545         struct viapm_softc *viapm = device_get_softc(dev);
  546         u_char val;
  547 
  548         VIAPM_LOCK(viapm);
  549         val = VIAPM_INB(EXTSMI_VAL);
  550         VIAPM_UNLOCK(viapm);
  551         return ((val & VIAPM_SCL) != 0);
  552 }
  553 
  554 static int
  555 viabb_getsda(device_t dev)
  556 {
  557         struct viapm_softc *viapm = device_get_softc(dev);
  558         u_char val;
  559 
  560         VIAPM_LOCK(viapm);
  561         val = VIAPM_INB(EXTSMI_VAL);
  562         VIAPM_UNLOCK(viapm);
  563         return ((val & VIAPM_SDA) != 0);
  564 }
  565 
  566 static int
  567 viapm_abort(struct viapm_softc *viapm)
  568 {
  569         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_KILL);
  570         DELAY(10);
  571 
  572         return (0);
  573 }
  574 
  575 static int
  576 viapm_clear(struct viapm_softc *viapm)
  577 {
  578         VIAPM_OUTB(SMBHST, SMBHST_FAILED | SMBHST_COLLID |
  579                 SMBHST_ERROR | SMBHST_INTR);
  580         DELAY(10);
  581 
  582         return (0);
  583 }
  584 
  585 static int
  586 viapm_busy(struct viapm_softc *viapm)
  587 {
  588         u_char sts;
  589 
  590         sts = VIAPM_INB(SMBHST);
  591 
  592         VIAPM_DEBUG(printf("viapm: idle? STS=0x%x\n", sts));
  593 
  594         return (sts & SMBHST_BUSY);
  595 }
  596 
  597 /*
  598  * Poll the SMBus controller
  599  */
  600 static int
  601 viapm_wait(struct viapm_softc *viapm)
  602 {
  603         int count = 10000;
  604         u_char sts = 0;
  605         int error;
  606 
  607         VIAPM_LOCK_ASSERT(viapm);
  608 
  609         /* wait for command to complete and SMBus controller is idle */
  610         while(count--) {
  611                 DELAY(10);
  612                 sts = VIAPM_INB(SMBHST);
  613 
  614                 /* check if the controller is processing a command */
  615                 if (!(sts & SMBHST_BUSY) && (sts & SMBHST_INTR))
  616                         break;
  617         }
  618 
  619         VIAPM_DEBUG(printf("viapm: SMBHST=0x%x\n", sts));
  620 
  621         error = SMB_ENOERR;
  622 
  623         if (!count)
  624                 error |= SMB_ETIMEOUT;
  625 
  626         if (sts & SMBHST_FAILED)
  627                 error |= SMB_EABORT;
  628 
  629         if (sts & SMBHST_COLLID)
  630                 error |= SMB_ENOACK;
  631 
  632         if (sts & SMBHST_ERROR)
  633                 error |= SMB_EBUSERR;
  634 
  635         if (error != SMB_ENOERR)
  636                 viapm_abort(viapm);
  637 
  638         viapm_clear(viapm);
  639 
  640         return (error);
  641 }
  642 
  643 static int
  644 viasmb_callback(device_t dev, int index, void *data)
  645 {
  646         int error = 0;
  647 
  648         switch (index) {
  649         case SMB_REQUEST_BUS:
  650         case SMB_RELEASE_BUS:
  651                 /* ok, bus allocation accepted */
  652                 break;
  653         default:
  654                 error = EINVAL;
  655         }
  656 
  657         return (error);
  658 }
  659 
  660 static int
  661 viasmb_quick(device_t dev, u_char slave, int how)
  662 {
  663         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  664         int error;
  665 
  666         VIAPM_LOCK(viapm);
  667         viapm_clear(viapm);
  668         if (viapm_busy(viapm)) {
  669                 VIAPM_UNLOCK(viapm);
  670                 return (SMB_EBUSY);
  671         }
  672 
  673         switch (how) {
  674         case SMB_QWRITE:
  675                 VIAPM_DEBUG(printf("viapm: QWRITE to 0x%x", slave));
  676                 VIAPM_OUTB(SMBHADDR, slave & ~LSB);
  677                 break;
  678         case SMB_QREAD:
  679                 VIAPM_DEBUG(printf("viapm: QREAD to 0x%x", slave));
  680                 VIAPM_OUTB(SMBHADDR, slave | LSB);
  681                 break;
  682         default:
  683                 panic("%s: unknown QUICK command (%x)!", __func__, how);
  684         }
  685 
  686         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_QUICK);
  687 
  688         error = viapm_wait(viapm);
  689         VIAPM_UNLOCK(viapm);
  690 
  691         return (error);
  692 }
  693 
  694 static int
  695 viasmb_sendb(device_t dev, u_char slave, char byte)
  696 {
  697         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  698         int error;
  699 
  700         VIAPM_LOCK(viapm);
  701         viapm_clear(viapm);
  702         if (viapm_busy(viapm)) {
  703                 VIAPM_UNLOCK(viapm);
  704                 return (SMB_EBUSY);
  705         }
  706 
  707         VIAPM_OUTB(SMBHADDR, slave & ~ LSB);
  708         VIAPM_OUTB(SMBHCMD, byte);
  709 
  710         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_SENDRECV);
  711 
  712         error = viapm_wait(viapm);
  713 
  714         VIAPM_DEBUG(printf("viapm: SENDB to 0x%x, byte=0x%x, error=0x%x\n", slave, byte, error));
  715         VIAPM_UNLOCK(viapm);
  716 
  717         return (error);
  718 }
  719 
  720 static int
  721 viasmb_recvb(device_t dev, u_char slave, char *byte)
  722 {
  723         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  724         int error;
  725 
  726         VIAPM_LOCK(viapm);
  727         viapm_clear(viapm);
  728         if (viapm_busy(viapm)) {
  729                 VIAPM_UNLOCK(viapm);
  730                 return (SMB_EBUSY);
  731         }
  732 
  733         VIAPM_OUTB(SMBHADDR, slave | LSB);
  734 
  735         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_SENDRECV);
  736 
  737         if ((error = viapm_wait(viapm)) == SMB_ENOERR)
  738                 *byte = VIAPM_INB(SMBHDATA0);
  739 
  740         VIAPM_DEBUG(printf("viapm: RECVB from 0x%x, byte=0x%x, error=0x%x\n", slave, *byte, error));
  741         VIAPM_UNLOCK(viapm);
  742 
  743         return (error);
  744 }
  745 
  746 static int
  747 viasmb_writeb(device_t dev, u_char slave, char cmd, char byte)
  748 {
  749         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  750         int error;
  751 
  752         VIAPM_LOCK(viapm);
  753         viapm_clear(viapm);
  754         if (viapm_busy(viapm)) {
  755                 VIAPM_UNLOCK(viapm);
  756                 return (SMB_EBUSY);
  757         }
  758 
  759         VIAPM_OUTB(SMBHADDR, slave & ~ LSB);
  760         VIAPM_OUTB(SMBHCMD, cmd);
  761         VIAPM_OUTB(SMBHDATA0, byte);
  762 
  763         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_BYTE);
  764 
  765         error = viapm_wait(viapm);
  766 
  767         VIAPM_DEBUG(printf("viapm: WRITEB to 0x%x, cmd=0x%x, byte=0x%x, error=0x%x\n", slave, cmd, byte, error));
  768         VIAPM_UNLOCK(viapm);
  769 
  770         return (error);
  771 }
  772 
  773 static int
  774 viasmb_readb(device_t dev, u_char slave, char cmd, char *byte)
  775 {
  776         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  777         int error;
  778 
  779         VIAPM_LOCK(viapm);
  780         viapm_clear(viapm);
  781         if (viapm_busy(viapm)) {
  782                 VIAPM_UNLOCK(viapm);
  783                 return (SMB_EBUSY);
  784         }
  785 
  786         VIAPM_OUTB(SMBHADDR, slave | LSB);
  787         VIAPM_OUTB(SMBHCMD, cmd);
  788 
  789         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_BYTE);
  790 
  791         if ((error = viapm_wait(viapm)) == SMB_ENOERR)
  792                 *byte = VIAPM_INB(SMBHDATA0);
  793 
  794         VIAPM_DEBUG(printf("viapm: READB from 0x%x, cmd=0x%x, byte=0x%x, error=0x%x\n", slave, cmd, *byte, error));
  795         VIAPM_UNLOCK(viapm);
  796 
  797         return (error);
  798 }
  799 
  800 static int
  801 viasmb_writew(device_t dev, u_char slave, char cmd, short word)
  802 {
  803         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  804         int error;
  805 
  806         VIAPM_LOCK(viapm);
  807         viapm_clear(viapm);
  808         if (viapm_busy(viapm)) {
  809                 VIAPM_UNLOCK(viapm);
  810                 return (SMB_EBUSY);
  811         }
  812 
  813         VIAPM_OUTB(SMBHADDR, slave & ~ LSB);
  814         VIAPM_OUTB(SMBHCMD, cmd);
  815         VIAPM_OUTB(SMBHDATA0, word & 0x00ff);
  816         VIAPM_OUTB(SMBHDATA1, (word & 0xff00) >> 8);
  817 
  818         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_WORD);
  819 
  820         error = viapm_wait(viapm);
  821 
  822         VIAPM_DEBUG(printf("viapm: WRITEW to 0x%x, cmd=0x%x, word=0x%x, error=0x%x\n", slave, cmd, word, error));
  823         VIAPM_UNLOCK(viapm);
  824 
  825         return (error);
  826 }
  827 
  828 static int
  829 viasmb_readw(device_t dev, u_char slave, char cmd, short *word)
  830 {
  831         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  832         int error;
  833         u_char high, low;
  834 
  835         VIAPM_LOCK(viapm);
  836         viapm_clear(viapm);
  837         if (viapm_busy(viapm)) {
  838                 VIAPM_UNLOCK(viapm);
  839                 return (SMB_EBUSY);
  840         }
  841 
  842         VIAPM_OUTB(SMBHADDR, slave | LSB);
  843         VIAPM_OUTB(SMBHCMD, cmd);
  844 
  845         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_WORD);
  846 
  847         if ((error = viapm_wait(viapm)) == SMB_ENOERR) {
  848                 low = VIAPM_INB(SMBHDATA0);
  849                 high = VIAPM_INB(SMBHDATA1);
  850 
  851                 *word = ((high & 0xff) << 8) | (low & 0xff);
  852         }
  853 
  854         VIAPM_DEBUG(printf("viapm: READW from 0x%x, cmd=0x%x, word=0x%x, error=0x%x\n", slave, cmd, *word, error));
  855         VIAPM_UNLOCK(viapm);
  856 
  857         return (error);
  858 }
  859 
  860 static int
  861 viasmb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
  862 {
  863         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  864         u_char i;
  865         int error;
  866 
  867         if (count < 1 || count > 32)
  868                 return (SMB_EINVAL);
  869 
  870         VIAPM_LOCK(viapm);
  871         viapm_clear(viapm);
  872         if (viapm_busy(viapm)) {
  873                 VIAPM_UNLOCK(viapm);
  874                 return (SMB_EBUSY);
  875         }
  876 
  877         VIAPM_OUTB(SMBHADDR, slave & ~LSB);
  878         VIAPM_OUTB(SMBHCMD, cmd);
  879         VIAPM_OUTB(SMBHDATA0, count);
  880         i = VIAPM_INB(SMBHCTRL);
  881 
  882         /* fill the 32-byte internal buffer */
  883         for (i = 0; i < count; i++) {
  884                 VIAPM_OUTB(SMBHBLOCK, buf[i]);
  885                 DELAY(2);
  886         }
  887         VIAPM_OUTB(SMBHCMD, cmd);
  888         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_BLOCK);
  889 
  890         error = viapm_wait(viapm);
  891 
  892         VIAPM_DEBUG(printf("viapm: WRITEBLK to 0x%x, count=0x%x, cmd=0x%x, error=0x%x", slave, count, cmd, error));
  893         VIAPM_UNLOCK(viapm);
  894 
  895         return (error);
  896 
  897 }
  898 
  899 static int
  900 viasmb_bread(device_t dev, u_char slave, char cmd, u_char *count, char *buf)
  901 {
  902         struct viapm_softc *viapm = (struct viapm_softc *)device_get_softc(dev);
  903         u_char data, len, i;
  904         int error;
  905 
  906         if (*count < 1 || *count > 32)
  907                 return (SMB_EINVAL);
  908 
  909         VIAPM_LOCK(viapm);
  910         viapm_clear(viapm);
  911         if (viapm_busy(viapm)) {
  912                 VIAPM_UNLOCK(viapm);
  913                 return (SMB_EBUSY);
  914         }
  915 
  916         VIAPM_OUTB(SMBHADDR, slave | LSB);
  917         VIAPM_OUTB(SMBHCMD, cmd);
  918         VIAPM_OUTB(SMBHCTRL, SMBHCTRL_START | SMBHCTRL_BLOCK);
  919 
  920         if ((error = viapm_wait(viapm)) != SMB_ENOERR)
  921                 goto error;
  922 
  923         len = VIAPM_INB(SMBHDATA0);
  924         i = VIAPM_INB(SMBHCTRL);                /* reset counter */
  925 
  926         /* read the 32-byte internal buffer */
  927         for (i = 0; i < len; i++) {
  928                 data = VIAPM_INB(SMBHBLOCK);
  929                 if (i < *count)
  930                         buf[i] = data;
  931                 DELAY(2);
  932         }
  933         *count = len;
  934 
  935 error:
  936         VIAPM_DEBUG(printf("viapm: READBLK to 0x%x, count=0x%x, cmd=0x%x, error=0x%x", slave, *count, cmd, error));
  937         VIAPM_UNLOCK(viapm);
  938 
  939         return (error);
  940 }
  941 
  942 static device_method_t viapm_methods[] = {
  943         /* device interface */
  944         DEVMETHOD(device_probe,         viapm_586b_probe),
  945         DEVMETHOD(device_attach,        viapm_586b_attach),
  946         DEVMETHOD(device_detach,        viapm_586b_detach),
  947 
  948         /* iicbb interface */
  949         DEVMETHOD(iicbb_callback,       viabb_callback),
  950         DEVMETHOD(iicbb_setscl,         viabb_setscl),
  951         DEVMETHOD(iicbb_setsda,         viabb_setsda),
  952         DEVMETHOD(iicbb_getscl,         viabb_getscl),
  953         DEVMETHOD(iicbb_getsda,         viabb_getsda),
  954         DEVMETHOD(iicbb_reset,          viabb_reset),
  955 
  956         /* Bus interface */
  957         DEVMETHOD(bus_print_child,      bus_generic_print_child),
  958         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
  959         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
  960         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
  961         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
  962         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
  963         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
  964 
  965         { 0, 0 }
  966 };
  967 
  968 static driver_t viapm_driver = {
  969         "viapm",
  970         viapm_methods,
  971         sizeof(struct viapm_softc),
  972 };
  973 
  974 static device_method_t viapropm_methods[] = {
  975         /* device interface */
  976         DEVMETHOD(device_probe,         viapm_pro_probe),
  977         DEVMETHOD(device_attach,        viapm_pro_attach),
  978         DEVMETHOD(device_detach,        viapm_pro_detach),
  979 
  980         /* smbus interface */
  981         DEVMETHOD(smbus_callback,       viasmb_callback),
  982         DEVMETHOD(smbus_quick,          viasmb_quick),
  983         DEVMETHOD(smbus_sendb,          viasmb_sendb),
  984         DEVMETHOD(smbus_recvb,          viasmb_recvb),
  985         DEVMETHOD(smbus_writeb,         viasmb_writeb),
  986         DEVMETHOD(smbus_readb,          viasmb_readb),
  987         DEVMETHOD(smbus_writew,         viasmb_writew),
  988         DEVMETHOD(smbus_readw,          viasmb_readw),
  989         DEVMETHOD(smbus_bwrite,         viasmb_bwrite),
  990         DEVMETHOD(smbus_bread,          viasmb_bread),
  991         
  992         /* Bus interface */
  993         DEVMETHOD(bus_print_child,      bus_generic_print_child),
  994         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
  995         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
  996         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
  997         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
  998         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
  999         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 1000 
 1001         { 0, 0 }
 1002 };
 1003 
 1004 static driver_t viapropm_driver = {
 1005         "viapropm",
 1006         viapropm_methods,
 1007         sizeof(struct viapm_softc),
 1008 };
 1009 
 1010 DRIVER_MODULE(viapm, pci, viapm_driver, viapm_devclass, 0, 0);
 1011 DRIVER_MODULE(viapropm, pci, viapropm_driver, viapropm_devclass, 0, 0);
 1012 DRIVER_MODULE(iicbb, viapm, iicbb_driver, iicbb_devclass, 0, 0);
 1013 DRIVER_MODULE(smbus, viapropm, smbus_driver, smbus_devclass, 0, 0);
 1014 
 1015 MODULE_DEPEND(viapm, pci, 1, 1, 1);
 1016 MODULE_DEPEND(viapropm, pci, 1, 1, 1);
 1017 MODULE_DEPEND(viapm, iicbb, IICBB_MINVER, IICBB_PREFVER, IICBB_MAXVER);
 1018 MODULE_DEPEND(viapropm, smbus, SMBUS_MINVER, SMBUS_PREFVER, SMBUS_MAXVER);
 1019 MODULE_VERSION(viapm, 1);
 1020 
 1021 #ifdef DEV_ISA
 1022 DRIVER_MODULE(isa, viapm, isa_driver, isa_devclass, 0, 0);
 1023 DRIVER_MODULE(isa, viapropm, isa_driver, isa_devclass, 0, 0);
 1024 MODULE_DEPEND(viapm, isa, 1, 1, 1);
 1025 MODULE_DEPEND(viapropm, isa, 1, 1, 1);
 1026 #endif

Cache object: 7ec1ebadf39e0dd228eae00407696510


[ 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.