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