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