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