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