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

Cache object: c7b2dc79edf007c54aa1cf50d749098a


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