Page MenuHomeFreeBSD
Differential D8175 Diff 21296 sys/dev/superio/superio.c

Changeset View

Standalone View

View Options

sys/dev/superio/superio.c

  • This file was added.
PropertyOld ValueNew Value
svn:eol-stylenullnative
\ No newline at end of property
svn:keywordsnullFreeBSD=%H
\ No newline at end of property
\ No newline at end of property
svn:mime-typenulltext/plain
\ No newline at end of property
/*
* Copyright (c) 2016 Andriy Gapon
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/proc.h>
#include <sys/rman.h>
#include <sys/time.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <machine/stdarg.h>
#include <isa/isavar.h>
#include <dev/superio/superio.h>
#include "isa_if.h"
typedef void (*sio_conf_enter_f)(struct resource*, uint16_t);
typedef void (*sio_conf_exit_f)(struct resource*, uint16_t);
impUnsubmitted
Not Done
Inline Actions

I know that sio stands for super I/O here, but sio was the serial driver for years and there's an immediate reaction to it :)

imp: I know that sio stands for super I/O here, but sio was the serial driver for years and there's…
avgAuthorUnsubmitted
Not Done
Inline Actions

Yes, I know. I used the full name in the interface, but decided that using the shorthand is acceptable for the implementation.
Not a problem to do s/sio/superio/ if that would be preferred.

avg: Yes, I know. I used the full name in the interface, but decided that using the shorthand is…
struct sio_conf_methods {
sio_conf_enter_f enter;
sio_conf_exit_f exit;
superio_vendor_t vendor;
};
struct superio_devinfo {
STAILQ_ENTRY(superio_devinfo) link;
struct resource_list resources;
device_t dev;
uint8_t ldn;
superio_dev_type_t type;
uint16_t iobase;
uint16_t iobase2;
uint8_t irq;
uint8_t dma;
};
struct siosc {
struct mtx conf_lock;
STAILQ_HEAD(, superio_devinfo) devlist;
struct resource* io_res;
int io_rid;
uint16_t io_port;
const struct sio_conf_methods *methods;
const struct logical_device *devices;
superio_vendor_t vendor;
uint16_t devid;
uint8_t revid;
uint8_t current_ldn;
uint8_t ldn_reg;
uint8_t enable_reg;
};
#define NUMPORTS 2
static uint8_t
sio_read(struct resource* res, uint8_t reg)
{
bus_write_1(res, 0, reg);
return (bus_read_1(res, 1));
}
/* Read a word from two one-byte registers, big endian. */
static uint16_t
sio_readw(struct resource* res, uint8_t reg)
{
uint16_t v;
v = sio_read(res, reg);
v <<= 8;
v |= sio_read(res, reg + 1);
return (v);
}
static void
sio_write(struct resource* res, uint8_t reg, uint8_t val)
{
bus_write_1(res, 0, reg);
bus_write_1(res, 1, val);
}
static void
sio_ldn_select(struct siosc *sc, uint8_t ldn)
{
mtx_assert(&sc->conf_lock, MA_OWNED);
if (ldn == sc->current_ldn)
return;
sio_write(sc->io_res, sc->ldn_reg, ldn);
sc->current_ldn = ldn;
}
static uint8_t
sio_ldn_read(struct siosc *sc, uint8_t ldn, uint8_t reg)
{
mtx_assert(&sc->conf_lock, MA_OWNED);
if (reg >= sc->enable_reg) {
sio_ldn_select(sc, ldn);
KASSERT(sc->current_ldn == ldn, ("sio_ldn_select failed"));
}
return (sio_read(sc->io_res, reg));
}
static uint16_t
sio_ldn_readw(struct siosc *sc, uint8_t ldn, uint8_t reg)
{
mtx_assert(&sc->conf_lock, MA_OWNED);
if (reg >= sc->enable_reg) {
sio_ldn_select(sc, ldn);
KASSERT(sc->current_ldn == ldn, ("sio_ldn_select failed"));
}
return (sio_readw(sc->io_res, reg));
}
static void
sio_ldn_write(struct siosc *sc, uint8_t ldn, uint8_t reg, uint8_t val)
{
mtx_assert(&sc->conf_lock, MA_OWNED);
if (reg <= sc->ldn_reg) {
printf("ignored attempt to write special register 0x%x\n", reg);
return;
}
sio_ldn_select(sc, ldn);
KASSERT(sc->current_ldn == ldn, ("sio_ldn_select failed"));
sio_write(sc->io_res, reg, val);
}
static void
sio_conf_enter(struct siosc *sc)
{
mtx_lock(&sc->conf_lock);
sc->methods->enter(sc->io_res, sc->io_port);
}
static void
sio_conf_exit(struct siosc *sc)
{
sc->methods->exit(sc->io_res, sc->io_port);
mtx_unlock(&sc->conf_lock);
}
static void
ite_conf_enter(struct resource* res, uint16_t port)
{
bus_write_1(res, 0, 0x87);
bus_write_1(res, 0, 0x01);
bus_write_1(res, 0, 0x55);
bus_write_1(res, 0, port == 0x2e ? 0x55 : 0xaa);
}
static void
ite_conf_exit(struct resource* res, uint16_t port)
{
sio_write(res, 0x02, 0x02);
}
static const struct sio_conf_methods ite_conf_methods = {
.enter = ite_conf_enter,
.exit = ite_conf_exit,
.vendor = SUPERIO_VENDOR_ITE
};
static const struct sio_conf_methods * const methods_table[] = {
&ite_conf_methods,
NULL
};
static const uint16_t ports_table[] = {
0x2e, 0x4e, 0
};
static const struct {
superio_vendor_t vendor;
uint16_t devid;
} superio_table[] = {
{ .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8712 },
{ .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8716 },
{ .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8718 },
{ .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8720 },
{ .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8721 },
{ .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8726 },
{ .vendor = SUPERIO_VENDOR_ITE, .devid = 0x8728 },
{ 0, 0 }
};
static const char *
devtype_to_str(superio_dev_type_t type)
{
switch (type) {
case SUPERIO_DEV_HWM:
return ("HWM");
case SUPERIO_DEV_WDT:
return ("WDT");
default:
return ("<unknown>");
}
}
static int
superio_detect(device_t dev, bool claim, struct siosc *sc)
{
struct resource *res;
rman_res_t port;
rman_res_t count;
uint16_t devid;
uint8_t revid;
int error;
int rid;
int i, m;
error = bus_get_resource(dev, SYS_RES_IOPORT, 0, &port, &count);
if (error != 0)
return (error);
if (port > UINT16_MAX || count < NUMPORTS) {
device_printf(dev, "unexpected I/O range size\n");
return (ENXIO);
}
/*
* Make a temporary resource reservation for hardware probing.
impUnsubmitted
Done
Inline Actions

Other drivers that do identify will put extra code to prevent that. Though looking at the probe routine it looks like this might be difficult...

imp: Other drivers that do identify will put extra code to prevent that. Though looking at the probe…
avgAuthorUnsubmitted
Done
Inline Actions

I see that wbwd driver has to solve a similar problem. I'm not sure if I like its solution, but it certainly works.
Essentially, the low level I/O methods accept both an IO resource and a numeric port. So they can be used both before a device is created and after resources are set up.

Maybe the following could work?
The device_probe method is reduced to always returning success. Instead the current probe code is called directly from the identify method with a child device. If probing fails then the device is removed.

avg: I see that `wbwd` driver has to solve a similar problem. I'm not sure if I like its solution…
* If we can't get the resources we need then
* we need to abort. Possibly this indicates
* the resources were used by another device
* in which case the probe would have failed anyhow.
*/
rid = 0;
res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, RF_ACTIVE);
if (res == NULL) {
if (claim)
device_printf(dev, "failed to allocate I/O resource\n");
return (ENXIO);
}
for (m = 0; methods_table[m] != NULL; m++) {
/*
* TODO: add Nuvoton (fka Winbond) support at the very least.
*/
if (methods_table[m]->vendor != SUPERIO_VENDOR_ITE)
continue;
methods_table[m]->enter(res, port);
if (methods_table[m]->vendor == SUPERIO_VENDOR_ITE) {
devid = sio_readw(res, 0x20);
revid = sio_read(res, 0x22);
} else if (methods_table[m]->vendor == SUPERIO_VENDOR_NUVOTON) {
devid = sio_read(res, 0x20);
revid = sio_read(res, 0x21);
} else {
continue;
}
methods_table[m]->exit(res, port);
for (i = 0; superio_table[i].vendor != 0; i++) {
if (superio_table[i].vendor !=
methods_table[m]->vendor)
continue;
if (superio_table[i].devid != devid)
continue;
break;
}
/* Found a matching SuperIO entry. */
if (superio_table[i].vendor != 0)
break;
}
if (claim) {
sc->methods = methods_table[m];
sc->io_res = res;
sc->io_rid = rid;
sc->io_port = port;
sc->devid = devid;
sc->revid = revid;
}
if (methods_table[m] == NULL)
error = ENXIO;
else
error = 0;
if (!claim || error != 0)
bus_release_resource(dev, SYS_RES_IOPORT, rid, res);
return (error);
}
impUnsubmitted
Done
Inline Actions

