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