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

Cache object: 6298871027e86d4feff1ff280ac15018


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