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/kern/subr_bus.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1997,1998,2003 Doug Rabson
    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: stable/10/sys/kern/subr_bus.c 308402 2016-11-07 09:19:04Z hselasky $");
   29 
   30 #include "opt_bus.h"
   31 #include "opt_random.h"
   32 
   33 #include <sys/param.h>
   34 #include <sys/conf.h>
   35 #include <sys/filio.h>
   36 #include <sys/lock.h>
   37 #include <sys/kernel.h>
   38 #include <sys/kobj.h>
   39 #include <sys/limits.h>
   40 #include <sys/malloc.h>
   41 #include <sys/module.h>
   42 #include <sys/mutex.h>
   43 #include <sys/poll.h>
   44 #include <sys/priv.h>
   45 #include <sys/proc.h>
   46 #include <sys/condvar.h>
   47 #include <sys/queue.h>
   48 #include <machine/bus.h>
   49 #include <sys/random.h>
   50 #include <sys/rman.h>
   51 #include <sys/selinfo.h>
   52 #include <sys/signalvar.h>
   53 #include <sys/sysctl.h>
   54 #include <sys/systm.h>
   55 #include <sys/uio.h>
   56 #include <sys/bus.h>
   57 #include <sys/interrupt.h>
   58 #include <sys/cpuset.h>
   59 
   60 #include <net/vnet.h>
   61 
   62 #include <machine/cpu.h>
   63 #include <machine/stdarg.h>
   64 
   65 #include <vm/uma.h>
   66 
   67 SYSCTL_NODE(_hw, OID_AUTO, bus, CTLFLAG_RW, NULL, NULL);
   68 SYSCTL_NODE(, OID_AUTO, dev, CTLFLAG_RW, NULL, NULL);
   69 
   70 /*
   71  * Used to attach drivers to devclasses.
   72  */
   73 typedef struct driverlink *driverlink_t;
   74 struct driverlink {
   75         kobj_class_t    driver;
   76         TAILQ_ENTRY(driverlink) link;   /* list of drivers in devclass */
   77         int             pass;
   78         TAILQ_ENTRY(driverlink) passlink;
   79 };
   80 
   81 /*
   82  * Forward declarations
   83  */
   84 typedef TAILQ_HEAD(devclass_list, devclass) devclass_list_t;
   85 typedef TAILQ_HEAD(driver_list, driverlink) driver_list_t;
   86 typedef TAILQ_HEAD(device_list, device) device_list_t;
   87 
   88 struct devclass {
   89         TAILQ_ENTRY(devclass) link;
   90         devclass_t      parent;         /* parent in devclass hierarchy */
   91         driver_list_t   drivers;     /* bus devclasses store drivers for bus */
   92         char            *name;
   93         device_t        *devices;       /* array of devices indexed by unit */
   94         int             maxunit;        /* size of devices array */
   95         int             flags;
   96 #define DC_HAS_CHILDREN         1
   97 
   98         struct sysctl_ctx_list sysctl_ctx;
   99         struct sysctl_oid *sysctl_tree;
  100 };
  101 
  102 /**
  103  * @brief Implementation of device.
  104  */
  105 struct device {
  106         /*
  107          * A device is a kernel object. The first field must be the
  108          * current ops table for the object.
  109          */
  110         KOBJ_FIELDS;
  111 
  112         /*
  113          * Device hierarchy.
  114          */
  115         TAILQ_ENTRY(device)     link;   /**< list of devices in parent */
  116         TAILQ_ENTRY(device)     devlink; /**< global device list membership */
  117         device_t        parent;         /**< parent of this device  */
  118         device_list_t   children;       /**< list of child devices */
  119 
  120         /*
  121          * Details of this device.
  122          */
  123         driver_t        *driver;        /**< current driver */
  124         devclass_t      devclass;       /**< current device class */
  125         int             unit;           /**< current unit number */
  126         char*           nameunit;       /**< name+unit e.g. foodev0 */
  127         char*           desc;           /**< driver specific description */
  128         int             busy;           /**< count of calls to device_busy() */
  129         device_state_t  state;          /**< current device state  */
  130         uint32_t        devflags;       /**< api level flags for device_get_flags() */
  131         u_int           flags;          /**< internal device flags  */
  132 #define DF_ENABLED      0x01            /* device should be probed/attached */
  133 #define DF_FIXEDCLASS   0x02            /* devclass specified at create time */
  134 #define DF_WILDCARD     0x04            /* unit was originally wildcard */
  135 #define DF_DESCMALLOCED 0x08            /* description was malloced */
  136 #define DF_QUIET        0x10            /* don't print verbose attach message */
  137 #define DF_DONENOMATCH  0x20            /* don't execute DEVICE_NOMATCH again */
  138 #define DF_EXTERNALSOFTC 0x40           /* softc not allocated by us */
  139 #define DF_REBID        0x80            /* Can rebid after attach */
  140         u_int   order;                  /**< order from device_add_child_ordered() */
  141         void    *ivars;                 /**< instance variables  */
  142         void    *softc;                 /**< current driver's variables  */
  143 
  144         struct sysctl_ctx_list sysctl_ctx; /**< state for sysctl variables  */
  145         struct sysctl_oid *sysctl_tree; /**< state for sysctl variables */
  146 };
  147 
  148 static MALLOC_DEFINE(M_BUS, "bus", "Bus data structures");
  149 static MALLOC_DEFINE(M_BUS_SC, "bus-sc", "Bus data structures, softc");
  150 
  151 static void devctl2_init(void);
  152 
  153 #ifdef BUS_DEBUG
  154 
  155 static int bus_debug = 1;
  156 TUNABLE_INT("bus.debug", &bus_debug);
  157 SYSCTL_INT(_debug, OID_AUTO, bus_debug, CTLFLAG_RW, &bus_debug, 0,
  158     "Debug bus code");
  159 
  160 #define PDEBUG(a)       if (bus_debug) {printf("%s:%d: ", __func__, __LINE__), printf a; printf("\n");}
  161 #define DEVICENAME(d)   ((d)? device_get_name(d): "no device")
  162 #define DRIVERNAME(d)   ((d)? d->name : "no driver")
  163 #define DEVCLANAME(d)   ((d)? d->name : "no devclass")
  164 
  165 /**
  166  * Produce the indenting, indent*2 spaces plus a '.' ahead of that to
  167  * prevent syslog from deleting initial spaces
  168  */
  169 #define indentprintf(p) do { int iJ; printf("."); for (iJ=0; iJ<indent; iJ++) printf("  "); printf p ; } while (0)
  170 
  171 static void print_device_short(device_t dev, int indent);
  172 static void print_device(device_t dev, int indent);
  173 void print_device_tree_short(device_t dev, int indent);
  174 void print_device_tree(device_t dev, int indent);
  175 static void print_driver_short(driver_t *driver, int indent);
  176 static void print_driver(driver_t *driver, int indent);
  177 static void print_driver_list(driver_list_t drivers, int indent);
  178 static void print_devclass_short(devclass_t dc, int indent);
  179 static void print_devclass(devclass_t dc, int indent);
  180 void print_devclass_list_short(void);
  181 void print_devclass_list(void);
  182 
  183 #else
  184 /* Make the compiler ignore the function calls */
  185 #define PDEBUG(a)                       /* nop */
  186 #define DEVICENAME(d)                   /* nop */
  187 #define DRIVERNAME(d)                   /* nop */
  188 #define DEVCLANAME(d)                   /* nop */
  189 
  190 #define print_device_short(d,i)         /* nop */
  191 #define print_device(d,i)               /* nop */
  192 #define print_device_tree_short(d,i)    /* nop */
  193 #define print_device_tree(d,i)          /* nop */
  194 #define print_driver_short(d,i)         /* nop */
  195 #define print_driver(d,i)               /* nop */
  196 #define print_driver_list(d,i)          /* nop */
  197 #define print_devclass_short(d,i)       /* nop */
  198 #define print_devclass(d,i)             /* nop */
  199 #define print_devclass_list_short()     /* nop */
  200 #define print_devclass_list()           /* nop */
  201 #endif
  202 
  203 /*
  204  * dev sysctl tree
  205  */
  206 
  207 enum {
  208         DEVCLASS_SYSCTL_PARENT,
  209 };
  210 
  211 static int
  212 devclass_sysctl_handler(SYSCTL_HANDLER_ARGS)
  213 {
  214         devclass_t dc = (devclass_t)arg1;
  215         const char *value;
  216 
  217         switch (arg2) {
  218         case DEVCLASS_SYSCTL_PARENT:
  219                 value = dc->parent ? dc->parent->name : "";
  220                 break;
  221         default:
  222                 return (EINVAL);
  223         }
  224         return (SYSCTL_OUT(req, value, strlen(value)));
  225 }
  226 
  227 static void
  228 devclass_sysctl_init(devclass_t dc)
  229 {
  230 
  231         if (dc->sysctl_tree != NULL)
  232                 return;
  233         sysctl_ctx_init(&dc->sysctl_ctx);
  234         dc->sysctl_tree = SYSCTL_ADD_NODE(&dc->sysctl_ctx,
  235             SYSCTL_STATIC_CHILDREN(_dev), OID_AUTO, dc->name,
  236             CTLFLAG_RD, NULL, "");
  237         SYSCTL_ADD_PROC(&dc->sysctl_ctx, SYSCTL_CHILDREN(dc->sysctl_tree),
  238             OID_AUTO, "%parent", CTLTYPE_STRING | CTLFLAG_RD,
  239             dc, DEVCLASS_SYSCTL_PARENT, devclass_sysctl_handler, "A",
  240             "parent class");
  241 }
  242 
  243 enum {
  244         DEVICE_SYSCTL_DESC,
  245         DEVICE_SYSCTL_DRIVER,
  246         DEVICE_SYSCTL_LOCATION,
  247         DEVICE_SYSCTL_PNPINFO,
  248         DEVICE_SYSCTL_PARENT,
  249 };
  250 
  251 static int
  252 device_sysctl_handler(SYSCTL_HANDLER_ARGS)
  253 {
  254         device_t dev = (device_t)arg1;
  255         const char *value;
  256         char *buf;
  257         int error;
  258 
  259         buf = NULL;
  260         switch (arg2) {
  261         case DEVICE_SYSCTL_DESC:
  262                 value = dev->desc ? dev->desc : "";
  263                 break;
  264         case DEVICE_SYSCTL_DRIVER:
  265                 value = dev->driver ? dev->driver->name : "";
  266                 break;
  267         case DEVICE_SYSCTL_LOCATION:
  268                 value = buf = malloc(1024, M_BUS, M_WAITOK | M_ZERO);
  269                 bus_child_location_str(dev, buf, 1024);
  270                 break;
  271         case DEVICE_SYSCTL_PNPINFO:
  272                 value = buf = malloc(1024, M_BUS, M_WAITOK | M_ZERO);
  273                 bus_child_pnpinfo_str(dev, buf, 1024);
  274                 break;
  275         case DEVICE_SYSCTL_PARENT:
  276                 value = dev->parent ? dev->parent->nameunit : "";
  277                 break;
  278         default:
  279                 return (EINVAL);
  280         }
  281         error = SYSCTL_OUT(req, value, strlen(value));
  282         if (buf != NULL)
  283                 free(buf, M_BUS);
  284         return (error);
  285 }
  286 
  287 static void
  288 device_sysctl_init(device_t dev)
  289 {
  290         devclass_t dc = dev->devclass;
  291         int domain;
  292 
  293         if (dev->sysctl_tree != NULL)
  294                 return;
  295         devclass_sysctl_init(dc);
  296         sysctl_ctx_init(&dev->sysctl_ctx);
  297         dev->sysctl_tree = SYSCTL_ADD_NODE(&dev->sysctl_ctx,
  298             SYSCTL_CHILDREN(dc->sysctl_tree), OID_AUTO,
  299             dev->nameunit + strlen(dc->name),
  300             CTLFLAG_RD, NULL, "");
  301         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  302             OID_AUTO, "%desc", CTLTYPE_STRING | CTLFLAG_RD,
  303             dev, DEVICE_SYSCTL_DESC, device_sysctl_handler, "A",
  304             "device description");
  305         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  306             OID_AUTO, "%driver", CTLTYPE_STRING | CTLFLAG_RD,
  307             dev, DEVICE_SYSCTL_DRIVER, device_sysctl_handler, "A",
  308             "device driver name");
  309         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  310             OID_AUTO, "%location", CTLTYPE_STRING | CTLFLAG_RD,
  311             dev, DEVICE_SYSCTL_LOCATION, device_sysctl_handler, "A",
  312             "device location relative to parent");
  313         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  314             OID_AUTO, "%pnpinfo", CTLTYPE_STRING | CTLFLAG_RD,
  315             dev, DEVICE_SYSCTL_PNPINFO, device_sysctl_handler, "A",
  316             "device identification");
  317         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  318             OID_AUTO, "%parent", CTLTYPE_STRING | CTLFLAG_RD,
  319             dev, DEVICE_SYSCTL_PARENT, device_sysctl_handler, "A",
  320             "parent device");
  321         if (bus_get_domain(dev, &domain) == 0)
  322                 SYSCTL_ADD_INT(&dev->sysctl_ctx,
  323                     SYSCTL_CHILDREN(dev->sysctl_tree), OID_AUTO, "%domain",
  324                     CTLFLAG_RD, NULL, domain, "NUMA domain");
  325 }
  326 
  327 static void
  328 device_sysctl_update(device_t dev)
  329 {
  330         devclass_t dc = dev->devclass;
  331 
  332         if (dev->sysctl_tree == NULL)
  333                 return;
  334         sysctl_rename_oid(dev->sysctl_tree, dev->nameunit + strlen(dc->name));
  335 }
  336 
  337 static void
  338 device_sysctl_fini(device_t dev)
  339 {
  340         if (dev->sysctl_tree == NULL)
  341                 return;
  342         sysctl_ctx_free(&dev->sysctl_ctx);
  343         dev->sysctl_tree = NULL;
  344 }
  345 
  346 /*
  347  * /dev/devctl implementation
  348  */
  349 
  350 /*
  351  * This design allows only one reader for /dev/devctl.  This is not desirable
  352  * in the long run, but will get a lot of hair out of this implementation.
  353  * Maybe we should make this device a clonable device.
  354  *
  355  * Also note: we specifically do not attach a device to the device_t tree
  356  * to avoid potential chicken and egg problems.  One could argue that all
  357  * of this belongs to the root node.  One could also further argue that the
  358  * sysctl interface that we have not might more properly be an ioctl
  359  * interface, but at this stage of the game, I'm not inclined to rock that
  360  * boat.
  361  *
  362  * I'm also not sure that the SIGIO support is done correctly or not, as
  363  * I copied it from a driver that had SIGIO support that likely hasn't been
  364  * tested since 3.4 or 2.2.8!
  365  */
  366 
  367 /* Deprecated way to adjust queue length */
  368 static int sysctl_devctl_disable(SYSCTL_HANDLER_ARGS);
  369 /* XXX Need to support old-style tunable hw.bus.devctl_disable" */
  370 SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_disable, CTLTYPE_INT | CTLFLAG_RW |
  371     CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_disable, "I",
  372     "devctl disable -- deprecated");
  373 
  374 #define DEVCTL_DEFAULT_QUEUE_LEN 1000
  375 static int sysctl_devctl_queue(SYSCTL_HANDLER_ARGS);
  376 static int devctl_queue_length = DEVCTL_DEFAULT_QUEUE_LEN;
  377 TUNABLE_INT("hw.bus.devctl_queue", &devctl_queue_length);
  378 SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_queue, CTLTYPE_INT | CTLFLAG_RW |
  379     CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_queue, "I", "devctl queue length");
  380 
  381 static d_open_t         devopen;
  382 static d_close_t        devclose;
  383 static d_read_t         devread;
  384 static d_ioctl_t        devioctl;
  385 static d_poll_t         devpoll;
  386 static d_kqfilter_t     devkqfilter;
  387 
  388 static struct cdevsw dev_cdevsw = {
  389         .d_version =    D_VERSION,
  390         .d_open =       devopen,
  391         .d_close =      devclose,
  392         .d_read =       devread,
  393         .d_ioctl =      devioctl,
  394         .d_poll =       devpoll,
  395         .d_kqfilter =   devkqfilter,
  396         .d_name =       "devctl",
  397 };
  398 
  399 struct dev_event_info
  400 {
  401         char *dei_data;
  402         TAILQ_ENTRY(dev_event_info) dei_link;
  403 };
  404 
  405 TAILQ_HEAD(devq, dev_event_info);
  406 
  407 static struct dev_softc
  408 {
  409         int     inuse;
  410         int     nonblock;
  411         int     queued;
  412         int     async;
  413         struct mtx mtx;
  414         struct cv cv;
  415         struct selinfo sel;
  416         struct devq devq;
  417         struct sigio *sigio;
  418 } devsoftc;
  419 
  420 static void     filt_devctl_detach(struct knote *kn);
  421 static int      filt_devctl_read(struct knote *kn, long hint);
  422 
  423 struct filterops devctl_rfiltops = {
  424         .f_isfd = 1,
  425         .f_detach = filt_devctl_detach,
  426         .f_event = filt_devctl_read,
  427 };
  428 
  429 static struct cdev *devctl_dev;
  430 
  431 static void
  432 devinit(void)
  433 {
  434         devctl_dev = make_dev_credf(MAKEDEV_ETERNAL, &dev_cdevsw, 0, NULL,
  435             UID_ROOT, GID_WHEEL, 0600, "devctl");
  436         mtx_init(&devsoftc.mtx, "dev mtx", "devd", MTX_DEF);
  437         cv_init(&devsoftc.cv, "dev cv");
  438         TAILQ_INIT(&devsoftc.devq);
  439         knlist_init_mtx(&devsoftc.sel.si_note, &devsoftc.mtx);
  440         devctl2_init();
  441 }
  442 
  443 static int
  444 devopen(struct cdev *dev, int oflags, int devtype, struct thread *td)
  445 {
  446 
  447         mtx_lock(&devsoftc.mtx);
  448         if (devsoftc.inuse) {
  449                 mtx_unlock(&devsoftc.mtx);
  450                 return (EBUSY);
  451         }
  452         /* move to init */
  453         devsoftc.inuse = 1;
  454         mtx_unlock(&devsoftc.mtx);
  455         return (0);
  456 }
  457 
  458 static int
  459 devclose(struct cdev *dev, int fflag, int devtype, struct thread *td)
  460 {
  461 
  462         mtx_lock(&devsoftc.mtx);
  463         devsoftc.inuse = 0;
  464         devsoftc.nonblock = 0;
  465         devsoftc.async = 0;
  466         cv_broadcast(&devsoftc.cv);
  467         funsetown(&devsoftc.sigio);
  468         mtx_unlock(&devsoftc.mtx);
  469         return (0);
  470 }
  471 
  472 /*
  473  * The read channel for this device is used to report changes to
  474  * userland in realtime.  We are required to free the data as well as
  475  * the n1 object because we allocate them separately.  Also note that
  476  * we return one record at a time.  If you try to read this device a
  477  * character at a time, you will lose the rest of the data.  Listening
  478  * programs are expected to cope.
  479  */
  480 static int
  481 devread(struct cdev *dev, struct uio *uio, int ioflag)
  482 {
  483         struct dev_event_info *n1;
  484         int rv;
  485 
  486         mtx_lock(&devsoftc.mtx);
  487         while (TAILQ_EMPTY(&devsoftc.devq)) {
  488                 if (devsoftc.nonblock) {
  489                         mtx_unlock(&devsoftc.mtx);
  490                         return (EAGAIN);
  491                 }
  492                 rv = cv_wait_sig(&devsoftc.cv, &devsoftc.mtx);
  493                 if (rv) {
  494                         /*
  495                          * Need to translate ERESTART to EINTR here? -- jake
  496                          */
  497                         mtx_unlock(&devsoftc.mtx);
  498                         return (rv);
  499                 }
  500         }
  501         n1 = TAILQ_FIRST(&devsoftc.devq);
  502         TAILQ_REMOVE(&devsoftc.devq, n1, dei_link);
  503         devsoftc.queued--;
  504         mtx_unlock(&devsoftc.mtx);
  505         rv = uiomove(n1->dei_data, strlen(n1->dei_data), uio);
  506         free(n1->dei_data, M_BUS);
  507         free(n1, M_BUS);
  508         return (rv);
  509 }
  510 
  511 static  int
  512 devioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
  513 {
  514         switch (cmd) {
  515 
  516         case FIONBIO:
  517                 if (*(int*)data)
  518                         devsoftc.nonblock = 1;
  519                 else
  520                         devsoftc.nonblock = 0;
  521                 return (0);
  522         case FIOASYNC:
  523                 if (*(int*)data)
  524                         devsoftc.async = 1;
  525                 else
  526                         devsoftc.async = 0;
  527                 return (0);
  528         case FIOSETOWN:
  529                 return fsetown(*(int *)data, &devsoftc.sigio);
  530         case FIOGETOWN:
  531                 *(int *)data = fgetown(&devsoftc.sigio);
  532                 return (0);
  533 
  534                 /* (un)Support for other fcntl() calls. */
  535         case FIOCLEX:
  536         case FIONCLEX:
  537         case FIONREAD:
  538         default:
  539                 break;
  540         }
  541         return (ENOTTY);
  542 }
  543 
  544 static  int
  545 devpoll(struct cdev *dev, int events, struct thread *td)
  546 {
  547         int     revents = 0;
  548 
  549         mtx_lock(&devsoftc.mtx);
  550         if (events & (POLLIN | POLLRDNORM)) {
  551                 if (!TAILQ_EMPTY(&devsoftc.devq))
  552                         revents = events & (POLLIN | POLLRDNORM);
  553                 else
  554                         selrecord(td, &devsoftc.sel);
  555         }
  556         mtx_unlock(&devsoftc.mtx);
  557 
  558         return (revents);
  559 }
  560 
  561 static int
  562 devkqfilter(struct cdev *dev, struct knote *kn)
  563 {
  564         int error;
  565 
  566         if (kn->kn_filter == EVFILT_READ) {
  567                 kn->kn_fop = &devctl_rfiltops;
  568                 knlist_add(&devsoftc.sel.si_note, kn, 0);
  569                 error = 0;
  570         } else
  571                 error = EINVAL;
  572         return (error);
  573 }
  574 
  575 static void
  576 filt_devctl_detach(struct knote *kn)
  577 {
  578 
  579         knlist_remove(&devsoftc.sel.si_note, kn, 0);
  580 }
  581 
  582 static int
  583 filt_devctl_read(struct knote *kn, long hint)
  584 {
  585         kn->kn_data = devsoftc.queued;
  586         return (kn->kn_data != 0);
  587 }
  588 
  589 /**
  590  * @brief Return whether the userland process is running
  591  */
  592 boolean_t
  593 devctl_process_running(void)
  594 {
  595         return (devsoftc.inuse == 1);
  596 }
  597 
  598 /**
  599  * @brief Queue data to be read from the devctl device
  600  *
  601  * Generic interface to queue data to the devctl device.  It is
  602  * assumed that @p data is properly formatted.  It is further assumed
  603  * that @p data is allocated using the M_BUS malloc type.
  604  */
  605 void
  606 devctl_queue_data_f(char *data, int flags)
  607 {
  608         struct dev_event_info *n1 = NULL, *n2 = NULL;
  609 
  610         if (strlen(data) == 0)
  611                 goto out;
  612         if (devctl_queue_length == 0)
  613                 goto out;
  614         n1 = malloc(sizeof(*n1), M_BUS, flags);
  615         if (n1 == NULL)
  616                 goto out;
  617         n1->dei_data = data;
  618         mtx_lock(&devsoftc.mtx);
  619         if (devctl_queue_length == 0) {
  620                 mtx_unlock(&devsoftc.mtx);
  621                 free(n1->dei_data, M_BUS);
  622                 free(n1, M_BUS);
  623                 return;
  624         }
  625         /* Leave at least one spot in the queue... */
  626         while (devsoftc.queued > devctl_queue_length - 1) {
  627                 n2 = TAILQ_FIRST(&devsoftc.devq);
  628                 TAILQ_REMOVE(&devsoftc.devq, n2, dei_link);
  629                 free(n2->dei_data, M_BUS);
  630                 free(n2, M_BUS);
  631                 devsoftc.queued--;
  632         }
  633         TAILQ_INSERT_TAIL(&devsoftc.devq, n1, dei_link);
  634         devsoftc.queued++;
  635         cv_broadcast(&devsoftc.cv);
  636         KNOTE_LOCKED(&devsoftc.sel.si_note, 0);
  637         mtx_unlock(&devsoftc.mtx);
  638         selwakeup(&devsoftc.sel);
  639         if (devsoftc.async && devsoftc.sigio != NULL)
  640                 pgsigio(&devsoftc.sigio, SIGIO, 0);
  641         return;
  642 out:
  643         /*
  644          * We have to free data on all error paths since the caller
  645          * assumes it will be free'd when this item is dequeued.
  646          */
  647         free(data, M_BUS);
  648         return;
  649 }
  650 
  651 void
  652 devctl_queue_data(char *data)
  653 {
  654 
  655         devctl_queue_data_f(data, M_NOWAIT);
  656 }
  657 
  658 /**
  659  * @brief Send a 'notification' to userland, using standard ways
  660  */
  661 void
  662 devctl_notify_f(const char *system, const char *subsystem, const char *type,
  663     const char *data, int flags)
  664 {
  665         int len = 0;
  666         char *msg;
  667 
  668         if (system == NULL)
  669                 return;         /* BOGUS!  Must specify system. */
  670         if (subsystem == NULL)
  671                 return;         /* BOGUS!  Must specify subsystem. */
  672         if (type == NULL)
  673                 return;         /* BOGUS!  Must specify type. */
  674         len += strlen(" system=") + strlen(system);
  675         len += strlen(" subsystem=") + strlen(subsystem);
  676         len += strlen(" type=") + strlen(type);
  677         /* add in the data message plus newline. */
  678         if (data != NULL)
  679                 len += strlen(data);
  680         len += 3;       /* '!', '\n', and NUL */
  681         msg = malloc(len, M_BUS, flags);
  682         if (msg == NULL)
  683                 return;         /* Drop it on the floor */
  684         if (data != NULL)
  685                 snprintf(msg, len, "!system=%s subsystem=%s type=%s %s\n",
  686                     system, subsystem, type, data);
  687         else
  688                 snprintf(msg, len, "!system=%s subsystem=%s type=%s\n",
  689                     system, subsystem, type);
  690         devctl_queue_data_f(msg, flags);
  691 }
  692 
  693 void
  694 devctl_notify(const char *system, const char *subsystem, const char *type,
  695     const char *data)
  696 {
  697 
  698         devctl_notify_f(system, subsystem, type, data, M_NOWAIT);
  699 }
  700 
  701 /*
  702  * Common routine that tries to make sending messages as easy as possible.
  703  * We allocate memory for the data, copy strings into that, but do not
  704  * free it unless there's an error.  The dequeue part of the driver should
  705  * free the data.  We don't send data when the device is disabled.  We do
  706  * send data, even when we have no listeners, because we wish to avoid
  707  * races relating to startup and restart of listening applications.
  708  *
  709  * devaddq is designed to string together the type of event, with the
  710  * object of that event, plus the plug and play info and location info
  711  * for that event.  This is likely most useful for devices, but less
  712  * useful for other consumers of this interface.  Those should use
  713  * the devctl_queue_data() interface instead.
  714  */
  715 static void
  716 devaddq(const char *type, const char *what, device_t dev)
  717 {
  718         char *data = NULL;
  719         char *loc = NULL;
  720         char *pnp = NULL;
  721         const char *parstr;
  722 
  723         if (!devctl_queue_length)/* Rare race, but lost races safely discard */
  724                 return;
  725         data = malloc(1024, M_BUS, M_NOWAIT);
  726         if (data == NULL)
  727                 goto bad;
  728 
  729         /* get the bus specific location of this device */
  730         loc = malloc(1024, M_BUS, M_NOWAIT);
  731         if (loc == NULL)
  732                 goto bad;
  733         *loc = '\0';
  734         bus_child_location_str(dev, loc, 1024);
  735 
  736         /* Get the bus specific pnp info of this device */
  737         pnp = malloc(1024, M_BUS, M_NOWAIT);
  738         if (pnp == NULL)
  739                 goto bad;
  740         *pnp = '\0';
  741         bus_child_pnpinfo_str(dev, pnp, 1024);
  742 
  743         /* Get the parent of this device, or / if high enough in the tree. */
  744         if (device_get_parent(dev) == NULL)
  745                 parstr = ".";   /* Or '/' ? */
  746         else
  747                 parstr = device_get_nameunit(device_get_parent(dev));
  748         /* String it all together. */
  749         snprintf(data, 1024, "%s%s at %s %s on %s\n", type, what, loc, pnp,
  750           parstr);
  751         free(loc, M_BUS);
  752         free(pnp, M_BUS);
  753         devctl_queue_data(data);
  754         return;
  755 bad:
  756         free(pnp, M_BUS);
  757         free(loc, M_BUS);
  758         free(data, M_BUS);
  759         return;
  760 }
  761 
  762 /*
  763  * A device was added to the tree.  We are called just after it successfully
  764  * attaches (that is, probe and attach success for this device).  No call
  765  * is made if a device is merely parented into the tree.  See devnomatch
  766  * if probe fails.  If attach fails, no notification is sent (but maybe
  767  * we should have a different message for this).
  768  */
  769 static void
  770 devadded(device_t dev)
  771 {
  772         devaddq("+", device_get_nameunit(dev), dev);
  773 }
  774 
  775 /*
  776  * A device was removed from the tree.  We are called just before this
  777  * happens.
  778  */
  779 static void
  780 devremoved(device_t dev)
  781 {
  782         devaddq("-", device_get_nameunit(dev), dev);
  783 }
  784 
  785 /*
  786  * Called when there's no match for this device.  This is only called
  787  * the first time that no match happens, so we don't keep getting this
  788  * message.  Should that prove to be undesirable, we can change it.
  789  * This is called when all drivers that can attach to a given bus
  790  * decline to accept this device.  Other errors may not be detected.
  791  */
  792 static void
  793 devnomatch(device_t dev)
  794 {
  795         devaddq("?", "", dev);
  796 }
  797 
  798 static int
  799 sysctl_devctl_disable(SYSCTL_HANDLER_ARGS)
  800 {
  801         struct dev_event_info *n1;
  802         int dis, error;
  803 
  804         dis = devctl_queue_length == 0;
  805         error = sysctl_handle_int(oidp, &dis, 0, req);
  806         if (error || !req->newptr)
  807                 return (error);
  808         mtx_lock(&devsoftc.mtx);
  809         if (dis) {
  810                 while (!TAILQ_EMPTY(&devsoftc.devq)) {
  811                         n1 = TAILQ_FIRST(&devsoftc.devq);
  812                         TAILQ_REMOVE(&devsoftc.devq, n1, dei_link);
  813                         free(n1->dei_data, M_BUS);
  814                         free(n1, M_BUS);
  815                 }
  816                 devsoftc.queued = 0;
  817                 devctl_queue_length = 0;
  818         } else {
  819                 devctl_queue_length = DEVCTL_DEFAULT_QUEUE_LEN;
  820         }
  821         mtx_unlock(&devsoftc.mtx);
  822         return (0);
  823 }
  824 
  825 static int
  826 sysctl_devctl_queue(SYSCTL_HANDLER_ARGS)
  827 {
  828         struct dev_event_info *n1;
  829         int q, error;
  830 
  831         q = devctl_queue_length;
  832         error = sysctl_handle_int(oidp, &q, 0, req);
  833         if (error || !req->newptr)
  834                 return (error);
  835         if (q < 0)
  836                 return (EINVAL);
  837         mtx_lock(&devsoftc.mtx);
  838         devctl_queue_length = q;
  839         while (devsoftc.queued > devctl_queue_length) {
  840                 n1 = TAILQ_FIRST(&devsoftc.devq);
  841                 TAILQ_REMOVE(&devsoftc.devq, n1, dei_link);
  842                 free(n1->dei_data, M_BUS);
  843                 free(n1, M_BUS);
  844                 devsoftc.queued--;
  845         }
  846         mtx_unlock(&devsoftc.mtx);
  847         return (0);
  848 }
  849 
  850 /* End of /dev/devctl code */
  851 
  852 static TAILQ_HEAD(,device)      bus_data_devices;
  853 static int bus_data_generation = 1;
  854 
  855 static kobj_method_t null_methods[] = {
  856         KOBJMETHOD_END
  857 };
  858 
  859 DEFINE_CLASS(null, null_methods, 0);
  860 
  861 /*
  862  * Bus pass implementation
  863  */
  864 
  865 static driver_list_t passes = TAILQ_HEAD_INITIALIZER(passes);
  866 int bus_current_pass = BUS_PASS_ROOT;
  867 
  868 /**
  869  * @internal
  870  * @brief Register the pass level of a new driver attachment
  871  *
  872  * Register a new driver attachment's pass level.  If no driver
  873  * attachment with the same pass level has been added, then @p new
  874  * will be added to the global passes list.
  875  *
  876  * @param new           the new driver attachment
  877  */
  878 static void
  879 driver_register_pass(struct driverlink *new)
  880 {
  881         struct driverlink *dl;
  882 
  883         /* We only consider pass numbers during boot. */
  884         if (bus_current_pass == BUS_PASS_DEFAULT)
  885                 return;
  886 
  887         /*
  888          * Walk the passes list.  If we already know about this pass
  889          * then there is nothing to do.  If we don't, then insert this
  890          * driver link into the list.
  891          */
  892         TAILQ_FOREACH(dl, &passes, passlink) {
  893                 if (dl->pass < new->pass)
  894                         continue;
  895                 if (dl->pass == new->pass)
  896                         return;
  897                 TAILQ_INSERT_BEFORE(dl, new, passlink);
  898                 return;
  899         }
  900         TAILQ_INSERT_TAIL(&passes, new, passlink);
  901 }
  902 
  903 /**
  904  * @brief Raise the current bus pass
  905  *
  906  * Raise the current bus pass level to @p pass.  Call the BUS_NEW_PASS()
  907  * method on the root bus to kick off a new device tree scan for each
  908  * new pass level that has at least one driver.
  909  */
  910 void
  911 bus_set_pass(int pass)
  912 {
  913         struct driverlink *dl;
  914 
  915         if (bus_current_pass > pass)
  916                 panic("Attempt to lower bus pass level");
  917 
  918         TAILQ_FOREACH(dl, &passes, passlink) {
  919                 /* Skip pass values below the current pass level. */
  920                 if (dl->pass <= bus_current_pass)
  921                         continue;
  922 
  923                 /*
  924                  * Bail once we hit a driver with a pass level that is
  925                  * too high.
  926                  */
  927                 if (dl->pass > pass)
  928                         break;
  929 
  930                 /*
  931                  * Raise the pass level to the next level and rescan
  932                  * the tree.
  933                  */
  934                 bus_current_pass = dl->pass;
  935                 BUS_NEW_PASS(root_bus);
  936         }
  937 
  938         /*
  939          * If there isn't a driver registered for the requested pass,
  940          * then bus_current_pass might still be less than 'pass'.  Set
  941          * it to 'pass' in that case.
  942          */
  943         if (bus_current_pass < pass)
  944                 bus_current_pass = pass;
  945         KASSERT(bus_current_pass == pass, ("Failed to update bus pass level"));
  946 }
  947 
  948 /*
  949  * Devclass implementation
  950  */
  951 
  952 static devclass_list_t devclasses = TAILQ_HEAD_INITIALIZER(devclasses);
  953 
  954 /**
  955  * @internal
  956  * @brief Find or create a device class
  957  *
  958  * If a device class with the name @p classname exists, return it,
  959  * otherwise if @p create is non-zero create and return a new device
  960  * class.
  961  *
  962  * If @p parentname is non-NULL, the parent of the devclass is set to
  963  * the devclass of that name.
  964  *
  965  * @param classname     the devclass name to find or create
  966  * @param parentname    the parent devclass name or @c NULL
  967  * @param create        non-zero to create a devclass
  968  */
  969 static devclass_t
  970 devclass_find_internal(const char *classname, const char *parentname,
  971                        int create)
  972 {
  973         devclass_t dc;
  974 
  975         PDEBUG(("looking for %s", classname));
  976         if (!classname)
  977                 return (NULL);
  978 
  979         TAILQ_FOREACH(dc, &devclasses, link) {
  980                 if (!strcmp(dc->name, classname))
  981                         break;
  982         }
  983 
  984         if (create && !dc) {
  985                 PDEBUG(("creating %s", classname));
  986                 dc = malloc(sizeof(struct devclass) + strlen(classname) + 1,
  987                     M_BUS, M_NOWAIT | M_ZERO);
  988                 if (!dc)
  989                         return (NULL);
  990                 dc->parent = NULL;
  991                 dc->name = (char*) (dc + 1);
  992                 strcpy(dc->name, classname);
  993                 TAILQ_INIT(&dc->drivers);
  994                 TAILQ_INSERT_TAIL(&devclasses, dc, link);
  995 
  996                 bus_data_generation_update();
  997         }
  998 
  999         /*
 1000          * If a parent class is specified, then set that as our parent so
 1001          * that this devclass will support drivers for the parent class as
 1002          * well.  If the parent class has the same name don't do this though
 1003          * as it creates a cycle that can trigger an infinite loop in
 1004          * device_probe_child() if a device exists for which there is no
 1005          * suitable driver.
 1006          */
 1007         if (parentname && dc && !dc->parent &&
 1008             strcmp(classname, parentname) != 0) {
 1009                 dc->parent = devclass_find_internal(parentname, NULL, TRUE);
 1010                 dc->parent->flags |= DC_HAS_CHILDREN;
 1011         }
 1012 
 1013         return (dc);
 1014 }
 1015 
 1016 /**
 1017  * @brief Create a device class
 1018  *
 1019  * If a device class with the name @p classname exists, return it,
 1020  * otherwise create and return a new device class.
 1021  *
 1022  * @param classname     the devclass name to find or create
 1023  */
 1024 devclass_t
 1025 devclass_create(const char *classname)
 1026 {
 1027         return (devclass_find_internal(classname, NULL, TRUE));
 1028 }
 1029 
 1030 /**
 1031  * @brief Find a device class
 1032  *
 1033  * If a device class with the name @p classname exists, return it,
 1034  * otherwise return @c NULL.
 1035  *
 1036  * @param classname     the devclass name to find
 1037  */
 1038 devclass_t
 1039 devclass_find(const char *classname)
 1040 {
 1041         return (devclass_find_internal(classname, NULL, FALSE));
 1042 }
 1043 
 1044 /**
 1045  * @brief Register that a device driver has been added to a devclass
 1046  *
 1047  * Register that a device driver has been added to a devclass.  This
 1048  * is called by devclass_add_driver to accomplish the recursive
 1049  * notification of all the children classes of dc, as well as dc.
 1050  * Each layer will have BUS_DRIVER_ADDED() called for all instances of
 1051  * the devclass.
 1052  *
 1053  * We do a full search here of the devclass list at each iteration
 1054  * level to save storing children-lists in the devclass structure.  If
 1055  * we ever move beyond a few dozen devices doing this, we may need to
 1056  * reevaluate...
 1057  *
 1058  * @param dc            the devclass to edit
 1059  * @param driver        the driver that was just added
 1060  */
 1061 static void
 1062 devclass_driver_added(devclass_t dc, driver_t *driver)
 1063 {
 1064         devclass_t parent;
 1065         int i;
 1066 
 1067         /*
 1068          * Call BUS_DRIVER_ADDED for any existing busses in this class.
 1069          */
 1070         for (i = 0; i < dc->maxunit; i++)
 1071                 if (dc->devices[i] && device_is_attached(dc->devices[i]))
 1072                         BUS_DRIVER_ADDED(dc->devices[i], driver);
 1073 
 1074         /*
 1075          * Walk through the children classes.  Since we only keep a
 1076          * single parent pointer around, we walk the entire list of
 1077          * devclasses looking for children.  We set the
 1078          * DC_HAS_CHILDREN flag when a child devclass is created on
 1079          * the parent, so we only walk the list for those devclasses
 1080          * that have children.
 1081          */
 1082         if (!(dc->flags & DC_HAS_CHILDREN))
 1083                 return;
 1084         parent = dc;
 1085         TAILQ_FOREACH(dc, &devclasses, link) {
 1086                 if (dc->parent == parent)
 1087                         devclass_driver_added(dc, driver);
 1088         }
 1089 }
 1090 
 1091 /**
 1092  * @brief Add a device driver to a device class
 1093  *
 1094  * Add a device driver to a devclass. This is normally called
 1095  * automatically by DRIVER_MODULE(). The BUS_DRIVER_ADDED() method of
 1096  * all devices in the devclass will be called to allow them to attempt
 1097  * to re-probe any unmatched children.
 1098  *
 1099  * @param dc            the devclass to edit
 1100  * @param driver        the driver to register
 1101  */
 1102 int
 1103 devclass_add_driver(devclass_t dc, driver_t *driver, int pass, devclass_t *dcp)
 1104 {
 1105         driverlink_t dl;
 1106         const char *parentname;
 1107 
 1108         PDEBUG(("%s", DRIVERNAME(driver)));
 1109 
 1110         /* Don't allow invalid pass values. */
 1111         if (pass <= BUS_PASS_ROOT)
 1112                 return (EINVAL);
 1113 
 1114         dl = malloc(sizeof *dl, M_BUS, M_NOWAIT|M_ZERO);
 1115         if (!dl)
 1116                 return (ENOMEM);
 1117 
 1118         /*
 1119          * Compile the driver's methods. Also increase the reference count
 1120          * so that the class doesn't get freed when the last instance
 1121          * goes. This means we can safely use static methods and avoids a
 1122          * double-free in devclass_delete_driver.
 1123          */
 1124         kobj_class_compile((kobj_class_t) driver);
 1125 
 1126         /*
 1127          * If the driver has any base classes, make the
 1128          * devclass inherit from the devclass of the driver's
 1129          * first base class. This will allow the system to
 1130          * search for drivers in both devclasses for children
 1131          * of a device using this driver.
 1132          */
 1133         if (driver->baseclasses)
 1134                 parentname = driver->baseclasses[0]->name;
 1135         else
 1136                 parentname = NULL;
 1137         *dcp = devclass_find_internal(driver->name, parentname, TRUE);
 1138 
 1139         dl->driver = driver;
 1140         TAILQ_INSERT_TAIL(&dc->drivers, dl, link);
 1141         driver->refs++;         /* XXX: kobj_mtx */
 1142         dl->pass = pass;
 1143         driver_register_pass(dl);
 1144 
 1145         devclass_driver_added(dc, driver);
 1146         bus_data_generation_update();
 1147         return (0);
 1148 }
 1149 
 1150 /**
 1151  * @brief Register that a device driver has been deleted from a devclass
 1152  *
 1153  * Register that a device driver has been removed from a devclass.
 1154  * This is called by devclass_delete_driver to accomplish the
 1155  * recursive notification of all the children classes of busclass, as
 1156  * well as busclass.  Each layer will attempt to detach the driver
 1157  * from any devices that are children of the bus's devclass.  The function
 1158  * will return an error if a device fails to detach.
 1159  * 
 1160  * We do a full search here of the devclass list at each iteration
 1161  * level to save storing children-lists in the devclass structure.  If
 1162  * we ever move beyond a few dozen devices doing this, we may need to
 1163  * reevaluate...
 1164  *
 1165  * @param busclass      the devclass of the parent bus
 1166  * @param dc            the devclass of the driver being deleted
 1167  * @param driver        the driver being deleted
 1168  */
 1169 static int
 1170 devclass_driver_deleted(devclass_t busclass, devclass_t dc, driver_t *driver)
 1171 {
 1172         devclass_t parent;
 1173         device_t dev;
 1174         int error, i;
 1175 
 1176         /*
 1177          * Disassociate from any devices.  We iterate through all the
 1178          * devices in the devclass of the driver and detach any which are
 1179          * using the driver and which have a parent in the devclass which
 1180          * we are deleting from.
 1181          *
 1182          * Note that since a driver can be in multiple devclasses, we
 1183          * should not detach devices which are not children of devices in
 1184          * the affected devclass.
 1185          */
 1186         for (i = 0; i < dc->maxunit; i++) {
 1187                 if (dc->devices[i]) {
 1188                         dev = dc->devices[i];
 1189                         if (dev->driver == driver && dev->parent &&
 1190                             dev->parent->devclass == busclass) {
 1191                                 if ((error = device_detach(dev)) != 0)
 1192                                         return (error);
 1193                                 BUS_PROBE_NOMATCH(dev->parent, dev);
 1194                                 devnomatch(dev);
 1195                                 dev->flags |= DF_DONENOMATCH;
 1196                         }
 1197                 }
 1198         }
 1199 
 1200         /*
 1201          * Walk through the children classes.  Since we only keep a
 1202          * single parent pointer around, we walk the entire list of
 1203          * devclasses looking for children.  We set the
 1204          * DC_HAS_CHILDREN flag when a child devclass is created on
 1205          * the parent, so we only walk the list for those devclasses
 1206          * that have children.
 1207          */
 1208         if (!(busclass->flags & DC_HAS_CHILDREN))
 1209                 return (0);
 1210         parent = busclass;
 1211         TAILQ_FOREACH(busclass, &devclasses, link) {
 1212                 if (busclass->parent == parent) {
 1213                         error = devclass_driver_deleted(busclass, dc, driver);
 1214                         if (error)
 1215                                 return (error);
 1216                 }
 1217         }
 1218         return (0);
 1219 }
 1220 
 1221 /**
 1222  * @brief Delete a device driver from a device class
 1223  *
 1224  * Delete a device driver from a devclass. This is normally called
 1225  * automatically by DRIVER_MODULE().
 1226  *
 1227  * If the driver is currently attached to any devices,
 1228  * devclass_delete_driver() will first attempt to detach from each
 1229  * device. If one of the detach calls fails, the driver will not be
 1230  * deleted.
 1231  *
 1232  * @param dc            the devclass to edit
 1233  * @param driver        the driver to unregister
 1234  */
 1235 int
 1236 devclass_delete_driver(devclass_t busclass, driver_t *driver)
 1237 {
 1238         devclass_t dc = devclass_find(driver->name);
 1239         driverlink_t dl;
 1240         int error;
 1241 
 1242         PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass)));
 1243 
 1244         if (!dc)
 1245                 return (0);
 1246 
 1247         /*
 1248          * Find the link structure in the bus' list of drivers.
 1249          */
 1250         TAILQ_FOREACH(dl, &busclass->drivers, link) {
 1251                 if (dl->driver == driver)
 1252                         break;
 1253         }
 1254 
 1255         if (!dl) {
 1256                 PDEBUG(("%s not found in %s list", driver->name,
 1257                     busclass->name));
 1258                 return (ENOENT);
 1259         }
 1260 
 1261         error = devclass_driver_deleted(busclass, dc, driver);
 1262         if (error != 0)
 1263                 return (error);
 1264 
 1265         TAILQ_REMOVE(&busclass->drivers, dl, link);
 1266         free(dl, M_BUS);
 1267 
 1268         /* XXX: kobj_mtx */
 1269         driver->refs--;
 1270         if (driver->refs == 0)
 1271                 kobj_class_free((kobj_class_t) driver);
 1272 
 1273         bus_data_generation_update();
 1274         return (0);
 1275 }
 1276 
 1277 /**
 1278  * @brief Quiesces a set of device drivers from a device class
 1279  *
 1280  * Quiesce a device driver from a devclass. This is normally called
 1281  * automatically by DRIVER_MODULE().
 1282  *
 1283  * If the driver is currently attached to any devices,
 1284  * devclass_quiesece_driver() will first attempt to quiesce each
 1285  * device.
 1286  *
 1287  * @param dc            the devclass to edit
 1288  * @param driver        the driver to unregister
 1289  */
 1290 static int
 1291 devclass_quiesce_driver(devclass_t busclass, driver_t *driver)
 1292 {
 1293         devclass_t dc = devclass_find(driver->name);
 1294         driverlink_t dl;
 1295         device_t dev;
 1296         int i;
 1297         int error;
 1298 
 1299         PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass)));
 1300 
 1301         if (!dc)
 1302                 return (0);
 1303 
 1304         /*
 1305          * Find the link structure in the bus' list of drivers.
 1306          */
 1307         TAILQ_FOREACH(dl, &busclass->drivers, link) {
 1308                 if (dl->driver == driver)
 1309                         break;
 1310         }
 1311 
 1312         if (!dl) {
 1313                 PDEBUG(("%s not found in %s list", driver->name,
 1314                     busclass->name));
 1315                 return (ENOENT);
 1316         }
 1317 
 1318         /*
 1319          * Quiesce all devices.  We iterate through all the devices in
 1320          * the devclass of the driver and quiesce any which are using
 1321          * the driver and which have a parent in the devclass which we
 1322          * are quiescing.
 1323          *
 1324          * Note that since a driver can be in multiple devclasses, we
 1325          * should not quiesce devices which are not children of
 1326          * devices in the affected devclass.
 1327          */
 1328         for (i = 0; i < dc->maxunit; i++) {
 1329                 if (dc->devices[i]) {
 1330                         dev = dc->devices[i];
 1331                         if (dev->driver == driver && dev->parent &&
 1332                             dev->parent->devclass == busclass) {
 1333                                 if ((error = device_quiesce(dev)) != 0)
 1334                                         return (error);
 1335                         }
 1336                 }
 1337         }
 1338 
 1339         return (0);
 1340 }
 1341 
 1342 /**
 1343  * @internal
 1344  */
 1345 static driverlink_t
 1346 devclass_find_driver_internal(devclass_t dc, const char *classname)
 1347 {
 1348         driverlink_t dl;
 1349 
 1350         PDEBUG(("%s in devclass %s", classname, DEVCLANAME(dc)));
 1351 
 1352         TAILQ_FOREACH(dl, &dc->drivers, link) {
 1353                 if (!strcmp(dl->driver->name, classname))
 1354                         return (dl);
 1355         }
 1356 
 1357         PDEBUG(("not found"));
 1358         return (NULL);
 1359 }
 1360 
 1361 /**
 1362  * @brief Return the name of the devclass
 1363  */
 1364 const char *
 1365 devclass_get_name(devclass_t dc)
 1366 {
 1367         return (dc->name);
 1368 }
 1369 
 1370 /**
 1371  * @brief Find a device given a unit number
 1372  *
 1373  * @param dc            the devclass to search
 1374  * @param unit          the unit number to search for
 1375  * 
 1376  * @returns             the device with the given unit number or @c
 1377  *                      NULL if there is no such device
 1378  */
 1379 device_t
 1380 devclass_get_device(devclass_t dc, int unit)
 1381 {
 1382         if (dc == NULL || unit < 0 || unit >= dc->maxunit)
 1383                 return (NULL);
 1384         return (dc->devices[unit]);
 1385 }
 1386 
 1387 /**
 1388  * @brief Find the softc field of a device given a unit number
 1389  *
 1390  * @param dc            the devclass to search
 1391  * @param unit          the unit number to search for
 1392  * 
 1393  * @returns             the softc field of the device with the given
 1394  *                      unit number or @c NULL if there is no such
 1395  *                      device
 1396  */
 1397 void *
 1398 devclass_get_softc(devclass_t dc, int unit)
 1399 {
 1400         device_t dev;
 1401 
 1402         dev = devclass_get_device(dc, unit);
 1403         if (!dev)
 1404                 return (NULL);
 1405 
 1406         return (device_get_softc(dev));
 1407 }
 1408 
 1409 /**
 1410  * @brief Get a list of devices in the devclass
 1411  *
 1412  * An array containing a list of all the devices in the given devclass
 1413  * is allocated and returned in @p *devlistp. The number of devices
 1414  * in the array is returned in @p *devcountp. The caller should free
 1415  * the array using @c free(p, M_TEMP), even if @p *devcountp is 0.
 1416  *
 1417  * @param dc            the devclass to examine
 1418  * @param devlistp      points at location for array pointer return
 1419  *                      value
 1420  * @param devcountp     points at location for array size return value
 1421  *
 1422  * @retval 0            success
 1423  * @retval ENOMEM       the array allocation failed
 1424  */
 1425 int
 1426 devclass_get_devices(devclass_t dc, device_t **devlistp, int *devcountp)
 1427 {
 1428         int count, i;
 1429         device_t *list;
 1430 
 1431         count = devclass_get_count(dc);
 1432         list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
 1433         if (!list)
 1434                 return (ENOMEM);
 1435 
 1436         count = 0;
 1437         for (i = 0; i < dc->maxunit; i++) {
 1438                 if (dc->devices[i]) {
 1439                         list[count] = dc->devices[i];
 1440                         count++;
 1441                 }
 1442         }
 1443 
 1444         *devlistp = list;
 1445         *devcountp = count;
 1446 
 1447         return (0);
 1448 }
 1449 
 1450 /**
 1451  * @brief Get a list of drivers in the devclass
 1452  *
 1453  * An array containing a list of pointers to all the drivers in the
 1454  * given devclass is allocated and returned in @p *listp.  The number
 1455  * of drivers in the array is returned in @p *countp. The caller should
 1456  * free the array using @c free(p, M_TEMP).
 1457  *
 1458  * @param dc            the devclass to examine
 1459  * @param listp         gives location for array pointer return value
 1460  * @param countp        gives location for number of array elements
 1461  *                      return value
 1462  *
 1463  * @retval 0            success
 1464  * @retval ENOMEM       the array allocation failed
 1465  */
 1466 int
 1467 devclass_get_drivers(devclass_t dc, driver_t ***listp, int *countp)
 1468 {
 1469         driverlink_t dl;
 1470         driver_t **list;
 1471         int count;
 1472 
 1473         count = 0;
 1474         TAILQ_FOREACH(dl, &dc->drivers, link)
 1475                 count++;
 1476         list = malloc(count * sizeof(driver_t *), M_TEMP, M_NOWAIT);
 1477         if (list == NULL)
 1478                 return (ENOMEM);
 1479 
 1480         count = 0;
 1481         TAILQ_FOREACH(dl, &dc->drivers, link) {
 1482                 list[count] = dl->driver;
 1483                 count++;
 1484         }
 1485         *listp = list;
 1486         *countp = count;
 1487 
 1488         return (0);
 1489 }
 1490 
 1491 /**
 1492  * @brief Get the number of devices in a devclass
 1493  *
 1494  * @param dc            the devclass to examine
 1495  */
 1496 int
 1497 devclass_get_count(devclass_t dc)
 1498 {
 1499         int count, i;
 1500 
 1501         count = 0;
 1502         for (i = 0; i < dc->maxunit; i++)
 1503                 if (dc->devices[i])
 1504                         count++;
 1505         return (count);
 1506 }
 1507 
 1508 /**
 1509  * @brief Get the maximum unit number used in a devclass
 1510  *
 1511  * Note that this is one greater than the highest currently-allocated
 1512  * unit.  If a null devclass_t is passed in, -1 is returned to indicate
 1513  * that not even the devclass has been allocated yet.
 1514  *
 1515  * @param dc            the devclass to examine
 1516  */
 1517 int
 1518 devclass_get_maxunit(devclass_t dc)
 1519 {
 1520         if (dc == NULL)
 1521                 return (-1);
 1522         return (dc->maxunit);
 1523 }
 1524 
 1525 /**
 1526  * @brief Find a free unit number in a devclass
 1527  *
 1528  * This function searches for the first unused unit number greater
 1529  * that or equal to @p unit.
 1530  *
 1531  * @param dc            the devclass to examine
 1532  * @param unit          the first unit number to check
 1533  */
 1534 int
 1535 devclass_find_free_unit(devclass_t dc, int unit)
 1536 {
 1537         if (dc == NULL)
 1538                 return (unit);
 1539         while (unit < dc->maxunit && dc->devices[unit] != NULL)
 1540                 unit++;
 1541         return (unit);
 1542 }
 1543 
 1544 /**
 1545  * @brief Set the parent of a devclass
 1546  *
 1547  * The parent class is normally initialised automatically by
 1548  * DRIVER_MODULE().
 1549  *
 1550  * @param dc            the devclass to edit
 1551  * @param pdc           the new parent devclass
 1552  */
 1553 void
 1554 devclass_set_parent(devclass_t dc, devclass_t pdc)
 1555 {
 1556         dc->parent = pdc;
 1557 }
 1558 
 1559 /**
 1560  * @brief Get the parent of a devclass
 1561  *
 1562  * @param dc            the devclass to examine
 1563  */
 1564 devclass_t
 1565 devclass_get_parent(devclass_t dc)
 1566 {
 1567         return (dc->parent);
 1568 }
 1569 
 1570 struct sysctl_ctx_list *
 1571 devclass_get_sysctl_ctx(devclass_t dc)
 1572 {
 1573         return (&dc->sysctl_ctx);
 1574 }
 1575 
 1576 struct sysctl_oid *
 1577 devclass_get_sysctl_tree(devclass_t dc)
 1578 {
 1579         return (dc->sysctl_tree);
 1580 }
 1581 
 1582 /**
 1583  * @internal
 1584  * @brief Allocate a unit number
 1585  *
 1586  * On entry, @p *unitp is the desired unit number (or @c -1 if any
 1587  * will do). The allocated unit number is returned in @p *unitp.
 1588 
 1589  * @param dc            the devclass to allocate from
 1590  * @param unitp         points at the location for the allocated unit
 1591  *                      number
 1592  *
 1593  * @retval 0            success
 1594  * @retval EEXIST       the requested unit number is already allocated
 1595  * @retval ENOMEM       memory allocation failure
 1596  */
 1597 static int
 1598 devclass_alloc_unit(devclass_t dc, device_t dev, int *unitp)
 1599 {
 1600         const char *s;
 1601         int unit = *unitp;
 1602 
 1603         PDEBUG(("unit %d in devclass %s", unit, DEVCLANAME(dc)));
 1604 
 1605         /* Ask the parent bus if it wants to wire this device. */
 1606         if (unit == -1)
 1607                 BUS_HINT_DEVICE_UNIT(device_get_parent(dev), dev, dc->name,
 1608                     &unit);
 1609 
 1610         /* If we were given a wired unit number, check for existing device */
 1611         /* XXX imp XXX */
 1612         if (unit != -1) {
 1613                 if (unit >= 0 && unit < dc->maxunit &&
 1614                     dc->devices[unit] != NULL) {
 1615                         if (bootverbose)
 1616                                 printf("%s: %s%d already exists; skipping it\n",
 1617                                     dc->name, dc->name, *unitp);
 1618                         return (EEXIST);
 1619                 }
 1620         } else {
 1621                 /* Unwired device, find the next available slot for it */
 1622                 unit = 0;
 1623                 for (unit = 0;; unit++) {
 1624                         /* If there is an "at" hint for a unit then skip it. */
 1625                         if (resource_string_value(dc->name, unit, "at", &s) ==
 1626                             0)
 1627                                 continue;
 1628 
 1629                         /* If this device slot is already in use, skip it. */
 1630                         if (unit < dc->maxunit && dc->devices[unit] != NULL)
 1631                                 continue;
 1632 
 1633                         break;
 1634                 }
 1635         }
 1636 
 1637         /*
 1638          * We've selected a unit beyond the length of the table, so let's
 1639          * extend the table to make room for all units up to and including
 1640          * this one.
 1641          */
 1642         if (unit >= dc->maxunit) {
 1643                 device_t *newlist, *oldlist;
 1644                 int newsize;
 1645 
 1646                 oldlist = dc->devices;
 1647                 newsize = roundup((unit + 1), MINALLOCSIZE / sizeof(device_t));
 1648                 newlist = malloc(sizeof(device_t) * newsize, M_BUS, M_NOWAIT);
 1649                 if (!newlist)
 1650                         return (ENOMEM);
 1651                 if (oldlist != NULL)
 1652                         bcopy(oldlist, newlist, sizeof(device_t) * dc->maxunit);
 1653                 bzero(newlist + dc->maxunit,
 1654                     sizeof(device_t) * (newsize - dc->maxunit));
 1655                 dc->devices = newlist;
 1656                 dc->maxunit = newsize;
 1657                 if (oldlist != NULL)
 1658                         free(oldlist, M_BUS);
 1659         }
 1660         PDEBUG(("now: unit %d in devclass %s", unit, DEVCLANAME(dc)));
 1661 
 1662         *unitp = unit;
 1663         return (0);
 1664 }
 1665 
 1666 /**
 1667  * @internal
 1668  * @brief Add a device to a devclass
 1669  *
 1670  * A unit number is allocated for the device (using the device's
 1671  * preferred unit number if any) and the device is registered in the
 1672  * devclass. This allows the device to be looked up by its unit
 1673  * number, e.g. by decoding a dev_t minor number.
 1674  *
 1675  * @param dc            the devclass to add to
 1676  * @param dev           the device to add
 1677  *
 1678  * @retval 0            success
 1679  * @retval EEXIST       the requested unit number is already allocated
 1680  * @retval ENOMEM       memory allocation failure
 1681  */
 1682 static int
 1683 devclass_add_device(devclass_t dc, device_t dev)
 1684 {
 1685         int buflen, error;
 1686 
 1687         PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
 1688 
 1689         buflen = snprintf(NULL, 0, "%s%d$", dc->name, INT_MAX);
 1690         if (buflen < 0)
 1691                 return (ENOMEM);
 1692         dev->nameunit = malloc(buflen, M_BUS, M_NOWAIT|M_ZERO);
 1693         if (!dev->nameunit)
 1694                 return (ENOMEM);
 1695 
 1696         if ((error = devclass_alloc_unit(dc, dev, &dev->unit)) != 0) {
 1697                 free(dev->nameunit, M_BUS);
 1698                 dev->nameunit = NULL;
 1699                 return (error);
 1700         }
 1701         dc->devices[dev->unit] = dev;
 1702         dev->devclass = dc;
 1703         snprintf(dev->nameunit, buflen, "%s%d", dc->name, dev->unit);
 1704 
 1705         return (0);
 1706 }
 1707 
 1708 /**
 1709  * @internal
 1710  * @brief Delete a device from a devclass
 1711  *
 1712  * The device is removed from the devclass's device list and its unit
 1713  * number is freed.
 1714 
 1715  * @param dc            the devclass to delete from
 1716  * @param dev           the device to delete
 1717  *
 1718  * @retval 0            success
 1719  */
 1720 static int
 1721 devclass_delete_device(devclass_t dc, device_t dev)
 1722 {
 1723         if (!dc || !dev)
 1724                 return (0);
 1725 
 1726         PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
 1727 
 1728         if (dev->devclass != dc || dc->devices[dev->unit] != dev)
 1729                 panic("devclass_delete_device: inconsistent device class");
 1730         dc->devices[dev->unit] = NULL;
 1731         if (dev->flags & DF_WILDCARD)
 1732                 dev->unit = -1;
 1733         dev->devclass = NULL;
 1734         free(dev->nameunit, M_BUS);
 1735         dev->nameunit = NULL;
 1736 
 1737         return (0);
 1738 }
 1739 
 1740 /**
 1741  * @internal
 1742  * @brief Make a new device and add it as a child of @p parent
 1743  *
 1744  * @param parent        the parent of the new device
 1745  * @param name          the devclass name of the new device or @c NULL
 1746  *                      to leave the devclass unspecified
 1747  * @parem unit          the unit number of the new device of @c -1 to
 1748  *                      leave the unit number unspecified
 1749  *
 1750  * @returns the new device
 1751  */
 1752 static device_t
 1753 make_device(device_t parent, const char *name, int unit)
 1754 {
 1755         device_t dev;
 1756         devclass_t dc;
 1757 
 1758         PDEBUG(("%s at %s as unit %d", name, DEVICENAME(parent), unit));
 1759 
 1760         if (name) {
 1761                 dc = devclass_find_internal(name, NULL, TRUE);
 1762                 if (!dc) {
 1763                         printf("make_device: can't find device class %s\n",
 1764                             name);
 1765                         return (NULL);
 1766                 }
 1767         } else {
 1768                 dc = NULL;
 1769         }
 1770 
 1771         dev = malloc(sizeof(struct device), M_BUS, M_NOWAIT|M_ZERO);
 1772         if (!dev)
 1773                 return (NULL);
 1774 
 1775         dev->parent = parent;
 1776         TAILQ_INIT(&dev->children);
 1777         kobj_init((kobj_t) dev, &null_class);
 1778         dev->driver = NULL;
 1779         dev->devclass = NULL;
 1780         dev->unit = unit;
 1781         dev->nameunit = NULL;
 1782         dev->desc = NULL;
 1783         dev->busy = 0;
 1784         dev->devflags = 0;
 1785         dev->flags = DF_ENABLED;
 1786         dev->order = 0;
 1787         if (unit == -1)
 1788                 dev->flags |= DF_WILDCARD;
 1789         if (name) {
 1790                 dev->flags |= DF_FIXEDCLASS;
 1791                 if (devclass_add_device(dc, dev)) {
 1792                         kobj_delete((kobj_t) dev, M_BUS);
 1793                         return (NULL);
 1794                 }
 1795         }
 1796         dev->ivars = NULL;
 1797         dev->softc = NULL;
 1798 
 1799         dev->state = DS_NOTPRESENT;
 1800 
 1801         TAILQ_INSERT_TAIL(&bus_data_devices, dev, devlink);
 1802         bus_data_generation_update();
 1803 
 1804         return (dev);
 1805 }
 1806 
 1807 /**
 1808  * @internal
 1809  * @brief Print a description of a device.
 1810  */
 1811 static int
 1812 device_print_child(device_t dev, device_t child)
 1813 {
 1814         int retval = 0;
 1815 
 1816         if (device_is_alive(child))
 1817                 retval += BUS_PRINT_CHILD(dev, child);
 1818         else
 1819                 retval += device_printf(child, " not found\n");
 1820 
 1821         return (retval);
 1822 }
 1823 
 1824 /**
 1825  * @brief Create a new device
 1826  *
 1827  * This creates a new device and adds it as a child of an existing
 1828  * parent device. The new device will be added after the last existing
 1829  * child with order zero.
 1830  * 
 1831  * @param dev           the device which will be the parent of the
 1832  *                      new child device
 1833  * @param name          devclass name for new device or @c NULL if not
 1834  *                      specified
 1835  * @param unit          unit number for new device or @c -1 if not
 1836  *                      specified
 1837  * 
 1838  * @returns             the new device
 1839  */
 1840 device_t
 1841 device_add_child(device_t dev, const char *name, int unit)
 1842 {
 1843         return (device_add_child_ordered(dev, 0, name, unit));
 1844 }
 1845 
 1846 /**
 1847  * @brief Create a new device
 1848  *
 1849  * This creates a new device and adds it as a child of an existing
 1850  * parent device. The new device will be added after the last existing
 1851  * child with the same order.
 1852  * 
 1853  * @param dev           the device which will be the parent of the
 1854  *                      new child device
 1855  * @param order         a value which is used to partially sort the
 1856  *                      children of @p dev - devices created using
 1857  *                      lower values of @p order appear first in @p
 1858  *                      dev's list of children
 1859  * @param name          devclass name for new device or @c NULL if not
 1860  *                      specified
 1861  * @param unit          unit number for new device or @c -1 if not
 1862  *                      specified
 1863  * 
 1864  * @returns             the new device
 1865  */
 1866 device_t
 1867 device_add_child_ordered(device_t dev, u_int order, const char *name, int unit)
 1868 {
 1869         device_t child;
 1870         device_t place;
 1871 
 1872         PDEBUG(("%s at %s with order %u as unit %d",
 1873             name, DEVICENAME(dev), order, unit));
 1874         KASSERT(name != NULL || unit == -1,
 1875             ("child device with wildcard name and specific unit number"));
 1876 
 1877         child = make_device(dev, name, unit);
 1878         if (child == NULL)
 1879                 return (child);
 1880         child->order = order;
 1881 
 1882         TAILQ_FOREACH(place, &dev->children, link) {
 1883                 if (place->order > order)
 1884                         break;
 1885         }
 1886 
 1887         if (place) {
 1888                 /*
 1889                  * The device 'place' is the first device whose order is
 1890                  * greater than the new child.
 1891                  */
 1892                 TAILQ_INSERT_BEFORE(place, child, link);
 1893         } else {
 1894                 /*
 1895                  * The new child's order is greater or equal to the order of
 1896                  * any existing device. Add the child to the tail of the list.
 1897                  */
 1898                 TAILQ_INSERT_TAIL(&dev->children, child, link);
 1899         }
 1900 
 1901         bus_data_generation_update();
 1902         return (child);
 1903 }
 1904 
 1905 /**
 1906  * @brief Delete a device
 1907  *
 1908  * This function deletes a device along with all of its children. If
 1909  * the device currently has a driver attached to it, the device is
 1910  * detached first using device_detach().
 1911  * 
 1912  * @param dev           the parent device
 1913  * @param child         the device to delete
 1914  *
 1915  * @retval 0            success
 1916  * @retval non-zero     a unit error code describing the error
 1917  */
 1918 int
 1919 device_delete_child(device_t dev, device_t child)
 1920 {
 1921         int error;
 1922         device_t grandchild;
 1923 
 1924         PDEBUG(("%s from %s", DEVICENAME(child), DEVICENAME(dev)));
 1925 
 1926         /* detach parent before deleting children, if any */
 1927         if ((error = device_detach(child)) != 0)
 1928                 return (error);
 1929         
 1930         /* remove children second */
 1931         while ((grandchild = TAILQ_FIRST(&child->children)) != NULL) {
 1932                 error = device_delete_child(child, grandchild);
 1933                 if (error)
 1934                         return (error);
 1935         }
 1936 
 1937         if (child->devclass)
 1938                 devclass_delete_device(child->devclass, child);
 1939         if (child->parent)
 1940                 BUS_CHILD_DELETED(dev, child);
 1941         TAILQ_REMOVE(&dev->children, child, link);
 1942         TAILQ_REMOVE(&bus_data_devices, child, devlink);
 1943         kobj_delete((kobj_t) child, M_BUS);
 1944 
 1945         bus_data_generation_update();
 1946         return (0);
 1947 }
 1948 
 1949 /**
 1950  * @brief Delete all children devices of the given device, if any.
 1951  *
 1952  * This function deletes all children devices of the given device, if
 1953  * any, using the device_delete_child() function for each device it
 1954  * finds. If a child device cannot be deleted, this function will
 1955  * return an error code.
 1956  * 
 1957  * @param dev           the parent device
 1958  *
 1959  * @retval 0            success
 1960  * @retval non-zero     a device would not detach
 1961  */
 1962 int
 1963 device_delete_children(device_t dev)
 1964 {
 1965         device_t child;
 1966         int error;
 1967 
 1968         PDEBUG(("Deleting all children of %s", DEVICENAME(dev)));
 1969 
 1970         error = 0;
 1971 
 1972         while ((child = TAILQ_FIRST(&dev->children)) != NULL) {
 1973                 error = device_delete_child(dev, child);
 1974                 if (error) {
 1975                         PDEBUG(("Failed deleting %s", DEVICENAME(child)));
 1976                         break;
 1977                 }
 1978         }
 1979         return (error);
 1980 }
 1981 
 1982 /**
 1983  * @brief Find a device given a unit number
 1984  *
 1985  * This is similar to devclass_get_devices() but only searches for
 1986  * devices which have @p dev as a parent.
 1987  *
 1988  * @param dev           the parent device to search
 1989  * @param unit          the unit number to search for.  If the unit is -1,
 1990  *                      return the first child of @p dev which has name
 1991  *                      @p classname (that is, the one with the lowest unit.)
 1992  *
 1993  * @returns             the device with the given unit number or @c
 1994  *                      NULL if there is no such device
 1995  */
 1996 device_t
 1997 device_find_child(device_t dev, const char *classname, int unit)
 1998 {
 1999         devclass_t dc;
 2000         device_t child;
 2001 
 2002         dc = devclass_find(classname);
 2003         if (!dc)
 2004                 return (NULL);
 2005 
 2006         if (unit != -1) {
 2007                 child = devclass_get_device(dc, unit);
 2008                 if (child && child->parent == dev)
 2009                         return (child);
 2010         } else {
 2011                 for (unit = 0; unit < devclass_get_maxunit(dc); unit++) {
 2012                         child = devclass_get_device(dc, unit);
 2013                         if (child && child->parent == dev)
 2014                                 return (child);
 2015                 }
 2016         }
 2017         return (NULL);
 2018 }
 2019 
 2020 /**
 2021  * @internal
 2022  */
 2023 static driverlink_t
 2024 first_matching_driver(devclass_t dc, device_t dev)
 2025 {
 2026         if (dev->devclass)
 2027                 return (devclass_find_driver_internal(dc, dev->devclass->name));
 2028         return (TAILQ_FIRST(&dc->drivers));
 2029 }
 2030 
 2031 /**
 2032  * @internal
 2033  */
 2034 static driverlink_t
 2035 next_matching_driver(devclass_t dc, device_t dev, driverlink_t last)
 2036 {
 2037         if (dev->devclass) {
 2038                 driverlink_t dl;
 2039                 for (dl = TAILQ_NEXT(last, link); dl; dl = TAILQ_NEXT(dl, link))
 2040                         if (!strcmp(dev->devclass->name, dl->driver->name))
 2041                                 return (dl);
 2042                 return (NULL);
 2043         }
 2044         return (TAILQ_NEXT(last, link));
 2045 }
 2046 
 2047 /**
 2048  * @internal
 2049  */
 2050 int
 2051 device_probe_child(device_t dev, device_t child)
 2052 {
 2053         devclass_t dc;
 2054         driverlink_t best = NULL;
 2055         driverlink_t dl;
 2056         int result, pri = 0;
 2057         int hasclass = (child->devclass != NULL);
 2058 
 2059         GIANT_REQUIRED;
 2060 
 2061         dc = dev->devclass;
 2062         if (!dc)
 2063                 panic("device_probe_child: parent device has no devclass");
 2064 
 2065         /*
 2066          * If the state is already probed, then return.  However, don't
 2067          * return if we can rebid this object.
 2068          */
 2069         if (child->state == DS_ALIVE && (child->flags & DF_REBID) == 0)
 2070                 return (0);
 2071 
 2072         for (; dc; dc = dc->parent) {
 2073                 for (dl = first_matching_driver(dc, child);
 2074                      dl;
 2075                      dl = next_matching_driver(dc, child, dl)) {
 2076                         /* If this driver's pass is too high, then ignore it. */
 2077                         if (dl->pass > bus_current_pass)
 2078                                 continue;
 2079 
 2080                         PDEBUG(("Trying %s", DRIVERNAME(dl->driver)));
 2081                         result = device_set_driver(child, dl->driver);
 2082                         if (result == ENOMEM)
 2083                                 return (result);
 2084                         else if (result != 0)
 2085                                 continue;
 2086                         if (!hasclass) {
 2087                                 if (device_set_devclass(child,
 2088                                     dl->driver->name) != 0) {
 2089                                         char const * devname =
 2090                                             device_get_name(child);
 2091                                         if (devname == NULL)
 2092                                                 devname = "(unknown)";
 2093                                         printf("driver bug: Unable to set "
 2094                                             "devclass (class: %s "
 2095                                             "devname: %s)\n",
 2096                                             dl->driver->name,
 2097                                             devname);
 2098                                         (void)device_set_driver(child, NULL);
 2099                                         continue;
 2100                                 }
 2101                         }
 2102 
 2103                         /* Fetch any flags for the device before probing. */
 2104                         resource_int_value(dl->driver->name, child->unit,
 2105                             "flags", &child->devflags);
 2106 
 2107                         result = DEVICE_PROBE(child);
 2108 
 2109                         /* Reset flags and devclass before the next probe. */
 2110                         child->devflags = 0;
 2111                         if (!hasclass)
 2112                                 (void)device_set_devclass(child, NULL);
 2113 
 2114                         /*
 2115                          * If the driver returns SUCCESS, there can be
 2116                          * no higher match for this device.
 2117                          */
 2118                         if (result == 0) {
 2119                                 best = dl;
 2120                                 pri = 0;
 2121                                 break;
 2122                         }
 2123 
 2124                         /*
 2125                          * Probes that return BUS_PROBE_NOWILDCARD or lower
 2126                          * only match on devices whose driver was explicitly
 2127                          * specified.
 2128                          */
 2129                         if (result <= BUS_PROBE_NOWILDCARD &&
 2130                             !(child->flags & DF_FIXEDCLASS)) {
 2131                                 result = ENXIO;
 2132                         }
 2133 
 2134                         /*
 2135                          * The driver returned an error so it
 2136                          * certainly doesn't match.
 2137                          */
 2138                         if (result > 0) {
 2139                                 (void)device_set_driver(child, NULL);
 2140                                 continue;
 2141                         }
 2142 
 2143                         /*
 2144                          * A priority lower than SUCCESS, remember the
 2145                          * best matching driver. Initialise the value
 2146                          * of pri for the first match.
 2147                          */
 2148                         if (best == NULL || result > pri) {
 2149                                 best = dl;
 2150                                 pri = result;
 2151                                 continue;
 2152                         }
 2153                 }
 2154                 /*
 2155                  * If we have an unambiguous match in this devclass,
 2156                  * don't look in the parent.
 2157                  */
 2158                 if (best && pri == 0)
 2159                         break;
 2160         }
 2161 
 2162         /*
 2163          * If we found a driver, change state and initialise the devclass.
 2164          */
 2165         /* XXX What happens if we rebid and got no best? */
 2166         if (best) {
 2167                 /*
 2168                  * If this device was attached, and we were asked to
 2169                  * rescan, and it is a different driver, then we have
 2170                  * to detach the old driver and reattach this new one.
 2171                  * Note, we don't have to check for DF_REBID here
 2172                  * because if the state is > DS_ALIVE, we know it must
 2173                  * be.
 2174                  *
 2175                  * This assumes that all DF_REBID drivers can have
 2176                  * their probe routine called at any time and that
 2177                  * they are idempotent as well as completely benign in
 2178                  * normal operations.
 2179                  *
 2180                  * We also have to make sure that the detach
 2181                  * succeeded, otherwise we fail the operation (or
 2182                  * maybe it should just fail silently?  I'm torn).
 2183                  */
 2184                 if (child->state > DS_ALIVE && best->driver != child->driver)
 2185                         if ((result = device_detach(dev)) != 0)
 2186                                 return (result);
 2187 
 2188                 /* Set the winning driver, devclass, and flags. */
 2189                 if (!child->devclass) {
 2190                         result = device_set_devclass(child, best->driver->name);
 2191                         if (result != 0)
 2192                                 return (result);
 2193                 }
 2194                 result = device_set_driver(child, best->driver);
 2195                 if (result != 0)
 2196                         return (result);
 2197                 resource_int_value(best->driver->name, child->unit,
 2198                     "flags", &child->devflags);
 2199 
 2200                 if (pri < 0) {
 2201                         /*
 2202                          * A bit bogus. Call the probe method again to make
 2203                          * sure that we have the right description.
 2204                          */
 2205                         DEVICE_PROBE(child);
 2206 #if 0
 2207                         child->flags |= DF_REBID;
 2208 #endif
 2209                 } else
 2210                         child->flags &= ~DF_REBID;
 2211                 child->state = DS_ALIVE;
 2212 
 2213                 bus_data_generation_update();
 2214                 return (0);
 2215         }
 2216 
 2217         return (ENXIO);
 2218 }
 2219 
 2220 /**
 2221  * @brief Return the parent of a device
 2222  */
 2223 device_t
 2224 device_get_parent(device_t dev)
 2225 {
 2226         return (dev->parent);
 2227 }
 2228 
 2229 /**
 2230  * @brief Get a list of children of a device
 2231  *
 2232  * An array containing a list of all the children of the given device
 2233  * is allocated and returned in @p *devlistp. The number of devices
 2234  * in the array is returned in @p *devcountp. The caller should free
 2235  * the array using @c free(p, M_TEMP).
 2236  *
 2237  * @param dev           the device to examine
 2238  * @param devlistp      points at location for array pointer return
 2239  *                      value
 2240  * @param devcountp     points at location for array size return value
 2241  *
 2242  * @retval 0            success
 2243  * @retval ENOMEM       the array allocation failed
 2244  */
 2245 int
 2246 device_get_children(device_t dev, device_t **devlistp, int *devcountp)
 2247 {
 2248         int count;
 2249         device_t child;
 2250         device_t *list;
 2251 
 2252         count = 0;
 2253         TAILQ_FOREACH(child, &dev->children, link) {
 2254                 count++;
 2255         }
 2256         if (count == 0) {
 2257                 *devlistp = NULL;
 2258                 *devcountp = 0;
 2259                 return (0);
 2260         }
 2261 
 2262         list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
 2263         if (!list)
 2264                 return (ENOMEM);
 2265 
 2266         count = 0;
 2267         TAILQ_FOREACH(child, &dev->children, link) {
 2268                 list[count] = child;
 2269                 count++;
 2270         }
 2271 
 2272         *devlistp = list;
 2273         *devcountp = count;
 2274 
 2275         return (0);
 2276 }
 2277 
 2278 /**
 2279  * @brief Return the current driver for the device or @c NULL if there
 2280  * is no driver currently attached
 2281  */
 2282 driver_t *
 2283 device_get_driver(device_t dev)
 2284 {
 2285         return (dev->driver);
 2286 }
 2287 
 2288 /**
 2289  * @brief Return the current devclass for the device or @c NULL if
 2290  * there is none.
 2291  */
 2292 devclass_t
 2293 device_get_devclass(device_t dev)
 2294 {
 2295         return (dev->devclass);
 2296 }
 2297 
 2298 /**
 2299  * @brief Return the name of the device's devclass or @c NULL if there
 2300  * is none.
 2301  */
 2302 const char *
 2303 device_get_name(device_t dev)
 2304 {
 2305         if (dev != NULL && dev->devclass)
 2306                 return (devclass_get_name(dev->devclass));
 2307         return (NULL);
 2308 }
 2309 
 2310 /**
 2311  * @brief Return a string containing the device's devclass name
 2312  * followed by an ascii representation of the device's unit number
 2313  * (e.g. @c "foo2").
 2314  */
 2315 const char *
 2316 device_get_nameunit(device_t dev)
 2317 {
 2318         return (dev->nameunit);
 2319 }
 2320 
 2321 /**
 2322  * @brief Return the device's unit number.
 2323  */
 2324 int
 2325 device_get_unit(device_t dev)
 2326 {
 2327         return (dev->unit);
 2328 }
 2329 
 2330 /**
 2331  * @brief Return the device's description string
 2332  */
 2333 const char *
 2334 device_get_desc(device_t dev)
 2335 {
 2336         return (dev->desc);
 2337 }
 2338 
 2339 /**
 2340  * @brief Return the device's flags
 2341  */
 2342 uint32_t
 2343 device_get_flags(device_t dev)
 2344 {
 2345         return (dev->devflags);
 2346 }
 2347 
 2348 struct sysctl_ctx_list *
 2349 device_get_sysctl_ctx(device_t dev)
 2350 {
 2351         return (&dev->sysctl_ctx);
 2352 }
 2353 
 2354 struct sysctl_oid *
 2355 device_get_sysctl_tree(device_t dev)
 2356 {
 2357         return (dev->sysctl_tree);
 2358 }
 2359 
 2360 /**
 2361  * @brief Print the name of the device followed by a colon and a space
 2362  *
 2363  * @returns the number of characters printed
 2364  */
 2365 int
 2366 device_print_prettyname(device_t dev)
 2367 {
 2368         const char *name = device_get_name(dev);
 2369 
 2370         if (name == NULL)
 2371                 return (printf("unknown: "));
 2372         return (printf("%s%d: ", name, device_get_unit(dev)));
 2373 }
 2374 
 2375 /**
 2376  * @brief Print the name of the device followed by a colon, a space
 2377  * and the result of calling vprintf() with the value of @p fmt and
 2378  * the following arguments.
 2379  *
 2380  * @returns the number of characters printed
 2381  */
 2382 int
 2383 device_printf(device_t dev, const char * fmt, ...)
 2384 {
 2385         va_list ap;
 2386         int retval;
 2387 
 2388         retval = device_print_prettyname(dev);
 2389         va_start(ap, fmt);
 2390         retval += vprintf(fmt, ap);
 2391         va_end(ap);
 2392         return (retval);
 2393 }
 2394 
 2395 /**
 2396  * @internal
 2397  */
 2398 static void
 2399 device_set_desc_internal(device_t dev, const char* desc, int copy)
 2400 {
 2401         if (dev->desc && (dev->flags & DF_DESCMALLOCED)) {
 2402                 free(dev->desc, M_BUS);
 2403                 dev->flags &= ~DF_DESCMALLOCED;
 2404                 dev->desc = NULL;
 2405         }
 2406 
 2407         if (copy && desc) {
 2408                 dev->desc = malloc(strlen(desc) + 1, M_BUS, M_NOWAIT);
 2409                 if (dev->desc) {
 2410                         strcpy(dev->desc, desc);
 2411                         dev->flags |= DF_DESCMALLOCED;
 2412                 }
 2413         } else {
 2414                 /* Avoid a -Wcast-qual warning */
 2415                 dev->desc = (char *)(uintptr_t) desc;
 2416         }
 2417 
 2418         bus_data_generation_update();
 2419 }
 2420 
 2421 /**
 2422  * @brief Set the device's description
 2423  *
 2424  * The value of @c desc should be a string constant that will not
 2425  * change (at least until the description is changed in a subsequent
 2426  * call to device_set_desc() or device_set_desc_copy()).
 2427  */
 2428 void
 2429 device_set_desc(device_t dev, const char* desc)
 2430 {
 2431         device_set_desc_internal(dev, desc, FALSE);
 2432 }
 2433 
 2434 /**
 2435  * @brief Set the device's description
 2436  *
 2437  * The string pointed to by @c desc is copied. Use this function if
 2438  * the device description is generated, (e.g. with sprintf()).
 2439  */
 2440 void
 2441 device_set_desc_copy(device_t dev, const char* desc)
 2442 {
 2443         device_set_desc_internal(dev, desc, TRUE);
 2444 }
 2445 
 2446 /**
 2447  * @brief Set the device's flags
 2448  */
 2449 void
 2450 device_set_flags(device_t dev, uint32_t flags)
 2451 {
 2452         dev->devflags = flags;
 2453 }
 2454 
 2455 /**
 2456  * @brief Return the device's softc field
 2457  *
 2458  * The softc is allocated and zeroed when a driver is attached, based
 2459  * on the size field of the driver.
 2460  */
 2461 void *
 2462 device_get_softc(device_t dev)
 2463 {
 2464         return (dev->softc);
 2465 }
 2466 
 2467 /**
 2468  * @brief Set the device's softc field
 2469  *
 2470  * Most drivers do not need to use this since the softc is allocated
 2471  * automatically when the driver is attached.
 2472  */
 2473 void
 2474 device_set_softc(device_t dev, void *softc)
 2475 {
 2476         if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC))
 2477                 free(dev->softc, M_BUS_SC);
 2478         dev->softc = softc;
 2479         if (dev->softc)
 2480                 dev->flags |= DF_EXTERNALSOFTC;
 2481         else
 2482                 dev->flags &= ~DF_EXTERNALSOFTC;
 2483 }
 2484 
 2485 /**
 2486  * @brief Free claimed softc
 2487  *
 2488  * Most drivers do not need to use this since the softc is freed
 2489  * automatically when the driver is detached.
 2490  */
 2491 void
 2492 device_free_softc(void *softc)
 2493 {
 2494         free(softc, M_BUS_SC);
 2495 }
 2496 
 2497 /**
 2498  * @brief Claim softc
 2499  *
 2500  * This function can be used to let the driver free the automatically
 2501  * allocated softc using "device_free_softc()". This function is
 2502  * useful when the driver is refcounting the softc and the softc
 2503  * cannot be freed when the "device_detach" method is called.
 2504  */
 2505 void
 2506 device_claim_softc(device_t dev)
 2507 {
 2508         if (dev->softc)
 2509                 dev->flags |= DF_EXTERNALSOFTC;
 2510         else
 2511                 dev->flags &= ~DF_EXTERNALSOFTC;
 2512 }
 2513 
 2514 /**
 2515  * @brief Get the device's ivars field
 2516  *
 2517  * The ivars field is used by the parent device to store per-device
 2518  * state (e.g. the physical location of the device or a list of
 2519  * resources).
 2520  */
 2521 void *
 2522 device_get_ivars(device_t dev)
 2523 {
 2524 
 2525         KASSERT(dev != NULL, ("device_get_ivars(NULL, ...)"));
 2526         return (dev->ivars);
 2527 }
 2528 
 2529 /**
 2530  * @brief Set the device's ivars field
 2531  */
 2532 void
 2533 device_set_ivars(device_t dev, void * ivars)
 2534 {
 2535 
 2536         KASSERT(dev != NULL, ("device_set_ivars(NULL, ...)"));
 2537         dev->ivars = ivars;
 2538 }
 2539 
 2540 /**
 2541  * @brief Return the device's state
 2542  */
 2543 device_state_t
 2544 device_get_state(device_t dev)
 2545 {
 2546         return (dev->state);
 2547 }
 2548 
 2549 /**
 2550  * @brief Set the DF_ENABLED flag for the device
 2551  */
 2552 void
 2553 device_enable(device_t dev)
 2554 {
 2555         dev->flags |= DF_ENABLED;
 2556 }
 2557 
 2558 /**
 2559  * @brief Clear the DF_ENABLED flag for the device
 2560  */
 2561 void
 2562 device_disable(device_t dev)
 2563 {
 2564         dev->flags &= ~DF_ENABLED;
 2565 }
 2566 
 2567 /**
 2568  * @brief Increment the busy counter for the device
 2569  */
 2570 void
 2571 device_busy(device_t dev)
 2572 {
 2573         if (dev->state < DS_ATTACHING)
 2574                 panic("device_busy: called for unattached device");
 2575         if (dev->busy == 0 && dev->parent)
 2576                 device_busy(dev->parent);
 2577         dev->busy++;
 2578         if (dev->state == DS_ATTACHED)
 2579                 dev->state = DS_BUSY;
 2580 }
 2581 
 2582 /**
 2583  * @brief Decrement the busy counter for the device
 2584  */
 2585 void
 2586 device_unbusy(device_t dev)
 2587 {
 2588         if (dev->busy != 0 && dev->state != DS_BUSY &&
 2589             dev->state != DS_ATTACHING)
 2590                 panic("device_unbusy: called for non-busy device %s",
 2591                     device_get_nameunit(dev));
 2592         dev->busy--;
 2593         if (dev->busy == 0) {
 2594                 if (dev->parent)
 2595                         device_unbusy(dev->parent);
 2596                 if (dev->state == DS_BUSY)
 2597                         dev->state = DS_ATTACHED;
 2598         }
 2599 }
 2600 
 2601 /**
 2602  * @brief Set the DF_QUIET flag for the device
 2603  */
 2604 void
 2605 device_quiet(device_t dev)
 2606 {
 2607         dev->flags |= DF_QUIET;
 2608 }
 2609 
 2610 /**
 2611  * @brief Clear the DF_QUIET flag for the device
 2612  */
 2613 void
 2614 device_verbose(device_t dev)
 2615 {
 2616         dev->flags &= ~DF_QUIET;
 2617 }
 2618 
 2619 /**
 2620  * @brief Return non-zero if the DF_QUIET flag is set on the device
 2621  */
 2622 int
 2623 device_is_quiet(device_t dev)
 2624 {
 2625         return ((dev->flags & DF_QUIET) != 0);
 2626 }
 2627 
 2628 /**
 2629  * @brief Return non-zero if the DF_ENABLED flag is set on the device
 2630  */
 2631 int
 2632 device_is_enabled(device_t dev)
 2633 {
 2634         return ((dev->flags & DF_ENABLED) != 0);
 2635 }
 2636 
 2637 /**
 2638  * @brief Return non-zero if the device was successfully probed
 2639  */
 2640 int
 2641 device_is_alive(device_t dev)
 2642 {
 2643         return (dev->state >= DS_ALIVE);
 2644 }
 2645 
 2646 /**
 2647  * @brief Return non-zero if the device currently has a driver
 2648  * attached to it
 2649  */
 2650 int
 2651 device_is_attached(device_t dev)
 2652 {
 2653         return (dev->state >= DS_ATTACHED);
 2654 }
 2655 
 2656 /**
 2657  * @brief Set the devclass of a device
 2658  * @see devclass_add_device().
 2659  */
 2660 int
 2661 device_set_devclass(device_t dev, const char *classname)
 2662 {
 2663         devclass_t dc;
 2664         int error;
 2665 
 2666         if (!classname) {
 2667                 if (dev->devclass)
 2668                         devclass_delete_device(dev->devclass, dev);
 2669                 return (0);
 2670         }
 2671 
 2672         if (dev->devclass) {
 2673                 printf("device_set_devclass: device class already set\n");
 2674                 return (EINVAL);
 2675         }
 2676 
 2677         dc = devclass_find_internal(classname, NULL, TRUE);
 2678         if (!dc)
 2679                 return (ENOMEM);
 2680 
 2681         error = devclass_add_device(dc, dev);
 2682 
 2683         bus_data_generation_update();
 2684         return (error);
 2685 }
 2686 
 2687 /**
 2688  * @brief Set the driver of a device
 2689  *
 2690  * @retval 0            success
 2691  * @retval EBUSY        the device already has a driver attached
 2692  * @retval ENOMEM       a memory allocation failure occurred
 2693  */
 2694 int
 2695 device_set_driver(device_t dev, driver_t *driver)
 2696 {
 2697         if (dev->state >= DS_ATTACHED)
 2698                 return (EBUSY);
 2699 
 2700         if (dev->driver == driver)
 2701                 return (0);
 2702 
 2703         if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) {
 2704                 free(dev->softc, M_BUS_SC);
 2705                 dev->softc = NULL;
 2706         }
 2707         device_set_desc(dev, NULL);
 2708         kobj_delete((kobj_t) dev, NULL);
 2709         dev->driver = driver;
 2710         if (driver) {
 2711                 kobj_init((kobj_t) dev, (kobj_class_t) driver);
 2712                 if (!(dev->flags & DF_EXTERNALSOFTC) && driver->size > 0) {
 2713                         dev->softc = malloc(driver->size, M_BUS_SC,
 2714                             M_NOWAIT | M_ZERO);
 2715                         if (!dev->softc) {
 2716                                 kobj_delete((kobj_t) dev, NULL);
 2717                                 kobj_init((kobj_t) dev, &null_class);
 2718                                 dev->driver = NULL;
 2719                                 return (ENOMEM);
 2720                         }
 2721                 }
 2722         } else {
 2723                 kobj_init((kobj_t) dev, &null_class);
 2724         }
 2725 
 2726         bus_data_generation_update();
 2727         return (0);
 2728 }
 2729 
 2730 /**
 2731  * @brief Probe a device, and return this status.
 2732  *
 2733  * This function is the core of the device autoconfiguration
 2734  * system. Its purpose is to select a suitable driver for a device and
 2735  * then call that driver to initialise the hardware appropriately. The
 2736  * driver is selected by calling the DEVICE_PROBE() method of a set of
 2737  * candidate drivers and then choosing the driver which returned the
 2738  * best value. This driver is then attached to the device using
 2739  * device_attach().
 2740  *
 2741  * The set of suitable drivers is taken from the list of drivers in
 2742  * the parent device's devclass. If the device was originally created
 2743  * with a specific class name (see device_add_child()), only drivers
 2744  * with that name are probed, otherwise all drivers in the devclass
 2745  * are probed. If no drivers return successful probe values in the
 2746  * parent devclass, the search continues in the parent of that
 2747  * devclass (see devclass_get_parent()) if any.
 2748  *
 2749  * @param dev           the device to initialise
 2750  *
 2751  * @retval 0            success
 2752  * @retval ENXIO        no driver was found
 2753  * @retval ENOMEM       memory allocation failure
 2754  * @retval non-zero     some other unix error code
 2755  * @retval -1           Device already attached
 2756  */
 2757 int
 2758 device_probe(device_t dev)
 2759 {
 2760         int error;
 2761 
 2762         GIANT_REQUIRED;
 2763 
 2764         if (dev->state >= DS_ALIVE && (dev->flags & DF_REBID) == 0)
 2765                 return (-1);
 2766 
 2767         if (!(dev->flags & DF_ENABLED)) {
 2768                 if (bootverbose && device_get_name(dev) != NULL) {
 2769                         device_print_prettyname(dev);
 2770                         printf("not probed (disabled)\n");
 2771                 }
 2772                 return (-1);
 2773         }
 2774         if ((error = device_probe_child(dev->parent, dev)) != 0) {              
 2775                 if (bus_current_pass == BUS_PASS_DEFAULT &&
 2776                     !(dev->flags & DF_DONENOMATCH)) {
 2777                         BUS_PROBE_NOMATCH(dev->parent, dev);
 2778                         devnomatch(dev);
 2779                         dev->flags |= DF_DONENOMATCH;
 2780                 }
 2781                 return (error);
 2782         }
 2783         return (0);
 2784 }
 2785 
 2786 /**
 2787  * @brief Probe a device and attach a driver if possible
 2788  *
 2789  * calls device_probe() and attaches if that was successful.
 2790  */
 2791 int
 2792 device_probe_and_attach(device_t dev)
 2793 {
 2794         int error;
 2795 
 2796         GIANT_REQUIRED;
 2797 
 2798         error = device_probe(dev);
 2799         if (error == -1)
 2800                 return (0);
 2801         else if (error != 0)
 2802                 return (error);
 2803 
 2804         CURVNET_SET_QUIET(vnet0);
 2805         error = device_attach(dev);
 2806         CURVNET_RESTORE();
 2807         return error;
 2808 }
 2809 
 2810 /**
 2811  * @brief Attach a device driver to a device
 2812  *
 2813  * This function is a wrapper around the DEVICE_ATTACH() driver
 2814  * method. In addition to calling DEVICE_ATTACH(), it initialises the
 2815  * device's sysctl tree, optionally prints a description of the device
 2816  * and queues a notification event for user-based device management
 2817  * services.
 2818  *
 2819  * Normally this function is only called internally from
 2820  * device_probe_and_attach().
 2821  *
 2822  * @param dev           the device to initialise
 2823  *
 2824  * @retval 0            success
 2825  * @retval ENXIO        no driver was found
 2826  * @retval ENOMEM       memory allocation failure
 2827  * @retval non-zero     some other unix error code
 2828  */
 2829 int
 2830 device_attach(device_t dev)
 2831 {
 2832         uint64_t attachtime;
 2833         int error;
 2834 
 2835         if (resource_disabled(dev->driver->name, dev->unit)) {
 2836                 device_disable(dev);
 2837                 if (bootverbose)
 2838                          device_printf(dev, "disabled via hints entry\n");
 2839                 return (ENXIO);
 2840         }
 2841 
 2842         device_sysctl_init(dev);
 2843         if (!device_is_quiet(dev))
 2844                 device_print_child(dev->parent, dev);
 2845         attachtime = get_cyclecount();
 2846         dev->state = DS_ATTACHING;
 2847         if ((error = DEVICE_ATTACH(dev)) != 0) {
 2848                 printf("device_attach: %s%d attach returned %d\n",
 2849                     dev->driver->name, dev->unit, error);
 2850                 if (!(dev->flags & DF_FIXEDCLASS))
 2851                         devclass_delete_device(dev->devclass, dev);
 2852                 (void)device_set_driver(dev, NULL);
 2853                 device_sysctl_fini(dev);
 2854                 KASSERT(dev->busy == 0, ("attach failed but busy"));
 2855                 dev->state = DS_NOTPRESENT;
 2856                 return (error);
 2857         }
 2858         attachtime = get_cyclecount() - attachtime;
 2859         /*
 2860          * 4 bits per device is a reasonable value for desktop and server
 2861          * hardware with good get_cyclecount() implementations, but may
 2862          * need to be adjusted on other platforms.
 2863          */
 2864 #ifdef RANDOM_DEBUG
 2865         printf("%s(): feeding %d bit(s) of entropy from %s%d\n",
 2866             __func__, 4, dev->driver->name, dev->unit);
 2867 #endif
 2868         random_harvest(&attachtime, sizeof(attachtime), 4, RANDOM_ATTACH);
 2869         device_sysctl_update(dev);
 2870         if (dev->busy)
 2871                 dev->state = DS_BUSY;
 2872         else
 2873                 dev->state = DS_ATTACHED;
 2874         dev->flags &= ~DF_DONENOMATCH;
 2875         devadded(dev);
 2876         return (0);
 2877 }
 2878 
 2879 /**
 2880  * @brief Detach a driver from a device
 2881  *
 2882  * This function is a wrapper around the DEVICE_DETACH() driver
 2883  * method. If the call to DEVICE_DETACH() succeeds, it calls
 2884  * BUS_CHILD_DETACHED() for the parent of @p dev, queues a
 2885  * notification event for user-based device management services and
 2886  * cleans up the device's sysctl tree.
 2887  *
 2888  * @param dev           the device to un-initialise
 2889  *
 2890  * @retval 0            success
 2891  * @retval ENXIO        no driver was found
 2892  * @retval ENOMEM       memory allocation failure
 2893  * @retval non-zero     some other unix error code
 2894  */
 2895 int
 2896 device_detach(device_t dev)
 2897 {
 2898         int error;
 2899 
 2900         GIANT_REQUIRED;
 2901 
 2902         PDEBUG(("%s", DEVICENAME(dev)));
 2903         if (dev->state == DS_BUSY)
 2904                 return (EBUSY);
 2905         if (dev->state != DS_ATTACHED)
 2906                 return (0);
 2907 
 2908         if ((error = DEVICE_DETACH(dev)) != 0)
 2909                 return (error);
 2910         devremoved(dev);
 2911         if (!device_is_quiet(dev))
 2912                 device_printf(dev, "detached\n");
 2913         if (dev->parent)
 2914                 BUS_CHILD_DETACHED(dev->parent, dev);
 2915 
 2916         if (!(dev->flags & DF_FIXEDCLASS))
 2917                 devclass_delete_device(dev->devclass, dev);
 2918 
 2919         dev->state = DS_NOTPRESENT;
 2920         (void)device_set_driver(dev, NULL);
 2921         device_sysctl_fini(dev);
 2922 
 2923         return (0);
 2924 }
 2925 
 2926 /**
 2927  * @brief Tells a driver to quiesce itself.
 2928  *
 2929  * This function is a wrapper around the DEVICE_QUIESCE() driver
 2930  * method. If the call to DEVICE_QUIESCE() succeeds.
 2931  *
 2932  * @param dev           the device to quiesce
 2933  *
 2934  * @retval 0            success
 2935  * @retval ENXIO        no driver was found
 2936  * @retval ENOMEM       memory allocation failure
 2937  * @retval non-zero     some other unix error code
 2938  */
 2939 int
 2940 device_quiesce(device_t dev)
 2941 {
 2942 
 2943         PDEBUG(("%s", DEVICENAME(dev)));
 2944         if (dev->state == DS_BUSY)
 2945                 return (EBUSY);
 2946         if (dev->state != DS_ATTACHED)
 2947                 return (0);
 2948 
 2949         return (DEVICE_QUIESCE(dev));
 2950 }
 2951 
 2952 /**
 2953  * @brief Notify a device of system shutdown
 2954  *
 2955  * This function calls the DEVICE_SHUTDOWN() driver method if the
 2956  * device currently has an attached driver.
 2957  *
 2958  * @returns the value returned by DEVICE_SHUTDOWN()
 2959  */
 2960 int
 2961 device_shutdown(device_t dev)
 2962 {
 2963         if (dev->state < DS_ATTACHED)
 2964                 return (0);
 2965         return (DEVICE_SHUTDOWN(dev));
 2966 }
 2967 
 2968 /**
 2969  * @brief Set the unit number of a device
 2970  *
 2971  * This function can be used to override the unit number used for a
 2972  * device (e.g. to wire a device to a pre-configured unit number).
 2973  */
 2974 int
 2975 device_set_unit(device_t dev, int unit)
 2976 {
 2977         devclass_t dc;
 2978         int err;
 2979 
 2980         dc = device_get_devclass(dev);
 2981         if (unit < dc->maxunit && dc->devices[unit])
 2982                 return (EBUSY);
 2983         err = devclass_delete_device(dc, dev);
 2984         if (err)
 2985                 return (err);
 2986         dev->unit = unit;
 2987         err = devclass_add_device(dc, dev);
 2988         if (err)
 2989                 return (err);
 2990 
 2991         bus_data_generation_update();
 2992         return (0);
 2993 }
 2994 
 2995 /*======================================*/
 2996 /*
 2997  * Some useful method implementations to make life easier for bus drivers.
 2998  */
 2999 
 3000 /**
 3001  * @brief Initialise a resource list.
 3002  *
 3003  * @param rl            the resource list to initialise
 3004  */
 3005 void
 3006 resource_list_init(struct resource_list *rl)
 3007 {
 3008         STAILQ_INIT(rl);
 3009 }
 3010 
 3011 /**
 3012  * @brief Reclaim memory used by a resource list.
 3013  *
 3014  * This function frees the memory for all resource entries on the list
 3015  * (if any).
 3016  *
 3017  * @param rl            the resource list to free               
 3018  */
 3019 void
 3020 resource_list_free(struct resource_list *rl)
 3021 {
 3022         struct resource_list_entry *rle;
 3023 
 3024         while ((rle = STAILQ_FIRST(rl)) != NULL) {
 3025                 if (rle->res)
 3026                         panic("resource_list_free: resource entry is busy");
 3027                 STAILQ_REMOVE_HEAD(rl, link);
 3028                 free(rle, M_BUS);
 3029         }
 3030 }
 3031 
 3032 /**
 3033  * @brief Add a resource entry.
 3034  *
 3035  * This function adds a resource entry using the given @p type, @p
 3036  * start, @p end and @p count values. A rid value is chosen by
 3037  * searching sequentially for the first unused rid starting at zero.
 3038  *
 3039  * @param rl            the resource list to edit
 3040  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3041  * @param start         the start address of the resource
 3042  * @param end           the end address of the resource
 3043  * @param count         XXX end-start+1
 3044  */
 3045 int
 3046 resource_list_add_next(struct resource_list *rl, int type, u_long start,
 3047     u_long end, u_long count)
 3048 {
 3049         int rid;
 3050 
 3051         rid = 0;
 3052         while (resource_list_find(rl, type, rid) != NULL)
 3053                 rid++;
 3054         resource_list_add(rl, type, rid, start, end, count);
 3055         return (rid);
 3056 }
 3057 
 3058 /**
 3059  * @brief Add or modify a resource entry.
 3060  *
 3061  * If an existing entry exists with the same type and rid, it will be
 3062  * modified using the given values of @p start, @p end and @p
 3063  * count. If no entry exists, a new one will be created using the
 3064  * given values.  The resource list entry that matches is then returned.
 3065  *
 3066  * @param rl            the resource list to edit
 3067  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3068  * @param rid           the resource identifier
 3069  * @param start         the start address of the resource
 3070  * @param end           the end address of the resource
 3071  * @param count         XXX end-start+1
 3072  */
 3073 struct resource_list_entry *
 3074 resource_list_add(struct resource_list *rl, int type, int rid,
 3075     u_long start, u_long end, u_long count)
 3076 {
 3077         struct resource_list_entry *rle;
 3078 
 3079         rle = resource_list_find(rl, type, rid);
 3080         if (!rle) {
 3081                 rle = malloc(sizeof(struct resource_list_entry), M_BUS,
 3082                     M_NOWAIT);
 3083                 if (!rle)
 3084                         panic("resource_list_add: can't record entry");
 3085                 STAILQ_INSERT_TAIL(rl, rle, link);
 3086                 rle->type = type;
 3087                 rle->rid = rid;
 3088                 rle->res = NULL;
 3089                 rle->flags = 0;
 3090         }
 3091 
 3092         if (rle->res)
 3093                 panic("resource_list_add: resource entry is busy");
 3094 
 3095         rle->start = start;
 3096         rle->end = end;
 3097         rle->count = count;
 3098         return (rle);
 3099 }
 3100 
 3101 /**
 3102  * @brief Determine if a resource entry is busy.
 3103  *
 3104  * Returns true if a resource entry is busy meaning that it has an
 3105  * associated resource that is not an unallocated "reserved" resource.
 3106  *
 3107  * @param rl            the resource list to search
 3108  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3109  * @param rid           the resource identifier
 3110  *
 3111  * @returns Non-zero if the entry is busy, zero otherwise.
 3112  */
 3113 int
 3114 resource_list_busy(struct resource_list *rl, int type, int rid)
 3115 {
 3116         struct resource_list_entry *rle;
 3117 
 3118         rle = resource_list_find(rl, type, rid);
 3119         if (rle == NULL || rle->res == NULL)
 3120                 return (0);
 3121         if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == RLE_RESERVED) {
 3122                 KASSERT(!(rman_get_flags(rle->res) & RF_ACTIVE),
 3123                     ("reserved resource is active"));
 3124                 return (0);
 3125         }
 3126         return (1);
 3127 }
 3128 
 3129 /**
 3130  * @brief Determine if a resource entry is reserved.
 3131  *
 3132  * Returns true if a resource entry is reserved meaning that it has an
 3133  * associated "reserved" resource.  The resource can either be
 3134  * allocated or unallocated.
 3135  *
 3136  * @param rl            the resource list to search
 3137  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3138  * @param rid           the resource identifier
 3139  *
 3140  * @returns Non-zero if the entry is reserved, zero otherwise.
 3141  */
 3142 int
 3143 resource_list_reserved(struct resource_list *rl, int type, int rid)
 3144 {
 3145         struct resource_list_entry *rle;
 3146 
 3147         rle = resource_list_find(rl, type, rid);
 3148         if (rle != NULL && rle->flags & RLE_RESERVED)
 3149                 return (1);
 3150         return (0);
 3151 }
 3152 
 3153 /**
 3154  * @brief Find a resource entry by type and rid.
 3155  *
 3156  * @param rl            the resource list to search
 3157  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3158  * @param rid           the resource identifier
 3159  *
 3160  * @returns the resource entry pointer or NULL if there is no such
 3161  * entry.
 3162  */
 3163 struct resource_list_entry *
 3164 resource_list_find(struct resource_list *rl, int type, int rid)
 3165 {
 3166         struct resource_list_entry *rle;
 3167 
 3168         STAILQ_FOREACH(rle, rl, link) {
 3169                 if (rle->type == type && rle->rid == rid)
 3170                         return (rle);
 3171         }
 3172         return (NULL);
 3173 }
 3174 
 3175 /**
 3176  * @brief Delete a resource entry.
 3177  *
 3178  * @param rl            the resource list to edit
 3179  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3180  * @param rid           the resource identifier
 3181  */
 3182 void
 3183 resource_list_delete(struct resource_list *rl, int type, int rid)
 3184 {
 3185         struct resource_list_entry *rle = resource_list_find(rl, type, rid);
 3186 
 3187         if (rle) {
 3188                 if (rle->res != NULL)
 3189                         panic("resource_list_delete: resource has not been released");
 3190                 STAILQ_REMOVE(rl, rle, resource_list_entry, link);
 3191                 free(rle, M_BUS);
 3192         }
 3193 }
 3194 
 3195 /**
 3196  * @brief Allocate a reserved resource
 3197  *
 3198  * This can be used by busses to force the allocation of resources
 3199  * that are always active in the system even if they are not allocated
 3200  * by a driver (e.g. PCI BARs).  This function is usually called when
 3201  * adding a new child to the bus.  The resource is allocated from the
 3202  * parent bus when it is reserved.  The resource list entry is marked
 3203  * with RLE_RESERVED to note that it is a reserved resource.
 3204  *
 3205  * Subsequent attempts to allocate the resource with
 3206  * resource_list_alloc() will succeed the first time and will set
 3207  * RLE_ALLOCATED to note that it has been allocated.  When a reserved
 3208  * resource that has been allocated is released with
 3209  * resource_list_release() the resource RLE_ALLOCATED is cleared, but
 3210  * the actual resource remains allocated.  The resource can be released to
 3211  * the parent bus by calling resource_list_unreserve().
 3212  *
 3213  * @param rl            the resource list to allocate from
 3214  * @param bus           the parent device of @p child
 3215  * @param child         the device for which the resource is being reserved
 3216  * @param type          the type of resource to allocate
 3217  * @param rid           a pointer to the resource identifier
 3218  * @param start         hint at the start of the resource range - pass
 3219  *                      @c 0UL for any start address
 3220  * @param end           hint at the end of the resource range - pass
 3221  *                      @c ~0UL for any end address
 3222  * @param count         hint at the size of range required - pass @c 1
 3223  *                      for any size
 3224  * @param flags         any extra flags to control the resource
 3225  *                      allocation - see @c RF_XXX flags in
 3226  *                      <sys/rman.h> for details
 3227  * 
 3228  * @returns             the resource which was allocated or @c NULL if no
 3229  *                      resource could be allocated
 3230  */
 3231 struct resource *
 3232 resource_list_reserve(struct resource_list *rl, device_t bus, device_t child,
 3233     int type, int *rid, u_long start, u_long end, u_long count, u_int flags)
 3234 {
 3235         struct resource_list_entry *rle = NULL;
 3236         int passthrough = (device_get_parent(child) != bus);
 3237         struct resource *r;
 3238 
 3239         if (passthrough)
 3240                 panic(
 3241     "resource_list_reserve() should only be called for direct children");
 3242         if (flags & RF_ACTIVE)
 3243                 panic(
 3244     "resource_list_reserve() should only reserve inactive resources");
 3245 
 3246         r = resource_list_alloc(rl, bus, child, type, rid, start, end, count,
 3247             flags);
 3248         if (r != NULL) {
 3249                 rle = resource_list_find(rl, type, *rid);
 3250                 rle->flags |= RLE_RESERVED;
 3251         }
 3252         return (r);
 3253 }
 3254 
 3255 /**
 3256  * @brief Helper function for implementing BUS_ALLOC_RESOURCE()
 3257  *
 3258  * Implement BUS_ALLOC_RESOURCE() by looking up a resource from the list
 3259  * and passing the allocation up to the parent of @p bus. This assumes
 3260  * that the first entry of @c device_get_ivars(child) is a struct
 3261  * resource_list. This also handles 'passthrough' allocations where a
 3262  * child is a remote descendant of bus by passing the allocation up to
 3263  * the parent of bus.
 3264  *
 3265  * Typically, a bus driver would store a list of child resources
 3266  * somewhere in the child device's ivars (see device_get_ivars()) and
 3267  * its implementation of BUS_ALLOC_RESOURCE() would find that list and
 3268  * then call resource_list_alloc() to perform the allocation.
 3269  *
 3270  * @param rl            the resource list to allocate from
 3271  * @param bus           the parent device of @p child
 3272  * @param child         the device which is requesting an allocation
 3273  * @param type          the type of resource to allocate
 3274  * @param rid           a pointer to the resource identifier
 3275  * @param start         hint at the start of the resource range - pass
 3276  *                      @c 0UL for any start address
 3277  * @param end           hint at the end of the resource range - pass
 3278  *                      @c ~0UL for any end address
 3279  * @param count         hint at the size of range required - pass @c 1
 3280  *                      for any size
 3281  * @param flags         any extra flags to control the resource
 3282  *                      allocation - see @c RF_XXX flags in
 3283  *                      <sys/rman.h> for details
 3284  * 
 3285  * @returns             the resource which was allocated or @c NULL if no
 3286  *                      resource could be allocated
 3287  */
 3288 struct resource *
 3289 resource_list_alloc(struct resource_list *rl, device_t bus, device_t child,
 3290     int type, int *rid, u_long start, u_long end, u_long count, u_int flags)
 3291 {
 3292         struct resource_list_entry *rle = NULL;
 3293         int passthrough = (device_get_parent(child) != bus);
 3294         int isdefault = (start == 0UL && end == ~0UL);
 3295 
 3296         if (passthrough) {
 3297                 return (BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
 3298                     type, rid, start, end, count, flags));
 3299         }
 3300 
 3301         rle = resource_list_find(rl, type, *rid);
 3302 
 3303         if (!rle)
 3304                 return (NULL);          /* no resource of that type/rid */
 3305 
 3306         if (rle->res) {
 3307                 if (rle->flags & RLE_RESERVED) {
 3308                         if (rle->flags & RLE_ALLOCATED)
 3309                                 return (NULL);
 3310                         if ((flags & RF_ACTIVE) &&
 3311                             bus_activate_resource(child, type, *rid,
 3312                             rle->res) != 0)
 3313                                 return (NULL);
 3314                         rle->flags |= RLE_ALLOCATED;
 3315                         return (rle->res);
 3316                 }
 3317                 device_printf(bus,
 3318                     "resource entry %#x type %d for child %s is busy\n", *rid,
 3319                     type, device_get_nameunit(child));
 3320                 return (NULL);
 3321         }
 3322 
 3323         if (isdefault) {
 3324                 start = rle->start;
 3325                 count = ulmax(count, rle->count);
 3326                 end = ulmax(rle->end, start + count - 1);
 3327         }
 3328 
 3329         rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
 3330             type, rid, start, end, count, flags);
 3331 
 3332         /*
 3333          * Record the new range.
 3334          */
 3335         if (rle->res) {
 3336                 rle->start = rman_get_start(rle->res);
 3337                 rle->end = rman_get_end(rle->res);
 3338                 rle->count = count;
 3339         }
 3340 
 3341         return (rle->res);
 3342 }
 3343 
 3344 /**
 3345  * @brief Helper function for implementing BUS_RELEASE_RESOURCE()
 3346  * 
 3347  * Implement BUS_RELEASE_RESOURCE() using a resource list. Normally
 3348  * used with resource_list_alloc().
 3349  * 
 3350  * @param rl            the resource list which was allocated from
 3351  * @param bus           the parent device of @p child
 3352  * @param child         the device which is requesting a release
 3353  * @param type          the type of resource to release
 3354  * @param rid           the resource identifier
 3355  * @param res           the resource to release
 3356  * 
 3357  * @retval 0            success
 3358  * @retval non-zero     a standard unix error code indicating what
 3359  *                      error condition prevented the operation
 3360  */
 3361 int
 3362 resource_list_release(struct resource_list *rl, device_t bus, device_t child,
 3363     int type, int rid, struct resource *res)
 3364 {
 3365         struct resource_list_entry *rle = NULL;
 3366         int passthrough = (device_get_parent(child) != bus);
 3367         int error;
 3368 
 3369         if (passthrough) {
 3370                 return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
 3371                     type, rid, res));
 3372         }
 3373 
 3374         rle = resource_list_find(rl, type, rid);
 3375 
 3376         if (!rle)
 3377                 panic("resource_list_release: can't find resource");
 3378         if (!rle->res)
 3379                 panic("resource_list_release: resource entry is not busy");
 3380         if (rle->flags & RLE_RESERVED) {
 3381                 if (rle->flags & RLE_ALLOCATED) {
 3382                         if (rman_get_flags(res) & RF_ACTIVE) {
 3383                                 error = bus_deactivate_resource(child, type,
 3384                                     rid, res);
 3385                                 if (error)
 3386                                         return (error);
 3387                         }
 3388                         rle->flags &= ~RLE_ALLOCATED;
 3389                         return (0);
 3390                 }
 3391                 return (EINVAL);
 3392         }
 3393 
 3394         error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
 3395             type, rid, res);
 3396         if (error)
 3397                 return (error);
 3398 
 3399         rle->res = NULL;
 3400         return (0);
 3401 }
 3402 
 3403 /**
 3404  * @brief Release all active resources of a given type
 3405  *
 3406  * Release all active resources of a specified type.  This is intended
 3407  * to be used to cleanup resources leaked by a driver after detach or
 3408  * a failed attach.
 3409  *
 3410  * @param rl            the resource list which was allocated from
 3411  * @param bus           the parent device of @p child
 3412  * @param child         the device whose active resources are being released
 3413  * @param type          the type of resources to release
 3414  * 
 3415  * @retval 0            success
 3416  * @retval EBUSY        at least one resource was active
 3417  */
 3418 int
 3419 resource_list_release_active(struct resource_list *rl, device_t bus,
 3420     device_t child, int type)
 3421 {
 3422         struct resource_list_entry *rle;
 3423         int error, retval;
 3424 
 3425         retval = 0;
 3426         STAILQ_FOREACH(rle, rl, link) {
 3427                 if (rle->type != type)
 3428                         continue;
 3429                 if (rle->res == NULL)
 3430                         continue;
 3431                 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) ==
 3432                     RLE_RESERVED)
 3433                         continue;
 3434                 retval = EBUSY;
 3435                 error = resource_list_release(rl, bus, child, type,
 3436                     rman_get_rid(rle->res), rle->res);
 3437                 if (error != 0)
 3438                         device_printf(bus,
 3439                             "Failed to release active resource: %d\n", error);
 3440         }
 3441         return (retval);
 3442 }
 3443 
 3444 
 3445 /**
 3446  * @brief Fully release a reserved resource
 3447  *
 3448  * Fully releases a resource reserved via resource_list_reserve().
 3449  *
 3450  * @param rl            the resource list which was allocated from
 3451  * @param bus           the parent device of @p child
 3452  * @param child         the device whose reserved resource is being released
 3453  * @param type          the type of resource to release
 3454  * @param rid           the resource identifier
 3455  * @param res           the resource to release
 3456  * 
 3457  * @retval 0            success
 3458  * @retval non-zero     a standard unix error code indicating what
 3459  *                      error condition prevented the operation
 3460  */
 3461 int
 3462 resource_list_unreserve(struct resource_list *rl, device_t bus, device_t child,
 3463     int type, int rid)
 3464 {
 3465         struct resource_list_entry *rle = NULL;
 3466         int passthrough = (device_get_parent(child) != bus);
 3467 
 3468         if (passthrough)
 3469                 panic(
 3470     "resource_list_unreserve() should only be called for direct children");
 3471 
 3472         rle = resource_list_find(rl, type, rid);
 3473 
 3474         if (!rle)
 3475                 panic("resource_list_unreserve: can't find resource");
 3476         if (!(rle->flags & RLE_RESERVED))
 3477                 return (EINVAL);
 3478         if (rle->flags & RLE_ALLOCATED)
 3479                 return (EBUSY);
 3480         rle->flags &= ~RLE_RESERVED;
 3481         return (resource_list_release(rl, bus, child, type, rid, rle->res));
 3482 }
 3483 
 3484 /**
 3485  * @brief Print a description of resources in a resource list
 3486  *
 3487  * Print all resources of a specified type, for use in BUS_PRINT_CHILD().
 3488  * The name is printed if at least one resource of the given type is available.
 3489  * The format is used to print resource start and end.
 3490  *
 3491  * @param rl            the resource list to print
 3492  * @param name          the name of @p type, e.g. @c "memory"
 3493  * @param type          type type of resource entry to print
 3494  * @param format        printf(9) format string to print resource
 3495  *                      start and end values
 3496  * 
 3497  * @returns             the number of characters printed
 3498  */
 3499 int
 3500 resource_list_print_type(struct resource_list *rl, const char *name, int type,
 3501     const char *format)
 3502 {
 3503         struct resource_list_entry *rle;
 3504         int printed, retval;
 3505 
 3506         printed = 0;
 3507         retval = 0;
 3508         /* Yes, this is kinda cheating */
 3509         STAILQ_FOREACH(rle, rl, link) {
 3510                 if (rle->type == type) {
 3511                         if (printed == 0)
 3512                                 retval += printf(" %s ", name);
 3513                         else
 3514                                 retval += printf(",");
 3515                         printed++;
 3516                         retval += printf(format, rle->start);
 3517                         if (rle->count > 1) {
 3518                                 retval += printf("-");
 3519                                 retval += printf(format, rle->start +
 3520                                                  rle->count - 1);
 3521                         }
 3522                 }
 3523         }
 3524         return (retval);
 3525 }
 3526 
 3527 /**
 3528  * @brief Releases all the resources in a list.
 3529  *
 3530  * @param rl            The resource list to purge.
 3531  * 
 3532  * @returns             nothing
 3533  */
 3534 void
 3535 resource_list_purge(struct resource_list *rl)
 3536 {
 3537         struct resource_list_entry *rle;
 3538 
 3539         while ((rle = STAILQ_FIRST(rl)) != NULL) {
 3540                 if (rle->res)
 3541                         bus_release_resource(rman_get_device(rle->res),
 3542                             rle->type, rle->rid, rle->res);
 3543                 STAILQ_REMOVE_HEAD(rl, link);
 3544                 free(rle, M_BUS);
 3545         }
 3546 }
 3547 
 3548 device_t
 3549 bus_generic_add_child(device_t dev, u_int order, const char *name, int unit)
 3550 {
 3551 
 3552         return (device_add_child_ordered(dev, order, name, unit));
 3553 }
 3554 
 3555 /**
 3556  * @brief Helper function for implementing DEVICE_PROBE()
 3557  *
 3558  * This function can be used to help implement the DEVICE_PROBE() for
 3559  * a bus (i.e. a device which has other devices attached to it). It
 3560  * calls the DEVICE_IDENTIFY() method of each driver in the device's
 3561  * devclass.
 3562  */
 3563 int
 3564 bus_generic_probe(device_t dev)
 3565 {
 3566         devclass_t dc = dev->devclass;
 3567         driverlink_t dl;
 3568 
 3569         TAILQ_FOREACH(dl, &dc->drivers, link) {
 3570                 /*
 3571                  * If this driver's pass is too high, then ignore it.
 3572                  * For most drivers in the default pass, this will
 3573                  * never be true.  For early-pass drivers they will
 3574                  * only call the identify routines of eligible drivers
 3575                  * when this routine is called.  Drivers for later
 3576                  * passes should have their identify routines called
 3577                  * on early-pass busses during BUS_NEW_PASS().
 3578                  */
 3579                 if (dl->pass > bus_current_pass)
 3580                         continue;
 3581                 DEVICE_IDENTIFY(dl->driver, dev);
 3582         }
 3583 
 3584         return (0);
 3585 }
 3586 
 3587 /**
 3588  * @brief Helper function for implementing DEVICE_ATTACH()
 3589  *
 3590  * This function can be used to help implement the DEVICE_ATTACH() for
 3591  * a bus. It calls device_probe_and_attach() for each of the device's
 3592  * children.
 3593  */
 3594 int
 3595 bus_generic_attach(device_t dev)
 3596 {
 3597         device_t child;
 3598 
 3599         TAILQ_FOREACH(child, &dev->children, link) {
 3600                 device_probe_and_attach(child);
 3601         }
 3602 
 3603         return (0);
 3604 }
 3605 
 3606 /**
 3607  * @brief Helper function for implementing DEVICE_DETACH()
 3608  *
 3609  * This function can be used to help implement the DEVICE_DETACH() for
 3610  * a bus. It calls device_detach() for each of the device's
 3611  * children.
 3612  */
 3613 int
 3614 bus_generic_detach(device_t dev)
 3615 {
 3616         device_t child;
 3617         int error;
 3618 
 3619         if (dev->state != DS_ATTACHED)
 3620                 return (EBUSY);
 3621 
 3622         TAILQ_FOREACH(child, &dev->children, link) {
 3623                 if ((error = device_detach(child)) != 0)
 3624                         return (error);
 3625         }
 3626 
 3627         return (0);
 3628 }
 3629 
 3630 /**
 3631  * @brief Helper function for implementing DEVICE_SHUTDOWN()
 3632  *
 3633  * This function can be used to help implement the DEVICE_SHUTDOWN()
 3634  * for a bus. It calls device_shutdown() for each of the device's
 3635  * children.
 3636  */
 3637 int
 3638 bus_generic_shutdown(device_t dev)
 3639 {
 3640         device_t child;
 3641 
 3642         TAILQ_FOREACH(child, &dev->children, link) {
 3643                 device_shutdown(child);
 3644         }
 3645 
 3646         return (0);
 3647 }
 3648 
 3649 /**
 3650  * @brief Helper function for implementing DEVICE_SUSPEND()
 3651  *
 3652  * This function can be used to help implement the DEVICE_SUSPEND()
 3653  * for a bus. It calls DEVICE_SUSPEND() for each of the device's
 3654  * children. If any call to DEVICE_SUSPEND() fails, the suspend
 3655  * operation is aborted and any devices which were suspended are
 3656  * resumed immediately by calling their DEVICE_RESUME() methods.
 3657  */
 3658 int
 3659 bus_generic_suspend(device_t dev)
 3660 {
 3661         int             error;
 3662         device_t        child, child2;
 3663 
 3664         TAILQ_FOREACH(child, &dev->children, link) {
 3665                 error = DEVICE_SUSPEND(child);
 3666                 if (error) {
 3667                         for (child2 = TAILQ_FIRST(&dev->children);
 3668                              child2 && child2 != child;
 3669                              child2 = TAILQ_NEXT(child2, link))
 3670                                 DEVICE_RESUME(child2);
 3671                         return (error);
 3672                 }
 3673         }
 3674         return (0);
 3675 }
 3676 
 3677 /**
 3678  * @brief Helper function for implementing DEVICE_RESUME()
 3679  *
 3680  * This function can be used to help implement the DEVICE_RESUME() for
 3681  * a bus. It calls DEVICE_RESUME() on each of the device's children.
 3682  */
 3683 int
 3684 bus_generic_resume(device_t dev)
 3685 {
 3686         device_t        child;
 3687 
 3688         TAILQ_FOREACH(child, &dev->children, link) {
 3689                 DEVICE_RESUME(child);
 3690                 /* if resume fails, there's nothing we can usefully do... */
 3691         }
 3692         return (0);
 3693 }
 3694 
 3695 /**
 3696  * @brief Helper function for implementing BUS_PRINT_CHILD().
 3697  *
 3698  * This function prints the first part of the ascii representation of
 3699  * @p child, including its name, unit and description (if any - see
 3700  * device_set_desc()).
 3701  *
 3702  * @returns the number of characters printed
 3703  */
 3704 int
 3705 bus_print_child_header(device_t dev, device_t child)
 3706 {
 3707         int     retval = 0;
 3708 
 3709         if (device_get_desc(child)) {
 3710                 retval += device_printf(child, "<%s>", device_get_desc(child));
 3711         } else {
 3712                 retval += printf("%s", device_get_nameunit(child));
 3713         }
 3714 
 3715         return (retval);
 3716 }
 3717 
 3718 /**
 3719  * @brief Helper function for implementing BUS_PRINT_CHILD().
 3720  *
 3721  * This function prints the last part of the ascii representation of
 3722  * @p child, which consists of the string @c " on " followed by the
 3723  * name and unit of the @p dev.
 3724  *
 3725  * @returns the number of characters printed
 3726  */
 3727 int
 3728 bus_print_child_footer(device_t dev, device_t child)
 3729 {
 3730         return (printf(" on %s\n", device_get_nameunit(dev)));
 3731 }
 3732 
 3733 /**
 3734  * @brief Helper function for implementing BUS_PRINT_CHILD().
 3735  *
 3736  * This function prints out the VM domain for the given device.
 3737  *
 3738  * @returns the number of characters printed
 3739  */
 3740 int
 3741 bus_print_child_domain(device_t dev, device_t child)
 3742 {
 3743         int domain;
 3744 
 3745         /* No domain? Don't print anything */
 3746         if (BUS_GET_DOMAIN(dev, child, &domain) != 0)
 3747                 return (0);
 3748 
 3749         return (printf(" numa-domain %d", domain));
 3750 }
 3751 
 3752 /**
 3753  * @brief Helper function for implementing BUS_PRINT_CHILD().
 3754  *
 3755  * This function simply calls bus_print_child_header() followed by
 3756  * bus_print_child_footer().
 3757  *
 3758  * @returns the number of characters printed
 3759  */
 3760 int
 3761 bus_generic_print_child(device_t dev, device_t child)
 3762 {
 3763         int     retval = 0;
 3764 
 3765         retval += bus_print_child_header(dev, child);
 3766         retval += bus_print_child_domain(dev, child);
 3767         retval += bus_print_child_footer(dev, child);
 3768 
 3769         return (retval);
 3770 }
 3771 
 3772 /**
 3773  * @brief Stub function for implementing BUS_READ_IVAR().
 3774  * 
 3775  * @returns ENOENT
 3776  */
 3777 int
 3778 bus_generic_read_ivar(device_t dev, device_t child, int index,
 3779     uintptr_t * result)
 3780 {
 3781         return (ENOENT);
 3782 }
 3783 
 3784 /**
 3785  * @brief Stub function for implementing BUS_WRITE_IVAR().
 3786  * 
 3787  * @returns ENOENT
 3788  */
 3789 int
 3790 bus_generic_write_ivar(device_t dev, device_t child, int index,
 3791     uintptr_t value)
 3792 {
 3793         return (ENOENT);
 3794 }
 3795 
 3796 /**
 3797  * @brief Stub function for implementing BUS_GET_RESOURCE_LIST().
 3798  * 
 3799  * @returns NULL
 3800  */
 3801 struct resource_list *
 3802 bus_generic_get_resource_list(device_t dev, device_t child)
 3803 {
 3804         return (NULL);
 3805 }
 3806 
 3807 /**
 3808  * @brief Helper function for implementing BUS_DRIVER_ADDED().
 3809  *
 3810  * This implementation of BUS_DRIVER_ADDED() simply calls the driver's
 3811  * DEVICE_IDENTIFY() method to allow it to add new children to the bus
 3812  * and then calls device_probe_and_attach() for each unattached child.
 3813  */
 3814 void
 3815 bus_generic_driver_added(device_t dev, driver_t *driver)
 3816 {
 3817         device_t child;
 3818 
 3819         DEVICE_IDENTIFY(driver, dev);
 3820         TAILQ_FOREACH(child, &dev->children, link) {
 3821                 if (child->state == DS_NOTPRESENT ||
 3822                     (child->flags & DF_REBID))
 3823                         device_probe_and_attach(child);
 3824         }
 3825 }
 3826 
 3827 /**
 3828  * @brief Helper function for implementing BUS_NEW_PASS().
 3829  *
 3830  * This implementing of BUS_NEW_PASS() first calls the identify
 3831  * routines for any drivers that probe at the current pass.  Then it
 3832  * walks the list of devices for this bus.  If a device is already
 3833  * attached, then it calls BUS_NEW_PASS() on that device.  If the
 3834  * device is not already attached, it attempts to attach a driver to
 3835  * it.
 3836  */
 3837 void
 3838 bus_generic_new_pass(device_t dev)
 3839 {
 3840         driverlink_t dl;
 3841         devclass_t dc;
 3842         device_t child;
 3843 
 3844         dc = dev->devclass;
 3845         TAILQ_FOREACH(dl, &dc->drivers, link) {
 3846                 if (dl->pass == bus_current_pass)
 3847                         DEVICE_IDENTIFY(dl->driver, dev);
 3848         }
 3849         TAILQ_FOREACH(child, &dev->children, link) {
 3850                 if (child->state >= DS_ATTACHED)
 3851                         BUS_NEW_PASS(child);
 3852                 else if (child->state == DS_NOTPRESENT)
 3853                         device_probe_and_attach(child);
 3854         }
 3855 }
 3856 
 3857 /**
 3858  * @brief Helper function for implementing BUS_SETUP_INTR().
 3859  *
 3860  * This simple implementation of BUS_SETUP_INTR() simply calls the
 3861  * BUS_SETUP_INTR() method of the parent of @p dev.
 3862  */
 3863 int
 3864 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq,
 3865     int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg, 
 3866     void **cookiep)
 3867 {
 3868         /* Propagate up the bus hierarchy until someone handles it. */
 3869         if (dev->parent)
 3870                 return (BUS_SETUP_INTR(dev->parent, child, irq, flags,
 3871                     filter, intr, arg, cookiep));
 3872         return (EINVAL);
 3873 }
 3874 
 3875 /**
 3876  * @brief Helper function for implementing BUS_TEARDOWN_INTR().
 3877  *
 3878  * This simple implementation of BUS_TEARDOWN_INTR() simply calls the
 3879  * BUS_TEARDOWN_INTR() method of the parent of @p dev.
 3880  */
 3881 int
 3882 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq,
 3883     void *cookie)
 3884 {
 3885         /* Propagate up the bus hierarchy until someone handles it. */
 3886         if (dev->parent)
 3887                 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie));
 3888         return (EINVAL);
 3889 }
 3890 
 3891 /**
 3892  * @brief Helper function for implementing BUS_ADJUST_RESOURCE().
 3893  *
 3894  * This simple implementation of BUS_ADJUST_RESOURCE() simply calls the
 3895  * BUS_ADJUST_RESOURCE() method of the parent of @p dev.
 3896  */
 3897 int
 3898 bus_generic_adjust_resource(device_t dev, device_t child, int type,
 3899     struct resource *r, u_long start, u_long end)
 3900 {
 3901         /* Propagate up the bus hierarchy until someone handles it. */
 3902         if (dev->parent)
 3903                 return (BUS_ADJUST_RESOURCE(dev->parent, child, type, r, start,
 3904                     end));
 3905         return (EINVAL);
 3906 }
 3907 
 3908 /**
 3909  * @brief Helper function for implementing BUS_ALLOC_RESOURCE().
 3910  *
 3911  * This simple implementation of BUS_ALLOC_RESOURCE() simply calls the
 3912  * BUS_ALLOC_RESOURCE() method of the parent of @p dev.
 3913  */
 3914 struct resource *
 3915 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid,
 3916     u_long start, u_long end, u_long count, u_int flags)
 3917 {
 3918         /* Propagate up the bus hierarchy until someone handles it. */
 3919         if (dev->parent)
 3920                 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid,
 3921                     start, end, count, flags));
 3922         return (NULL);
 3923 }
 3924 
 3925 /**
 3926  * @brief Helper function for implementing BUS_RELEASE_RESOURCE().
 3927  *
 3928  * This simple implementation of BUS_RELEASE_RESOURCE() simply calls the
 3929  * BUS_RELEASE_RESOURCE() method of the parent of @p dev.
 3930  */
 3931 int
 3932 bus_generic_release_resource(device_t dev, device_t child, int type, int rid,
 3933     struct resource *r)
 3934 {
 3935         /* Propagate up the bus hierarchy until someone handles it. */
 3936         if (dev->parent)
 3937                 return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid,
 3938                     r));
 3939         return (EINVAL);
 3940 }
 3941 
 3942 /**
 3943  * @brief Helper function for implementing BUS_ACTIVATE_RESOURCE().
 3944  *
 3945  * This simple implementation of BUS_ACTIVATE_RESOURCE() simply calls the
 3946  * BUS_ACTIVATE_RESOURCE() method of the parent of @p dev.
 3947  */
 3948 int
 3949 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid,
 3950     struct resource *r)
 3951 {
 3952         /* Propagate up the bus hierarchy until someone handles it. */
 3953         if (dev->parent)
 3954                 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid,
 3955                     r));
 3956         return (EINVAL);
 3957 }
 3958 
 3959 /**
 3960  * @brief Helper function for implementing BUS_DEACTIVATE_RESOURCE().
 3961  *
 3962  * This simple implementation of BUS_DEACTIVATE_RESOURCE() simply calls the
 3963  * BUS_DEACTIVATE_RESOURCE() method of the parent of @p dev.
 3964  */
 3965 int
 3966 bus_generic_deactivate_resource(device_t dev, device_t child, int type,
 3967     int rid, struct resource *r)
 3968 {
 3969         /* Propagate up the bus hierarchy until someone handles it. */
 3970         if (dev->parent)
 3971                 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid,
 3972                     r));
 3973         return (EINVAL);
 3974 }
 3975 
 3976 /**
 3977  * @brief Helper function for implementing BUS_BIND_INTR().
 3978  *
 3979  * This simple implementation of BUS_BIND_INTR() simply calls the
 3980  * BUS_BIND_INTR() method of the parent of @p dev.
 3981  */
 3982 int
 3983 bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq,
 3984     int cpu)
 3985 {
 3986 
 3987         /* Propagate up the bus hierarchy until someone handles it. */
 3988         if (dev->parent)
 3989                 return (BUS_BIND_INTR(dev->parent, child, irq, cpu));
 3990         return (EINVAL);
 3991 }
 3992 
 3993 /**
 3994  * @brief Helper function for implementing BUS_CONFIG_INTR().
 3995  *
 3996  * This simple implementation of BUS_CONFIG_INTR() simply calls the
 3997  * BUS_CONFIG_INTR() method of the parent of @p dev.
 3998  */
 3999 int
 4000 bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig,
 4001     enum intr_polarity pol)
 4002 {
 4003 
 4004         /* Propagate up the bus hierarchy until someone handles it. */
 4005         if (dev->parent)
 4006                 return (BUS_CONFIG_INTR(dev->parent, irq, trig, pol));
 4007         return (EINVAL);
 4008 }
 4009 
 4010 /**
 4011  * @brief Helper function for implementing BUS_DESCRIBE_INTR().
 4012  *
 4013  * This simple implementation of BUS_DESCRIBE_INTR() simply calls the
 4014  * BUS_DESCRIBE_INTR() method of the parent of @p dev.
 4015  */
 4016 int
 4017 bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq,
 4018     void *cookie, const char *descr)
 4019 {
 4020 
 4021         /* Propagate up the bus hierarchy until someone handles it. */
 4022         if (dev->parent)
 4023                 return (BUS_DESCRIBE_INTR(dev->parent, child, irq, cookie,
 4024                     descr));
 4025         return (EINVAL);
 4026 }
 4027 
 4028 /**
 4029  * @brief Helper function for implementing BUS_GET_DMA_TAG().
 4030  *
 4031  * This simple implementation of BUS_GET_DMA_TAG() simply calls the
 4032  * BUS_GET_DMA_TAG() method of the parent of @p dev.
 4033  */
 4034 bus_dma_tag_t
 4035 bus_generic_get_dma_tag(device_t dev, device_t child)
 4036 {
 4037 
 4038         /* Propagate up the bus hierarchy until someone handles it. */
 4039         if (dev->parent != NULL)
 4040                 return (BUS_GET_DMA_TAG(dev->parent, child));
 4041         return (NULL);
 4042 }
 4043 
 4044 /**
 4045  * @brief Helper function for implementing BUS_GET_RESOURCE().
 4046  *
 4047  * This implementation of BUS_GET_RESOURCE() uses the
 4048  * resource_list_find() function to do most of the work. It calls
 4049  * BUS_GET_RESOURCE_LIST() to find a suitable resource list to
 4050  * search.
 4051  */
 4052 int
 4053 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid,
 4054     u_long *startp, u_long *countp)
 4055 {
 4056         struct resource_list *          rl = NULL;
 4057         struct resource_list_entry *    rle = NULL;
 4058 
 4059         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4060         if (!rl)
 4061                 return (EINVAL);
 4062 
 4063         rle = resource_list_find(rl, type, rid);
 4064         if (!rle)
 4065                 return (ENOENT);
 4066 
 4067         if (startp)
 4068                 *startp = rle->start;
 4069         if (countp)
 4070                 *countp = rle->count;
 4071 
 4072         return (0);
 4073 }
 4074 
 4075 /**
 4076  * @brief Helper function for implementing BUS_SET_RESOURCE().
 4077  *
 4078  * This implementation of BUS_SET_RESOURCE() uses the
 4079  * resource_list_add() function to do most of the work. It calls
 4080  * BUS_GET_RESOURCE_LIST() to find a suitable resource list to
 4081  * edit.
 4082  */
 4083 int
 4084 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid,
 4085     u_long start, u_long count)
 4086 {
 4087         struct resource_list *          rl = NULL;
 4088 
 4089         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4090         if (!rl)
 4091                 return (EINVAL);
 4092 
 4093         resource_list_add(rl, type, rid, start, (start + count - 1), count);
 4094 
 4095         return (0);
 4096 }
 4097 
 4098 /**
 4099  * @brief Helper function for implementing BUS_DELETE_RESOURCE().
 4100  *
 4101  * This implementation of BUS_DELETE_RESOURCE() uses the
 4102  * resource_list_delete() function to do most of the work. It calls
 4103  * BUS_GET_RESOURCE_LIST() to find a suitable resource list to
 4104  * edit.
 4105  */
 4106 void
 4107 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid)
 4108 {
 4109         struct resource_list *          rl = NULL;
 4110 
 4111         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4112         if (!rl)
 4113                 return;
 4114 
 4115         resource_list_delete(rl, type, rid);
 4116 
 4117         return;
 4118 }
 4119 
 4120 /**
 4121  * @brief Helper function for implementing BUS_RELEASE_RESOURCE().
 4122  *
 4123  * This implementation of BUS_RELEASE_RESOURCE() uses the
 4124  * resource_list_release() function to do most of the work. It calls
 4125  * BUS_GET_RESOURCE_LIST() to find a suitable resource list.
 4126  */
 4127 int
 4128 bus_generic_rl_release_resource(device_t dev, device_t child, int type,
 4129     int rid, struct resource *r)
 4130 {
 4131         struct resource_list *          rl = NULL;
 4132 
 4133         if (device_get_parent(child) != dev)
 4134                 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
 4135                     type, rid, r));
 4136 
 4137         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4138         if (!rl)
 4139                 return (EINVAL);
 4140 
 4141         return (resource_list_release(rl, dev, child, type, rid, r));
 4142 }
 4143 
 4144 /**
 4145  * @brief Helper function for implementing BUS_ALLOC_RESOURCE().
 4146  *
 4147  * This implementation of BUS_ALLOC_RESOURCE() uses the
 4148  * resource_list_alloc() function to do most of the work. It calls
 4149  * BUS_GET_RESOURCE_LIST() to find a suitable resource list.
 4150  */
 4151 struct resource *
 4152 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type,
 4153     int *rid, u_long start, u_long end, u_long count, u_int flags)
 4154 {
 4155         struct resource_list *          rl = NULL;
 4156 
 4157         if (device_get_parent(child) != dev)
 4158                 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
 4159                     type, rid, start, end, count, flags));
 4160 
 4161         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4162         if (!rl)
 4163                 return (NULL);
 4164 
 4165         return (resource_list_alloc(rl, dev, child, type, rid,
 4166             start, end, count, flags));
 4167 }
 4168 
 4169 /**
 4170  * @brief Helper function for implementing BUS_CHILD_PRESENT().
 4171  *
 4172  * This simple implementation of BUS_CHILD_PRESENT() simply calls the
 4173  * BUS_CHILD_PRESENT() method of the parent of @p dev.
 4174  */
 4175 int
 4176 bus_generic_child_present(device_t dev, device_t child)
 4177 {
 4178         return (BUS_CHILD_PRESENT(device_get_parent(dev), dev));
 4179 }
 4180 
 4181 int
 4182 bus_generic_get_domain(device_t dev, device_t child, int *domain)
 4183 {
 4184 
 4185         if (dev->parent)
 4186                 return (BUS_GET_DOMAIN(dev->parent, dev, domain));
 4187 
 4188         return (ENOENT);
 4189 }
 4190 
 4191 /*
 4192  * Some convenience functions to make it easier for drivers to use the
 4193  * resource-management functions.  All these really do is hide the
 4194  * indirection through the parent's method table, making for slightly
 4195  * less-wordy code.  In the future, it might make sense for this code
 4196  * to maintain some sort of a list of resources allocated by each device.
 4197  */
 4198 
 4199 int
 4200 bus_alloc_resources(device_t dev, struct resource_spec *rs,
 4201     struct resource **res)
 4202 {
 4203         int i;
 4204 
 4205         for (i = 0; rs[i].type != -1; i++)
 4206                 res[i] = NULL;
 4207         for (i = 0; rs[i].type != -1; i++) {
 4208                 res[i] = bus_alloc_resource_any(dev,
 4209                     rs[i].type, &rs[i].rid, rs[i].flags);
 4210                 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) {
 4211                         bus_release_resources(dev, rs, res);
 4212                         return (ENXIO);
 4213                 }
 4214         }
 4215         return (0);
 4216 }
 4217 
 4218 void
 4219 bus_release_resources(device_t dev, const struct resource_spec *rs,
 4220     struct resource **res)
 4221 {
 4222         int i;
 4223 
 4224         for (i = 0; rs[i].type != -1; i++)
 4225                 if (res[i] != NULL) {
 4226                         bus_release_resource(
 4227                             dev, rs[i].type, rs[i].rid, res[i]);
 4228                         res[i] = NULL;
 4229                 }
 4230 }
 4231 
 4232 /**
 4233  * @brief Wrapper function for BUS_ALLOC_RESOURCE().
 4234  *
 4235  * This function simply calls the BUS_ALLOC_RESOURCE() method of the
 4236  * parent of @p dev.
 4237  */
 4238 struct resource *
 4239 bus_alloc_resource(device_t dev, int type, int *rid, u_long start, u_long end,
 4240     u_long count, u_int flags)
 4241 {
 4242         if (dev->parent == NULL)
 4243                 return (NULL);
 4244         return (BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end,
 4245             count, flags));
 4246 }
 4247 
 4248 /**
 4249  * @brief Wrapper function for BUS_ADJUST_RESOURCE().
 4250  *
 4251  * This function simply calls the BUS_ADJUST_RESOURCE() method of the
 4252  * parent of @p dev.
 4253  */
 4254 int
 4255 bus_adjust_resource(device_t dev, int type, struct resource *r, u_long start,
 4256     u_long end)
 4257 {
 4258         if (dev->parent == NULL)
 4259                 return (EINVAL);
 4260         return (BUS_ADJUST_RESOURCE(dev->parent, dev, type, r, start, end));
 4261 }
 4262 
 4263 /**
 4264  * @brief Wrapper function for BUS_ACTIVATE_RESOURCE().
 4265  *
 4266  * This function simply calls the BUS_ACTIVATE_RESOURCE() method of the
 4267  * parent of @p dev.
 4268  */
 4269 int
 4270 bus_activate_resource(device_t dev, int type, int rid, struct resource *r)
 4271 {
 4272         if (dev->parent == NULL)
 4273                 return (EINVAL);
 4274         return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
 4275 }
 4276 
 4277 /**
 4278  * @brief Wrapper function for BUS_DEACTIVATE_RESOURCE().
 4279  *
 4280  * This function simply calls the BUS_DEACTIVATE_RESOURCE() method of the
 4281  * parent of @p dev.
 4282  */
 4283 int
 4284 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r)
 4285 {
 4286         if (dev->parent == NULL)
 4287                 return (EINVAL);
 4288         return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
 4289 }
 4290 
 4291 /**
 4292  * @brief Wrapper function for BUS_RELEASE_RESOURCE().
 4293  *
 4294  * This function simply calls the BUS_RELEASE_RESOURCE() method of the
 4295  * parent of @p dev.
 4296  */
 4297 int
 4298 bus_release_resource(device_t dev, int type, int rid, struct resource *r)
 4299 {
 4300         if (dev->parent == NULL)
 4301                 return (EINVAL);
 4302         return (BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r));
 4303 }
 4304 
 4305 /**
 4306  * @brief Wrapper function for BUS_SETUP_INTR().
 4307  *
 4308  * This function simply calls the BUS_SETUP_INTR() method of the
 4309  * parent of @p dev.
 4310  */
 4311 int
 4312 bus_setup_intr(device_t dev, struct resource *r, int flags,
 4313     driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep)
 4314 {
 4315         int error;
 4316 
 4317         if (dev->parent == NULL)
 4318                 return (EINVAL);
 4319         error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler,
 4320             arg, cookiep);
 4321         if (error != 0)
 4322                 return (error);
 4323         if (handler != NULL && !(flags & INTR_MPSAFE))
 4324                 device_printf(dev, "[GIANT-LOCKED]\n");
 4325         return (0);
 4326 }
 4327 
 4328 /**
 4329  * @brief Wrapper function for BUS_TEARDOWN_INTR().
 4330  *
 4331  * This function simply calls the BUS_TEARDOWN_INTR() method of the
 4332  * parent of @p dev.
 4333  */
 4334 int
 4335 bus_teardown_intr(device_t dev, struct resource *r, void *cookie)
 4336 {
 4337         if (dev->parent == NULL)
 4338                 return (EINVAL);
 4339         return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie));
 4340 }
 4341 
 4342 /**
 4343  * @brief Wrapper function for BUS_BIND_INTR().
 4344  *
 4345  * This function simply calls the BUS_BIND_INTR() method of the
 4346  * parent of @p dev.
 4347  */
 4348 int
 4349 bus_bind_intr(device_t dev, struct resource *r, int cpu)
 4350 {
 4351         if (dev->parent == NULL)
 4352                 return (EINVAL);
 4353         return (BUS_BIND_INTR(dev->parent, dev, r, cpu));
 4354 }
 4355 
 4356 /**
 4357  * @brief Wrapper function for BUS_DESCRIBE_INTR().
 4358  *
 4359  * This function first formats the requested description into a
 4360  * temporary buffer and then calls the BUS_DESCRIBE_INTR() method of
 4361  * the parent of @p dev.
 4362  */
 4363 int
 4364 bus_describe_intr(device_t dev, struct resource *irq, void *cookie,
 4365     const char *fmt, ...)
 4366 {
 4367         va_list ap;
 4368         char descr[MAXCOMLEN + 1];
 4369 
 4370         if (dev->parent == NULL)
 4371                 return (EINVAL);
 4372         va_start(ap, fmt);
 4373         vsnprintf(descr, sizeof(descr), fmt, ap);
 4374         va_end(ap);
 4375         return (BUS_DESCRIBE_INTR(dev->parent, dev, irq, cookie, descr));
 4376 }
 4377 
 4378 /**
 4379  * @brief Wrapper function for BUS_SET_RESOURCE().
 4380  *
 4381  * This function simply calls the BUS_SET_RESOURCE() method of the
 4382  * parent of @p dev.
 4383  */
 4384 int
 4385 bus_set_resource(device_t dev, int type, int rid,
 4386     u_long start, u_long count)
 4387 {
 4388         return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4389             start, count));
 4390 }
 4391 
 4392 /**
 4393  * @brief Wrapper function for BUS_GET_RESOURCE().
 4394  *
 4395  * This function simply calls the BUS_GET_RESOURCE() method of the
 4396  * parent of @p dev.
 4397  */
 4398 int
 4399 bus_get_resource(device_t dev, int type, int rid,
 4400     u_long *startp, u_long *countp)
 4401 {
 4402         return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4403             startp, countp));
 4404 }
 4405 
 4406 /**
 4407  * @brief Wrapper function for BUS_GET_RESOURCE().
 4408  *
 4409  * This function simply calls the BUS_GET_RESOURCE() method of the
 4410  * parent of @p dev and returns the start value.
 4411  */
 4412 u_long
 4413 bus_get_resource_start(device_t dev, int type, int rid)
 4414 {
 4415         u_long start, count;
 4416         int error;
 4417 
 4418         error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4419             &start, &count);
 4420         if (error)
 4421                 return (0);
 4422         return (start);
 4423 }
 4424 
 4425 /**
 4426  * @brief Wrapper function for BUS_GET_RESOURCE().
 4427  *
 4428  * This function simply calls the BUS_GET_RESOURCE() method of the
 4429  * parent of @p dev and returns the count value.
 4430  */
 4431 u_long
 4432 bus_get_resource_count(device_t dev, int type, int rid)
 4433 {
 4434         u_long start, count;
 4435         int error;
 4436 
 4437         error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4438             &start, &count);
 4439         if (error)
 4440                 return (0);
 4441         return (count);
 4442 }
 4443 
 4444 /**
 4445  * @brief Wrapper function for BUS_DELETE_RESOURCE().
 4446  *
 4447  * This function simply calls the BUS_DELETE_RESOURCE() method of the
 4448  * parent of @p dev.
 4449  */
 4450 void
 4451 bus_delete_resource(device_t dev, int type, int rid)
 4452 {
 4453         BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid);
 4454 }
 4455 
 4456 /**
 4457  * @brief Wrapper function for BUS_CHILD_PRESENT().
 4458  *
 4459  * This function simply calls the BUS_CHILD_PRESENT() method of the
 4460  * parent of @p dev.
 4461  */
 4462 int
 4463 bus_child_present(device_t child)
 4464 {
 4465         return (BUS_CHILD_PRESENT(device_get_parent(child), child));
 4466 }
 4467 
 4468 /**
 4469  * @brief Wrapper function for BUS_CHILD_PNPINFO_STR().
 4470  *
 4471  * This function simply calls the BUS_CHILD_PNPINFO_STR() method of the
 4472  * parent of @p dev.
 4473  */
 4474 int
 4475 bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen)
 4476 {
 4477         device_t parent;
 4478 
 4479         parent = device_get_parent(child);
 4480         if (parent == NULL) {
 4481                 *buf = '\0';
 4482                 return (0);
 4483         }
 4484         return (BUS_CHILD_PNPINFO_STR(parent, child, buf, buflen));
 4485 }
 4486 
 4487 /**
 4488  * @brief Wrapper function for BUS_CHILD_LOCATION_STR().
 4489  *
 4490  * This function simply calls the BUS_CHILD_LOCATION_STR() method of the
 4491  * parent of @p dev.
 4492  */
 4493 int
 4494 bus_child_location_str(device_t child, char *buf, size_t buflen)
 4495 {
 4496         device_t parent;
 4497 
 4498         parent = device_get_parent(child);
 4499         if (parent == NULL) {
 4500                 *buf = '\0';
 4501                 return (0);
 4502         }
 4503         return (BUS_CHILD_LOCATION_STR(parent, child, buf, buflen));
 4504 }
 4505 
 4506 /**
 4507  * @brief Wrapper function for BUS_GET_DMA_TAG().
 4508  *
 4509  * This function simply calls the BUS_GET_DMA_TAG() method of the
 4510  * parent of @p dev.
 4511  */
 4512 bus_dma_tag_t
 4513 bus_get_dma_tag(device_t dev)
 4514 {
 4515         device_t parent;
 4516 
 4517         parent = device_get_parent(dev);
 4518         if (parent == NULL)
 4519                 return (NULL);
 4520         return (BUS_GET_DMA_TAG(parent, dev));
 4521 }
 4522 
 4523 /**
 4524  * @brief Wrapper function for BUS_GET_DOMAIN().
 4525  *
 4526  * This function simply calls the BUS_GET_DOMAIN() method of the
 4527  * parent of @p dev.
 4528  */
 4529 int
 4530 bus_get_domain(device_t dev, int *domain)
 4531 {
 4532         return (BUS_GET_DOMAIN(device_get_parent(dev), dev, domain));
 4533 }
 4534 
 4535 /* Resume all devices and then notify userland that we're up again. */
 4536 static int
 4537 root_resume(device_t dev)
 4538 {
 4539         int error;
 4540 
 4541         error = bus_generic_resume(dev);
 4542         if (error == 0)
 4543                 devctl_notify("kern", "power", "resume", NULL);
 4544         return (error);
 4545 }
 4546 
 4547 static int
 4548 root_print_child(device_t dev, device_t child)
 4549 {
 4550         int     retval = 0;
 4551 
 4552         retval += bus_print_child_header(dev, child);
 4553         retval += printf("\n");
 4554 
 4555         return (retval);
 4556 }
 4557 
 4558 static int
 4559 root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
 4560     driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)
 4561 {
 4562         /*
 4563          * If an interrupt mapping gets to here something bad has happened.
 4564          */
 4565         panic("root_setup_intr");
 4566 }
 4567 
 4568 /*
 4569  * If we get here, assume that the device is permanent and really is
 4570  * present in the system.  Removable bus drivers are expected to intercept
 4571  * this call long before it gets here.  We return -1 so that drivers that
 4572  * really care can check vs -1 or some ERRNO returned higher in the food
 4573  * chain.
 4574  */
 4575 static int
 4576 root_child_present(device_t dev, device_t child)
 4577 {
 4578         return (-1);
 4579 }
 4580 
 4581 static kobj_method_t root_methods[] = {
 4582         /* Device interface */
 4583         KOBJMETHOD(device_shutdown,     bus_generic_shutdown),
 4584         KOBJMETHOD(device_suspend,      bus_generic_suspend),
 4585         KOBJMETHOD(device_resume,       root_resume),
 4586 
 4587         /* Bus interface */
 4588         KOBJMETHOD(bus_print_child,     root_print_child),
 4589         KOBJMETHOD(bus_read_ivar,       bus_generic_read_ivar),
 4590         KOBJMETHOD(bus_write_ivar,      bus_generic_write_ivar),
 4591         KOBJMETHOD(bus_setup_intr,      root_setup_intr),
 4592         KOBJMETHOD(bus_child_present,   root_child_present),
 4593 
 4594         KOBJMETHOD_END
 4595 };
 4596 
 4597 static driver_t root_driver = {
 4598         "root",
 4599         root_methods,
 4600         1,                      /* no softc */
 4601 };
 4602 
 4603 device_t        root_bus;
 4604 devclass_t      root_devclass;
 4605 
 4606 static int
 4607 root_bus_module_handler(module_t mod, int what, void* arg)
 4608 {
 4609         switch (what) {
 4610         case MOD_LOAD:
 4611                 TAILQ_INIT(&bus_data_devices);
 4612                 kobj_class_compile((kobj_class_t) &root_driver);
 4613                 root_bus = make_device(NULL, "root", 0);
 4614                 root_bus->desc = "System root bus";
 4615                 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver);
 4616                 root_bus->driver = &root_driver;
 4617                 root_bus->state = DS_ATTACHED;
 4618                 root_devclass = devclass_find_internal("root", NULL, FALSE);
 4619                 devinit();
 4620                 return (0);
 4621 
 4622         case MOD_SHUTDOWN:
 4623                 device_shutdown(root_bus);
 4624                 return (0);
 4625         default:
 4626                 return (EOPNOTSUPP);
 4627         }
 4628 
 4629         return (0);
 4630 }
 4631 
 4632 static moduledata_t root_bus_mod = {
 4633         "rootbus",
 4634         root_bus_module_handler,
 4635         NULL
 4636 };
 4637 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
 4638 
 4639 /**
 4640  * @brief Automatically configure devices
 4641  *
 4642  * This function begins the autoconfiguration process by calling
 4643  * device_probe_and_attach() for each child of the @c root0 device.
 4644  */ 
 4645 void
 4646 root_bus_configure(void)
 4647 {
 4648 
 4649         PDEBUG(("."));
 4650 
 4651         /* Eventually this will be split up, but this is sufficient for now. */
 4652         bus_set_pass(BUS_PASS_DEFAULT);
 4653 }
 4654 
 4655 /**
 4656  * @brief Module handler for registering device drivers
 4657  *
 4658  * This module handler is used to automatically register device
 4659  * drivers when modules are loaded. If @p what is MOD_LOAD, it calls
 4660  * devclass_add_driver() for the driver described by the
 4661  * driver_module_data structure pointed to by @p arg
 4662  */
 4663 int
 4664 driver_module_handler(module_t mod, int what, void *arg)
 4665 {
 4666         struct driver_module_data *dmd;
 4667         devclass_t bus_devclass;
 4668         kobj_class_t driver;
 4669         int error, pass;
 4670 
 4671         dmd = (struct driver_module_data *)arg;
 4672         bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE);
 4673         error = 0;
 4674 
 4675         switch (what) {
 4676         case MOD_LOAD:
 4677                 if (dmd->dmd_chainevh)
 4678                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
 4679 
 4680                 pass = dmd->dmd_pass;
 4681                 driver = dmd->dmd_driver;
 4682                 PDEBUG(("Loading module: driver %s on bus %s (pass %d)",
 4683                     DRIVERNAME(driver), dmd->dmd_busname, pass));
 4684                 error = devclass_add_driver(bus_devclass, driver, pass,
 4685                     dmd->dmd_devclass);
 4686                 break;
 4687 
 4688         case MOD_UNLOAD:
 4689                 PDEBUG(("Unloading module: driver %s from bus %s",
 4690                     DRIVERNAME(dmd->dmd_driver),
 4691                     dmd->dmd_busname));
 4692                 error = devclass_delete_driver(bus_devclass,
 4693                     dmd->dmd_driver);
 4694 
 4695                 if (!error && dmd->dmd_chainevh)
 4696                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
 4697                 break;
 4698         case MOD_QUIESCE:
 4699                 PDEBUG(("Quiesce module: driver %s from bus %s",
 4700                     DRIVERNAME(dmd->dmd_driver),
 4701                     dmd->dmd_busname));
 4702                 error = devclass_quiesce_driver(bus_devclass,
 4703                     dmd->dmd_driver);
 4704 
 4705                 if (!error && dmd->dmd_chainevh)
 4706                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
 4707                 break;
 4708         default:
 4709                 error = EOPNOTSUPP;
 4710                 break;
 4711         }
 4712 
 4713         return (error);
 4714 }
 4715 
 4716 /**
 4717  * @brief Enumerate all hinted devices for this bus.
 4718  *
 4719  * Walks through the hints for this bus and calls the bus_hinted_child
 4720  * routine for each one it fines.  It searches first for the specific
 4721  * bus that's being probed for hinted children (eg isa0), and then for
 4722  * generic children (eg isa).
 4723  *
 4724  * @param       dev     bus device to enumerate
 4725  */
 4726 void
 4727 bus_enumerate_hinted_children(device_t bus)
 4728 {
 4729         int i;
 4730         const char *dname, *busname;
 4731         int dunit;
 4732 
 4733         /*
 4734          * enumerate all devices on the specific bus
 4735          */
 4736         busname = device_get_nameunit(bus);
 4737         i = 0;
 4738         while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0)
 4739                 BUS_HINTED_CHILD(bus, dname, dunit);
 4740 
 4741         /*
 4742          * and all the generic ones.
 4743          */
 4744         busname = device_get_name(bus);
 4745         i = 0;
 4746         while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0)
 4747                 BUS_HINTED_CHILD(bus, dname, dunit);
 4748 }
 4749 
 4750 #ifdef BUS_DEBUG
 4751 
 4752 /* the _short versions avoid iteration by not calling anything that prints
 4753  * more than oneliners. I love oneliners.
 4754  */
 4755 
 4756 static void
 4757 print_device_short(device_t dev, int indent)
 4758 {
 4759         if (!dev)
 4760                 return;
 4761 
 4762         indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s%s,%sivars,%ssoftc,busy=%d\n",
 4763             dev->unit, dev->desc,
 4764             (dev->parent? "":"no "),
 4765             (TAILQ_EMPTY(&dev->children)? "no ":""),
 4766             (dev->flags&DF_ENABLED? "enabled,":"disabled,"),
 4767             (dev->flags&DF_FIXEDCLASS? "fixed,":""),
 4768             (dev->flags&DF_WILDCARD? "wildcard,":""),
 4769             (dev->flags&DF_DESCMALLOCED? "descmalloced,":""),
 4770             (dev->flags&DF_REBID? "rebiddable,":""),
 4771             (dev->ivars? "":"no "),
 4772             (dev->softc? "":"no "),
 4773             dev->busy));
 4774 }
 4775 
 4776 static void
 4777 print_device(device_t dev, int indent)
 4778 {
 4779         if (!dev)
 4780                 return;
 4781 
 4782         print_device_short(dev, indent);
 4783 
 4784         indentprintf(("Parent:\n"));
 4785         print_device_short(dev->parent, indent+1);
 4786         indentprintf(("Driver:\n"));
 4787         print_driver_short(dev->driver, indent+1);
 4788         indentprintf(("Devclass:\n"));
 4789         print_devclass_short(dev->devclass, indent+1);
 4790 }
 4791 
 4792 void
 4793 print_device_tree_short(device_t dev, int indent)
 4794 /* print the device and all its children (indented) */
 4795 {
 4796         device_t child;
 4797 
 4798         if (!dev)
 4799                 return;
 4800 
 4801         print_device_short(dev, indent);
 4802 
 4803         TAILQ_FOREACH(child, &dev->children, link) {
 4804                 print_device_tree_short(child, indent+1);
 4805         }
 4806 }
 4807 
 4808 void
 4809 print_device_tree(device_t dev, int indent)
 4810 /* print the device and all its children (indented) */
 4811 {
 4812         device_t child;
 4813 
 4814         if (!dev)
 4815                 return;
 4816 
 4817         print_device(dev, indent);
 4818 
 4819         TAILQ_FOREACH(child, &dev->children, link) {
 4820                 print_device_tree(child, indent+1);
 4821         }
 4822 }
 4823 
 4824 static void
 4825 print_driver_short(driver_t *driver, int indent)
 4826 {
 4827         if (!driver)
 4828                 return;
 4829 
 4830         indentprintf(("driver %s: softc size = %zd\n",
 4831             driver->name, driver->size));
 4832 }
 4833 
 4834 static void
 4835 print_driver(driver_t *driver, int indent)
 4836 {
 4837         if (!driver)
 4838                 return;
 4839 
 4840         print_driver_short(driver, indent);
 4841 }
 4842 
 4843 static void
 4844 print_driver_list(driver_list_t drivers, int indent)
 4845 {
 4846         driverlink_t driver;
 4847 
 4848         TAILQ_FOREACH(driver, &drivers, link) {
 4849                 print_driver(driver->driver, indent);
 4850         }
 4851 }
 4852 
 4853 static void
 4854 print_devclass_short(devclass_t dc, int indent)
 4855 {
 4856         if ( !dc )
 4857                 return;
 4858 
 4859         indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit));
 4860 }
 4861 
 4862 static void
 4863 print_devclass(devclass_t dc, int indent)
 4864 {
 4865         int i;
 4866 
 4867         if ( !dc )
 4868                 return;
 4869 
 4870         print_devclass_short(dc, indent);
 4871         indentprintf(("Drivers:\n"));
 4872         print_driver_list(dc->drivers, indent+1);
 4873 
 4874         indentprintf(("Devices:\n"));
 4875         for (i = 0; i < dc->maxunit; i++)
 4876                 if (dc->devices[i])
 4877                         print_device(dc->devices[i], indent+1);
 4878 }
 4879 
 4880 void
 4881 print_devclass_list_short(void)
 4882 {
 4883         devclass_t dc;
 4884 
 4885         printf("Short listing of devclasses, drivers & devices:\n");
 4886         TAILQ_FOREACH(dc, &devclasses, link) {
 4887                 print_devclass_short(dc, 0);
 4888         }
 4889 }
 4890 
 4891 void
 4892 print_devclass_list(void)
 4893 {
 4894         devclass_t dc;
 4895 
 4896         printf("Full listing of devclasses, drivers & devices:\n");
 4897         TAILQ_FOREACH(dc, &devclasses, link) {
 4898                 print_devclass(dc, 0);
 4899         }
 4900 }
 4901 
 4902 #endif
 4903 
 4904 /*
 4905  * User-space access to the device tree.
 4906  *
 4907  * We implement a small set of nodes:
 4908  *
 4909  * hw.bus                       Single integer read method to obtain the
 4910  *                              current generation count.
 4911  * hw.bus.devices               Reads the entire device tree in flat space.
 4912  * hw.bus.rman                  Resource manager interface
 4913  *
 4914  * We might like to add the ability to scan devclasses and/or drivers to
 4915  * determine what else is currently loaded/available.
 4916  */
 4917 
 4918 static int
 4919 sysctl_bus(SYSCTL_HANDLER_ARGS)
 4920 {
 4921         struct u_businfo        ubus;
 4922 
 4923         ubus.ub_version = BUS_USER_VERSION;
 4924         ubus.ub_generation = bus_data_generation;
 4925 
 4926         return (SYSCTL_OUT(req, &ubus, sizeof(ubus)));
 4927 }
 4928 SYSCTL_NODE(_hw_bus, OID_AUTO, info, CTLFLAG_RW, sysctl_bus,
 4929     "bus-related data");
 4930 
 4931 static int
 4932 sysctl_devices(SYSCTL_HANDLER_ARGS)
 4933 {
 4934         int                     *name = (int *)arg1;
 4935         u_int                   namelen = arg2;
 4936         int                     index;
 4937         struct device           *dev;
 4938         struct u_device         udev;   /* XXX this is a bit big */
 4939         int                     error;
 4940 
 4941         if (namelen != 2)
 4942                 return (EINVAL);
 4943 
 4944         if (bus_data_generation_check(name[0]))
 4945                 return (EINVAL);
 4946 
 4947         index = name[1];
 4948 
 4949         /*
 4950          * Scan the list of devices, looking for the requested index.
 4951          */
 4952         TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
 4953                 if (index-- == 0)
 4954                         break;
 4955         }
 4956         if (dev == NULL)
 4957                 return (ENOENT);
 4958 
 4959         /*
 4960          * Populate the return array.
 4961          */
 4962         bzero(&udev, sizeof(udev));
 4963         udev.dv_handle = (uintptr_t)dev;
 4964         udev.dv_parent = (uintptr_t)dev->parent;
 4965         if (dev->nameunit != NULL)
 4966                 strlcpy(udev.dv_name, dev->nameunit, sizeof(udev.dv_name));
 4967         if (dev->desc != NULL)
 4968                 strlcpy(udev.dv_desc, dev->desc, sizeof(udev.dv_desc));
 4969         if (dev->driver != NULL && dev->driver->name != NULL)
 4970                 strlcpy(udev.dv_drivername, dev->driver->name,
 4971                     sizeof(udev.dv_drivername));
 4972         bus_child_pnpinfo_str(dev, udev.dv_pnpinfo, sizeof(udev.dv_pnpinfo));
 4973         bus_child_location_str(dev, udev.dv_location, sizeof(udev.dv_location));
 4974         udev.dv_devflags = dev->devflags;
 4975         udev.dv_flags = dev->flags;
 4976         udev.dv_state = dev->state;
 4977         error = SYSCTL_OUT(req, &udev, sizeof(udev));
 4978         return (error);
 4979 }
 4980 
 4981 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, CTLFLAG_RD, sysctl_devices,
 4982     "system device tree");
 4983 
 4984 int
 4985 bus_data_generation_check(int generation)
 4986 {
 4987         if (generation != bus_data_generation)
 4988                 return (1);
 4989 
 4990         /* XXX generate optimised lists here? */
 4991         return (0);
 4992 }
 4993 
 4994 void
 4995 bus_data_generation_update(void)
 4996 {
 4997         bus_data_generation++;
 4998 }
 4999 
 5000 int
 5001 bus_free_resource(device_t dev, int type, struct resource *r)
 5002 {
 5003         if (r == NULL)
 5004                 return (0);
 5005         return (bus_release_resource(dev, type, rman_get_rid(r), r));
 5006 }
 5007 
 5008 device_t
 5009 device_lookup_by_name(const char *name)
 5010 {
 5011         device_t dev;
 5012 
 5013         TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
 5014                 if (dev->nameunit != NULL && strcmp(dev->nameunit, name) == 0)
 5015                         return (dev);
 5016         }
 5017         return (NULL);
 5018 }
 5019 
 5020 /*
 5021  * /dev/devctl2 implementation.  The existing /dev/devctl device has
 5022  * implicit semantics on open, so it could not be reused for this.
 5023  * Another option would be to call this /dev/bus?
 5024  */
 5025 static int
 5026 find_device(struct devreq *req, device_t *devp)
 5027 {
 5028         device_t dev;
 5029 
 5030         /*
 5031          * First, ensure that the name is nul terminated.
 5032          */
 5033         if (memchr(req->dr_name, '\0', sizeof(req->dr_name)) == NULL)
 5034                 return (EINVAL);
 5035 
 5036         /*
 5037          * Second, try to find an attached device whose name matches
 5038          * 'name'.
 5039          */
 5040         dev = device_lookup_by_name(req->dr_name);
 5041         if (dev != NULL) {
 5042                 *devp = dev;
 5043                 return (0);
 5044         }
 5045 
 5046         /* Finally, give device enumerators a chance. */
 5047         dev = NULL;
 5048         EVENTHANDLER_INVOKE(dev_lookup, req->dr_name, &dev);
 5049         if (dev == NULL)
 5050                 return (ENOENT);
 5051         *devp = dev;
 5052         return (0);
 5053 }
 5054 
 5055 static bool
 5056 driver_exists(struct device *bus, const char *driver)
 5057 {
 5058         devclass_t dc;
 5059 
 5060         for (dc = bus->devclass; dc != NULL; dc = dc->parent) {
 5061                 if (devclass_find_driver_internal(dc, driver) != NULL)
 5062                         return (true);
 5063         }
 5064         return (false);
 5065 }
 5066 
 5067 static int
 5068 devctl2_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag,
 5069     struct thread *td)
 5070 {
 5071         struct devreq *req;
 5072         device_t dev;
 5073         int error, old;
 5074 
 5075         /* Locate the device to control. */
 5076         mtx_lock(&Giant);
 5077         req = (struct devreq *)data;
 5078         switch (cmd) {
 5079         case DEV_ATTACH:
 5080         case DEV_DETACH:
 5081         case DEV_ENABLE:
 5082         case DEV_DISABLE:
 5083         case DEV_SET_DRIVER:
 5084         case DEV_CLEAR_DRIVER:
 5085                 error = priv_check(td, PRIV_DRIVER);
 5086                 if (error == 0)
 5087                         error = find_device(req, &dev);
 5088                 break;
 5089         default:
 5090                 error = ENOTTY;
 5091                 break;
 5092         }
 5093         if (error) {
 5094                 mtx_unlock(&Giant);
 5095                 return (error);
 5096         }
 5097 
 5098         /* Perform the requested operation. */
 5099         switch (cmd) {
 5100         case DEV_ATTACH:
 5101                 if (device_is_attached(dev) && (dev->flags & DF_REBID) == 0)
 5102                         error = EBUSY;
 5103                 else if (!device_is_enabled(dev))
 5104                         error = ENXIO;
 5105                 else
 5106                         error = device_probe_and_attach(dev);
 5107                 break;
 5108         case DEV_DETACH:
 5109                 if (!device_is_attached(dev)) {
 5110                         error = ENXIO;
 5111                         break;
 5112                 }
 5113                 if (!(req->dr_flags & DEVF_FORCE_DETACH)) {
 5114                         error = device_quiesce(dev);
 5115                         if (error)
 5116                                 break;
 5117                 }
 5118                 error = device_detach(dev);
 5119                 break;
 5120         case DEV_ENABLE:
 5121                 if (device_is_enabled(dev)) {
 5122                         error = EBUSY;
 5123                         break;
 5124                 }
 5125 
 5126                 /*
 5127                  * If the device has been probed but not attached (e.g.
 5128                  * when it has been disabled by a loader hint), just
 5129                  * attach the device rather than doing a full probe.
 5130                  */
 5131                 device_enable(dev);
 5132                 if (device_is_alive(dev)) {
 5133                         /*
 5134                          * If the device was disabled via a hint, clear
 5135                          * the hint.
 5136                          */
 5137                         if (resource_disabled(dev->driver->name, dev->unit))
 5138                                 resource_unset_value(dev->driver->name,
 5139                                     dev->unit, "disabled");
 5140                         error = device_attach(dev);
 5141                 } else
 5142                         error = device_probe_and_attach(dev);
 5143                 break;
 5144         case DEV_DISABLE:
 5145                 if (!device_is_enabled(dev)) {
 5146                         error = ENXIO;
 5147                         break;
 5148                 }
 5149 
 5150                 if (!(req->dr_flags & DEVF_FORCE_DETACH)) {
 5151                         error = device_quiesce(dev);
 5152                         if (error)
 5153                                 break;
 5154                 }
 5155 
 5156                 /*
 5157                  * Force DF_FIXEDCLASS on around detach to preserve
 5158                  * the existing name.
 5159                  */
 5160                 old = dev->flags;
 5161                 dev->flags |= DF_FIXEDCLASS;
 5162                 error = device_detach(dev);
 5163                 if (!(old & DF_FIXEDCLASS))
 5164                         dev->flags &= ~DF_FIXEDCLASS;
 5165                 if (error == 0)
 5166                         device_disable(dev);
 5167                 break;
 5168         case DEV_SET_DRIVER: {
 5169                 devclass_t dc;
 5170                 char driver[128];
 5171 
 5172                 error = copyinstr(req->dr_data, driver, sizeof(driver), NULL);
 5173                 if (error)
 5174                         break;
 5175                 if (driver[0] == '\0') {
 5176                         error = EINVAL;
 5177                         break;
 5178                 }
 5179                 if (dev->devclass != NULL &&
 5180                     strcmp(driver, dev->devclass->name) == 0)
 5181                         /* XXX: Could possibly force DF_FIXEDCLASS on? */
 5182                         break;
 5183 
 5184                 /*
 5185                  * Scan drivers for this device's bus looking for at
 5186                  * least one matching driver.
 5187                  */
 5188                 if (dev->parent == NULL) {
 5189                         error = EINVAL;
 5190                         break;
 5191                 }
 5192                 if (!driver_exists(dev->parent, driver)) {
 5193                         error = ENOENT;
 5194                         break;
 5195                 }
 5196                 dc = devclass_create(driver);
 5197                 if (dc == NULL) {
 5198                         error = ENOMEM;
 5199                         break;
 5200                 }
 5201 
 5202                 /* Detach device if necessary. */
 5203                 if (device_is_attached(dev)) {
 5204                         if (req->dr_flags & DEVF_SET_DRIVER_DETACH)
 5205                                 error = device_detach(dev);
 5206                         else
 5207                                 error = EBUSY;
 5208                         if (error)
 5209                                 break;
 5210                 }
 5211 
 5212                 /* Clear any previously-fixed device class and unit. */
 5213                 if (dev->flags & DF_FIXEDCLASS)
 5214                         devclass_delete_device(dev->devclass, dev);
 5215                 dev->flags |= DF_WILDCARD;
 5216                 dev->unit = -1;
 5217 
 5218                 /* Force the new device class. */
 5219                 error = devclass_add_device(dc, dev);
 5220                 if (error)
 5221                         break;
 5222                 dev->flags |= DF_FIXEDCLASS;
 5223                 error = device_probe_and_attach(dev);
 5224                 break;
 5225         }
 5226         case DEV_CLEAR_DRIVER:
 5227                 if (!(dev->flags & DF_FIXEDCLASS)) {
 5228                         error = 0;
 5229                         break;
 5230                 }
 5231                 if (device_is_attached(dev)) {
 5232                         if (req->dr_flags & DEVF_CLEAR_DRIVER_DETACH)
 5233                                 error = device_detach(dev);
 5234                         else
 5235                                 error = EBUSY;
 5236                         if (error)
 5237                                 break;
 5238                 }
 5239 
 5240                 dev->flags &= ~DF_FIXEDCLASS;
 5241                 dev->flags |= DF_WILDCARD;
 5242                 devclass_delete_device(dev->devclass, dev);
 5243                 error = device_probe_and_attach(dev);
 5244                 break;
 5245         }
 5246         mtx_unlock(&Giant);
 5247         return (error);
 5248 }
 5249 
 5250 static struct cdevsw devctl2_cdevsw = {
 5251         .d_version =    D_VERSION,
 5252         .d_ioctl =      devctl2_ioctl,
 5253         .d_name =       "devctl2",
 5254 };
 5255 
 5256 static void
 5257 devctl2_init(void)
 5258 {
 5259 
 5260         make_dev_credf(MAKEDEV_ETERNAL, &devctl2_cdevsw, 0, NULL,
 5261             UID_ROOT, GID_WHEEL, 0600, "devctl2");
 5262 }

Cache object: 9857cb1c020ea1eaa1ce4945a5dbfca3


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