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