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