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-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 4d921c7b7b1b27d98e56258378b9d0ba


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