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