How do we even get here? We continue a few lines up if vendor != ITE, so how can it be NUVOTON here?

imp: How do we even get here? We continue a few lines up if vendor != ITE, so how can it be NUVOTON…
avgAuthorUnsubmitted
Done
Inline Actions

It's a place holder for when the Nuvoton support is added. Just so that I don't forget that the device ID is read differently (some register but byte vs word).

avg: It's a place holder for when the Nuvoton support is added. Just so that I don't forget that the…
static void
superio_identify(driver_t *driver, device_t parent)
{
device_t child;
int i;
/*
* Don't create child devices if any already exist.
* Those could be created via isa hints or if this
* driver is loaded, unloaded and then loaded again.
*/
if (device_find_child(parent, "superio", -1)) {
if (bootverbose)
printf("superio: device(s) already created\n");
return;
}
/*
* Create a child for each candidate port.
* It would be nice if we could somehow clean up those
* that this driver fails to probe.
*/
for (i = 0; ports_table[i] != 0; i++) {
child = BUS_ADD_CHILD(parent, ISA_ORDER_SPECULATIVE,
"superio", -1);
if (child == NULL) {
device_printf(parent, "failed to add superio child\n");
continue;
}
bus_set_resource(child, SYS_RES_IOPORT, 0, ports_table[i], 2);
if (superio_detect(child, false, NULL) != 0)
device_delete_child(parent, child);
}
}
static int
superio_probe(device_t dev)
{
char desc[64];
struct siosc *sc;
int error;
/* Make sure we do not claim some ISA PNP device. */
if (isa_get_logicalid(dev) != 0)
return (ENXIO);
/*
* XXX We can populate the softc now only because we return
* BUS_PROBE_SPECIFIC
*/
sc = device_get_softc(dev);
error = superio_detect(dev, true, sc);
if (error != 0)
return (error);
sc->vendor = sc->methods->vendor;
KASSERT(sc->vendor == SUPERIO_VENDOR_ITE,
("Only ITE SuperIO-s are supported"));
sc->ldn_reg = 0x07;
sc->enable_reg = 0x30;
sc->current_ldn = 0xff; /* no device should have this */
snprintf(desc, sizeof(desc), "ITE IT%4x SuperIO (revision 0x%02x)",
sc->devid, sc->revid);
device_set_desc_copy(dev, desc);
return (BUS_PROBE_SPECIFIC);
}
static void
superio_add_known_child(device_t dev, superio_dev_type_t type, uint8_t ldn)
{
struct siosc *sc = device_get_softc(dev);
struct superio_devinfo *dinfo;
device_t child;
child = BUS_ADD_CHILD(dev, 0, NULL, -1);
if (child == NULL) {
device_printf(dev, "failed to add child for ldn %d, type %s\n",
ldn, devtype_to_str(type));
return;
}
dinfo = device_get_ivars(child);
dinfo->ldn = ldn;
dinfo->type = type;
sio_conf_enter(sc);
dinfo->iobase = sio_ldn_readw(sc, ldn, 0x60);
dinfo->iobase2 = sio_ldn_readw(sc, ldn, 0x62);
dinfo->irq = sio_ldn_readw(sc, ldn, 0x70);
dinfo->dma = sio_ldn_readw(sc, ldn, 0x74);
sio_conf_exit(sc);
STAILQ_INSERT_TAIL(&sc->devlist, dinfo, link);
}
static int
superio_attach(device_t dev)
{
struct siosc *sc = device_get_softc(dev);
mtx_init(&sc->conf_lock, device_get_nameunit(dev), "superio", MTX_DEF);
STAILQ_INIT(&sc->devlist);
switch(sc->vendor) {
case SUPERIO_VENDOR_ITE:
/*
* All supported ITE devices have a watchdog timer
* configurable via LDN 7 (GPIO) and a hardware monitoring
* (environment controller) component at LDN 4.
*/
superio_add_known_child(dev, SUPERIO_DEV_HWM, 4);
superio_add_known_child(dev, SUPERIO_DEV_WDT, 7);
break;
case SUPERIO_VENDOR_NUVOTON:
default:
break;
}
bus_generic_probe(dev);
bus_generic_attach(dev);
return (0);
}
static int
superio_detach(device_t dev)
{
struct siosc *sc = device_get_softc(dev);
int error;
error = bus_generic_detach(dev);
if (error != 0)
return (error);
device_delete_children(dev);
bus_release_resource(dev, SYS_RES_IOPORT, sc->io_rid, sc->io_res);
mtx_destroy(&sc->conf_lock);
return (0);
}
static device_t
superio_add_child(device_t dev, u_int order, const char *name, int unit)
{
struct superio_devinfo *dinfo;
device_t child;
child = device_add_child_ordered(dev, order, name, unit);
if (child == NULL)
return (NULL);
dinfo = malloc(sizeof(*dinfo), M_DEVBUF, M_NOWAIT | M_ZERO);
if (dinfo == NULL) {
device_delete_child(dev, child);
return (NULL);
}
resource_list_init(&dinfo->resources);
device_set_ivars(child, dinfo);
return (child);
}
static int
superio_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
{
struct superio_devinfo *dinfo;
dinfo = device_get_ivars(child);
switch (which) {
case SUPERIO_IVAR_LDN:
*result = dinfo->ldn;
break;
case SUPERIO_IVAR_TYPE:
*result = dinfo->type;
break;
case SUPERIO_IVAR_IOBASE:
*result = dinfo->iobase;
break;
case SUPERIO_IVAR_IOBASE2:
*result = dinfo->iobase2;
break;
case SUPERIO_IVAR_IRQ:
*result = dinfo->irq;
break;
case SUPERIO_IVAR_DMA:
*result = dinfo->dma;
break;
default:
return (ENOENT);
}
return (0);
}
static int
superio_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
{
switch (which) {
case SUPERIO_IVAR_LDN:
case SUPERIO_IVAR_TYPE:
case SUPERIO_IVAR_IOBASE:
case SUPERIO_IVAR_IOBASE2:
case SUPERIO_IVAR_IRQ:
case SUPERIO_IVAR_DMA:
return (EINVAL);
default:
return (ENOENT);
}
}
static struct resource_list *
superio_get_resource_list(device_t dev, device_t child)
{
struct superio_devinfo *dinfo = device_get_ivars(child);
return (&dinfo->resources);
}
static int
superio_printf(struct superio_devinfo *dinfo, const char *fmt, ...)
{
va_list ap;
int retval;
retval = printf("superio:%s@ldn%0x2x: ",
devtype_to_str(dinfo->type), dinfo->ldn);
va_start(ap, fmt);
retval += vprintf(fmt, ap);
va_end(ap);
return (retval);
}
static void
superio_child_detached(device_t dev, device_t child)
{
struct superio_devinfo *dinfo;
struct resource_list *rl;
dinfo = device_get_ivars(child);
rl = &dinfo->resources;
if (resource_list_release_active(rl, dev, child, SYS_RES_IRQ) != 0)
superio_printf(dinfo, "Device leaked IRQ resources\n");
if (resource_list_release_active(rl, dev, child, SYS_RES_MEMORY) != 0)
superio_printf(dinfo, "Device leaked memory resources\n");
if (resource_list_release_active(rl, dev, child, SYS_RES_IOPORT) != 0)
superio_printf(dinfo, "Device leaked I/O resources\n");
}
static int
superio_child_location_str(device_t parent, device_t child, char *buf,
size_t buflen)
{
superio_dev_type_t type;
uint8_t ldn;
ldn = superio_get_ldn(child);
type = superio_get_type(child);
snprintf(buf, buflen, "ldn=0x%02x type=%s", ldn, devtype_to_str(type));
return (0);
}
static int
superio_print_child(device_t parent, device_t child)
{
superio_dev_type_t type;
uint8_t ldn;
int retval;
ldn = superio_get_ldn(child);
type = superio_get_type(child);
retval = bus_print_child_header(parent, child);
retval += printf(" at %s ldn 0x%02x", devtype_to_str(type), ldn);
retval += bus_print_child_footer(parent, child);
return (retval);
}
superio_vendor_t
superio_vendor(device_t dev)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
return (sc->vendor);
}
uint16_t
superio_devid(device_t dev)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
return (sc->devid);
}
uint8_t
superio_revid(device_t dev)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
return (sc->revid);
}
uint8_t
superio_read(device_t dev, uint8_t reg)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
struct superio_devinfo *dinfo = device_get_ivars(dev);
uint8_t v;
sio_conf_enter(sc);
v = sio_ldn_read(sc, dinfo->ldn, reg);
sio_conf_exit(sc);
return (v);
}
void
superio_write(device_t dev, uint8_t reg, uint8_t val)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
struct superio_devinfo *dinfo = device_get_ivars(dev);
sio_conf_enter(sc);
sio_ldn_write(sc, dinfo->ldn, reg, val);
sio_conf_exit(sc);
}
bool
superio_dev_enabled(device_t dev)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
struct superio_devinfo *dinfo = device_get_ivars(dev);
uint8_t v;
/* GPIO device is always active in ITE chips. */
if (sc->vendor == SUPERIO_VENDOR_ITE && dinfo->ldn == 7)
return (true);
v = superio_read(dev, sc->enable_reg);
return ((v & 0x01) != 0);
}
void
superio_dev_enable(device_t dev)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
struct superio_devinfo *dinfo = device_get_ivars(dev);
uint8_t v;
/* GPIO device is always active in ITE chips. */
if (sc->vendor == SUPERIO_VENDOR_ITE && dinfo->ldn == 7)
return;
sio_conf_enter(sc);
v = sio_ldn_read(sc, dinfo->ldn, sc->enable_reg);
v |= 0x01;
sio_ldn_write(sc, dinfo->ldn, sc->enable_reg, v);
sio_conf_exit(sc);
}
void
superio_dev_disable(device_t dev)
{
device_t sio_dev = device_get_parent(dev);
struct siosc *sc = device_get_softc(sio_dev);
struct superio_devinfo *dinfo = device_get_ivars(dev);
uint8_t v;
/* GPIO device is always active in ITE chips. */
if (sc->vendor == SUPERIO_VENDOR_ITE && dinfo->ldn == 7)
return;
sio_conf_enter(sc);
v = sio_ldn_read(sc, dinfo->ldn, sc->enable_reg);
v &= ~0x01;
sio_ldn_write(sc, dinfo->ldn, sc->enable_reg, v);
sio_conf_exit(sc);
}
device_t
superio_find_dev(device_t superio, superio_dev_type_t type, int ldn)
{
struct siosc *sc = device_get_softc(superio);
struct superio_devinfo *dinfo;
if (ldn < -1 || ldn > UINT8_MAX)
return (NULL); /* ERANGE */
if (type == SUPERIO_DEV_NONE && ldn == -1)
return (NULL); /* EINVAL */
STAILQ_FOREACH(dinfo, &sc->devlist, link) {
if (ldn != -1 && dinfo->ldn != ldn)
continue;
if (type != SUPERIO_DEV_NONE && dinfo->type != type)
continue;
return (dinfo->dev);
}
return (NULL);
}
static devclass_t superio_devclass;
static device_method_t superio_methods[] = {
DEVMETHOD(device_identify, superio_identify),
DEVMETHOD(device_probe, superio_probe),
DEVMETHOD(device_attach, superio_attach),
DEVMETHOD(device_detach, superio_detach),
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(device_suspend, bus_generic_suspend),
DEVMETHOD(device_resume, bus_generic_resume),
DEVMETHOD(bus_add_child, superio_add_child),
DEVMETHOD(bus_child_detached, superio_child_detached),
DEVMETHOD(bus_child_location_str, superio_child_location_str),
DEVMETHOD(bus_print_child, superio_print_child),
DEVMETHOD(bus_read_ivar, superio_read_ivar),
DEVMETHOD(bus_write_ivar, superio_write_ivar),
DEVMETHOD(bus_get_resource_list, superio_get_resource_list),
DEVMETHOD(bus_alloc_resource, bus_generic_rl_alloc_resource),
DEVMETHOD(bus_release_resource, bus_generic_rl_release_resource),
DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource),
DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource),
DEVMETHOD(bus_delete_resource, bus_generic_rl_delete_resource),
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
DEVMETHOD_END
};
static driver_t superio_driver = {
"superio",
superio_methods,
sizeof(struct siosc)
};
DRIVER_MODULE(superio, isa, superio_driver, superio_devclass, 0, 0);
MODULE_VERSION(superio, 1);