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), MINALLOCSIZE / sizeof(device_t)); 1690 newlist = malloc(sizeof(device_t) * newsize, M_BUS, M_NOWAIT); 1691 if (!newlist) 1692 return (ENOMEM); 1693 if (oldlist != NULL) 1694 bcopy(oldlist, newlist, sizeof(device_t) * dc->maxunit); 1695 bzero(newlist + dc->maxunit, 1696 sizeof(device_t) * (newsize - dc->maxunit)); 1697 dc->devices = newlist; 1698 dc->maxunit = newsize; 1699 if (oldlist != NULL) 1700 free(oldlist, M_BUS); 1701 } 1702 PDEBUG(("now: unit %d in devclass %s", unit, DEVCLANAME(dc))); 1703 1704 *unitp = unit; 1705 return (0); 1706 } 1707 1708 /** 1709 * @internal 1710 * @brief Add a device to a devclass 1711 * 1712 * A unit number is allocated for the device (using the device's 1713 * preferred unit number if any) and the device is registered in the 1714 * devclass. This allows the device to be looked up by its unit 1715 * number, e.g. by decoding a dev_t minor number. 1716 * 1717 * @param dc the devclass to add to 1718 * @param dev the device to add 1719 * 1720 * @retval 0 success 1721 * @retval EEXIST the requested unit number is already allocated 1722 * @retval ENOMEM memory allocation failure 1723 */ 1724 static int 1725 devclass_add_device(devclass_t dc, device_t dev) 1726 { 1727 int buflen, error; 1728 1729 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc))); 1730 1731 buflen = snprintf(NULL, 0, "%s%d$", dc->name, INT_MAX); 1732 if (buflen < 0) 1733 return (ENOMEM); 1734 dev->nameunit = malloc(buflen, M_BUS, M_NOWAIT|M_ZERO); 1735 if (!dev->nameunit) 1736 return (ENOMEM); 1737 1738 if ((error = devclass_alloc_unit(dc, dev, &dev->unit)) != 0) { 1739 free(dev->nameunit, M_BUS); 1740 dev->nameunit = NULL; 1741 return (error); 1742 } 1743 dc->devices[dev->unit] = dev; 1744 dev->devclass = dc; 1745 snprintf(dev->nameunit, buflen, "%s%d", dc->name, dev->unit); 1746 1747 return (0); 1748 } 1749 1750 /** 1751 * @internal 1752 * @brief Delete a device from a devclass 1753 * 1754 * The device is removed from the devclass's device list and its unit 1755 * number is freed. 1756 1757 * @param dc the devclass to delete from 1758 * @param dev the device to delete 1759 * 1760 * @retval 0 success 1761 */ 1762 static int 1763 devclass_delete_device(devclass_t dc, device_t dev) 1764 { 1765 if (!dc || !dev) 1766 return (0); 1767 1768 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc))); 1769 1770 if (dev->devclass != dc || dc->devices[dev->unit] != dev) 1771 panic("devclass_delete_device: inconsistent device class"); 1772 dc->devices[dev->unit] = NULL; 1773 if (dev->flags & DF_WILDCARD) 1774 dev->unit = -1; 1775 dev->devclass = NULL; 1776 free(dev->nameunit, M_BUS); 1777 dev->nameunit = NULL; 1778 1779 return (0); 1780 } 1781 1782 /** 1783 * @internal 1784 * @brief Make a new device and add it as a child of @p parent 1785 * 1786 * @param parent the parent of the new device 1787 * @param name the devclass name of the new device or @c NULL 1788 * to leave the devclass unspecified 1789 * @parem unit the unit number of the new device of @c -1 to 1790 * leave the unit number unspecified 1791 * 1792 * @returns the new device 1793 */ 1794 static device_t 1795 make_device(device_t parent, const char *name, int unit) 1796 { 1797 device_t dev; 1798 devclass_t dc; 1799 1800 PDEBUG(("%s at %s as unit %d", name, DEVICENAME(parent), unit)); 1801 1802 if (name) { 1803 dc = devclass_find_internal(name, NULL, TRUE); 1804 if (!dc) { 1805 printf("make_device: can't find device class %s\n", 1806 name); 1807 return (NULL); 1808 } 1809 } else { 1810 dc = NULL; 1811 } 1812 1813 dev = malloc(sizeof(*dev), M_BUS, M_NOWAIT|M_ZERO); 1814 if (!dev) 1815 return (NULL); 1816 1817 dev->parent = parent; 1818 TAILQ_INIT(&dev->children); 1819 kobj_init((kobj_t) dev, &null_class); 1820 dev->driver = NULL; 1821 dev->devclass = NULL; 1822 dev->unit = unit; 1823 dev->nameunit = NULL; 1824 dev->desc = NULL; 1825 dev->busy = 0; 1826 dev->devflags = 0; 1827 dev->flags = DF_ENABLED; 1828 dev->order = 0; 1829 if (unit == -1) 1830 dev->flags |= DF_WILDCARD; 1831 if (name) { 1832 dev->flags |= DF_FIXEDCLASS; 1833 if (devclass_add_device(dc, dev)) { 1834 kobj_delete((kobj_t) dev, M_BUS); 1835 return (NULL); 1836 } 1837 } 1838 if (parent != NULL && device_has_quiet_children(parent)) 1839 dev->flags |= DF_QUIET | DF_QUIET_CHILDREN; 1840 dev->ivars = NULL; 1841 dev->softc = NULL; 1842 1843 dev->state = DS_NOTPRESENT; 1844 1845 TAILQ_INSERT_TAIL(&bus_data_devices, dev, devlink); 1846 bus_data_generation_update(); 1847 1848 return (dev); 1849 } 1850 1851 /** 1852 * @internal 1853 * @brief Print a description of a device. 1854 */ 1855 static int 1856 device_print_child(device_t dev, device_t child) 1857 { 1858 int retval = 0; 1859 1860 if (device_is_alive(child)) 1861 retval += BUS_PRINT_CHILD(dev, child); 1862 else 1863 retval += device_printf(child, " not found\n"); 1864 1865 return (retval); 1866 } 1867 1868 /** 1869 * @brief Create a new device 1870 * 1871 * This creates a new device and adds it as a child of an existing 1872 * parent device. The new device will be added after the last existing 1873 * child with order zero. 1874 * 1875 * @param dev the device which will be the parent of the 1876 * new child device 1877 * @param name devclass name for new device or @c NULL if not 1878 * specified 1879 * @param unit unit number for new device or @c -1 if not 1880 * specified 1881 * 1882 * @returns the new device 1883 */ 1884 device_t 1885 device_add_child(device_t dev, const char *name, int unit) 1886 { 1887 return (device_add_child_ordered(dev, 0, name, unit)); 1888 } 1889 1890 /** 1891 * @brief Create a new device 1892 * 1893 * This creates a new device and adds it as a child of an existing 1894 * parent device. The new device will be added after the last existing 1895 * child with the same order. 1896 * 1897 * @param dev the device which will be the parent of the 1898 * new child device 1899 * @param order a value which is used to partially sort the 1900 * children of @p dev - devices created using 1901 * lower values of @p order appear first in @p 1902 * dev's list of children 1903 * @param name devclass name for new device or @c NULL if not 1904 * specified 1905 * @param unit unit number for new device or @c -1 if not 1906 * specified 1907 * 1908 * @returns the new device 1909 */ 1910 device_t 1911 device_add_child_ordered(device_t dev, u_int order, const char *name, int unit) 1912 { 1913 device_t child; 1914 device_t place; 1915 1916 PDEBUG(("%s at %s with order %u as unit %d", 1917 name, DEVICENAME(dev), order, unit)); 1918 KASSERT(name != NULL || unit == -1, 1919 ("child device with wildcard name and specific unit number")); 1920 1921 child = make_device(dev, name, unit); 1922 if (child == NULL) 1923 return (child); 1924 child->order = order; 1925 1926 TAILQ_FOREACH(place, &dev->children, link) { 1927 if (place->order > order) 1928 break; 1929 } 1930 1931 if (place) { 1932 /* 1933 * The device 'place' is the first device whose order is 1934 * greater than the new child. 1935 */ 1936 TAILQ_INSERT_BEFORE(place, child, link); 1937 } else { 1938 /* 1939 * The new child's order is greater or equal to the order of 1940 * any existing device. Add the child to the tail of the list. 1941 */ 1942 TAILQ_INSERT_TAIL(&dev->children, child, link); 1943 } 1944 1945 bus_data_generation_update(); 1946 return (child); 1947 } 1948 1949 /** 1950 * @brief Delete a device 1951 * 1952 * This function deletes a device along with all of its children. If 1953 * the device currently has a driver attached to it, the device is 1954 * detached first using device_detach(). 1955 * 1956 * @param dev the parent device 1957 * @param child the device to delete 1958 * 1959 * @retval 0 success 1960 * @retval non-zero a unit error code describing the error 1961 */ 1962 int 1963 device_delete_child(device_t dev, device_t child) 1964 { 1965 int error; 1966 device_t grandchild; 1967 1968 PDEBUG(("%s from %s", DEVICENAME(child), DEVICENAME(dev))); 1969 1970 /* detach parent before deleting children, if any */ 1971 if ((error = device_detach(child)) != 0) 1972 return (error); 1973 1974 /* remove children second */ 1975 while ((grandchild = TAILQ_FIRST(&child->children)) != NULL) { 1976 error = device_delete_child(child, grandchild); 1977 if (error) 1978 return (error); 1979 } 1980 1981 if (child->devclass) 1982 devclass_delete_device(child->devclass, child); 1983 if (child->parent) 1984 BUS_CHILD_DELETED(dev, child); 1985 TAILQ_REMOVE(&dev->children, child, link); 1986 TAILQ_REMOVE(&bus_data_devices, child, devlink); 1987 kobj_delete((kobj_t) child, M_BUS); 1988 1989 bus_data_generation_update(); 1990 return (0); 1991 } 1992 1993 /** 1994 * @brief Delete all children devices of the given device, if any. 1995 * 1996 * This function deletes all children devices of the given device, if 1997 * any, using the device_delete_child() function for each device it 1998 * finds. If a child device cannot be deleted, this function will 1999 * return an error code. 2000 * 2001 * @param dev the parent device 2002 * 2003 * @retval 0 success 2004 * @retval non-zero a device would not detach 2005 */ 2006 int 2007 device_delete_children(device_t dev) 2008 { 2009 device_t child; 2010 int error; 2011 2012 PDEBUG(("Deleting all children of %s", DEVICENAME(dev))); 2013 2014 error = 0; 2015 2016 while ((child = TAILQ_FIRST(&dev->children)) != NULL) { 2017 error = device_delete_child(dev, child); 2018 if (error) { 2019 PDEBUG(("Failed deleting %s", DEVICENAME(child))); 2020 break; 2021 } 2022 } 2023 return (error); 2024 } 2025 2026 /** 2027 * @brief Find a device given a unit number 2028 * 2029 * This is similar to devclass_get_devices() but only searches for 2030 * devices which have @p dev as a parent. 2031 * 2032 * @param dev the parent device to search 2033 * @param unit the unit number to search for. If the unit is -1, 2034 * return the first child of @p dev which has name 2035 * @p classname (that is, the one with the lowest unit.) 2036 * 2037 * @returns the device with the given unit number or @c 2038 * NULL if there is no such device 2039 */ 2040 device_t 2041 device_find_child(device_t dev, const char *classname, int unit) 2042 { 2043 devclass_t dc; 2044 device_t child; 2045 2046 dc = devclass_find(classname); 2047 if (!dc) 2048 return (NULL); 2049 2050 if (unit != -1) { 2051 child = devclass_get_device(dc, unit); 2052 if (child && child->parent == dev) 2053 return (child); 2054 } else { 2055 for (unit = 0; unit < devclass_get_maxunit(dc); unit++) { 2056 child = devclass_get_device(dc, unit); 2057 if (child && child->parent == dev) 2058 return (child); 2059 } 2060 } 2061 return (NULL); 2062 } 2063 2064 /** 2065 * @internal 2066 */ 2067 static driverlink_t 2068 first_matching_driver(devclass_t dc, device_t dev) 2069 { 2070 if (dev->devclass) 2071 return (devclass_find_driver_internal(dc, dev->devclass->name)); 2072 return (TAILQ_FIRST(&dc->drivers)); 2073 } 2074 2075 /** 2076 * @internal 2077 */ 2078 static driverlink_t 2079 next_matching_driver(devclass_t dc, device_t dev, driverlink_t last) 2080 { 2081 if (dev->devclass) { 2082 driverlink_t dl; 2083 for (dl = TAILQ_NEXT(last, link); dl; dl = TAILQ_NEXT(dl, link)) 2084 if (!strcmp(dev->devclass->name, dl->driver->name)) 2085 return (dl); 2086 return (NULL); 2087 } 2088 return (TAILQ_NEXT(last, link)); 2089 } 2090 2091 /** 2092 * @internal 2093 */ 2094 int 2095 device_probe_child(device_t dev, device_t child) 2096 { 2097 devclass_t dc; 2098 driverlink_t best = NULL; 2099 driverlink_t dl; 2100 int result, pri = 0; 2101 int hasclass = (child->devclass != NULL); 2102 2103 GIANT_REQUIRED; 2104 2105 dc = dev->devclass; 2106 if (!dc) 2107 panic("device_probe_child: parent device has no devclass"); 2108 2109 /* 2110 * If the state is already probed, then return. However, don't 2111 * return if we can rebid this object. 2112 */ 2113 if (child->state == DS_ALIVE && (child->flags & DF_REBID) == 0) 2114 return (0); 2115 2116 for (; dc; dc = dc->parent) { 2117 for (dl = first_matching_driver(dc, child); 2118 dl; 2119 dl = next_matching_driver(dc, child, dl)) { 2120 /* If this driver's pass is too high, then ignore it. */ 2121 if (dl->pass > bus_current_pass) 2122 continue; 2123 2124 PDEBUG(("Trying %s", DRIVERNAME(dl->driver))); 2125 result = device_set_driver(child, dl->driver); 2126 if (result == ENOMEM) 2127 return (result); 2128 else if (result != 0) 2129 continue; 2130 if (!hasclass) { 2131 if (device_set_devclass(child, 2132 dl->driver->name) != 0) { 2133 char const * devname = 2134 device_get_name(child); 2135 if (devname == NULL) 2136 devname = "(unknown)"; 2137 printf("driver bug: Unable to set " 2138 "devclass (class: %s " 2139 "devname: %s)\n", 2140 dl->driver->name, 2141 devname); 2142 (void)device_set_driver(child, NULL); 2143 continue; 2144 } 2145 } 2146 2147 /* Fetch any flags for the device before probing. */ 2148 resource_int_value(dl->driver->name, child->unit, 2149 "flags", &child->devflags); 2150 2151 result = DEVICE_PROBE(child); 2152 2153 /* Reset flags and devclass before the next probe. */ 2154 child->devflags = 0; 2155 if (!hasclass) 2156 (void)device_set_devclass(child, NULL); 2157 2158 /* 2159 * If the driver returns SUCCESS, there can be 2160 * no higher match for this device. 2161 */ 2162 if (result == 0) { 2163 best = dl; 2164 pri = 0; 2165 break; 2166 } 2167 2168 /* 2169 * Reset DF_QUIET in case this driver doesn't 2170 * end up as the best driver. 2171 */ 2172 device_verbose(child); 2173 2174 /* 2175 * Probes that return BUS_PROBE_NOWILDCARD or lower 2176 * only match on devices whose driver was explicitly 2177 * specified. 2178 */ 2179 if (result <= BUS_PROBE_NOWILDCARD && 2180 !(child->flags & DF_FIXEDCLASS)) { 2181 result = ENXIO; 2182 } 2183 2184 /* 2185 * The driver returned an error so it 2186 * certainly doesn't match. 2187 */ 2188 if (result > 0) { 2189 (void)device_set_driver(child, NULL); 2190 continue; 2191 } 2192 2193 /* 2194 * A priority lower than SUCCESS, remember the 2195 * best matching driver. Initialise the value 2196 * of pri for the first match. 2197 */ 2198 if (best == NULL || result > pri) { 2199 best = dl; 2200 pri = result; 2201 continue; 2202 } 2203 } 2204 /* 2205 * If we have an unambiguous match in this devclass, 2206 * don't look in the parent. 2207 */ 2208 if (best && pri == 0) 2209 break; 2210 } 2211 2212 /* 2213 * If we found a driver, change state and initialise the devclass. 2214 */ 2215 /* XXX What happens if we rebid and got no best? */ 2216 if (best) { 2217 /* 2218 * If this device was attached, and we were asked to 2219 * rescan, and it is a different driver, then we have 2220 * to detach the old driver and reattach this new one. 2221 * Note, we don't have to check for DF_REBID here 2222 * because if the state is > DS_ALIVE, we know it must 2223 * be. 2224 * 2225 * This assumes that all DF_REBID drivers can have 2226 * their probe routine called at any time and that 2227 * they are idempotent as well as completely benign in 2228 * normal operations. 2229 * 2230 * We also have to make sure that the detach 2231 * succeeded, otherwise we fail the operation (or 2232 * maybe it should just fail silently? I'm torn). 2233 */ 2234 if (child->state > DS_ALIVE && best->driver != child->driver) 2235 if ((result = device_detach(dev)) != 0) 2236 return (result); 2237 2238 /* Set the winning driver, devclass, and flags. */ 2239 if (!child->devclass) { 2240 result = device_set_devclass(child, best->driver->name); 2241 if (result != 0) 2242 return (result); 2243 } 2244 result = device_set_driver(child, best->driver); 2245 if (result != 0) 2246 return (result); 2247 resource_int_value(best->driver->name, child->unit, 2248 "flags", &child->devflags); 2249 2250 if (pri < 0) { 2251 /* 2252 * A bit bogus. Call the probe method again to make 2253 * sure that we have the right description. 2254 */ 2255 DEVICE_PROBE(child); 2256 #if 0 2257 child->flags |= DF_REBID; 2258 #endif 2259 } else 2260 child->flags &= ~DF_REBID; 2261 child->state = DS_ALIVE; 2262 2263 bus_data_generation_update(); 2264 return (0); 2265 } 2266 2267 return (ENXIO); 2268 } 2269 2270 /** 2271 * @brief Return the parent of a device 2272 */ 2273 device_t 2274 device_get_parent(device_t dev) 2275 { 2276 return (dev->parent); 2277 } 2278 2279 /** 2280 * @brief Get a list of children of a device 2281 * 2282 * An array containing a list of all the children of the given device 2283 * is allocated and returned in @p *devlistp. The number of devices 2284 * in the array is returned in @p *devcountp. The caller should free 2285 * the array using @c free(p, M_TEMP). 2286 * 2287 * @param dev the device to examine 2288 * @param devlistp points at location for array pointer return 2289 * value 2290 * @param devcountp points at location for array size return value 2291 * 2292 * @retval 0 success 2293 * @retval ENOMEM the array allocation failed 2294 */ 2295 int 2296 device_get_children(device_t dev, device_t **devlistp, int *devcountp) 2297 { 2298 int count; 2299 device_t child; 2300 device_t *list; 2301 2302 count = 0; 2303 TAILQ_FOREACH(child, &dev->children, link) { 2304 count++; 2305 } 2306 if (count == 0) { 2307 *devlistp = NULL; 2308 *devcountp = 0; 2309 return (0); 2310 } 2311 2312 list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO); 2313 if (!list) 2314 return (ENOMEM); 2315 2316 count = 0; 2317 TAILQ_FOREACH(child, &dev->children, link) { 2318 list[count] = child; 2319 count++; 2320 } 2321 2322 *devlistp = list; 2323 *devcountp = count; 2324 2325 return (0); 2326 } 2327 2328 /** 2329 * @brief Return the current driver for the device or @c NULL if there 2330 * is no driver currently attached 2331 */ 2332 driver_t * 2333 device_get_driver(device_t dev) 2334 { 2335 return (dev->driver); 2336 } 2337 2338 /** 2339 * @brief Return the current devclass for the device or @c NULL if 2340 * there is none. 2341 */ 2342 devclass_t 2343 device_get_devclass(device_t dev) 2344 { 2345 return (dev->devclass); 2346 } 2347 2348 /** 2349 * @brief Return the name of the device's devclass or @c NULL if there 2350 * is none. 2351 */ 2352 const char * 2353 device_get_name(device_t dev) 2354 { 2355 if (dev != NULL && dev->devclass) 2356 return (devclass_get_name(dev->devclass)); 2357 return (NULL); 2358 } 2359 2360 /** 2361 * @brief Return a string containing the device's devclass name 2362 * followed by an ascii representation of the device's unit number 2363 * (e.g. @c "foo2"). 2364 */ 2365 const char * 2366 device_get_nameunit(device_t dev) 2367 { 2368 return (dev->nameunit); 2369 } 2370 2371 /** 2372 * @brief Return the device's unit number. 2373 */ 2374 int 2375 device_get_unit(device_t dev) 2376 { 2377 return (dev->unit); 2378 } 2379 2380 /** 2381 * @brief Return the device's description string 2382 */ 2383 const char * 2384 device_get_desc(device_t dev) 2385 { 2386 return (dev->desc); 2387 } 2388 2389 /** 2390 * @brief Return the device's flags 2391 */ 2392 uint32_t 2393 device_get_flags(device_t dev) 2394 { 2395 return (dev->devflags); 2396 } 2397 2398 struct sysctl_ctx_list * 2399 device_get_sysctl_ctx(device_t dev) 2400 { 2401 return (&dev->sysctl_ctx); 2402 } 2403 2404 struct sysctl_oid * 2405 device_get_sysctl_tree(device_t dev) 2406 { 2407 return (dev->sysctl_tree); 2408 } 2409 2410 /** 2411 * @brief Print the name of the device followed by a colon and a space 2412 * 2413 * @returns the number of characters printed 2414 */ 2415 int 2416 device_print_prettyname(device_t dev) 2417 { 2418 const char *name = device_get_name(dev); 2419 2420 if (name == NULL) 2421 return (printf("unknown: ")); 2422 return (printf("%s%d: ", name, device_get_unit(dev))); 2423 } 2424 2425 /** 2426 * @brief Print the name of the device followed by a colon, a space 2427 * and the result of calling vprintf() with the value of @p fmt and 2428 * the following arguments. 2429 * 2430 * @returns the number of characters printed 2431 */ 2432 int 2433 device_printf(device_t dev, const char * fmt, ...) 2434 { 2435 char buf[128]; 2436 struct sbuf sb; 2437 const char *name; 2438 va_list ap; 2439 size_t retval; 2440 2441 retval = 0; 2442 2443 sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN); 2444 sbuf_set_drain(&sb, sbuf_printf_drain, &retval); 2445 2446 name = device_get_name(dev); 2447 2448 if (name == NULL) 2449 sbuf_cat(&sb, "unknown: "); 2450 else 2451 sbuf_printf(&sb, "%s%d: ", name, device_get_unit(dev)); 2452 2453 va_start(ap, fmt); 2454 sbuf_vprintf(&sb, fmt, ap); 2455 va_end(ap); 2456 2457 sbuf_finish(&sb); 2458 sbuf_delete(&sb); 2459 2460 return (retval); 2461 } 2462 2463 /** 2464 * @internal 2465 */ 2466 static void 2467 device_set_desc_internal(device_t dev, const char* desc, int copy) 2468 { 2469 if (dev->desc && (dev->flags & DF_DESCMALLOCED)) { 2470 free(dev->desc, M_BUS); 2471 dev->flags &= ~DF_DESCMALLOCED; 2472 dev->desc = NULL; 2473 } 2474 2475 if (copy && desc) { 2476 dev->desc = malloc(strlen(desc) + 1, M_BUS, M_NOWAIT); 2477 if (dev->desc) { 2478 strcpy(dev->desc, desc); 2479 dev->flags |= DF_DESCMALLOCED; 2480 } 2481 } else { 2482 /* Avoid a -Wcast-qual warning */ 2483 dev->desc = (char *)(uintptr_t) desc; 2484 } 2485 2486 bus_data_generation_update(); 2487 } 2488 2489 /** 2490 * @brief Set the device's description 2491 * 2492 * The value of @c desc should be a string constant that will not 2493 * change (at least until the description is changed in a subsequent 2494 * call to device_set_desc() or device_set_desc_copy()). 2495 */ 2496 void 2497 device_set_desc(device_t dev, const char* desc) 2498 { 2499 device_set_desc_internal(dev, desc, FALSE); 2500 } 2501 2502 /** 2503 * @brief Set the device's description 2504 * 2505 * The string pointed to by @c desc is copied. Use this function if 2506 * the device description is generated, (e.g. with sprintf()). 2507 */ 2508 void 2509 device_set_desc_copy(device_t dev, const char* desc) 2510 { 2511 device_set_desc_internal(dev, desc, TRUE); 2512 } 2513 2514 /** 2515 * @brief Set the device's flags 2516 */ 2517 void 2518 device_set_flags(device_t dev, uint32_t flags) 2519 { 2520 dev->devflags = flags; 2521 } 2522 2523 /** 2524 * @brief Return the device's softc field 2525 * 2526 * The softc is allocated and zeroed when a driver is attached, based 2527 * on the size field of the driver. 2528 */ 2529 void * 2530 device_get_softc(device_t dev) 2531 { 2532 return (dev->softc); 2533 } 2534 2535 /** 2536 * @brief Set the device's softc field 2537 * 2538 * Most drivers do not need to use this since the softc is allocated 2539 * automatically when the driver is attached. 2540 */ 2541 void 2542 device_set_softc(device_t dev, void *softc) 2543 { 2544 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) 2545 free_domain(dev->softc, M_BUS_SC); 2546 dev->softc = softc; 2547 if (dev->softc) 2548 dev->flags |= DF_EXTERNALSOFTC; 2549 else 2550 dev->flags &= ~DF_EXTERNALSOFTC; 2551 } 2552 2553 /** 2554 * @brief Free claimed softc 2555 * 2556 * Most drivers do not need to use this since the softc is freed 2557 * automatically when the driver is detached. 2558 */ 2559 void 2560 device_free_softc(void *softc) 2561 { 2562 free_domain(softc, M_BUS_SC); 2563 } 2564 2565 /** 2566 * @brief Claim softc 2567 * 2568 * This function can be used to let the driver free the automatically 2569 * allocated softc using "device_free_softc()". This function is 2570 * useful when the driver is refcounting the softc and the softc 2571 * cannot be freed when the "device_detach" method is called. 2572 */ 2573 void 2574 device_claim_softc(device_t dev) 2575 { 2576 if (dev->softc) 2577 dev->flags |= DF_EXTERNALSOFTC; 2578 else 2579 dev->flags &= ~DF_EXTERNALSOFTC; 2580 } 2581 2582 /** 2583 * @brief Get the device's ivars field 2584 * 2585 * The ivars field is used by the parent device to store per-device 2586 * state (e.g. the physical location of the device or a list of 2587 * resources). 2588 */ 2589 void * 2590 device_get_ivars(device_t dev) 2591 { 2592 2593 KASSERT(dev != NULL, ("device_get_ivars(NULL, ...)")); 2594 return (dev->ivars); 2595 } 2596 2597 /** 2598 * @brief Set the device's ivars field 2599 */ 2600 void 2601 device_set_ivars(device_t dev, void * ivars) 2602 { 2603 2604 KASSERT(dev != NULL, ("device_set_ivars(NULL, ...)")); 2605 dev->ivars = ivars; 2606 } 2607 2608 /** 2609 * @brief Return the device's state 2610 */ 2611 device_state_t 2612 device_get_state(device_t dev) 2613 { 2614 return (dev->state); 2615 } 2616 2617 /** 2618 * @brief Set the DF_ENABLED flag for the device 2619 */ 2620 void 2621 device_enable(device_t dev) 2622 { 2623 dev->flags |= DF_ENABLED; 2624 } 2625 2626 /** 2627 * @brief Clear the DF_ENABLED flag for the device 2628 */ 2629 void 2630 device_disable(device_t dev) 2631 { 2632 dev->flags &= ~DF_ENABLED; 2633 } 2634 2635 /** 2636 * @brief Increment the busy counter for the device 2637 */ 2638 void 2639 device_busy(device_t dev) 2640 { 2641 if (dev->state < DS_ATTACHING) 2642 panic("device_busy: called for unattached device"); 2643 if (dev->busy == 0 && dev->parent) 2644 device_busy(dev->parent); 2645 dev->busy++; 2646 if (dev->state == DS_ATTACHED) 2647 dev->state = DS_BUSY; 2648 } 2649 2650 /** 2651 * @brief Decrement the busy counter for the device 2652 */ 2653 void 2654 device_unbusy(device_t dev) 2655 { 2656 if (dev->busy != 0 && dev->state != DS_BUSY && 2657 dev->state != DS_ATTACHING) 2658 panic("device_unbusy: called for non-busy device %s", 2659 device_get_nameunit(dev)); 2660 dev->busy--; 2661 if (dev->busy == 0) { 2662 if (dev->parent) 2663 device_unbusy(dev->parent); 2664 if (dev->state == DS_BUSY) 2665 dev->state = DS_ATTACHED; 2666 } 2667 } 2668 2669 /** 2670 * @brief Set the DF_QUIET flag for the device 2671 */ 2672 void 2673 device_quiet(device_t dev) 2674 { 2675 dev->flags |= DF_QUIET; 2676 } 2677 2678 /** 2679 * @brief Set the DF_QUIET_CHILDREN flag for the device 2680 */ 2681 void 2682 device_quiet_children(device_t dev) 2683 { 2684 dev->flags |= DF_QUIET_CHILDREN; 2685 } 2686 2687 /** 2688 * @brief Clear the DF_QUIET flag for the device 2689 */ 2690 void 2691 device_verbose(device_t dev) 2692 { 2693 dev->flags &= ~DF_QUIET; 2694 } 2695 2696 /** 2697 * @brief Return non-zero if the DF_QUIET_CHIDLREN flag is set on the device 2698 */ 2699 int 2700 device_has_quiet_children(device_t dev) 2701 { 2702 return ((dev->flags & DF_QUIET_CHILDREN) != 0); 2703 } 2704 2705 /** 2706 * @brief Return non-zero if the DF_QUIET flag is set on the device 2707 */ 2708 int 2709 device_is_quiet(device_t dev) 2710 { 2711 return ((dev->flags & DF_QUIET) != 0); 2712 } 2713 2714 /** 2715 * @brief Return non-zero if the DF_ENABLED flag is set on the device 2716 */ 2717 int 2718 device_is_enabled(device_t dev) 2719 { 2720 return ((dev->flags & DF_ENABLED) != 0); 2721 } 2722 2723 /** 2724 * @brief Return non-zero if the device was successfully probed 2725 */ 2726 int 2727 device_is_alive(device_t dev) 2728 { 2729 return (dev->state >= DS_ALIVE); 2730 } 2731 2732 /** 2733 * @brief Return non-zero if the device currently has a driver 2734 * attached to it 2735 */ 2736 int 2737 device_is_attached(device_t dev) 2738 { 2739 return (dev->state >= DS_ATTACHED); 2740 } 2741 2742 /** 2743 * @brief Return non-zero if the device is currently suspended. 2744 */ 2745 int 2746 device_is_suspended(device_t dev) 2747 { 2748 return ((dev->flags & DF_SUSPENDED) != 0); 2749 } 2750 2751 /** 2752 * @brief Set the devclass of a device 2753 * @see devclass_add_device(). 2754 */ 2755 int 2756 device_set_devclass(device_t dev, const char *classname) 2757 { 2758 devclass_t dc; 2759 int error; 2760 2761 if (!classname) { 2762 if (dev->devclass) 2763 devclass_delete_device(dev->devclass, dev); 2764 return (0); 2765 } 2766 2767 if (dev->devclass) { 2768 printf("device_set_devclass: device class already set\n"); 2769 return (EINVAL); 2770 } 2771 2772 dc = devclass_find_internal(classname, NULL, TRUE); 2773 if (!dc) 2774 return (ENOMEM); 2775 2776 error = devclass_add_device(dc, dev); 2777 2778 bus_data_generation_update(); 2779 return (error); 2780 } 2781 2782 /** 2783 * @brief Set the devclass of a device and mark the devclass fixed. 2784 * @see device_set_devclass() 2785 */ 2786 int 2787 device_set_devclass_fixed(device_t dev, const char *classname) 2788 { 2789 int error; 2790 2791 if (classname == NULL) 2792 return (EINVAL); 2793 2794 error = device_set_devclass(dev, classname); 2795 if (error) 2796 return (error); 2797 dev->flags |= DF_FIXEDCLASS; 2798 return (0); 2799 } 2800 2801 /** 2802 * @brief Query the device to determine if it's of a fixed devclass 2803 * @see device_set_devclass_fixed() 2804 */ 2805 bool 2806 device_is_devclass_fixed(device_t dev) 2807 { 2808 return ((dev->flags & DF_FIXEDCLASS) != 0); 2809 } 2810 2811 /** 2812 * @brief Set the driver of a device 2813 * 2814 * @retval 0 success 2815 * @retval EBUSY the device already has a driver attached 2816 * @retval ENOMEM a memory allocation failure occurred 2817 */ 2818 int 2819 device_set_driver(device_t dev, driver_t *driver) 2820 { 2821 int domain; 2822 struct domainset *policy; 2823 2824 if (dev->state >= DS_ATTACHED) 2825 return (EBUSY); 2826 2827 if (dev->driver == driver) 2828 return (0); 2829 2830 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) { 2831 free_domain(dev->softc, M_BUS_SC); 2832 dev->softc = NULL; 2833 } 2834 device_set_desc(dev, NULL); 2835 kobj_delete((kobj_t) dev, NULL); 2836 dev->driver = driver; 2837 if (driver) { 2838 kobj_init((kobj_t) dev, (kobj_class_t) driver); 2839 if (!(dev->flags & DF_EXTERNALSOFTC) && driver->size > 0) { 2840 if (bus_get_domain(dev, &domain) == 0) 2841 policy = DOMAINSET_PREF(domain); 2842 else 2843 policy = DOMAINSET_RR(); 2844 dev->softc = malloc_domainset(driver->size, M_BUS_SC, 2845 policy, M_NOWAIT | M_ZERO); 2846 if (!dev->softc) { 2847 kobj_delete((kobj_t) dev, NULL); 2848 kobj_init((kobj_t) dev, &null_class); 2849 dev->driver = NULL; 2850 return (ENOMEM); 2851 } 2852 } 2853 } else { 2854 kobj_init((kobj_t) dev, &null_class); 2855 } 2856 2857 bus_data_generation_update(); 2858 return (0); 2859 } 2860 2861 /** 2862 * @brief Probe a device, and return this status. 2863 * 2864 * This function is the core of the device autoconfiguration 2865 * system. Its purpose is to select a suitable driver for a device and 2866 * then call that driver to initialise the hardware appropriately. The 2867 * driver is selected by calling the DEVICE_PROBE() method of a set of 2868 * candidate drivers and then choosing the driver which returned the 2869 * best value. This driver is then attached to the device using 2870 * device_attach(). 2871 * 2872 * The set of suitable drivers is taken from the list of drivers in 2873 * the parent device's devclass. If the device was originally created 2874 * with a specific class name (see device_add_child()), only drivers 2875 * with that name are probed, otherwise all drivers in the devclass 2876 * are probed. If no drivers return successful probe values in the 2877 * parent devclass, the search continues in the parent of that 2878 * devclass (see devclass_get_parent()) if any. 2879 * 2880 * @param dev the device to initialise 2881 * 2882 * @retval 0 success 2883 * @retval ENXIO no driver was found 2884 * @retval ENOMEM memory allocation failure 2885 * @retval non-zero some other unix error code 2886 * @retval -1 Device already attached 2887 */ 2888 int 2889 device_probe(device_t dev) 2890 { 2891 int error; 2892 2893 GIANT_REQUIRED; 2894 2895 if (dev->state >= DS_ALIVE && (dev->flags & DF_REBID) == 0) 2896 return (-1); 2897 2898 if (!(dev->flags & DF_ENABLED)) { 2899 if (bootverbose && device_get_name(dev) != NULL) { 2900 device_print_prettyname(dev); 2901 printf("not probed (disabled)\n"); 2902 } 2903 return (-1); 2904 } 2905 if ((error = device_probe_child(dev->parent, dev)) != 0) { 2906 if (bus_current_pass == BUS_PASS_DEFAULT && 2907 !(dev->flags & DF_DONENOMATCH)) { 2908 BUS_PROBE_NOMATCH(dev->parent, dev); 2909 devnomatch(dev); 2910 dev->flags |= DF_DONENOMATCH; 2911 } 2912 return (error); 2913 } 2914 return (0); 2915 } 2916 2917 /** 2918 * @brief Probe a device and attach a driver if possible 2919 * 2920 * calls device_probe() and attaches if that was successful. 2921 */ 2922 int 2923 device_probe_and_attach(device_t dev) 2924 { 2925 int error; 2926 2927 GIANT_REQUIRED; 2928 2929 error = device_probe(dev); 2930 if (error == -1) 2931 return (0); 2932 else if (error != 0) 2933 return (error); 2934 2935 CURVNET_SET_QUIET(vnet0); 2936 error = device_attach(dev); 2937 CURVNET_RESTORE(); 2938 return error; 2939 } 2940 2941 /** 2942 * @brief Attach a device driver to a device 2943 * 2944 * This function is a wrapper around the DEVICE_ATTACH() driver 2945 * method. In addition to calling DEVICE_ATTACH(), it initialises the 2946 * device's sysctl tree, optionally prints a description of the device 2947 * and queues a notification event for user-based device management 2948 * services. 2949 * 2950 * Normally this function is only called internally from 2951 * device_probe_and_attach(). 2952 * 2953 * @param dev the device to initialise 2954 * 2955 * @retval 0 success 2956 * @retval ENXIO no driver was found 2957 * @retval ENOMEM memory allocation failure 2958 * @retval non-zero some other unix error code 2959 */ 2960 int 2961 device_attach(device_t dev) 2962 { 2963 uint64_t attachtime; 2964 uint16_t attachentropy; 2965 int error; 2966 2967 if (resource_disabled(dev->driver->name, dev->unit)) { 2968 device_disable(dev); 2969 if (bootverbose) 2970 device_printf(dev, "disabled via hints entry\n"); 2971 return (ENXIO); 2972 } 2973 2974 device_sysctl_init(dev); 2975 if (!device_is_quiet(dev)) 2976 device_print_child(dev->parent, dev); 2977 attachtime = get_cyclecount(); 2978 dev->state = DS_ATTACHING; 2979 if ((error = DEVICE_ATTACH(dev)) != 0) { 2980 printf("device_attach: %s%d attach returned %d\n", 2981 dev->driver->name, dev->unit, error); 2982 if (!(dev->flags & DF_FIXEDCLASS)) 2983 devclass_delete_device(dev->devclass, dev); 2984 (void)device_set_driver(dev, NULL); 2985 device_sysctl_fini(dev); 2986 KASSERT(dev->busy == 0, ("attach failed but busy")); 2987 dev->state = DS_NOTPRESENT; 2988 return (error); 2989 } 2990 dev->flags |= DF_ATTACHED_ONCE; 2991 /* We only need the low bits of this time, but ranges from tens to thousands 2992 * have been seen, so keep 2 bytes' worth. 2993 */ 2994 attachentropy = (uint16_t)(get_cyclecount() - attachtime); 2995 random_harvest_direct(&attachentropy, sizeof(attachentropy), RANDOM_ATTACH); 2996 device_sysctl_update(dev); 2997 if (dev->busy) 2998 dev->state = DS_BUSY; 2999 else 3000 dev->state = DS_ATTACHED; 3001 dev->flags &= ~DF_DONENOMATCH; 3002 EVENTHANDLER_DIRECT_INVOKE(device_attach, dev); 3003 devadded(dev); 3004 return (0); 3005 } 3006 3007 /** 3008 * @brief Detach a driver from a device 3009 * 3010 * This function is a wrapper around the DEVICE_DETACH() driver 3011 * method. If the call to DEVICE_DETACH() succeeds, it calls 3012 * BUS_CHILD_DETACHED() for the parent of @p dev, queues a 3013 * notification event for user-based device management services and 3014 * cleans up the device's sysctl tree. 3015 * 3016 * @param dev the device to un-initialise 3017 * 3018 * @retval 0 success 3019 * @retval ENXIO no driver was found 3020 * @retval ENOMEM memory allocation failure 3021 * @retval non-zero some other unix error code 3022 */ 3023 int 3024 device_detach(device_t dev) 3025 { 3026 int error; 3027 3028 GIANT_REQUIRED; 3029 3030 PDEBUG(("%s", DEVICENAME(dev))); 3031 if (dev->state == DS_BUSY) 3032 return (EBUSY); 3033 if (dev->state == DS_ATTACHING) { 3034 device_printf(dev, "device in attaching state! Deferring detach.\n"); 3035 return (EBUSY); 3036 } 3037 if (dev->state != DS_ATTACHED) 3038 return (0); 3039 3040 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, EVHDEV_DETACH_BEGIN); 3041 if ((error = DEVICE_DETACH(dev)) != 0) { 3042 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, 3043 EVHDEV_DETACH_FAILED); 3044 return (error); 3045 } else { 3046 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, 3047 EVHDEV_DETACH_COMPLETE); 3048 } 3049 devremoved(dev); 3050 if (!device_is_quiet(dev)) 3051 device_printf(dev, "detached\n"); 3052 if (dev->parent) 3053 BUS_CHILD_DETACHED(dev->parent, dev); 3054 3055 if (!(dev->flags & DF_FIXEDCLASS)) 3056 devclass_delete_device(dev->devclass, dev); 3057 3058 device_verbose(dev); 3059 dev->state = DS_NOTPRESENT; 3060 (void)device_set_driver(dev, NULL); 3061 device_sysctl_fini(dev); 3062 3063 return (0); 3064 } 3065 3066 /** 3067 * @brief Tells a driver to quiesce itself. 3068 * 3069 * This function is a wrapper around the DEVICE_QUIESCE() driver 3070 * method. If the call to DEVICE_QUIESCE() succeeds. 3071 * 3072 * @param dev the device to quiesce 3073 * 3074 * @retval 0 success 3075 * @retval ENXIO no driver was found 3076 * @retval ENOMEM memory allocation failure 3077 * @retval non-zero some other unix error code 3078 */ 3079 int 3080 device_quiesce(device_t dev) 3081 { 3082 3083 PDEBUG(("%s", DEVICENAME(dev))); 3084 if (dev->state == DS_BUSY) 3085 return (EBUSY); 3086 if (dev->state != DS_ATTACHED) 3087 return (0); 3088 3089 return (DEVICE_QUIESCE(dev)); 3090 } 3091 3092 /** 3093 * @brief Notify a device of system shutdown 3094 * 3095 * This function calls the DEVICE_SHUTDOWN() driver method if the 3096 * device currently has an attached driver. 3097 * 3098 * @returns the value returned by DEVICE_SHUTDOWN() 3099 */ 3100 int 3101 device_shutdown(device_t dev) 3102 { 3103 if (dev->state < DS_ATTACHED) 3104 return (0); 3105 return (DEVICE_SHUTDOWN(dev)); 3106 } 3107 3108 /** 3109 * @brief Set the unit number of a device 3110 * 3111 * This function can be used to override the unit number used for a 3112 * device (e.g. to wire a device to a pre-configured unit number). 3113 */ 3114 int 3115 device_set_unit(device_t dev, int unit) 3116 { 3117 devclass_t dc; 3118 int err; 3119 3120 dc = device_get_devclass(dev); 3121 if (unit < dc->maxunit && dc->devices[unit]) 3122 return (EBUSY); 3123 err = devclass_delete_device(dc, dev); 3124 if (err) 3125 return (err); 3126 dev->unit = unit; 3127 err = devclass_add_device(dc, dev); 3128 if (err) 3129 return (err); 3130 3131 bus_data_generation_update(); 3132 return (0); 3133 } 3134 3135 /*======================================*/ 3136 /* 3137 * Some useful method implementations to make life easier for bus drivers. 3138 */ 3139 3140 void 3141 resource_init_map_request_impl(struct resource_map_request *args, size_t sz) 3142 { 3143 3144 bzero(args, sz); 3145 args->size = sz; 3146 args->memattr = VM_MEMATTR_UNCACHEABLE; 3147 } 3148 3149 /** 3150 * @brief Initialise a resource list. 3151 * 3152 * @param rl the resource list to initialise 3153 */ 3154 void 3155 resource_list_init(struct resource_list *rl) 3156 { 3157 STAILQ_INIT(rl); 3158 } 3159 3160 /** 3161 * @brief Reclaim memory used by a resource list. 3162 * 3163 * This function frees the memory for all resource entries on the list 3164 * (if any). 3165 * 3166 * @param rl the resource list to free 3167 */ 3168 void 3169 resource_list_free(struct resource_list *rl) 3170 { 3171 struct resource_list_entry *rle; 3172 3173 while ((rle = STAILQ_FIRST(rl)) != NULL) { 3174 if (rle->res) 3175 panic("resource_list_free: resource entry is busy"); 3176 STAILQ_REMOVE_HEAD(rl, link); 3177 free(rle, M_BUS); 3178 } 3179 } 3180 3181 /** 3182 * @brief Add a resource entry. 3183 * 3184 * This function adds a resource entry using the given @p type, @p 3185 * start, @p end and @p count values. A rid value is chosen by 3186 * searching sequentially for the first unused rid starting at zero. 3187 * 3188 * @param rl the resource list to edit 3189 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3190 * @param start the start address of the resource 3191 * @param end the end address of the resource 3192 * @param count XXX end-start+1 3193 */ 3194 int 3195 resource_list_add_next(struct resource_list *rl, int type, rman_res_t start, 3196 rman_res_t end, rman_res_t count) 3197 { 3198 int rid; 3199 3200 rid = 0; 3201 while (resource_list_find(rl, type, rid) != NULL) 3202 rid++; 3203 resource_list_add(rl, type, rid, start, end, count); 3204 return (rid); 3205 } 3206 3207 /** 3208 * @brief Add or modify a resource entry. 3209 * 3210 * If an existing entry exists with the same type and rid, it will be 3211 * modified using the given values of @p start, @p end and @p 3212 * count. If no entry exists, a new one will be created using the 3213 * given values. The resource list entry that matches is then returned. 3214 * 3215 * @param rl the resource list to edit 3216 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3217 * @param rid the resource identifier 3218 * @param start the start address of the resource 3219 * @param end the end address of the resource 3220 * @param count XXX end-start+1 3221 */ 3222 struct resource_list_entry * 3223 resource_list_add(struct resource_list *rl, int type, int rid, 3224 rman_res_t start, rman_res_t end, rman_res_t count) 3225 { 3226 struct resource_list_entry *rle; 3227 3228 rle = resource_list_find(rl, type, rid); 3229 if (!rle) { 3230 rle = malloc(sizeof(struct resource_list_entry), M_BUS, 3231 M_NOWAIT); 3232 if (!rle) 3233 panic("resource_list_add: can't record entry"); 3234 STAILQ_INSERT_TAIL(rl, rle, link); 3235 rle->type = type; 3236 rle->rid = rid; 3237 rle->res = NULL; 3238 rle->flags = 0; 3239 } 3240 3241 if (rle->res) 3242 panic("resource_list_add: resource entry is busy"); 3243 3244 rle->start = start; 3245 rle->end = end; 3246 rle->count = count; 3247 return (rle); 3248 } 3249 3250 /** 3251 * @brief Determine if a resource entry is busy. 3252 * 3253 * Returns true if a resource entry is busy meaning that it has an 3254 * associated resource that is not an unallocated "reserved" resource. 3255 * 3256 * @param rl the resource list to search 3257 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3258 * @param rid the resource identifier 3259 * 3260 * @returns Non-zero if the entry is busy, zero otherwise. 3261 */ 3262 int 3263 resource_list_busy(struct resource_list *rl, int type, int rid) 3264 { 3265 struct resource_list_entry *rle; 3266 3267 rle = resource_list_find(rl, type, rid); 3268 if (rle == NULL || rle->res == NULL) 3269 return (0); 3270 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == RLE_RESERVED) { 3271 KASSERT(!(rman_get_flags(rle->res) & RF_ACTIVE), 3272 ("reserved resource is active")); 3273 return (0); 3274 } 3275 return (1); 3276 } 3277 3278 /** 3279 * @brief Determine if a resource entry is reserved. 3280 * 3281 * Returns true if a resource entry is reserved meaning that it has an 3282 * associated "reserved" resource. The resource can either be 3283 * allocated or unallocated. 3284 * 3285 * @param rl the resource list to search 3286 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3287 * @param rid the resource identifier 3288 * 3289 * @returns Non-zero if the entry is reserved, zero otherwise. 3290 */ 3291 int 3292 resource_list_reserved(struct resource_list *rl, int type, int rid) 3293 { 3294 struct resource_list_entry *rle; 3295 3296 rle = resource_list_find(rl, type, rid); 3297 if (rle != NULL && rle->flags & RLE_RESERVED) 3298 return (1); 3299 return (0); 3300 } 3301 3302 /** 3303 * @brief Find a resource entry by type and rid. 3304 * 3305 * @param rl the resource list to search 3306 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3307 * @param rid the resource identifier 3308 * 3309 * @returns the resource entry pointer or NULL if there is no such 3310 * entry. 3311 */ 3312 struct resource_list_entry * 3313 resource_list_find(struct resource_list *rl, int type, int rid) 3314 { 3315 struct resource_list_entry *rle; 3316 3317 STAILQ_FOREACH(rle, rl, link) { 3318 if (rle->type == type && rle->rid == rid) 3319 return (rle); 3320 } 3321 return (NULL); 3322 } 3323 3324 /** 3325 * @brief Delete a resource entry. 3326 * 3327 * @param rl the resource list to edit 3328 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3329 * @param rid the resource identifier 3330 */ 3331 void 3332 resource_list_delete(struct resource_list *rl, int type, int rid) 3333 { 3334 struct resource_list_entry *rle = resource_list_find(rl, type, rid); 3335 3336 if (rle) { 3337 if (rle->res != NULL) 3338 panic("resource_list_delete: resource has not been released"); 3339 STAILQ_REMOVE(rl, rle, resource_list_entry, link); 3340 free(rle, M_BUS); 3341 } 3342 } 3343 3344 /** 3345 * @brief Allocate a reserved resource 3346 * 3347 * This can be used by buses to force the allocation of resources 3348 * that are always active in the system even if they are not allocated 3349 * by a driver (e.g. PCI BARs). This function is usually called when 3350 * adding a new child to the bus. The resource is allocated from the 3351 * parent bus when it is reserved. The resource list entry is marked 3352 * with RLE_RESERVED to note that it is a reserved resource. 3353 * 3354 * Subsequent attempts to allocate the resource with 3355 * resource_list_alloc() will succeed the first time and will set 3356 * RLE_ALLOCATED to note that it has been allocated. When a reserved 3357 * resource that has been allocated is released with 3358 * resource_list_release() the resource RLE_ALLOCATED is cleared, but 3359 * the actual resource remains allocated. The resource can be released to 3360 * the parent bus by calling resource_list_unreserve(). 3361 * 3362 * @param rl the resource list to allocate from 3363 * @param bus the parent device of @p child 3364 * @param child the device for which the resource is being reserved 3365 * @param type the type of resource to allocate 3366 * @param rid a pointer to the resource identifier 3367 * @param start hint at the start of the resource range - pass 3368 * @c 0 for any start address 3369 * @param end hint at the end of the resource range - pass 3370 * @c ~0 for any end address 3371 * @param count hint at the size of range required - pass @c 1 3372 * for any size 3373 * @param flags any extra flags to control the resource 3374 * allocation - see @c RF_XXX flags in 3375 * <sys/rman.h> for details 3376 * 3377 * @returns the resource which was allocated or @c NULL if no 3378 * resource could be allocated 3379 */ 3380 struct resource * 3381 resource_list_reserve(struct resource_list *rl, device_t bus, device_t child, 3382 int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 3383 { 3384 struct resource_list_entry *rle = NULL; 3385 int passthrough = (device_get_parent(child) != bus); 3386 struct resource *r; 3387 3388 if (passthrough) 3389 panic( 3390 "resource_list_reserve() should only be called for direct children"); 3391 if (flags & RF_ACTIVE) 3392 panic( 3393 "resource_list_reserve() should only reserve inactive resources"); 3394 3395 r = resource_list_alloc(rl, bus, child, type, rid, start, end, count, 3396 flags); 3397 if (r != NULL) { 3398 rle = resource_list_find(rl, type, *rid); 3399 rle->flags |= RLE_RESERVED; 3400 } 3401 return (r); 3402 } 3403 3404 /** 3405 * @brief Helper function for implementing BUS_ALLOC_RESOURCE() 3406 * 3407 * Implement BUS_ALLOC_RESOURCE() by looking up a resource from the list 3408 * and passing the allocation up to the parent of @p bus. This assumes 3409 * that the first entry of @c device_get_ivars(child) is a struct 3410 * resource_list. This also handles 'passthrough' allocations where a 3411 * child is a remote descendant of bus by passing the allocation up to 3412 * the parent of bus. 3413 * 3414 * Typically, a bus driver would store a list of child resources 3415 * somewhere in the child device's ivars (see device_get_ivars()) and 3416 * its implementation of BUS_ALLOC_RESOURCE() would find that list and 3417 * then call resource_list_alloc() to perform the allocation. 3418 * 3419 * @param rl the resource list to allocate from 3420 * @param bus the parent device of @p child 3421 * @param child the device which is requesting an allocation 3422 * @param type the type of resource to allocate 3423 * @param rid a pointer to the resource identifier 3424 * @param start hint at the start of the resource range - pass 3425 * @c 0 for any start address 3426 * @param end hint at the end of the resource range - pass 3427 * @c ~0 for any end address 3428 * @param count hint at the size of range required - pass @c 1 3429 * for any size 3430 * @param flags any extra flags to control the resource 3431 * allocation - see @c RF_XXX flags in 3432 * <sys/rman.h> for details 3433 * 3434 * @returns the resource which was allocated or @c NULL if no 3435 * resource could be allocated 3436 */ 3437 struct resource * 3438 resource_list_alloc(struct resource_list *rl, device_t bus, device_t child, 3439 int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 3440 { 3441 struct resource_list_entry *rle = NULL; 3442 int passthrough = (device_get_parent(child) != bus); 3443 int isdefault = RMAN_IS_DEFAULT_RANGE(start, end); 3444 3445 if (passthrough) { 3446 return (BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 3447 type, rid, start, end, count, flags)); 3448 } 3449 3450 rle = resource_list_find(rl, type, *rid); 3451 3452 if (!rle) 3453 return (NULL); /* no resource of that type/rid */ 3454 3455 if (rle->res) { 3456 if (rle->flags & RLE_RESERVED) { 3457 if (rle->flags & RLE_ALLOCATED) 3458 return (NULL); 3459 if ((flags & RF_ACTIVE) && 3460 bus_activate_resource(child, type, *rid, 3461 rle->res) != 0) 3462 return (NULL); 3463 rle->flags |= RLE_ALLOCATED; 3464 return (rle->res); 3465 } 3466 device_printf(bus, 3467 "resource entry %#x type %d for child %s is busy\n", *rid, 3468 type, device_get_nameunit(child)); 3469 return (NULL); 3470 } 3471 3472 if (isdefault) { 3473 start = rle->start; 3474 count = ulmax(count, rle->count); 3475 end = ulmax(rle->end, start + count - 1); 3476 } 3477 3478 rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 3479 type, rid, start, end, count, flags); 3480 3481 /* 3482 * Record the new range. 3483 */ 3484 if (rle->res) { 3485 rle->start = rman_get_start(rle->res); 3486 rle->end = rman_get_end(rle->res); 3487 rle->count = count; 3488 } 3489 3490 return (rle->res); 3491 } 3492 3493 /** 3494 * @brief Helper function for implementing BUS_RELEASE_RESOURCE() 3495 * 3496 * Implement BUS_RELEASE_RESOURCE() using a resource list. Normally 3497 * used with resource_list_alloc(). 3498 * 3499 * @param rl the resource list which was allocated from 3500 * @param bus the parent device of @p child 3501 * @param child the device which is requesting a release 3502 * @param type the type of resource to release 3503 * @param rid the resource identifier 3504 * @param res the resource to release 3505 * 3506 * @retval 0 success 3507 * @retval non-zero a standard unix error code indicating what 3508 * error condition prevented the operation 3509 */ 3510 int 3511 resource_list_release(struct resource_list *rl, device_t bus, device_t child, 3512 int type, int rid, struct resource *res) 3513 { 3514 struct resource_list_entry *rle = NULL; 3515 int passthrough = (device_get_parent(child) != bus); 3516 int error; 3517 3518 if (passthrough) { 3519 return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 3520 type, rid, res)); 3521 } 3522 3523 rle = resource_list_find(rl, type, rid); 3524 3525 if (!rle) 3526 panic("resource_list_release: can't find resource"); 3527 if (!rle->res) 3528 panic("resource_list_release: resource entry is not busy"); 3529 if (rle->flags & RLE_RESERVED) { 3530 if (rle->flags & RLE_ALLOCATED) { 3531 if (rman_get_flags(res) & RF_ACTIVE) { 3532 error = bus_deactivate_resource(child, type, 3533 rid, res); 3534 if (error) 3535 return (error); 3536 } 3537 rle->flags &= ~RLE_ALLOCATED; 3538 return (0); 3539 } 3540 return (EINVAL); 3541 } 3542 3543 error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 3544 type, rid, res); 3545 if (error) 3546 return (error); 3547 3548 rle->res = NULL; 3549 return (0); 3550 } 3551 3552 /** 3553 * @brief Release all active resources of a given type 3554 * 3555 * Release all active resources of a specified type. This is intended 3556 * to be used to cleanup resources leaked by a driver after detach or 3557 * a failed attach. 3558 * 3559 * @param rl the resource list which was allocated from 3560 * @param bus the parent device of @p child 3561 * @param child the device whose active resources are being released 3562 * @param type the type of resources to release 3563 * 3564 * @retval 0 success 3565 * @retval EBUSY at least one resource was active 3566 */ 3567 int 3568 resource_list_release_active(struct resource_list *rl, device_t bus, 3569 device_t child, int type) 3570 { 3571 struct resource_list_entry *rle; 3572 int error, retval; 3573 3574 retval = 0; 3575 STAILQ_FOREACH(rle, rl, link) { 3576 if (rle->type != type) 3577 continue; 3578 if (rle->res == NULL) 3579 continue; 3580 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == 3581 RLE_RESERVED) 3582 continue; 3583 retval = EBUSY; 3584 error = resource_list_release(rl, bus, child, type, 3585 rman_get_rid(rle->res), rle->res); 3586 if (error != 0) 3587 device_printf(bus, 3588 "Failed to release active resource: %d\n", error); 3589 } 3590 return (retval); 3591 } 3592 3593 3594 /** 3595 * @brief Fully release a reserved resource 3596 * 3597 * Fully releases a resource reserved via resource_list_reserve(). 3598 * 3599 * @param rl the resource list which was allocated from 3600 * @param bus the parent device of @p child 3601 * @param child the device whose reserved resource is being released 3602 * @param type the type of resource to release 3603 * @param rid the resource identifier 3604 * @param res the resource to release 3605 * 3606 * @retval 0 success 3607 * @retval non-zero a standard unix error code indicating what 3608 * error condition prevented the operation 3609 */ 3610 int 3611 resource_list_unreserve(struct resource_list *rl, device_t bus, device_t child, 3612 int type, int rid) 3613 { 3614 struct resource_list_entry *rle = NULL; 3615 int passthrough = (device_get_parent(child) != bus); 3616 3617 if (passthrough) 3618 panic( 3619 "resource_list_unreserve() should only be called for direct children"); 3620 3621 rle = resource_list_find(rl, type, rid); 3622 3623 if (!rle) 3624 panic("resource_list_unreserve: can't find resource"); 3625 if (!(rle->flags & RLE_RESERVED)) 3626 return (EINVAL); 3627 if (rle->flags & RLE_ALLOCATED) 3628 return (EBUSY); 3629 rle->flags &= ~RLE_RESERVED; 3630 return (resource_list_release(rl, bus, child, type, rid, rle->res)); 3631 } 3632 3633 /** 3634 * @brief Print a description of resources in a resource list 3635 * 3636 * Print all resources of a specified type, for use in BUS_PRINT_CHILD(). 3637 * The name is printed if at least one resource of the given type is available. 3638 * The format is used to print resource start and end. 3639 * 3640 * @param rl the resource list to print 3641 * @param name the name of @p type, e.g. @c "memory" 3642 * @param type type type of resource entry to print 3643 * @param format printf(9) format string to print resource 3644 * start and end values 3645 * 3646 * @returns the number of characters printed 3647 */ 3648 int 3649 resource_list_print_type(struct resource_list *rl, const char *name, int type, 3650 const char *format) 3651 { 3652 struct resource_list_entry *rle; 3653 int printed, retval; 3654 3655 printed = 0; 3656 retval = 0; 3657 /* Yes, this is kinda cheating */ 3658 STAILQ_FOREACH(rle, rl, link) { 3659 if (rle->type == type) { 3660 if (printed == 0) 3661 retval += printf(" %s ", name); 3662 else 3663 retval += printf(","); 3664 printed++; 3665 retval += printf(format, rle->start); 3666 if (rle->count > 1) { 3667 retval += printf("-"); 3668 retval += printf(format, rle->start + 3669 rle->count - 1); 3670 } 3671 } 3672 } 3673 return (retval); 3674 } 3675 3676 /** 3677 * @brief Releases all the resources in a list. 3678 * 3679 * @param rl The resource list to purge. 3680 * 3681 * @returns nothing 3682 */ 3683 void 3684 resource_list_purge(struct resource_list *rl) 3685 { 3686 struct resource_list_entry *rle; 3687 3688 while ((rle = STAILQ_FIRST(rl)) != NULL) { 3689 if (rle->res) 3690 bus_release_resource(rman_get_device(rle->res), 3691 rle->type, rle->rid, rle->res); 3692 STAILQ_REMOVE_HEAD(rl, link); 3693 free(rle, M_BUS); 3694 } 3695 } 3696 3697 device_t 3698 bus_generic_add_child(device_t dev, u_int order, const char *name, int unit) 3699 { 3700 3701 return (device_add_child_ordered(dev, order, name, unit)); 3702 } 3703 3704 /** 3705 * @brief Helper function for implementing DEVICE_PROBE() 3706 * 3707 * This function can be used to help implement the DEVICE_PROBE() for 3708 * a bus (i.e. a device which has other devices attached to it). It 3709 * calls the DEVICE_IDENTIFY() method of each driver in the device's 3710 * devclass. 3711 */ 3712 int 3713 bus_generic_probe(device_t dev) 3714 { 3715 devclass_t dc = dev->devclass; 3716 driverlink_t dl; 3717 3718 TAILQ_FOREACH(dl, &dc->drivers, link) { 3719 /* 3720 * If this driver's pass is too high, then ignore it. 3721 * For most drivers in the default pass, this will 3722 * never be true. For early-pass drivers they will 3723 * only call the identify routines of eligible drivers 3724 * when this routine is called. Drivers for later 3725 * passes should have their identify routines called 3726 * on early-pass buses during BUS_NEW_PASS(). 3727 */ 3728 if (dl->pass > bus_current_pass) 3729 continue; 3730 DEVICE_IDENTIFY(dl->driver, dev); 3731 } 3732 3733 return (0); 3734 } 3735 3736 /** 3737 * @brief Helper function for implementing DEVICE_ATTACH() 3738 * 3739 * This function can be used to help implement the DEVICE_ATTACH() for 3740 * a bus. It calls device_probe_and_attach() for each of the device's 3741 * children. 3742 */ 3743 int 3744 bus_generic_attach(device_t dev) 3745 { 3746 device_t child; 3747 3748 TAILQ_FOREACH(child, &dev->children, link) { 3749 device_probe_and_attach(child); 3750 } 3751 3752 return (0); 3753 } 3754 3755 /** 3756 * @brief Helper function for delaying attaching children 3757 * 3758 * Many buses can't run transactions on the bus which children need to probe and 3759 * attach until after interrupts and/or timers are running. This function 3760 * delays their attach until interrupts and timers are enabled. 3761 */ 3762 int 3763 bus_delayed_attach_children(device_t dev) 3764 { 3765 /* Probe and attach the bus children when interrupts are available */ 3766 config_intrhook_oneshot((ich_func_t)bus_generic_attach, dev); 3767 3768 return (0); 3769 } 3770 3771 /** 3772 * @brief Helper function for implementing DEVICE_DETACH() 3773 * 3774 * This function can be used to help implement the DEVICE_DETACH() for 3775 * a bus. It calls device_detach() for each of the device's 3776 * children. 3777 */ 3778 int 3779 bus_generic_detach(device_t dev) 3780 { 3781 device_t child; 3782 int error; 3783 3784 if (dev->state != DS_ATTACHED) 3785 return (EBUSY); 3786 3787 /* 3788 * Detach children in the reverse order. 3789 * See bus_generic_suspend for details. 3790 */ 3791 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3792 if ((error = device_detach(child)) != 0) 3793 return (error); 3794 } 3795 3796 return (0); 3797 } 3798 3799 /** 3800 * @brief Helper function for implementing DEVICE_SHUTDOWN() 3801 * 3802 * This function can be used to help implement the DEVICE_SHUTDOWN() 3803 * for a bus. It calls device_shutdown() for each of the device's 3804 * children. 3805 */ 3806 int 3807 bus_generic_shutdown(device_t dev) 3808 { 3809 device_t child; 3810 3811 /* 3812 * Shut down children in the reverse order. 3813 * See bus_generic_suspend for details. 3814 */ 3815 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3816 device_shutdown(child); 3817 } 3818 3819 return (0); 3820 } 3821 3822 /** 3823 * @brief Default function for suspending a child device. 3824 * 3825 * This function is to be used by a bus's DEVICE_SUSPEND_CHILD(). 3826 */ 3827 int 3828 bus_generic_suspend_child(device_t dev, device_t child) 3829 { 3830 int error; 3831 3832 error = DEVICE_SUSPEND(child); 3833 3834 if (error == 0) 3835 child->flags |= DF_SUSPENDED; 3836 3837 return (error); 3838 } 3839 3840 /** 3841 * @brief Default function for resuming a child device. 3842 * 3843 * This function is to be used by a bus's DEVICE_RESUME_CHILD(). 3844 */ 3845 int 3846 bus_generic_resume_child(device_t dev, device_t child) 3847 { 3848 3849 DEVICE_RESUME(child); 3850 child->flags &= ~DF_SUSPENDED; 3851 3852 return (0); 3853 } 3854 3855 /** 3856 * @brief Helper function for implementing DEVICE_SUSPEND() 3857 * 3858 * This function can be used to help implement the DEVICE_SUSPEND() 3859 * for a bus. It calls DEVICE_SUSPEND() for each of the device's 3860 * children. If any call to DEVICE_SUSPEND() fails, the suspend 3861 * operation is aborted and any devices which were suspended are 3862 * resumed immediately by calling their DEVICE_RESUME() methods. 3863 */ 3864 int 3865 bus_generic_suspend(device_t dev) 3866 { 3867 int error; 3868 device_t child; 3869 3870 /* 3871 * Suspend children in the reverse order. 3872 * For most buses all children are equal, so the order does not matter. 3873 * Other buses, such as acpi, carefully order their child devices to 3874 * express implicit dependencies between them. For such buses it is 3875 * safer to bring down devices in the reverse order. 3876 */ 3877 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3878 error = BUS_SUSPEND_CHILD(dev, child); 3879 if (error != 0) { 3880 child = TAILQ_NEXT(child, link); 3881 if (child != NULL) { 3882 TAILQ_FOREACH_FROM(child, &dev->children, link) 3883 BUS_RESUME_CHILD(dev, child); 3884 } 3885 return (error); 3886 } 3887 } 3888 return (0); 3889 } 3890 3891 /** 3892 * @brief Helper function for implementing DEVICE_RESUME() 3893 * 3894 * This function can be used to help implement the DEVICE_RESUME() for 3895 * a bus. It calls DEVICE_RESUME() on each of the device's children. 3896 */ 3897 int 3898 bus_generic_resume(device_t dev) 3899 { 3900 device_t child; 3901 3902 TAILQ_FOREACH(child, &dev->children, link) { 3903 BUS_RESUME_CHILD(dev, child); 3904 /* if resume fails, there's nothing we can usefully do... */ 3905 } 3906 return (0); 3907 } 3908 3909 3910 /** 3911 * @brief Helper function for implementing BUS_RESET_POST 3912 * 3913 * Bus can use this function to implement common operations of 3914 * re-attaching or resuming the children after the bus itself was 3915 * reset, and after restoring bus-unique state of children. 3916 * 3917 * @param dev The bus 3918 * #param flags DEVF_RESET_* 3919 */ 3920 int 3921 bus_helper_reset_post(device_t dev, int flags) 3922 { 3923 device_t child; 3924 int error, error1; 3925 3926 error = 0; 3927 TAILQ_FOREACH(child, &dev->children,link) { 3928 BUS_RESET_POST(dev, child); 3929 error1 = (flags & DEVF_RESET_DETACH) != 0 ? 3930 device_probe_and_attach(child) : 3931 BUS_RESUME_CHILD(dev, child); 3932 if (error == 0 && error1 != 0) 3933 error = error1; 3934 } 3935 return (error); 3936 } 3937 3938 static void 3939 bus_helper_reset_prepare_rollback(device_t dev, device_t child, int flags) 3940 { 3941 3942 child = TAILQ_NEXT(child, link); 3943 if (child == NULL) 3944 return; 3945 TAILQ_FOREACH_FROM(child, &dev->children,link) { 3946 BUS_RESET_POST(dev, child); 3947 if ((flags & DEVF_RESET_DETACH) != 0) 3948 device_probe_and_attach(child); 3949 else 3950 BUS_RESUME_CHILD(dev, child); 3951 } 3952 } 3953 3954 /** 3955 * @brief Helper function for implementing BUS_RESET_PREPARE 3956 * 3957 * Bus can use this function to implement common operations of 3958 * detaching or suspending the children before the bus itself is 3959 * reset, and then save bus-unique state of children that must 3960 * persists around reset. 3961 * 3962 * @param dev The bus 3963 * #param flags DEVF_RESET_* 3964 */ 3965 int 3966 bus_helper_reset_prepare(device_t dev, int flags) 3967 { 3968 device_t child; 3969 int error; 3970 3971 if (dev->state != DS_ATTACHED) 3972 return (EBUSY); 3973 3974 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3975 if ((flags & DEVF_RESET_DETACH) != 0) { 3976 error = device_get_state(child) == DS_ATTACHED ? 3977 device_detach(child) : 0; 3978 } else { 3979 error = BUS_SUSPEND_CHILD(dev, child); 3980 } 3981 if (error == 0) { 3982 error = BUS_RESET_PREPARE(dev, child); 3983 if (error != 0) { 3984 if ((flags & DEVF_RESET_DETACH) != 0) 3985 device_probe_and_attach(child); 3986 else 3987 BUS_RESUME_CHILD(dev, child); 3988 } 3989 } 3990 if (error != 0) { 3991 bus_helper_reset_prepare_rollback(dev, child, flags); 3992 return (error); 3993 } 3994 } 3995 return (0); 3996 } 3997 3998 /** 3999 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4000 * 4001 * This function prints the first part of the ascii representation of 4002 * @p child, including its name, unit and description (if any - see 4003 * device_set_desc()). 4004 * 4005 * @returns the number of characters printed 4006 */ 4007 int 4008 bus_print_child_header(device_t dev, device_t child) 4009 { 4010 int retval = 0; 4011 4012 if (device_get_desc(child)) { 4013 retval += device_printf(child, "<%s>", device_get_desc(child)); 4014 } else { 4015 retval += printf("%s", device_get_nameunit(child)); 4016 } 4017 4018 return (retval); 4019 } 4020 4021 /** 4022 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4023 * 4024 * This function prints the last part of the ascii representation of 4025 * @p child, which consists of the string @c " on " followed by the 4026 * name and unit of the @p dev. 4027 * 4028 * @returns the number of characters printed 4029 */ 4030 int 4031 bus_print_child_footer(device_t dev, device_t child) 4032 { 4033 return (printf(" on %s\n", device_get_nameunit(dev))); 4034 } 4035 4036 /** 4037 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4038 * 4039 * This function prints out the VM domain for the given device. 4040 * 4041 * @returns the number of characters printed 4042 */ 4043 int 4044 bus_print_child_domain(device_t dev, device_t child) 4045 { 4046 int domain; 4047 4048 /* No domain? Don't print anything */ 4049 if (BUS_GET_DOMAIN(dev, child, &domain) != 0) 4050 return (0); 4051 4052 return (printf(" numa-domain %d", domain)); 4053 } 4054 4055 /** 4056 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4057 * 4058 * This function simply calls bus_print_child_header() followed by 4059 * bus_print_child_footer(). 4060 * 4061 * @returns the number of characters printed 4062 */ 4063 int 4064 bus_generic_print_child(device_t dev, device_t child) 4065 { 4066 int retval = 0; 4067 4068 retval += bus_print_child_header(dev, child); 4069 retval += bus_print_child_domain(dev, child); 4070 retval += bus_print_child_footer(dev, child); 4071 4072 return (retval); 4073 } 4074 4075 /** 4076 * @brief Stub function for implementing BUS_READ_IVAR(). 4077 * 4078 * @returns ENOENT 4079 */ 4080 int 4081 bus_generic_read_ivar(device_t dev, device_t child, int index, 4082 uintptr_t * result) 4083 { 4084 return (ENOENT); 4085 } 4086 4087 /** 4088 * @brief Stub function for implementing BUS_WRITE_IVAR(). 4089 * 4090 * @returns ENOENT 4091 */ 4092 int 4093 bus_generic_write_ivar(device_t dev, device_t child, int index, 4094 uintptr_t value) 4095 { 4096 return (ENOENT); 4097 } 4098 4099 /** 4100 * @brief Stub function for implementing BUS_GET_RESOURCE_LIST(). 4101 * 4102 * @returns NULL 4103 */ 4104 struct resource_list * 4105 bus_generic_get_resource_list(device_t dev, device_t child) 4106 { 4107 return (NULL); 4108 } 4109 4110 /** 4111 * @brief Helper function for implementing BUS_DRIVER_ADDED(). 4112 * 4113 * This implementation of BUS_DRIVER_ADDED() simply calls the driver's 4114 * DEVICE_IDENTIFY() method to allow it to add new children to the bus 4115 * and then calls device_probe_and_attach() for each unattached child. 4116 */ 4117 void 4118 bus_generic_driver_added(device_t dev, driver_t *driver) 4119 { 4120 device_t child; 4121 4122 DEVICE_IDENTIFY(driver, dev); 4123 TAILQ_FOREACH(child, &dev->children, link) { 4124 if (child->state == DS_NOTPRESENT || 4125 (child->flags & DF_REBID)) 4126 device_probe_and_attach(child); 4127 } 4128 } 4129 4130 /** 4131 * @brief Helper function for implementing BUS_NEW_PASS(). 4132 * 4133 * This implementing of BUS_NEW_PASS() first calls the identify 4134 * routines for any drivers that probe at the current pass. Then it 4135 * walks the list of devices for this bus. If a device is already 4136 * attached, then it calls BUS_NEW_PASS() on that device. If the 4137 * device is not already attached, it attempts to attach a driver to 4138 * it. 4139 */ 4140 void 4141 bus_generic_new_pass(device_t dev) 4142 { 4143 driverlink_t dl; 4144 devclass_t dc; 4145 device_t child; 4146 4147 dc = dev->devclass; 4148 TAILQ_FOREACH(dl, &dc->drivers, link) { 4149 if (dl->pass == bus_current_pass) 4150 DEVICE_IDENTIFY(dl->driver, dev); 4151 } 4152 TAILQ_FOREACH(child, &dev->children, link) { 4153 if (child->state >= DS_ATTACHED) 4154 BUS_NEW_PASS(child); 4155 else if (child->state == DS_NOTPRESENT) 4156 device_probe_and_attach(child); 4157 } 4158 } 4159 4160 /** 4161 * @brief Helper function for implementing BUS_SETUP_INTR(). 4162 * 4163 * This simple implementation of BUS_SETUP_INTR() simply calls the 4164 * BUS_SETUP_INTR() method of the parent of @p dev. 4165 */ 4166 int 4167 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq, 4168 int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg, 4169 void **cookiep) 4170 { 4171 /* Propagate up the bus hierarchy until someone handles it. */ 4172 if (dev->parent) 4173 return (BUS_SETUP_INTR(dev->parent, child, irq, flags, 4174 filter, intr, arg, cookiep)); 4175 return (EINVAL); 4176 } 4177 4178 /** 4179 * @brief Helper function for implementing BUS_TEARDOWN_INTR(). 4180 * 4181 * This simple implementation of BUS_TEARDOWN_INTR() simply calls the 4182 * BUS_TEARDOWN_INTR() method of the parent of @p dev. 4183 */ 4184 int 4185 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq, 4186 void *cookie) 4187 { 4188 /* Propagate up the bus hierarchy until someone handles it. */ 4189 if (dev->parent) 4190 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie)); 4191 return (EINVAL); 4192 } 4193 4194 /** 4195 * @brief Helper function for implementing BUS_SUSPEND_INTR(). 4196 * 4197 * This simple implementation of BUS_SUSPEND_INTR() simply calls the 4198 * BUS_SUSPEND_INTR() method of the parent of @p dev. 4199 */ 4200 int 4201 bus_generic_suspend_intr(device_t dev, device_t child, struct resource *irq) 4202 { 4203 /* Propagate up the bus hierarchy until someone handles it. */ 4204 if (dev->parent) 4205 return (BUS_SUSPEND_INTR(dev->parent, child, irq)); 4206 return (EINVAL); 4207 } 4208 4209 /** 4210 * @brief Helper function for implementing BUS_RESUME_INTR(). 4211 * 4212 * This simple implementation of BUS_RESUME_INTR() simply calls the 4213 * BUS_RESUME_INTR() method of the parent of @p dev. 4214 */ 4215 int 4216 bus_generic_resume_intr(device_t dev, device_t child, struct resource *irq) 4217 { 4218 /* Propagate up the bus hierarchy until someone handles it. */ 4219 if (dev->parent) 4220 return (BUS_RESUME_INTR(dev->parent, child, irq)); 4221 return (EINVAL); 4222 } 4223 4224 /** 4225 * @brief Helper function for implementing BUS_ADJUST_RESOURCE(). 4226 * 4227 * This simple implementation of BUS_ADJUST_RESOURCE() simply calls the 4228 * BUS_ADJUST_RESOURCE() method of the parent of @p dev. 4229 */ 4230 int 4231 bus_generic_adjust_resource(device_t dev, device_t child, int type, 4232 struct resource *r, rman_res_t start, rman_res_t end) 4233 { 4234 /* Propagate up the bus hierarchy until someone handles it. */ 4235 if (dev->parent) 4236 return (BUS_ADJUST_RESOURCE(dev->parent, child, type, r, start, 4237 end)); 4238 return (EINVAL); 4239 } 4240 4241 /** 4242 * @brief Helper function for implementing BUS_ALLOC_RESOURCE(). 4243 * 4244 * This simple implementation of BUS_ALLOC_RESOURCE() simply calls the 4245 * BUS_ALLOC_RESOURCE() method of the parent of @p dev. 4246 */ 4247 struct resource * 4248 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid, 4249 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 4250 { 4251 /* Propagate up the bus hierarchy until someone handles it. */ 4252 if (dev->parent) 4253 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid, 4254 start, end, count, flags)); 4255 return (NULL); 4256 } 4257 4258 /** 4259 * @brief Helper function for implementing BUS_RELEASE_RESOURCE(). 4260 * 4261 * This simple implementation of BUS_RELEASE_RESOURCE() simply calls the 4262 * BUS_RELEASE_RESOURCE() method of the parent of @p dev. 4263 */ 4264 int 4265 bus_generic_release_resource(device_t dev, device_t child, int type, int rid, 4266 struct resource *r) 4267 { 4268 /* Propagate up the bus hierarchy until someone handles it. */ 4269 if (dev->parent) 4270 return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid, 4271 r)); 4272 return (EINVAL); 4273 } 4274 4275 /** 4276 * @brief Helper function for implementing BUS_ACTIVATE_RESOURCE(). 4277 * 4278 * This simple implementation of BUS_ACTIVATE_RESOURCE() simply calls the 4279 * BUS_ACTIVATE_RESOURCE() method of the parent of @p dev. 4280 */ 4281 int 4282 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid, 4283 struct resource *r) 4284 { 4285 /* Propagate up the bus hierarchy until someone handles it. */ 4286 if (dev->parent) 4287 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid, 4288 r)); 4289 return (EINVAL); 4290 } 4291 4292 /** 4293 * @brief Helper function for implementing BUS_DEACTIVATE_RESOURCE(). 4294 * 4295 * This simple implementation of BUS_DEACTIVATE_RESOURCE() simply calls the 4296 * BUS_DEACTIVATE_RESOURCE() method of the parent of @p dev. 4297 */ 4298 int 4299 bus_generic_deactivate_resource(device_t dev, device_t child, int type, 4300 int rid, struct resource *r) 4301 { 4302 /* Propagate up the bus hierarchy until someone handles it. */ 4303 if (dev->parent) 4304 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid, 4305 r)); 4306 return (EINVAL); 4307 } 4308 4309 /** 4310 * @brief Helper function for implementing BUS_MAP_RESOURCE(). 4311 * 4312 * This simple implementation of BUS_MAP_RESOURCE() simply calls the 4313 * BUS_MAP_RESOURCE() method of the parent of @p dev. 4314 */ 4315 int 4316 bus_generic_map_resource(device_t dev, device_t child, int type, 4317 struct resource *r, struct resource_map_request *args, 4318 struct resource_map *map) 4319 { 4320 /* Propagate up the bus hierarchy until someone handles it. */ 4321 if (dev->parent) 4322 return (BUS_MAP_RESOURCE(dev->parent, child, type, r, args, 4323 map)); 4324 return (EINVAL); 4325 } 4326 4327 /** 4328 * @brief Helper function for implementing BUS_UNMAP_RESOURCE(). 4329 * 4330 * This simple implementation of BUS_UNMAP_RESOURCE() simply calls the 4331 * BUS_UNMAP_RESOURCE() method of the parent of @p dev. 4332 */ 4333 int 4334 bus_generic_unmap_resource(device_t dev, device_t child, int type, 4335 struct resource *r, struct resource_map *map) 4336 { 4337 /* Propagate up the bus hierarchy until someone handles it. */ 4338 if (dev->parent) 4339 return (BUS_UNMAP_RESOURCE(dev->parent, child, type, r, map)); 4340 return (EINVAL); 4341 } 4342 4343 /** 4344 * @brief Helper function for implementing BUS_BIND_INTR(). 4345 * 4346 * This simple implementation of BUS_BIND_INTR() simply calls the 4347 * BUS_BIND_INTR() method of the parent of @p dev. 4348 */ 4349 int 4350 bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq, 4351 int cpu) 4352 { 4353 4354 /* Propagate up the bus hierarchy until someone handles it. */ 4355 if (dev->parent) 4356 return (BUS_BIND_INTR(dev->parent, child, irq, cpu)); 4357 return (EINVAL); 4358 } 4359 4360 /** 4361 * @brief Helper function for implementing BUS_CONFIG_INTR(). 4362 * 4363 * This simple implementation of BUS_CONFIG_INTR() simply calls the 4364 * BUS_CONFIG_INTR() method of the parent of @p dev. 4365 */ 4366 int 4367 bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig, 4368 enum intr_polarity pol) 4369 { 4370 4371 /* Propagate up the bus hierarchy until someone handles it. */ 4372 if (dev->parent) 4373 return (BUS_CONFIG_INTR(dev->parent, irq, trig, pol)); 4374 return (EINVAL); 4375 } 4376 4377 /** 4378 * @brief Helper function for implementing BUS_DESCRIBE_INTR(). 4379 * 4380 * This simple implementation of BUS_DESCRIBE_INTR() simply calls the 4381 * BUS_DESCRIBE_INTR() method of the parent of @p dev. 4382 */ 4383 int 4384 bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq, 4385 void *cookie, const char *descr) 4386 { 4387 4388 /* Propagate up the bus hierarchy until someone handles it. */ 4389 if (dev->parent) 4390 return (BUS_DESCRIBE_INTR(dev->parent, child, irq, cookie, 4391 descr)); 4392 return (EINVAL); 4393 } 4394 4395 /** 4396 * @brief Helper function for implementing BUS_GET_CPUS(). 4397 * 4398 * This simple implementation of BUS_GET_CPUS() simply calls the 4399 * BUS_GET_CPUS() method of the parent of @p dev. 4400 */ 4401 int 4402 bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op, 4403 size_t setsize, cpuset_t *cpuset) 4404 { 4405 4406 /* Propagate up the bus hierarchy until someone handles it. */ 4407 if (dev->parent != NULL) 4408 return (BUS_GET_CPUS(dev->parent, child, op, setsize, cpuset)); 4409 return (EINVAL); 4410 } 4411 4412 /** 4413 * @brief Helper function for implementing BUS_GET_DMA_TAG(). 4414 * 4415 * This simple implementation of BUS_GET_DMA_TAG() simply calls the 4416 * BUS_GET_DMA_TAG() method of the parent of @p dev. 4417 */ 4418 bus_dma_tag_t 4419 bus_generic_get_dma_tag(device_t dev, device_t child) 4420 { 4421 4422 /* Propagate up the bus hierarchy until someone handles it. */ 4423 if (dev->parent != NULL) 4424 return (BUS_GET_DMA_TAG(dev->parent, child)); 4425 return (NULL); 4426 } 4427 4428 /** 4429 * @brief Helper function for implementing BUS_GET_BUS_TAG(). 4430 * 4431 * This simple implementation of BUS_GET_BUS_TAG() simply calls the 4432 * BUS_GET_BUS_TAG() method of the parent of @p dev. 4433 */ 4434 bus_space_tag_t 4435 bus_generic_get_bus_tag(device_t dev, device_t child) 4436 { 4437 4438 /* Propagate up the bus hierarchy until someone handles it. */ 4439 if (dev->parent != NULL) 4440 return (BUS_GET_BUS_TAG(dev->parent, child)); 4441 return ((bus_space_tag_t)0); 4442 } 4443 4444 /** 4445 * @brief Helper function for implementing BUS_GET_RESOURCE(). 4446 * 4447 * This implementation of BUS_GET_RESOURCE() uses the 4448 * resource_list_find() function to do most of the work. It calls 4449 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4450 * search. 4451 */ 4452 int 4453 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid, 4454 rman_res_t *startp, rman_res_t *countp) 4455 { 4456 struct resource_list * rl = NULL; 4457 struct resource_list_entry * rle = NULL; 4458 4459 rl = BUS_GET_RESOURCE_LIST(dev, child); 4460 if (!rl) 4461 return (EINVAL); 4462 4463 rle = resource_list_find(rl, type, rid); 4464 if (!rle) 4465 return (ENOENT); 4466 4467 if (startp) 4468 *startp = rle->start; 4469 if (countp) 4470 *countp = rle->count; 4471 4472 return (0); 4473 } 4474 4475 /** 4476 * @brief Helper function for implementing BUS_SET_RESOURCE(). 4477 * 4478 * This implementation of BUS_SET_RESOURCE() uses the 4479 * resource_list_add() function to do most of the work. It calls 4480 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4481 * edit. 4482 */ 4483 int 4484 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid, 4485 rman_res_t start, rman_res_t count) 4486 { 4487 struct resource_list * rl = NULL; 4488 4489 rl = BUS_GET_RESOURCE_LIST(dev, child); 4490 if (!rl) 4491 return (EINVAL); 4492 4493 resource_list_add(rl, type, rid, start, (start + count - 1), count); 4494 4495 return (0); 4496 } 4497 4498 /** 4499 * @brief Helper function for implementing BUS_DELETE_RESOURCE(). 4500 * 4501 * This implementation of BUS_DELETE_RESOURCE() uses the 4502 * resource_list_delete() function to do most of the work. It calls 4503 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4504 * edit. 4505 */ 4506 void 4507 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid) 4508 { 4509 struct resource_list * rl = NULL; 4510 4511 rl = BUS_GET_RESOURCE_LIST(dev, child); 4512 if (!rl) 4513 return; 4514 4515 resource_list_delete(rl, type, rid); 4516 4517 return; 4518 } 4519 4520 /** 4521 * @brief Helper function for implementing BUS_RELEASE_RESOURCE(). 4522 * 4523 * This implementation of BUS_RELEASE_RESOURCE() uses the 4524 * resource_list_release() function to do most of the work. It calls 4525 * BUS_GET_RESOURCE_LIST() to find a suitable resource list. 4526 */ 4527 int 4528 bus_generic_rl_release_resource(device_t dev, device_t child, int type, 4529 int rid, struct resource *r) 4530 { 4531 struct resource_list * rl = NULL; 4532 4533 if (device_get_parent(child) != dev) 4534 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, 4535 type, rid, r)); 4536 4537 rl = BUS_GET_RESOURCE_LIST(dev, child); 4538 if (!rl) 4539 return (EINVAL); 4540 4541 return (resource_list_release(rl, dev, child, type, rid, r)); 4542 } 4543 4544 /** 4545 * @brief Helper function for implementing BUS_ALLOC_RESOURCE(). 4546 * 4547 * This implementation of BUS_ALLOC_RESOURCE() uses the 4548 * resource_list_alloc() function to do most of the work. It calls 4549 * BUS_GET_RESOURCE_LIST() to find a suitable resource list. 4550 */ 4551 struct resource * 4552 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type, 4553 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 4554 { 4555 struct resource_list * rl = NULL; 4556 4557 if (device_get_parent(child) != dev) 4558 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 4559 type, rid, start, end, count, flags)); 4560 4561 rl = BUS_GET_RESOURCE_LIST(dev, child); 4562 if (!rl) 4563 return (NULL); 4564 4565 return (resource_list_alloc(rl, dev, child, type, rid, 4566 start, end, count, flags)); 4567 } 4568 4569 /** 4570 * @brief Helper function for implementing BUS_CHILD_PRESENT(). 4571 * 4572 * This simple implementation of BUS_CHILD_PRESENT() simply calls the 4573 * BUS_CHILD_PRESENT() method of the parent of @p dev. 4574 */ 4575 int 4576 bus_generic_child_present(device_t dev, device_t child) 4577 { 4578 return (BUS_CHILD_PRESENT(device_get_parent(dev), dev)); 4579 } 4580 4581 int 4582 bus_generic_get_domain(device_t dev, device_t child, int *domain) 4583 { 4584 4585 if (dev->parent) 4586 return (BUS_GET_DOMAIN(dev->parent, dev, domain)); 4587 4588 return (ENOENT); 4589 } 4590 4591 /** 4592 * @brief Helper function for implementing BUS_RESCAN(). 4593 * 4594 * This null implementation of BUS_RESCAN() always fails to indicate 4595 * the bus does not support rescanning. 4596 */ 4597 int 4598 bus_null_rescan(device_t dev) 4599 { 4600 4601 return (ENXIO); 4602 } 4603 4604 /* 4605 * Some convenience functions to make it easier for drivers to use the 4606 * resource-management functions. All these really do is hide the 4607 * indirection through the parent's method table, making for slightly 4608 * less-wordy code. In the future, it might make sense for this code 4609 * to maintain some sort of a list of resources allocated by each device. 4610 */ 4611 4612 int 4613 bus_alloc_resources(device_t dev, struct resource_spec *rs, 4614 struct resource **res) 4615 { 4616 int i; 4617 4618 for (i = 0; rs[i].type != -1; i++) 4619 res[i] = NULL; 4620 for (i = 0; rs[i].type != -1; i++) { 4621 res[i] = bus_alloc_resource_any(dev, 4622 rs[i].type, &rs[i].rid, rs[i].flags); 4623 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) { 4624 bus_release_resources(dev, rs, res); 4625 return (ENXIO); 4626 } 4627 } 4628 return (0); 4629 } 4630 4631 void 4632 bus_release_resources(device_t dev, const struct resource_spec *rs, 4633 struct resource **res) 4634 { 4635 int i; 4636 4637 for (i = 0; rs[i].type != -1; i++) 4638 if (res[i] != NULL) { 4639 bus_release_resource( 4640 dev, rs[i].type, rs[i].rid, res[i]); 4641 res[i] = NULL; 4642 } 4643 } 4644 4645 /** 4646 * @brief Wrapper function for BUS_ALLOC_RESOURCE(). 4647 * 4648 * This function simply calls the BUS_ALLOC_RESOURCE() method of the 4649 * parent of @p dev. 4650 */ 4651 struct resource * 4652 bus_alloc_resource(device_t dev, int type, int *rid, rman_res_t start, 4653 rman_res_t end, rman_res_t count, u_int flags) 4654 { 4655 struct resource *res; 4656 4657 if (dev->parent == NULL) 4658 return (NULL); 4659 res = BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end, 4660 count, flags); 4661 return (res); 4662 } 4663 4664 /** 4665 * @brief Wrapper function for BUS_ADJUST_RESOURCE(). 4666 * 4667 * This function simply calls the BUS_ADJUST_RESOURCE() method of the 4668 * parent of @p dev. 4669 */ 4670 int 4671 bus_adjust_resource(device_t dev, int type, struct resource *r, rman_res_t start, 4672 rman_res_t end) 4673 { 4674 if (dev->parent == NULL) 4675 return (EINVAL); 4676 return (BUS_ADJUST_RESOURCE(dev->parent, dev, type, r, start, end)); 4677 } 4678 4679 /** 4680 * @brief Wrapper function for BUS_ACTIVATE_RESOURCE(). 4681 * 4682 * This function simply calls the BUS_ACTIVATE_RESOURCE() method of the 4683 * parent of @p dev. 4684 */ 4685 int 4686 bus_activate_resource(device_t dev, int type, int rid, struct resource *r) 4687 { 4688 if (dev->parent == NULL) 4689 return (EINVAL); 4690 return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 4691 } 4692 4693 /** 4694 * @brief Wrapper function for BUS_DEACTIVATE_RESOURCE(). 4695 * 4696 * This function simply calls the BUS_DEACTIVATE_RESOURCE() method of the 4697 * parent of @p dev. 4698 */ 4699 int 4700 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r) 4701 { 4702 if (dev->parent == NULL) 4703 return (EINVAL); 4704 return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 4705 } 4706 4707 /** 4708 * @brief Wrapper function for BUS_MAP_RESOURCE(). 4709 * 4710 * This function simply calls the BUS_MAP_RESOURCE() method of the 4711 * parent of @p dev. 4712 */ 4713 int 4714 bus_map_resource(device_t dev, int type, struct resource *r, 4715 struct resource_map_request *args, struct resource_map *map) 4716 { 4717 if (dev->parent == NULL) 4718 return (EINVAL); 4719 return (BUS_MAP_RESOURCE(dev->parent, dev, type, r, args, map)); 4720 } 4721 4722 /** 4723 * @brief Wrapper function for BUS_UNMAP_RESOURCE(). 4724 * 4725 * This function simply calls the BUS_UNMAP_RESOURCE() method of the 4726 * parent of @p dev. 4727 */ 4728 int 4729 bus_unmap_resource(device_t dev, int type, struct resource *r, 4730 struct resource_map *map) 4731 { 4732 if (dev->parent == NULL) 4733 return (EINVAL); 4734 return (BUS_UNMAP_RESOURCE(dev->parent, dev, type, r, map)); 4735 } 4736 4737 /** 4738 * @brief Wrapper function for BUS_RELEASE_RESOURCE(). 4739 * 4740 * This function simply calls the BUS_RELEASE_RESOURCE() method of the 4741 * parent of @p dev. 4742 */ 4743 int 4744 bus_release_resource(device_t dev, int type, int rid, struct resource *r) 4745 { 4746 int rv; 4747 4748 if (dev->parent == NULL) 4749 return (EINVAL); 4750 rv = BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r); 4751 return (rv); 4752 } 4753 4754 /** 4755 * @brief Wrapper function for BUS_SETUP_INTR(). 4756 * 4757 * This function simply calls the BUS_SETUP_INTR() method of the 4758 * parent of @p dev. 4759 */ 4760 int 4761 bus_setup_intr(device_t dev, struct resource *r, int flags, 4762 driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep) 4763 { 4764 int error; 4765 4766 if (dev->parent == NULL) 4767 return (EINVAL); 4768 error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler, 4769 arg, cookiep); 4770 if (error != 0) 4771 return (error); 4772 if (handler != NULL && !(flags & INTR_MPSAFE)) 4773 device_printf(dev, "[GIANT-LOCKED]\n"); 4774 return (0); 4775 } 4776 4777 /** 4778 * @brief Wrapper function for BUS_TEARDOWN_INTR(). 4779 * 4780 * This function simply calls the BUS_TEARDOWN_INTR() method of the 4781 * parent of @p dev. 4782 */ 4783 int 4784 bus_teardown_intr(device_t dev, struct resource *r, void *cookie) 4785 { 4786 if (dev->parent == NULL) 4787 return (EINVAL); 4788 return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie)); 4789 } 4790 4791 /** 4792 * @brief Wrapper function for BUS_SUSPEND_INTR(). 4793 * 4794 * This function simply calls the BUS_SUSPEND_INTR() method of the 4795 * parent of @p dev. 4796 */ 4797 int 4798 bus_suspend_intr(device_t dev, struct resource *r) 4799 { 4800 if (dev->parent == NULL) 4801 return (EINVAL); 4802 return (BUS_SUSPEND_INTR(dev->parent, dev, r)); 4803 } 4804 4805 /** 4806 * @brief Wrapper function for BUS_RESUME_INTR(). 4807 * 4808 * This function simply calls the BUS_RESUME_INTR() method of the 4809 * parent of @p dev. 4810 */ 4811 int 4812 bus_resume_intr(device_t dev, struct resource *r) 4813 { 4814 if (dev->parent == NULL) 4815 return (EINVAL); 4816 return (BUS_RESUME_INTR(dev->parent, dev, r)); 4817 } 4818 4819 /** 4820 * @brief Wrapper function for BUS_BIND_INTR(). 4821 * 4822 * This function simply calls the BUS_BIND_INTR() method of the 4823 * parent of @p dev. 4824 */ 4825 int 4826 bus_bind_intr(device_t dev, struct resource *r, int cpu) 4827 { 4828 if (dev->parent == NULL) 4829 return (EINVAL); 4830 return (BUS_BIND_INTR(dev->parent, dev, r, cpu)); 4831 } 4832 4833 /** 4834 * @brief Wrapper function for BUS_DESCRIBE_INTR(). 4835 * 4836 * This function first formats the requested description into a 4837 * temporary buffer and then calls the BUS_DESCRIBE_INTR() method of 4838 * the parent of @p dev. 4839 */ 4840 int 4841 bus_describe_intr(device_t dev, struct resource *irq, void *cookie, 4842 const char *fmt, ...) 4843 { 4844 va_list ap; 4845 char descr[MAXCOMLEN + 1]; 4846 4847 if (dev->parent == NULL) 4848 return (EINVAL); 4849 va_start(ap, fmt); 4850 vsnprintf(descr, sizeof(descr), fmt, ap); 4851 va_end(ap); 4852 return (BUS_DESCRIBE_INTR(dev->parent, dev, irq, cookie, descr)); 4853 } 4854 4855 /** 4856 * @brief Wrapper function for BUS_SET_RESOURCE(). 4857 * 4858 * This function simply calls the BUS_SET_RESOURCE() method of the 4859 * parent of @p dev. 4860 */ 4861 int 4862 bus_set_resource(device_t dev, int type, int rid, 4863 rman_res_t start, rman_res_t count) 4864 { 4865 return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid, 4866 start, count)); 4867 } 4868 4869 /** 4870 * @brief Wrapper function for BUS_GET_RESOURCE(). 4871 * 4872 * This function simply calls the BUS_GET_RESOURCE() method of the 4873 * parent of @p dev. 4874 */ 4875 int 4876 bus_get_resource(device_t dev, int type, int rid, 4877 rman_res_t *startp, rman_res_t *countp) 4878 { 4879 return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4880 startp, countp)); 4881 } 4882 4883 /** 4884 * @brief Wrapper function for BUS_GET_RESOURCE(). 4885 * 4886 * This function simply calls the BUS_GET_RESOURCE() method of the 4887 * parent of @p dev and returns the start value. 4888 */ 4889 rman_res_t 4890 bus_get_resource_start(device_t dev, int type, int rid) 4891 { 4892 rman_res_t start; 4893 rman_res_t count; 4894 int error; 4895 4896 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4897 &start, &count); 4898 if (error) 4899 return (0); 4900 return (start); 4901 } 4902 4903 /** 4904 * @brief Wrapper function for BUS_GET_RESOURCE(). 4905 * 4906 * This function simply calls the BUS_GET_RESOURCE() method of the 4907 * parent of @p dev and returns the count value. 4908 */ 4909 rman_res_t 4910 bus_get_resource_count(device_t dev, int type, int rid) 4911 { 4912 rman_res_t start; 4913 rman_res_t count; 4914 int error; 4915 4916 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4917 &start, &count); 4918 if (error) 4919 return (0); 4920 return (count); 4921 } 4922 4923 /** 4924 * @brief Wrapper function for BUS_DELETE_RESOURCE(). 4925 * 4926 * This function simply calls the BUS_DELETE_RESOURCE() method of the 4927 * parent of @p dev. 4928 */ 4929 void 4930 bus_delete_resource(device_t dev, int type, int rid) 4931 { 4932 BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid); 4933 } 4934 4935 /** 4936 * @brief Wrapper function for BUS_CHILD_PRESENT(). 4937 * 4938 * This function simply calls the BUS_CHILD_PRESENT() method of the 4939 * parent of @p dev. 4940 */ 4941 int 4942 bus_child_present(device_t child) 4943 { 4944 return (BUS_CHILD_PRESENT(device_get_parent(child), child)); 4945 } 4946 4947 /** 4948 * @brief Wrapper function for BUS_CHILD_PNPINFO_STR(). 4949 * 4950 * This function simply calls the BUS_CHILD_PNPINFO_STR() method of the 4951 * parent of @p dev. 4952 */ 4953 int 4954 bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen) 4955 { 4956 device_t parent; 4957 4958 parent = device_get_parent(child); 4959 if (parent == NULL) { 4960 *buf = '\0'; 4961 return (0); 4962 } 4963 return (BUS_CHILD_PNPINFO_STR(parent, child, buf, buflen)); 4964 } 4965 4966 /** 4967 * @brief Wrapper function for BUS_CHILD_LOCATION_STR(). 4968 * 4969 * This function simply calls the BUS_CHILD_LOCATION_STR() method of the 4970 * parent of @p dev. 4971 */ 4972 int 4973 bus_child_location_str(device_t child, char *buf, size_t buflen) 4974 { 4975 device_t parent; 4976 4977 parent = device_get_parent(child); 4978 if (parent == NULL) { 4979 *buf = '\0'; 4980 return (0); 4981 } 4982 return (BUS_CHILD_LOCATION_STR(parent, child, buf, buflen)); 4983 } 4984 4985 /** 4986 * @brief Wrapper function for BUS_GET_CPUS(). 4987 * 4988 * This function simply calls the BUS_GET_CPUS() method of the 4989 * parent of @p dev. 4990 */ 4991 int 4992 bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, cpuset_t *cpuset) 4993 { 4994 device_t parent; 4995 4996 parent = device_get_parent(dev); 4997 if (parent == NULL) 4998 return (EINVAL); 4999 return (BUS_GET_CPUS(parent, dev, op, setsize, cpuset)); 5000 } 5001 5002 /** 5003 * @brief Wrapper function for BUS_GET_DMA_TAG(). 5004 * 5005 * This function simply calls the BUS_GET_DMA_TAG() method of the 5006 * parent of @p dev. 5007 */ 5008 bus_dma_tag_t 5009 bus_get_dma_tag(device_t dev) 5010 { 5011 device_t parent; 5012 5013 parent = device_get_parent(dev); 5014 if (parent == NULL) 5015 return (NULL); 5016 return (BUS_GET_DMA_TAG(parent, dev)); 5017 } 5018 5019 /** 5020 * @brief Wrapper function for BUS_GET_BUS_TAG(). 5021 * 5022 * This function simply calls the BUS_GET_BUS_TAG() method of the 5023 * parent of @p dev. 5024 */ 5025 bus_space_tag_t 5026 bus_get_bus_tag(device_t dev) 5027 { 5028 device_t parent; 5029 5030 parent = device_get_parent(dev); 5031 if (parent == NULL) 5032 return ((bus_space_tag_t)0); 5033 return (BUS_GET_BUS_TAG(parent, dev)); 5034 } 5035 5036 /** 5037 * @brief Wrapper function for BUS_GET_DOMAIN(). 5038 * 5039 * This function simply calls the BUS_GET_DOMAIN() method of the 5040 * parent of @p dev. 5041 */ 5042 int 5043 bus_get_domain(device_t dev, int *domain) 5044 { 5045 return (BUS_GET_DOMAIN(device_get_parent(dev), dev, domain)); 5046 } 5047 5048 /* Resume all devices and then notify userland that we're up again. */ 5049 static int 5050 root_resume(device_t dev) 5051 { 5052 int error; 5053 5054 error = bus_generic_resume(dev); 5055 if (error == 0) 5056 devctl_notify("kern", "power", "resume", NULL); 5057 return (error); 5058 } 5059 5060 static int 5061 root_print_child(device_t dev, device_t child) 5062 { 5063 int retval = 0; 5064 5065 retval += bus_print_child_header(dev, child); 5066 retval += printf("\n"); 5067 5068 return (retval); 5069 } 5070 5071 static int 5072 root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags, 5073 driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep) 5074 { 5075 /* 5076 * If an interrupt mapping gets to here something bad has happened. 5077 */ 5078 panic("root_setup_intr"); 5079 } 5080 5081 /* 5082 * If we get here, assume that the device is permanent and really is 5083 * present in the system. Removable bus drivers are expected to intercept 5084 * this call long before it gets here. We return -1 so that drivers that 5085 * really care can check vs -1 or some ERRNO returned higher in the food 5086 * chain. 5087 */ 5088 static int 5089 root_child_present(device_t dev, device_t child) 5090 { 5091 return (-1); 5092 } 5093 5094 static int 5095 root_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize, 5096 cpuset_t *cpuset) 5097 { 5098 5099 switch (op) { 5100 case INTR_CPUS: 5101 /* Default to returning the set of all CPUs. */ 5102 if (setsize != sizeof(cpuset_t)) 5103 return (EINVAL); 5104 *cpuset = all_cpus; 5105 return (0); 5106 default: 5107 return (EINVAL); 5108 } 5109 } 5110 5111 static kobj_method_t root_methods[] = { 5112 /* Device interface */ 5113 KOBJMETHOD(device_shutdown, bus_generic_shutdown), 5114 KOBJMETHOD(device_suspend, bus_generic_suspend), 5115 KOBJMETHOD(device_resume, root_resume), 5116 5117 /* Bus interface */ 5118 KOBJMETHOD(bus_print_child, root_print_child), 5119 KOBJMETHOD(bus_read_ivar, bus_generic_read_ivar), 5120 KOBJMETHOD(bus_write_ivar, bus_generic_write_ivar), 5121 KOBJMETHOD(bus_setup_intr, root_setup_intr), 5122 KOBJMETHOD(bus_child_present, root_child_present), 5123 KOBJMETHOD(bus_get_cpus, root_get_cpus), 5124 5125 KOBJMETHOD_END 5126 }; 5127 5128 static driver_t root_driver = { 5129 "root", 5130 root_methods, 5131 1, /* no softc */ 5132 }; 5133 5134 device_t root_bus; 5135 devclass_t root_devclass; 5136 5137 static int 5138 root_bus_module_handler(module_t mod, int what, void* arg) 5139 { 5140 switch (what) { 5141 case MOD_LOAD: 5142 TAILQ_INIT(&bus_data_devices); 5143 kobj_class_compile((kobj_class_t) &root_driver); 5144 root_bus = make_device(NULL, "root", 0); 5145 root_bus->desc = "System root bus"; 5146 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver); 5147 root_bus->driver = &root_driver; 5148 root_bus->state = DS_ATTACHED; 5149 root_devclass = devclass_find_internal("root", NULL, FALSE); 5150 devinit(); 5151 return (0); 5152 5153 case MOD_SHUTDOWN: 5154 device_shutdown(root_bus); 5155 return (0); 5156 default: 5157 return (EOPNOTSUPP); 5158 } 5159 5160 return (0); 5161 } 5162 5163 static moduledata_t root_bus_mod = { 5164 "rootbus", 5165 root_bus_module_handler, 5166 NULL 5167 }; 5168 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 5169 5170 /** 5171 * @brief Automatically configure devices 5172 * 5173 * This function begins the autoconfiguration process by calling 5174 * device_probe_and_attach() for each child of the @c root0 device. 5175 */ 5176 void 5177 root_bus_configure(void) 5178 { 5179 5180 PDEBUG((".")); 5181 5182 /* Eventually this will be split up, but this is sufficient for now. */ 5183 bus_set_pass(BUS_PASS_DEFAULT); 5184 } 5185 5186 /** 5187 * @brief Module handler for registering device drivers 5188 * 5189 * This module handler is used to automatically register device 5190 * drivers when modules are loaded. If @p what is MOD_LOAD, it calls 5191 * devclass_add_driver() for the driver described by the 5192 * driver_module_data structure pointed to by @p arg 5193 */ 5194 int 5195 driver_module_handler(module_t mod, int what, void *arg) 5196 { 5197 struct driver_module_data *dmd; 5198 devclass_t bus_devclass; 5199 kobj_class_t driver; 5200 int error, pass; 5201 5202 dmd = (struct driver_module_data *)arg; 5203 bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE); 5204 error = 0; 5205 5206 switch (what) { 5207 case MOD_LOAD: 5208 if (dmd->dmd_chainevh) 5209 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5210 5211 pass = dmd->dmd_pass; 5212 driver = dmd->dmd_driver; 5213 PDEBUG(("Loading module: driver %s on bus %s (pass %d)", 5214 DRIVERNAME(driver), dmd->dmd_busname, pass)); 5215 error = devclass_add_driver(bus_devclass, driver, pass, 5216 dmd->dmd_devclass); 5217 break; 5218 5219 case MOD_UNLOAD: 5220 PDEBUG(("Unloading module: driver %s from bus %s", 5221 DRIVERNAME(dmd->dmd_driver), 5222 dmd->dmd_busname)); 5223 error = devclass_delete_driver(bus_devclass, 5224 dmd->dmd_driver); 5225 5226 if (!error && dmd->dmd_chainevh) 5227 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5228 break; 5229 case MOD_QUIESCE: 5230 PDEBUG(("Quiesce module: driver %s from bus %s", 5231 DRIVERNAME(dmd->dmd_driver), 5232 dmd->dmd_busname)); 5233 error = devclass_quiesce_driver(bus_devclass, 5234 dmd->dmd_driver); 5235 5236 if (!error && dmd->dmd_chainevh) 5237 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5238 break; 5239 default: 5240 error = EOPNOTSUPP; 5241 break; 5242 } 5243 5244 return (error); 5245 } 5246 5247 /** 5248 * @brief Enumerate all hinted devices for this bus. 5249 * 5250 * Walks through the hints for this bus and calls the bus_hinted_child 5251 * routine for each one it fines. It searches first for the specific 5252 * bus that's being probed for hinted children (eg isa0), and then for 5253 * generic children (eg isa). 5254 * 5255 * @param dev bus device to enumerate 5256 */ 5257 void 5258 bus_enumerate_hinted_children(device_t bus) 5259 { 5260 int i; 5261 const char *dname, *busname; 5262 int dunit; 5263 5264 /* 5265 * enumerate all devices on the specific bus 5266 */ 5267 busname = device_get_nameunit(bus); 5268 i = 0; 5269 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0) 5270 BUS_HINTED_CHILD(bus, dname, dunit); 5271 5272 /* 5273 * and all the generic ones. 5274 */ 5275 busname = device_get_name(bus); 5276 i = 0; 5277 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0) 5278 BUS_HINTED_CHILD(bus, dname, dunit); 5279 } 5280 5281 #ifdef BUS_DEBUG 5282 5283 /* the _short versions avoid iteration by not calling anything that prints 5284 * more than oneliners. I love oneliners. 5285 */ 5286 5287 static void 5288 print_device_short(device_t dev, int indent) 5289 { 5290 if (!dev) 5291 return; 5292 5293 indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s%s%s,%sivars,%ssoftc,busy=%d\n", 5294 dev->unit, dev->desc, 5295 (dev->parent? "":"no "), 5296 (TAILQ_EMPTY(&dev->children)? "no ":""), 5297 (dev->flags&DF_ENABLED? "enabled,":"disabled,"), 5298 (dev->flags&DF_FIXEDCLASS? "fixed,":""), 5299 (dev->flags&DF_WILDCARD? "wildcard,":""), 5300 (dev->flags&DF_DESCMALLOCED? "descmalloced,":""), 5301 (dev->flags&DF_REBID? "rebiddable,":""), 5302 (dev->flags&DF_SUSPENDED? "suspended,":""), 5303 (dev->ivars? "":"no "), 5304 (dev->softc? "":"no "), 5305 dev->busy)); 5306 } 5307 5308 static void 5309 print_device(device_t dev, int indent) 5310 { 5311 if (!dev) 5312 return; 5313 5314 print_device_short(dev, indent); 5315 5316 indentprintf(("Parent:\n")); 5317 print_device_short(dev->parent, indent+1); 5318 indentprintf(("Driver:\n")); 5319 print_driver_short(dev->driver, indent+1); 5320 indentprintf(("Devclass:\n")); 5321 print_devclass_short(dev->devclass, indent+1); 5322 } 5323 5324 void 5325 print_device_tree_short(device_t dev, int indent) 5326 /* print the device and all its children (indented) */ 5327 { 5328 device_t child; 5329 5330 if (!dev) 5331 return; 5332 5333 print_device_short(dev, indent); 5334 5335 TAILQ_FOREACH(child, &dev->children, link) { 5336 print_device_tree_short(child, indent+1); 5337 } 5338 } 5339 5340 void 5341 print_device_tree(device_t dev, int indent) 5342 /* print the device and all its children (indented) */ 5343 { 5344 device_t child; 5345 5346 if (!dev) 5347 return; 5348 5349 print_device(dev, indent); 5350 5351 TAILQ_FOREACH(child, &dev->children, link) { 5352 print_device_tree(child, indent+1); 5353 } 5354 } 5355 5356 static void 5357 print_driver_short(driver_t *driver, int indent) 5358 { 5359 if (!driver) 5360 return; 5361 5362 indentprintf(("driver %s: softc size = %zd\n", 5363 driver->name, driver->size)); 5364 } 5365 5366 static void 5367 print_driver(driver_t *driver, int indent) 5368 { 5369 if (!driver) 5370 return; 5371 5372 print_driver_short(driver, indent); 5373 } 5374 5375 static void 5376 print_driver_list(driver_list_t drivers, int indent) 5377 { 5378 driverlink_t driver; 5379 5380 TAILQ_FOREACH(driver, &drivers, link) { 5381 print_driver(driver->driver, indent); 5382 } 5383 } 5384 5385 static void 5386 print_devclass_short(devclass_t dc, int indent) 5387 { 5388 if ( !dc ) 5389 return; 5390 5391 indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit)); 5392 } 5393 5394 static void 5395 print_devclass(devclass_t dc, int indent) 5396 { 5397 int i; 5398 5399 if ( !dc ) 5400 return; 5401 5402 print_devclass_short(dc, indent); 5403 indentprintf(("Drivers:\n")); 5404 print_driver_list(dc->drivers, indent+1); 5405 5406 indentprintf(("Devices:\n")); 5407 for (i = 0; i < dc->maxunit; i++) 5408 if (dc->devices[i]) 5409 print_device(dc->devices[i], indent+1); 5410 } 5411 5412 void 5413 print_devclass_list_short(void) 5414 { 5415 devclass_t dc; 5416 5417 printf("Short listing of devclasses, drivers & devices:\n"); 5418 TAILQ_FOREACH(dc, &devclasses, link) { 5419 print_devclass_short(dc, 0); 5420 } 5421 } 5422 5423 void 5424 print_devclass_list(void) 5425 { 5426 devclass_t dc; 5427 5428 printf("Full listing of devclasses, drivers & devices:\n"); 5429 TAILQ_FOREACH(dc, &devclasses, link) { 5430 print_devclass(dc, 0); 5431 } 5432 } 5433 5434 #endif 5435 5436 /* 5437 * User-space access to the device tree. 5438 * 5439 * We implement a small set of nodes: 5440 * 5441 * hw.bus Single integer read method to obtain the 5442 * current generation count. 5443 * hw.bus.devices Reads the entire device tree in flat space. 5444 * hw.bus.rman Resource manager interface 5445 * 5446 * We might like to add the ability to scan devclasses and/or drivers to 5447 * determine what else is currently loaded/available. 5448 */ 5449 5450 static int 5451 sysctl_bus(SYSCTL_HANDLER_ARGS) 5452 { 5453 struct u_businfo ubus; 5454 5455 ubus.ub_version = BUS_USER_VERSION; 5456 ubus.ub_generation = bus_data_generation; 5457 5458 return (SYSCTL_OUT(req, &ubus, sizeof(ubus))); 5459 } 5460 SYSCTL_NODE(_hw_bus, OID_AUTO, info, CTLFLAG_RW, sysctl_bus, 5461 "bus-related data"); 5462 5463 static int 5464 sysctl_devices(SYSCTL_HANDLER_ARGS) 5465 { 5466 int *name = (int *)arg1; 5467 u_int namelen = arg2; 5468 int index; 5469 device_t dev; 5470 struct u_device *udev; 5471 int error; 5472 char *walker, *ep; 5473 5474 if (namelen != 2) 5475 return (EINVAL); 5476 5477 if (bus_data_generation_check(name[0])) 5478 return (EINVAL); 5479 5480 index = name[1]; 5481 5482 /* 5483 * Scan the list of devices, looking for the requested index. 5484 */ 5485 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 5486 if (index-- == 0) 5487 break; 5488 } 5489 if (dev == NULL) 5490 return (ENOENT); 5491 5492 /* 5493 * Populate the return item, careful not to overflow the buffer. 5494 */ 5495 udev = malloc(sizeof(*udev), M_BUS, M_WAITOK | M_ZERO); 5496 if (udev == NULL) 5497 return (ENOMEM); 5498 udev->dv_handle = (uintptr_t)dev; 5499 udev->dv_parent = (uintptr_t)dev->parent; 5500 udev->dv_devflags = dev->devflags; 5501 udev->dv_flags = dev->flags; 5502 udev->dv_state = dev->state; 5503 walker = udev->dv_fields; 5504 ep = walker + sizeof(udev->dv_fields); 5505 #define CP(src) \ 5506 if ((src) == NULL) \ 5507 *walker++ = '\0'; \ 5508 else { \ 5509 strlcpy(walker, (src), ep - walker); \ 5510 walker += strlen(walker) + 1; \ 5511 } \ 5512 if (walker >= ep) \ 5513 break; 5514 5515 do { 5516 CP(dev->nameunit); 5517 CP(dev->desc); 5518 CP(dev->driver != NULL ? dev->driver->name : NULL); 5519 bus_child_pnpinfo_str(dev, walker, ep - walker); 5520 walker += strlen(walker) + 1; 5521 if (walker >= ep) 5522 break; 5523 bus_child_location_str(dev, walker, ep - walker); 5524 walker += strlen(walker) + 1; 5525 if (walker >= ep) 5526 break; 5527 *walker++ = '\0'; 5528 } while (0); 5529 #undef CP 5530 error = SYSCTL_OUT(req, udev, sizeof(*udev)); 5531 free(udev, M_BUS); 5532 return (error); 5533 } 5534 5535 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, CTLFLAG_RD, sysctl_devices, 5536 "system device tree"); 5537 5538 int 5539 bus_data_generation_check(int generation) 5540 { 5541 if (generation != bus_data_generation) 5542 return (1); 5543 5544 /* XXX generate optimised lists here? */ 5545 return (0); 5546 } 5547 5548 void 5549 bus_data_generation_update(void) 5550 { 5551 bus_data_generation++; 5552 } 5553 5554 int 5555 bus_free_resource(device_t dev, int type, struct resource *r) 5556 { 5557 if (r == NULL) 5558 return (0); 5559 return (bus_release_resource(dev, type, rman_get_rid(r), r)); 5560 } 5561 5562 device_t 5563 device_lookup_by_name(const char *name) 5564 { 5565 device_t dev; 5566 5567 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 5568 if (dev->nameunit != NULL && strcmp(dev->nameunit, name) == 0) 5569 return (dev); 5570 } 5571 return (NULL); 5572 } 5573 5574 /* 5575 * /dev/devctl2 implementation. The existing /dev/devctl device has 5576 * implicit semantics on open, so it could not be reused for this. 5577 * Another option would be to call this /dev/bus? 5578 */ 5579 static int 5580 find_device(struct devreq *req, device_t *devp) 5581 { 5582 device_t dev; 5583 5584 /* 5585 * First, ensure that the name is nul terminated. 5586 */ 5587 if (memchr(req->dr_name, '\0', sizeof(req->dr_name)) == NULL) 5588 return (EINVAL); 5589 5590 /* 5591 * Second, try to find an attached device whose name matches 5592 * 'name'. 5593 */ 5594 dev = device_lookup_by_name(req->dr_name); 5595 if (dev != NULL) { 5596 *devp = dev; 5597 return (0); 5598 } 5599 5600 /* Finally, give device enumerators a chance. */ 5601 dev = NULL; 5602 EVENTHANDLER_DIRECT_INVOKE(dev_lookup, req->dr_name, &dev); 5603 if (dev == NULL) 5604 return (ENOENT); 5605 *devp = dev; 5606 return (0); 5607 } 5608 5609 static bool 5610 driver_exists(device_t bus, const char *driver) 5611 { 5612 devclass_t dc; 5613 5614 for (dc = bus->devclass; dc != NULL; dc = dc->parent) { 5615 if (devclass_find_driver_internal(dc, driver) != NULL) 5616 return (true); 5617 } 5618 return (false); 5619 } 5620 5621 static void 5622 device_gen_nomatch(device_t dev) 5623 { 5624 device_t child; 5625 5626 if (dev->flags & DF_NEEDNOMATCH && 5627 dev->state == DS_NOTPRESENT) { 5628 BUS_PROBE_NOMATCH(dev->parent, dev); 5629 devnomatch(dev); 5630 dev->flags |= DF_DONENOMATCH; 5631 } 5632 dev->flags &= ~DF_NEEDNOMATCH; 5633 TAILQ_FOREACH(child, &dev->children, link) { 5634 device_gen_nomatch(child); 5635 } 5636 } 5637 5638 static void 5639 device_do_deferred_actions(void) 5640 { 5641 devclass_t dc; 5642 driverlink_t dl; 5643 5644 /* 5645 * Walk through the devclasses to find all the drivers we've tagged as 5646 * deferred during the freeze and call the driver added routines. They 5647 * have already been added to the lists in the background, so the driver 5648 * added routines that trigger a probe will have all the right bidders 5649 * for the probe auction. 5650 */ 5651 TAILQ_FOREACH(dc, &devclasses, link) { 5652 TAILQ_FOREACH(dl, &dc->drivers, link) { 5653 if (dl->flags & DL_DEFERRED_PROBE) { 5654 devclass_driver_added(dc, dl->driver); 5655 dl->flags &= ~DL_DEFERRED_PROBE; 5656 } 5657 } 5658 } 5659 5660 /* 5661 * We also defer no-match events during a freeze. Walk the tree and 5662 * generate all the pent-up events that are still relevant. 5663 */ 5664 device_gen_nomatch(root_bus); 5665 bus_data_generation_update(); 5666 } 5667 5668 static int 5669 devctl2_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag, 5670 struct thread *td) 5671 { 5672 struct devreq *req; 5673 device_t dev; 5674 int error, old; 5675 5676 /* Locate the device to control. */ 5677 mtx_lock(&Giant); 5678 req = (struct devreq *)data; 5679 switch (cmd) { 5680 case DEV_ATTACH: 5681 case DEV_DETACH: 5682 case DEV_ENABLE: 5683 case DEV_DISABLE: 5684 case DEV_SUSPEND: 5685 case DEV_RESUME: 5686 case DEV_SET_DRIVER: 5687 case DEV_CLEAR_DRIVER: 5688 case DEV_RESCAN: 5689 case DEV_DELETE: 5690 case DEV_RESET: 5691 error = priv_check(td, PRIV_DRIVER); 5692 if (error == 0) 5693 error = find_device(req, &dev); 5694 break; 5695 case DEV_FREEZE: 5696 case DEV_THAW: 5697 error = priv_check(td, PRIV_DRIVER); 5698 break; 5699 default: 5700 error = ENOTTY; 5701 break; 5702 } 5703 if (error) { 5704 mtx_unlock(&Giant); 5705 return (error); 5706 } 5707 5708 /* Perform the requested operation. */ 5709 switch (cmd) { 5710 case DEV_ATTACH: 5711 if (device_is_attached(dev) && (dev->flags & DF_REBID) == 0) 5712 error = EBUSY; 5713 else if (!device_is_enabled(dev)) 5714 error = ENXIO; 5715 else 5716 error = device_probe_and_attach(dev); 5717 break; 5718 case DEV_DETACH: 5719 if (!device_is_attached(dev)) { 5720 error = ENXIO; 5721 break; 5722 } 5723 if (!(req->dr_flags & DEVF_FORCE_DETACH)) { 5724 error = device_quiesce(dev); 5725 if (error) 5726 break; 5727 } 5728 error = device_detach(dev); 5729 break; 5730 case DEV_ENABLE: 5731 if (device_is_enabled(dev)) { 5732 error = EBUSY; 5733 break; 5734 } 5735 5736 /* 5737 * If the device has been probed but not attached (e.g. 5738 * when it has been disabled by a loader hint), just 5739 * attach the device rather than doing a full probe. 5740 */ 5741 device_enable(dev); 5742 if (device_is_alive(dev)) { 5743 /* 5744 * If the device was disabled via a hint, clear 5745 * the hint. 5746 */ 5747 if (resource_disabled(dev->driver->name, dev->unit)) 5748 resource_unset_value(dev->driver->name, 5749 dev->unit, "disabled"); 5750 error = device_attach(dev); 5751 } else 5752 error = device_probe_and_attach(dev); 5753 break; 5754 case DEV_DISABLE: 5755 if (!device_is_enabled(dev)) { 5756 error = ENXIO; 5757 break; 5758 } 5759 5760 if (!(req->dr_flags & DEVF_FORCE_DETACH)) { 5761 error = device_quiesce(dev); 5762 if (error) 5763 break; 5764 } 5765 5766 /* 5767 * Force DF_FIXEDCLASS on around detach to preserve 5768 * the existing name. 5769 */ 5770 old = dev->flags; 5771 dev->flags |= DF_FIXEDCLASS; 5772 error = device_detach(dev); 5773 if (!(old & DF_FIXEDCLASS)) 5774 dev->flags &= ~DF_FIXEDCLASS; 5775 if (error == 0) 5776 device_disable(dev); 5777 break; 5778 case DEV_SUSPEND: 5779 if (device_is_suspended(dev)) { 5780 error = EBUSY; 5781 break; 5782 } 5783 if (device_get_parent(dev) == NULL) { 5784 error = EINVAL; 5785 break; 5786 } 5787 error = BUS_SUSPEND_CHILD(device_get_parent(dev), dev); 5788 break; 5789 case DEV_RESUME: 5790 if (!device_is_suspended(dev)) { 5791 error = EINVAL; 5792 break; 5793 } 5794 if (device_get_parent(dev) == NULL) { 5795 error = EINVAL; 5796 break; 5797 } 5798 error = BUS_RESUME_CHILD(device_get_parent(dev), dev); 5799 break; 5800 case DEV_SET_DRIVER: { 5801 devclass_t dc; 5802 char driver[128]; 5803 5804 error = copyinstr(req->dr_data, driver, sizeof(driver), NULL); 5805 if (error) 5806 break; 5807 if (driver[0] == '\0') { 5808 error = EINVAL; 5809 break; 5810 } 5811 if (dev->devclass != NULL && 5812 strcmp(driver, dev->devclass->name) == 0) 5813 /* XXX: Could possibly force DF_FIXEDCLASS on? */ 5814 break; 5815 5816 /* 5817 * Scan drivers for this device's bus looking for at 5818 * least one matching driver. 5819 */ 5820 if (dev->parent == NULL) { 5821 error = EINVAL; 5822 break; 5823 } 5824 if (!driver_exists(dev->parent, driver)) { 5825 error = ENOENT; 5826 break; 5827 } 5828 dc = devclass_create(driver); 5829 if (dc == NULL) { 5830 error = ENOMEM; 5831 break; 5832 } 5833 5834 /* Detach device if necessary. */ 5835 if (device_is_attached(dev)) { 5836 if (req->dr_flags & DEVF_SET_DRIVER_DETACH) 5837 error = device_detach(dev); 5838 else 5839 error = EBUSY; 5840 if (error) 5841 break; 5842 } 5843 5844 /* Clear any previously-fixed device class and unit. */ 5845 if (dev->flags & DF_FIXEDCLASS) 5846 devclass_delete_device(dev->devclass, dev); 5847 dev->flags |= DF_WILDCARD; 5848 dev->unit = -1; 5849 5850 /* Force the new device class. */ 5851 error = devclass_add_device(dc, dev); 5852 if (error) 5853 break; 5854 dev->flags |= DF_FIXEDCLASS; 5855 error = device_probe_and_attach(dev); 5856 break; 5857 } 5858 case DEV_CLEAR_DRIVER: 5859 if (!(dev->flags & DF_FIXEDCLASS)) { 5860 error = 0; 5861 break; 5862 } 5863 if (device_is_attached(dev)) { 5864 if (req->dr_flags & DEVF_CLEAR_DRIVER_DETACH) 5865 error = device_detach(dev); 5866 else 5867 error = EBUSY; 5868 if (error) 5869 break; 5870 } 5871 5872 dev->flags &= ~DF_FIXEDCLASS; 5873 dev->flags |= DF_WILDCARD; 5874 devclass_delete_device(dev->devclass, dev); 5875 error = device_probe_and_attach(dev); 5876 break; 5877 case DEV_RESCAN: 5878 if (!device_is_attached(dev)) { 5879 error = ENXIO; 5880 break; 5881 } 5882 error = BUS_RESCAN(dev); 5883 break; 5884 case DEV_DELETE: { 5885 device_t parent; 5886 5887 parent = device_get_parent(dev); 5888 if (parent == NULL) { 5889 error = EINVAL; 5890 break; 5891 } 5892 if (!(req->dr_flags & DEVF_FORCE_DELETE)) { 5893 if (bus_child_present(dev) != 0) { 5894 error = EBUSY; 5895 break; 5896 } 5897 } 5898 5899 error = device_delete_child(parent, dev); 5900 break; 5901 } 5902 case DEV_FREEZE: 5903 if (device_frozen) 5904 error = EBUSY; 5905 else 5906 device_frozen = true; 5907 break; 5908 case DEV_THAW: 5909 if (!device_frozen) 5910 error = EBUSY; 5911 else { 5912 device_do_deferred_actions(); 5913 device_frozen = false; 5914 } 5915 break; 5916 case DEV_RESET: 5917 if ((req->dr_flags & ~(DEVF_RESET_DETACH)) != 0) { 5918 error = EINVAL; 5919 break; 5920 } 5921 error = BUS_RESET_CHILD(device_get_parent(dev), dev, 5922 req->dr_flags); 5923 break; 5924 } 5925 mtx_unlock(&Giant); 5926 return (error); 5927 } 5928 5929 static struct cdevsw devctl2_cdevsw = { 5930 .d_version = D_VERSION, 5931 .d_ioctl = devctl2_ioctl, 5932 .d_name = "devctl2", 5933 }; 5934 5935 static void 5936 devctl2_init(void) 5937 { 5938 5939 make_dev_credf(MAKEDEV_ETERNAL, &devctl2_cdevsw, 0, NULL, 5940 UID_ROOT, GID_WHEEL, 0600, "devctl2"); 5941 } 5942 5943 /* 5944 * APIs to manage deprecation and obsolescence. 5945 */ 5946 static int obsolete_panic = 0; 5947 SYSCTL_INT(_debug, OID_AUTO, obsolete_panic, CTLFLAG_RWTUN, &obsolete_panic, 0, 5948 "Panic when obsolete features are used (0 = never, 1 = if osbolete, " 5949 "2 = if deprecated)"); 5950 5951 static void 5952 gone_panic(int major, int running, const char *msg) 5953 { 5954 5955 switch (obsolete_panic) 5956 { 5957 case 0: 5958 return; 5959 case 1: 5960 if (running < major) 5961 return; 5962 /* FALLTHROUGH */ 5963 default: 5964 panic("%s", msg); 5965 } 5966 } 5967 5968 void 5969 _gone_in(int major, const char *msg) 5970 { 5971 5972 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg); 5973 if (P_OSREL_MAJOR(__FreeBSD_version) >= major) 5974 printf("Obsolete code will be removed soon: %s\n", msg); 5975 else 5976 printf("Deprecated code (to be removed in FreeBSD %d): %s\n", 5977 major, msg); 5978 } 5979 5980 void 5981 _gone_in_dev(device_t dev, int major, const char *msg) 5982 { 5983 5984 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg); 5985 if (P_OSREL_MAJOR(__FreeBSD_version) >= major) 5986 device_printf(dev, 5987 "Obsolete code will be removed soon: %s\n", msg); 5988 else 5989 device_printf(dev, 5990 "Deprecated code (to be removed in FreeBSD %d): %s\n", 5991 major, msg); 5992 } 5993 5994 #ifdef DDB 5995 DB_SHOW_COMMAND(device, db_show_device) 5996 { 5997 device_t dev; 5998 5999 if (!have_addr) 6000 return; 6001 6002 dev = (device_t)addr; 6003 6004 db_printf("name: %s\n", device_get_nameunit(dev)); 6005 db_printf(" driver: %s\n", DRIVERNAME(dev->driver)); 6006 db_printf(" class: %s\n", DEVCLANAME(dev->devclass)); 6007 db_printf(" addr: %p\n", dev); 6008 db_printf(" parent: %p\n", dev->parent); 6009 db_printf(" softc: %p\n", dev->softc); 6010 db_printf(" ivars: %p\n", dev->ivars); 6011 } 6012 6013 DB_SHOW_ALL_COMMAND(devices, db_show_all_devices) 6014 { 6015 device_t dev; 6016 6017 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 6018 db_show_device((db_expr_t)dev, true, count, modif); 6019 } 6020 } 6021 #endif 6022