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 implementing DEVICE_DETACH() 3757 * 3758 * This function can be used to help implement the DEVICE_DETACH() for 3759 * a bus. It calls device_detach() for each of the device's 3760 * children. 3761 */ 3762 int 3763 bus_generic_detach(device_t dev) 3764 { 3765 device_t child; 3766 int error; 3767 3768 if (dev->state != DS_ATTACHED) 3769 return (EBUSY); 3770 3771 /* 3772 * Detach children in the reverse order. 3773 * See bus_generic_suspend for details. 3774 */ 3775 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3776 if ((error = device_detach(child)) != 0) 3777 return (error); 3778 } 3779 3780 return (0); 3781 } 3782 3783 /** 3784 * @brief Helper function for implementing DEVICE_SHUTDOWN() 3785 * 3786 * This function can be used to help implement the DEVICE_SHUTDOWN() 3787 * for a bus. It calls device_shutdown() for each of the device's 3788 * children. 3789 */ 3790 int 3791 bus_generic_shutdown(device_t dev) 3792 { 3793 device_t child; 3794 3795 /* 3796 * Shut down children in the reverse order. 3797 * See bus_generic_suspend for details. 3798 */ 3799 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3800 device_shutdown(child); 3801 } 3802 3803 return (0); 3804 } 3805 3806 /** 3807 * @brief Default function for suspending a child device. 3808 * 3809 * This function is to be used by a bus's DEVICE_SUSPEND_CHILD(). 3810 */ 3811 int 3812 bus_generic_suspend_child(device_t dev, device_t child) 3813 { 3814 int error; 3815 3816 error = DEVICE_SUSPEND(child); 3817 3818 if (error == 0) 3819 child->flags |= DF_SUSPENDED; 3820 3821 return (error); 3822 } 3823 3824 /** 3825 * @brief Default function for resuming a child device. 3826 * 3827 * This function is to be used by a bus's DEVICE_RESUME_CHILD(). 3828 */ 3829 int 3830 bus_generic_resume_child(device_t dev, device_t child) 3831 { 3832 3833 DEVICE_RESUME(child); 3834 child->flags &= ~DF_SUSPENDED; 3835 3836 return (0); 3837 } 3838 3839 /** 3840 * @brief Helper function for implementing DEVICE_SUSPEND() 3841 * 3842 * This function can be used to help implement the DEVICE_SUSPEND() 3843 * for a bus. It calls DEVICE_SUSPEND() for each of the device's 3844 * children. If any call to DEVICE_SUSPEND() fails, the suspend 3845 * operation is aborted and any devices which were suspended are 3846 * resumed immediately by calling their DEVICE_RESUME() methods. 3847 */ 3848 int 3849 bus_generic_suspend(device_t dev) 3850 { 3851 int error; 3852 device_t child; 3853 3854 /* 3855 * Suspend children in the reverse order. 3856 * For most buses all children are equal, so the order does not matter. 3857 * Other buses, such as acpi, carefully order their child devices to 3858 * express implicit dependencies between them. For such buses it is 3859 * safer to bring down devices in the reverse order. 3860 */ 3861 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3862 error = BUS_SUSPEND_CHILD(dev, child); 3863 if (error != 0) { 3864 child = TAILQ_NEXT(child, link); 3865 if (child != NULL) { 3866 TAILQ_FOREACH_FROM(child, &dev->children, link) 3867 BUS_RESUME_CHILD(dev, child); 3868 } 3869 return (error); 3870 } 3871 } 3872 return (0); 3873 } 3874 3875 /** 3876 * @brief Helper function for implementing DEVICE_RESUME() 3877 * 3878 * This function can be used to help implement the DEVICE_RESUME() for 3879 * a bus. It calls DEVICE_RESUME() on each of the device's children. 3880 */ 3881 int 3882 bus_generic_resume(device_t dev) 3883 { 3884 device_t child; 3885 3886 TAILQ_FOREACH(child, &dev->children, link) { 3887 BUS_RESUME_CHILD(dev, child); 3888 /* if resume fails, there's nothing we can usefully do... */ 3889 } 3890 return (0); 3891 } 3892 3893 3894 /** 3895 * @brief Helper function for implementing BUS_RESET_POST 3896 * 3897 * Bus can use this function to implement common operations of 3898 * re-attaching or resuming the children after the bus itself was 3899 * reset, and after restoring bus-unique state of children. 3900 * 3901 * @param dev The bus 3902 * #param flags DEVF_RESET_* 3903 */ 3904 int 3905 bus_helper_reset_post(device_t dev, int flags) 3906 { 3907 device_t child; 3908 int error, error1; 3909 3910 error = 0; 3911 TAILQ_FOREACH(child, &dev->children,link) { 3912 BUS_RESET_POST(dev, child); 3913 error1 = (flags & DEVF_RESET_DETACH) != 0 ? 3914 device_probe_and_attach(child) : 3915 BUS_RESUME_CHILD(dev, child); 3916 if (error == 0 && error1 != 0) 3917 error = error1; 3918 } 3919 return (error); 3920 } 3921 3922 static void 3923 bus_helper_reset_prepare_rollback(device_t dev, device_t child, int flags) 3924 { 3925 3926 child = TAILQ_NEXT(child, link); 3927 if (child == NULL) 3928 return; 3929 TAILQ_FOREACH_FROM(child, &dev->children,link) { 3930 BUS_RESET_POST(dev, child); 3931 if ((flags & DEVF_RESET_DETACH) != 0) 3932 device_probe_and_attach(child); 3933 else 3934 BUS_RESUME_CHILD(dev, child); 3935 } 3936 } 3937 3938 /** 3939 * @brief Helper function for implementing BUS_RESET_PREPARE 3940 * 3941 * Bus can use this function to implement common operations of 3942 * detaching or suspending the children before the bus itself is 3943 * reset, and then save bus-unique state of children that must 3944 * persists around reset. 3945 * 3946 * @param dev The bus 3947 * #param flags DEVF_RESET_* 3948 */ 3949 int 3950 bus_helper_reset_prepare(device_t dev, int flags) 3951 { 3952 device_t child; 3953 int error; 3954 3955 if (dev->state != DS_ATTACHED) 3956 return (EBUSY); 3957 3958 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3959 if ((flags & DEVF_RESET_DETACH) != 0) { 3960 error = device_get_state(child) == DS_ATTACHED ? 3961 device_detach(child) : 0; 3962 } else { 3963 error = BUS_SUSPEND_CHILD(dev, child); 3964 } 3965 if (error == 0) { 3966 error = BUS_RESET_PREPARE(dev, child); 3967 if (error != 0) { 3968 if ((flags & DEVF_RESET_DETACH) != 0) 3969 device_probe_and_attach(child); 3970 else 3971 BUS_RESUME_CHILD(dev, child); 3972 } 3973 } 3974 if (error != 0) { 3975 bus_helper_reset_prepare_rollback(dev, child, flags); 3976 return (error); 3977 } 3978 } 3979 return (0); 3980 } 3981 3982 /** 3983 * @brief Helper function for implementing BUS_PRINT_CHILD(). 3984 * 3985 * This function prints the first part of the ascii representation of 3986 * @p child, including its name, unit and description (if any - see 3987 * device_set_desc()). 3988 * 3989 * @returns the number of characters printed 3990 */ 3991 int 3992 bus_print_child_header(device_t dev, device_t child) 3993 { 3994 int retval = 0; 3995 3996 if (device_get_desc(child)) { 3997 retval += device_printf(child, "<%s>", device_get_desc(child)); 3998 } else { 3999 retval += printf("%s", device_get_nameunit(child)); 4000 } 4001 4002 return (retval); 4003 } 4004 4005 /** 4006 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4007 * 4008 * This function prints the last part of the ascii representation of 4009 * @p child, which consists of the string @c " on " followed by the 4010 * name and unit of the @p dev. 4011 * 4012 * @returns the number of characters printed 4013 */ 4014 int 4015 bus_print_child_footer(device_t dev, device_t child) 4016 { 4017 return (printf(" on %s\n", device_get_nameunit(dev))); 4018 } 4019 4020 /** 4021 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4022 * 4023 * This function prints out the VM domain for the given device. 4024 * 4025 * @returns the number of characters printed 4026 */ 4027 int 4028 bus_print_child_domain(device_t dev, device_t child) 4029 { 4030 int domain; 4031 4032 /* No domain? Don't print anything */ 4033 if (BUS_GET_DOMAIN(dev, child, &domain) != 0) 4034 return (0); 4035 4036 return (printf(" numa-domain %d", domain)); 4037 } 4038 4039 /** 4040 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4041 * 4042 * This function simply calls bus_print_child_header() followed by 4043 * bus_print_child_footer(). 4044 * 4045 * @returns the number of characters printed 4046 */ 4047 int 4048 bus_generic_print_child(device_t dev, device_t child) 4049 { 4050 int retval = 0; 4051 4052 retval += bus_print_child_header(dev, child); 4053 retval += bus_print_child_domain(dev, child); 4054 retval += bus_print_child_footer(dev, child); 4055 4056 return (retval); 4057 } 4058 4059 /** 4060 * @brief Stub function for implementing BUS_READ_IVAR(). 4061 * 4062 * @returns ENOENT 4063 */ 4064 int 4065 bus_generic_read_ivar(device_t dev, device_t child, int index, 4066 uintptr_t * result) 4067 { 4068 return (ENOENT); 4069 } 4070 4071 /** 4072 * @brief Stub function for implementing BUS_WRITE_IVAR(). 4073 * 4074 * @returns ENOENT 4075 */ 4076 int 4077 bus_generic_write_ivar(device_t dev, device_t child, int index, 4078 uintptr_t value) 4079 { 4080 return (ENOENT); 4081 } 4082 4083 /** 4084 * @brief Stub function for implementing BUS_GET_RESOURCE_LIST(). 4085 * 4086 * @returns NULL 4087 */ 4088 struct resource_list * 4089 bus_generic_get_resource_list(device_t dev, device_t child) 4090 { 4091 return (NULL); 4092 } 4093 4094 /** 4095 * @brief Helper function for implementing BUS_DRIVER_ADDED(). 4096 * 4097 * This implementation of BUS_DRIVER_ADDED() simply calls the driver's 4098 * DEVICE_IDENTIFY() method to allow it to add new children to the bus 4099 * and then calls device_probe_and_attach() for each unattached child. 4100 */ 4101 void 4102 bus_generic_driver_added(device_t dev, driver_t *driver) 4103 { 4104 device_t child; 4105 4106 DEVICE_IDENTIFY(driver, dev); 4107 TAILQ_FOREACH(child, &dev->children, link) { 4108 if (child->state == DS_NOTPRESENT || 4109 (child->flags & DF_REBID)) 4110 device_probe_and_attach(child); 4111 } 4112 } 4113 4114 /** 4115 * @brief Helper function for implementing BUS_NEW_PASS(). 4116 * 4117 * This implementing of BUS_NEW_PASS() first calls the identify 4118 * routines for any drivers that probe at the current pass. Then it 4119 * walks the list of devices for this bus. If a device is already 4120 * attached, then it calls BUS_NEW_PASS() on that device. If the 4121 * device is not already attached, it attempts to attach a driver to 4122 * it. 4123 */ 4124 void 4125 bus_generic_new_pass(device_t dev) 4126 { 4127 driverlink_t dl; 4128 devclass_t dc; 4129 device_t child; 4130 4131 dc = dev->devclass; 4132 TAILQ_FOREACH(dl, &dc->drivers, link) { 4133 if (dl->pass == bus_current_pass) 4134 DEVICE_IDENTIFY(dl->driver, dev); 4135 } 4136 TAILQ_FOREACH(child, &dev->children, link) { 4137 if (child->state >= DS_ATTACHED) 4138 BUS_NEW_PASS(child); 4139 else if (child->state == DS_NOTPRESENT) 4140 device_probe_and_attach(child); 4141 } 4142 } 4143 4144 /** 4145 * @brief Helper function for implementing BUS_SETUP_INTR(). 4146 * 4147 * This simple implementation of BUS_SETUP_INTR() simply calls the 4148 * BUS_SETUP_INTR() method of the parent of @p dev. 4149 */ 4150 int 4151 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq, 4152 int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg, 4153 void **cookiep) 4154 { 4155 /* Propagate up the bus hierarchy until someone handles it. */ 4156 if (dev->parent) 4157 return (BUS_SETUP_INTR(dev->parent, child, irq, flags, 4158 filter, intr, arg, cookiep)); 4159 return (EINVAL); 4160 } 4161 4162 /** 4163 * @brief Helper function for implementing BUS_TEARDOWN_INTR(). 4164 * 4165 * This simple implementation of BUS_TEARDOWN_INTR() simply calls the 4166 * BUS_TEARDOWN_INTR() method of the parent of @p dev. 4167 */ 4168 int 4169 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq, 4170 void *cookie) 4171 { 4172 /* Propagate up the bus hierarchy until someone handles it. */ 4173 if (dev->parent) 4174 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie)); 4175 return (EINVAL); 4176 } 4177 4178 /** 4179 * @brief Helper function for implementing BUS_SUSPEND_INTR(). 4180 * 4181 * This simple implementation of BUS_SUSPEND_INTR() simply calls the 4182 * BUS_SUSPEND_INTR() method of the parent of @p dev. 4183 */ 4184 int 4185 bus_generic_suspend_intr(device_t dev, device_t child, struct resource *irq) 4186 { 4187 /* Propagate up the bus hierarchy until someone handles it. */ 4188 if (dev->parent) 4189 return (BUS_SUSPEND_INTR(dev->parent, child, irq)); 4190 return (EINVAL); 4191 } 4192 4193 /** 4194 * @brief Helper function for implementing BUS_RESUME_INTR(). 4195 * 4196 * This simple implementation of BUS_RESUME_INTR() simply calls the 4197 * BUS_RESUME_INTR() method of the parent of @p dev. 4198 */ 4199 int 4200 bus_generic_resume_intr(device_t dev, device_t child, struct resource *irq) 4201 { 4202 /* Propagate up the bus hierarchy until someone handles it. */ 4203 if (dev->parent) 4204 return (BUS_RESUME_INTR(dev->parent, child, irq)); 4205 return (EINVAL); 4206 } 4207 4208 /** 4209 * @brief Helper function for implementing BUS_ADJUST_RESOURCE(). 4210 * 4211 * This simple implementation of BUS_ADJUST_RESOURCE() simply calls the 4212 * BUS_ADJUST_RESOURCE() method of the parent of @p dev. 4213 */ 4214 int 4215 bus_generic_adjust_resource(device_t dev, device_t child, int type, 4216 struct resource *r, rman_res_t start, rman_res_t end) 4217 { 4218 /* Propagate up the bus hierarchy until someone handles it. */ 4219 if (dev->parent) 4220 return (BUS_ADJUST_RESOURCE(dev->parent, child, type, r, start, 4221 end)); 4222 return (EINVAL); 4223 } 4224 4225 /** 4226 * @brief Helper function for implementing BUS_ALLOC_RESOURCE(). 4227 * 4228 * This simple implementation of BUS_ALLOC_RESOURCE() simply calls the 4229 * BUS_ALLOC_RESOURCE() method of the parent of @p dev. 4230 */ 4231 struct resource * 4232 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid, 4233 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 4234 { 4235 /* Propagate up the bus hierarchy until someone handles it. */ 4236 if (dev->parent) 4237 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid, 4238 start, end, count, flags)); 4239 return (NULL); 4240 } 4241 4242 /** 4243 * @brief Helper function for implementing BUS_RELEASE_RESOURCE(). 4244 * 4245 * This simple implementation of BUS_RELEASE_RESOURCE() simply calls the 4246 * BUS_RELEASE_RESOURCE() method of the parent of @p dev. 4247 */ 4248 int 4249 bus_generic_release_resource(device_t dev, device_t child, int type, int rid, 4250 struct resource *r) 4251 { 4252 /* Propagate up the bus hierarchy until someone handles it. */ 4253 if (dev->parent) 4254 return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid, 4255 r)); 4256 return (EINVAL); 4257 } 4258 4259 /** 4260 * @brief Helper function for implementing BUS_ACTIVATE_RESOURCE(). 4261 * 4262 * This simple implementation of BUS_ACTIVATE_RESOURCE() simply calls the 4263 * BUS_ACTIVATE_RESOURCE() method of the parent of @p dev. 4264 */ 4265 int 4266 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid, 4267 struct resource *r) 4268 { 4269 /* Propagate up the bus hierarchy until someone handles it. */ 4270 if (dev->parent) 4271 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid, 4272 r)); 4273 return (EINVAL); 4274 } 4275 4276 /** 4277 * @brief Helper function for implementing BUS_DEACTIVATE_RESOURCE(). 4278 * 4279 * This simple implementation of BUS_DEACTIVATE_RESOURCE() simply calls the 4280 * BUS_DEACTIVATE_RESOURCE() method of the parent of @p dev. 4281 */ 4282 int 4283 bus_generic_deactivate_resource(device_t dev, device_t child, int type, 4284 int rid, struct resource *r) 4285 { 4286 /* Propagate up the bus hierarchy until someone handles it. */ 4287 if (dev->parent) 4288 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid, 4289 r)); 4290 return (EINVAL); 4291 } 4292 4293 /** 4294 * @brief Helper function for implementing BUS_MAP_RESOURCE(). 4295 * 4296 * This simple implementation of BUS_MAP_RESOURCE() simply calls the 4297 * BUS_MAP_RESOURCE() method of the parent of @p dev. 4298 */ 4299 int 4300 bus_generic_map_resource(device_t dev, device_t child, int type, 4301 struct resource *r, struct resource_map_request *args, 4302 struct resource_map *map) 4303 { 4304 /* Propagate up the bus hierarchy until someone handles it. */ 4305 if (dev->parent) 4306 return (BUS_MAP_RESOURCE(dev->parent, child, type, r, args, 4307 map)); 4308 return (EINVAL); 4309 } 4310 4311 /** 4312 * @brief Helper function for implementing BUS_UNMAP_RESOURCE(). 4313 * 4314 * This simple implementation of BUS_UNMAP_RESOURCE() simply calls the 4315 * BUS_UNMAP_RESOURCE() method of the parent of @p dev. 4316 */ 4317 int 4318 bus_generic_unmap_resource(device_t dev, device_t child, int type, 4319 struct resource *r, struct resource_map *map) 4320 { 4321 /* Propagate up the bus hierarchy until someone handles it. */ 4322 if (dev->parent) 4323 return (BUS_UNMAP_RESOURCE(dev->parent, child, type, r, map)); 4324 return (EINVAL); 4325 } 4326 4327 /** 4328 * @brief Helper function for implementing BUS_BIND_INTR(). 4329 * 4330 * This simple implementation of BUS_BIND_INTR() simply calls the 4331 * BUS_BIND_INTR() method of the parent of @p dev. 4332 */ 4333 int 4334 bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq, 4335 int cpu) 4336 { 4337 4338 /* Propagate up the bus hierarchy until someone handles it. */ 4339 if (dev->parent) 4340 return (BUS_BIND_INTR(dev->parent, child, irq, cpu)); 4341 return (EINVAL); 4342 } 4343 4344 /** 4345 * @brief Helper function for implementing BUS_CONFIG_INTR(). 4346 * 4347 * This simple implementation of BUS_CONFIG_INTR() simply calls the 4348 * BUS_CONFIG_INTR() method of the parent of @p dev. 4349 */ 4350 int 4351 bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig, 4352 enum intr_polarity pol) 4353 { 4354 4355 /* Propagate up the bus hierarchy until someone handles it. */ 4356 if (dev->parent) 4357 return (BUS_CONFIG_INTR(dev->parent, irq, trig, pol)); 4358 return (EINVAL); 4359 } 4360 4361 /** 4362 * @brief Helper function for implementing BUS_DESCRIBE_INTR(). 4363 * 4364 * This simple implementation of BUS_DESCRIBE_INTR() simply calls the 4365 * BUS_DESCRIBE_INTR() method of the parent of @p dev. 4366 */ 4367 int 4368 bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq, 4369 void *cookie, const char *descr) 4370 { 4371 4372 /* Propagate up the bus hierarchy until someone handles it. */ 4373 if (dev->parent) 4374 return (BUS_DESCRIBE_INTR(dev->parent, child, irq, cookie, 4375 descr)); 4376 return (EINVAL); 4377 } 4378 4379 /** 4380 * @brief Helper function for implementing BUS_GET_CPUS(). 4381 * 4382 * This simple implementation of BUS_GET_CPUS() simply calls the 4383 * BUS_GET_CPUS() method of the parent of @p dev. 4384 */ 4385 int 4386 bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op, 4387 size_t setsize, cpuset_t *cpuset) 4388 { 4389 4390 /* Propagate up the bus hierarchy until someone handles it. */ 4391 if (dev->parent != NULL) 4392 return (BUS_GET_CPUS(dev->parent, child, op, setsize, cpuset)); 4393 return (EINVAL); 4394 } 4395 4396 /** 4397 * @brief Helper function for implementing BUS_GET_DMA_TAG(). 4398 * 4399 * This simple implementation of BUS_GET_DMA_TAG() simply calls the 4400 * BUS_GET_DMA_TAG() method of the parent of @p dev. 4401 */ 4402 bus_dma_tag_t 4403 bus_generic_get_dma_tag(device_t dev, device_t child) 4404 { 4405 4406 /* Propagate up the bus hierarchy until someone handles it. */ 4407 if (dev->parent != NULL) 4408 return (BUS_GET_DMA_TAG(dev->parent, child)); 4409 return (NULL); 4410 } 4411 4412 /** 4413 * @brief Helper function for implementing BUS_GET_BUS_TAG(). 4414 * 4415 * This simple implementation of BUS_GET_BUS_TAG() simply calls the 4416 * BUS_GET_BUS_TAG() method of the parent of @p dev. 4417 */ 4418 bus_space_tag_t 4419 bus_generic_get_bus_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_BUS_TAG(dev->parent, child)); 4425 return ((bus_space_tag_t)0); 4426 } 4427 4428 /** 4429 * @brief Helper function for implementing BUS_GET_RESOURCE(). 4430 * 4431 * This implementation of BUS_GET_RESOURCE() uses the 4432 * resource_list_find() function to do most of the work. It calls 4433 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4434 * search. 4435 */ 4436 int 4437 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid, 4438 rman_res_t *startp, rman_res_t *countp) 4439 { 4440 struct resource_list * rl = NULL; 4441 struct resource_list_entry * rle = NULL; 4442 4443 rl = BUS_GET_RESOURCE_LIST(dev, child); 4444 if (!rl) 4445 return (EINVAL); 4446 4447 rle = resource_list_find(rl, type, rid); 4448 if (!rle) 4449 return (ENOENT); 4450 4451 if (startp) 4452 *startp = rle->start; 4453 if (countp) 4454 *countp = rle->count; 4455 4456 return (0); 4457 } 4458 4459 /** 4460 * @brief Helper function for implementing BUS_SET_RESOURCE(). 4461 * 4462 * This implementation of BUS_SET_RESOURCE() uses the 4463 * resource_list_add() function to do most of the work. It calls 4464 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4465 * edit. 4466 */ 4467 int 4468 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid, 4469 rman_res_t start, rman_res_t count) 4470 { 4471 struct resource_list * rl = NULL; 4472 4473 rl = BUS_GET_RESOURCE_LIST(dev, child); 4474 if (!rl) 4475 return (EINVAL); 4476 4477 resource_list_add(rl, type, rid, start, (start + count - 1), count); 4478 4479 return (0); 4480 } 4481 4482 /** 4483 * @brief Helper function for implementing BUS_DELETE_RESOURCE(). 4484 * 4485 * This implementation of BUS_DELETE_RESOURCE() uses the 4486 * resource_list_delete() function to do most of the work. It calls 4487 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4488 * edit. 4489 */ 4490 void 4491 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid) 4492 { 4493 struct resource_list * rl = NULL; 4494 4495 rl = BUS_GET_RESOURCE_LIST(dev, child); 4496 if (!rl) 4497 return; 4498 4499 resource_list_delete(rl, type, rid); 4500 4501 return; 4502 } 4503 4504 /** 4505 * @brief Helper function for implementing BUS_RELEASE_RESOURCE(). 4506 * 4507 * This implementation of BUS_RELEASE_RESOURCE() uses the 4508 * resource_list_release() function to do most of the work. It calls 4509 * BUS_GET_RESOURCE_LIST() to find a suitable resource list. 4510 */ 4511 int 4512 bus_generic_rl_release_resource(device_t dev, device_t child, int type, 4513 int rid, struct resource *r) 4514 { 4515 struct resource_list * rl = NULL; 4516 4517 if (device_get_parent(child) != dev) 4518 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, 4519 type, rid, r)); 4520 4521 rl = BUS_GET_RESOURCE_LIST(dev, child); 4522 if (!rl) 4523 return (EINVAL); 4524 4525 return (resource_list_release(rl, dev, child, type, rid, r)); 4526 } 4527 4528 /** 4529 * @brief Helper function for implementing BUS_ALLOC_RESOURCE(). 4530 * 4531 * This implementation of BUS_ALLOC_RESOURCE() uses the 4532 * resource_list_alloc() function to do most of the work. It calls 4533 * BUS_GET_RESOURCE_LIST() to find a suitable resource list. 4534 */ 4535 struct resource * 4536 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type, 4537 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 4538 { 4539 struct resource_list * rl = NULL; 4540 4541 if (device_get_parent(child) != dev) 4542 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 4543 type, rid, start, end, count, flags)); 4544 4545 rl = BUS_GET_RESOURCE_LIST(dev, child); 4546 if (!rl) 4547 return (NULL); 4548 4549 return (resource_list_alloc(rl, dev, child, type, rid, 4550 start, end, count, flags)); 4551 } 4552 4553 /** 4554 * @brief Helper function for implementing BUS_CHILD_PRESENT(). 4555 * 4556 * This simple implementation of BUS_CHILD_PRESENT() simply calls the 4557 * BUS_CHILD_PRESENT() method of the parent of @p dev. 4558 */ 4559 int 4560 bus_generic_child_present(device_t dev, device_t child) 4561 { 4562 return (BUS_CHILD_PRESENT(device_get_parent(dev), dev)); 4563 } 4564 4565 int 4566 bus_generic_get_domain(device_t dev, device_t child, int *domain) 4567 { 4568 4569 if (dev->parent) 4570 return (BUS_GET_DOMAIN(dev->parent, dev, domain)); 4571 4572 return (ENOENT); 4573 } 4574 4575 /** 4576 * @brief Helper function for implementing BUS_RESCAN(). 4577 * 4578 * This null implementation of BUS_RESCAN() always fails to indicate 4579 * the bus does not support rescanning. 4580 */ 4581 int 4582 bus_null_rescan(device_t dev) 4583 { 4584 4585 return (ENXIO); 4586 } 4587 4588 /* 4589 * Some convenience functions to make it easier for drivers to use the 4590 * resource-management functions. All these really do is hide the 4591 * indirection through the parent's method table, making for slightly 4592 * less-wordy code. In the future, it might make sense for this code 4593 * to maintain some sort of a list of resources allocated by each device. 4594 */ 4595 4596 int 4597 bus_alloc_resources(device_t dev, struct resource_spec *rs, 4598 struct resource **res) 4599 { 4600 int i; 4601 4602 for (i = 0; rs[i].type != -1; i++) 4603 res[i] = NULL; 4604 for (i = 0; rs[i].type != -1; i++) { 4605 res[i] = bus_alloc_resource_any(dev, 4606 rs[i].type, &rs[i].rid, rs[i].flags); 4607 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) { 4608 bus_release_resources(dev, rs, res); 4609 return (ENXIO); 4610 } 4611 } 4612 return (0); 4613 } 4614 4615 void 4616 bus_release_resources(device_t dev, const struct resource_spec *rs, 4617 struct resource **res) 4618 { 4619 int i; 4620 4621 for (i = 0; rs[i].type != -1; i++) 4622 if (res[i] != NULL) { 4623 bus_release_resource( 4624 dev, rs[i].type, rs[i].rid, res[i]); 4625 res[i] = NULL; 4626 } 4627 } 4628 4629 /** 4630 * @brief Wrapper function for BUS_ALLOC_RESOURCE(). 4631 * 4632 * This function simply calls the BUS_ALLOC_RESOURCE() method of the 4633 * parent of @p dev. 4634 */ 4635 struct resource * 4636 bus_alloc_resource(device_t dev, int type, int *rid, rman_res_t start, 4637 rman_res_t end, rman_res_t count, u_int flags) 4638 { 4639 struct resource *res; 4640 4641 if (dev->parent == NULL) 4642 return (NULL); 4643 res = BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end, 4644 count, flags); 4645 return (res); 4646 } 4647 4648 /** 4649 * @brief Wrapper function for BUS_ADJUST_RESOURCE(). 4650 * 4651 * This function simply calls the BUS_ADJUST_RESOURCE() method of the 4652 * parent of @p dev. 4653 */ 4654 int 4655 bus_adjust_resource(device_t dev, int type, struct resource *r, rman_res_t start, 4656 rman_res_t end) 4657 { 4658 if (dev->parent == NULL) 4659 return (EINVAL); 4660 return (BUS_ADJUST_RESOURCE(dev->parent, dev, type, r, start, end)); 4661 } 4662 4663 /** 4664 * @brief Wrapper function for BUS_ACTIVATE_RESOURCE(). 4665 * 4666 * This function simply calls the BUS_ACTIVATE_RESOURCE() method of the 4667 * parent of @p dev. 4668 */ 4669 int 4670 bus_activate_resource(device_t dev, int type, int rid, struct resource *r) 4671 { 4672 if (dev->parent == NULL) 4673 return (EINVAL); 4674 return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 4675 } 4676 4677 /** 4678 * @brief Wrapper function for BUS_DEACTIVATE_RESOURCE(). 4679 * 4680 * This function simply calls the BUS_DEACTIVATE_RESOURCE() method of the 4681 * parent of @p dev. 4682 */ 4683 int 4684 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r) 4685 { 4686 if (dev->parent == NULL) 4687 return (EINVAL); 4688 return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 4689 } 4690 4691 /** 4692 * @brief Wrapper function for BUS_MAP_RESOURCE(). 4693 * 4694 * This function simply calls the BUS_MAP_RESOURCE() method of the 4695 * parent of @p dev. 4696 */ 4697 int 4698 bus_map_resource(device_t dev, int type, struct resource *r, 4699 struct resource_map_request *args, struct resource_map *map) 4700 { 4701 if (dev->parent == NULL) 4702 return (EINVAL); 4703 return (BUS_MAP_RESOURCE(dev->parent, dev, type, r, args, map)); 4704 } 4705 4706 /** 4707 * @brief Wrapper function for BUS_UNMAP_RESOURCE(). 4708 * 4709 * This function simply calls the BUS_UNMAP_RESOURCE() method of the 4710 * parent of @p dev. 4711 */ 4712 int 4713 bus_unmap_resource(device_t dev, int type, struct resource *r, 4714 struct resource_map *map) 4715 { 4716 if (dev->parent == NULL) 4717 return (EINVAL); 4718 return (BUS_UNMAP_RESOURCE(dev->parent, dev, type, r, map)); 4719 } 4720 4721 /** 4722 * @brief Wrapper function for BUS_RELEASE_RESOURCE(). 4723 * 4724 * This function simply calls the BUS_RELEASE_RESOURCE() method of the 4725 * parent of @p dev. 4726 */ 4727 int 4728 bus_release_resource(device_t dev, int type, int rid, struct resource *r) 4729 { 4730 int rv; 4731 4732 if (dev->parent == NULL) 4733 return (EINVAL); 4734 rv = BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r); 4735 return (rv); 4736 } 4737 4738 /** 4739 * @brief Wrapper function for BUS_SETUP_INTR(). 4740 * 4741 * This function simply calls the BUS_SETUP_INTR() method of the 4742 * parent of @p dev. 4743 */ 4744 int 4745 bus_setup_intr(device_t dev, struct resource *r, int flags, 4746 driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep) 4747 { 4748 int error; 4749 4750 if (dev->parent == NULL) 4751 return (EINVAL); 4752 error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler, 4753 arg, cookiep); 4754 if (error != 0) 4755 return (error); 4756 if (handler != NULL && !(flags & INTR_MPSAFE)) 4757 device_printf(dev, "[GIANT-LOCKED]\n"); 4758 return (0); 4759 } 4760 4761 /** 4762 * @brief Wrapper function for BUS_TEARDOWN_INTR(). 4763 * 4764 * This function simply calls the BUS_TEARDOWN_INTR() method of the 4765 * parent of @p dev. 4766 */ 4767 int 4768 bus_teardown_intr(device_t dev, struct resource *r, void *cookie) 4769 { 4770 if (dev->parent == NULL) 4771 return (EINVAL); 4772 return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie)); 4773 } 4774 4775 /** 4776 * @brief Wrapper function for BUS_SUSPEND_INTR(). 4777 * 4778 * This function simply calls the BUS_SUSPEND_INTR() method of the 4779 * parent of @p dev. 4780 */ 4781 int 4782 bus_suspend_intr(device_t dev, struct resource *r) 4783 { 4784 if (dev->parent == NULL) 4785 return (EINVAL); 4786 return (BUS_SUSPEND_INTR(dev->parent, dev, r)); 4787 } 4788 4789 /** 4790 * @brief Wrapper function for BUS_RESUME_INTR(). 4791 * 4792 * This function simply calls the BUS_RESUME_INTR() method of the 4793 * parent of @p dev. 4794 */ 4795 int 4796 bus_resume_intr(device_t dev, struct resource *r) 4797 { 4798 if (dev->parent == NULL) 4799 return (EINVAL); 4800 return (BUS_RESUME_INTR(dev->parent, dev, r)); 4801 } 4802 4803 /** 4804 * @brief Wrapper function for BUS_BIND_INTR(). 4805 * 4806 * This function simply calls the BUS_BIND_INTR() method of the 4807 * parent of @p dev. 4808 */ 4809 int 4810 bus_bind_intr(device_t dev, struct resource *r, int cpu) 4811 { 4812 if (dev->parent == NULL) 4813 return (EINVAL); 4814 return (BUS_BIND_INTR(dev->parent, dev, r, cpu)); 4815 } 4816 4817 /** 4818 * @brief Wrapper function for BUS_DESCRIBE_INTR(). 4819 * 4820 * This function first formats the requested description into a 4821 * temporary buffer and then calls the BUS_DESCRIBE_INTR() method of 4822 * the parent of @p dev. 4823 */ 4824 int 4825 bus_describe_intr(device_t dev, struct resource *irq, void *cookie, 4826 const char *fmt, ...) 4827 { 4828 va_list ap; 4829 char descr[MAXCOMLEN + 1]; 4830 4831 if (dev->parent == NULL) 4832 return (EINVAL); 4833 va_start(ap, fmt); 4834 vsnprintf(descr, sizeof(descr), fmt, ap); 4835 va_end(ap); 4836 return (BUS_DESCRIBE_INTR(dev->parent, dev, irq, cookie, descr)); 4837 } 4838 4839 /** 4840 * @brief Wrapper function for BUS_SET_RESOURCE(). 4841 * 4842 * This function simply calls the BUS_SET_RESOURCE() method of the 4843 * parent of @p dev. 4844 */ 4845 int 4846 bus_set_resource(device_t dev, int type, int rid, 4847 rman_res_t start, rman_res_t count) 4848 { 4849 return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid, 4850 start, count)); 4851 } 4852 4853 /** 4854 * @brief Wrapper function for BUS_GET_RESOURCE(). 4855 * 4856 * This function simply calls the BUS_GET_RESOURCE() method of the 4857 * parent of @p dev. 4858 */ 4859 int 4860 bus_get_resource(device_t dev, int type, int rid, 4861 rman_res_t *startp, rman_res_t *countp) 4862 { 4863 return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4864 startp, countp)); 4865 } 4866 4867 /** 4868 * @brief Wrapper function for BUS_GET_RESOURCE(). 4869 * 4870 * This function simply calls the BUS_GET_RESOURCE() method of the 4871 * parent of @p dev and returns the start value. 4872 */ 4873 rman_res_t 4874 bus_get_resource_start(device_t dev, int type, int rid) 4875 { 4876 rman_res_t start; 4877 rman_res_t count; 4878 int error; 4879 4880 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4881 &start, &count); 4882 if (error) 4883 return (0); 4884 return (start); 4885 } 4886 4887 /** 4888 * @brief Wrapper function for BUS_GET_RESOURCE(). 4889 * 4890 * This function simply calls the BUS_GET_RESOURCE() method of the 4891 * parent of @p dev and returns the count value. 4892 */ 4893 rman_res_t 4894 bus_get_resource_count(device_t dev, int type, int rid) 4895 { 4896 rman_res_t start; 4897 rman_res_t count; 4898 int error; 4899 4900 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4901 &start, &count); 4902 if (error) 4903 return (0); 4904 return (count); 4905 } 4906 4907 /** 4908 * @brief Wrapper function for BUS_DELETE_RESOURCE(). 4909 * 4910 * This function simply calls the BUS_DELETE_RESOURCE() method of the 4911 * parent of @p dev. 4912 */ 4913 void 4914 bus_delete_resource(device_t dev, int type, int rid) 4915 { 4916 BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid); 4917 } 4918 4919 /** 4920 * @brief Wrapper function for BUS_CHILD_PRESENT(). 4921 * 4922 * This function simply calls the BUS_CHILD_PRESENT() method of the 4923 * parent of @p dev. 4924 */ 4925 int 4926 bus_child_present(device_t child) 4927 { 4928 return (BUS_CHILD_PRESENT(device_get_parent(child), child)); 4929 } 4930 4931 /** 4932 * @brief Wrapper function for BUS_CHILD_PNPINFO_STR(). 4933 * 4934 * This function simply calls the BUS_CHILD_PNPINFO_STR() method of the 4935 * parent of @p dev. 4936 */ 4937 int 4938 bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen) 4939 { 4940 device_t parent; 4941 4942 parent = device_get_parent(child); 4943 if (parent == NULL) { 4944 *buf = '\0'; 4945 return (0); 4946 } 4947 return (BUS_CHILD_PNPINFO_STR(parent, child, buf, buflen)); 4948 } 4949 4950 /** 4951 * @brief Wrapper function for BUS_CHILD_LOCATION_STR(). 4952 * 4953 * This function simply calls the BUS_CHILD_LOCATION_STR() method of the 4954 * parent of @p dev. 4955 */ 4956 int 4957 bus_child_location_str(device_t child, char *buf, size_t buflen) 4958 { 4959 device_t parent; 4960 4961 parent = device_get_parent(child); 4962 if (parent == NULL) { 4963 *buf = '\0'; 4964 return (0); 4965 } 4966 return (BUS_CHILD_LOCATION_STR(parent, child, buf, buflen)); 4967 } 4968 4969 /** 4970 * @brief Wrapper function for BUS_GET_CPUS(). 4971 * 4972 * This function simply calls the BUS_GET_CPUS() method of the 4973 * parent of @p dev. 4974 */ 4975 int 4976 bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, cpuset_t *cpuset) 4977 { 4978 device_t parent; 4979 4980 parent = device_get_parent(dev); 4981 if (parent == NULL) 4982 return (EINVAL); 4983 return (BUS_GET_CPUS(parent, dev, op, setsize, cpuset)); 4984 } 4985 4986 /** 4987 * @brief Wrapper function for BUS_GET_DMA_TAG(). 4988 * 4989 * This function simply calls the BUS_GET_DMA_TAG() method of the 4990 * parent of @p dev. 4991 */ 4992 bus_dma_tag_t 4993 bus_get_dma_tag(device_t dev) 4994 { 4995 device_t parent; 4996 4997 parent = device_get_parent(dev); 4998 if (parent == NULL) 4999 return (NULL); 5000 return (BUS_GET_DMA_TAG(parent, dev)); 5001 } 5002 5003 /** 5004 * @brief Wrapper function for BUS_GET_BUS_TAG(). 5005 * 5006 * This function simply calls the BUS_GET_BUS_TAG() method of the 5007 * parent of @p dev. 5008 */ 5009 bus_space_tag_t 5010 bus_get_bus_tag(device_t dev) 5011 { 5012 device_t parent; 5013 5014 parent = device_get_parent(dev); 5015 if (parent == NULL) 5016 return ((bus_space_tag_t)0); 5017 return (BUS_GET_BUS_TAG(parent, dev)); 5018 } 5019 5020 /** 5021 * @brief Wrapper function for BUS_GET_DOMAIN(). 5022 * 5023 * This function simply calls the BUS_GET_DOMAIN() method of the 5024 * parent of @p dev. 5025 */ 5026 int 5027 bus_get_domain(device_t dev, int *domain) 5028 { 5029 return (BUS_GET_DOMAIN(device_get_parent(dev), dev, domain)); 5030 } 5031 5032 /* Resume all devices and then notify userland that we're up again. */ 5033 static int 5034 root_resume(device_t dev) 5035 { 5036 int error; 5037 5038 error = bus_generic_resume(dev); 5039 if (error == 0) 5040 devctl_notify("kern", "power", "resume", NULL); 5041 return (error); 5042 } 5043 5044 static int 5045 root_print_child(device_t dev, device_t child) 5046 { 5047 int retval = 0; 5048 5049 retval += bus_print_child_header(dev, child); 5050 retval += printf("\n"); 5051 5052 return (retval); 5053 } 5054 5055 static int 5056 root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags, 5057 driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep) 5058 { 5059 /* 5060 * If an interrupt mapping gets to here something bad has happened. 5061 */ 5062 panic("root_setup_intr"); 5063 } 5064 5065 /* 5066 * If we get here, assume that the device is permanent and really is 5067 * present in the system. Removable bus drivers are expected to intercept 5068 * this call long before it gets here. We return -1 so that drivers that 5069 * really care can check vs -1 or some ERRNO returned higher in the food 5070 * chain. 5071 */ 5072 static int 5073 root_child_present(device_t dev, device_t child) 5074 { 5075 return (-1); 5076 } 5077 5078 static int 5079 root_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize, 5080 cpuset_t *cpuset) 5081 { 5082 5083 switch (op) { 5084 case INTR_CPUS: 5085 /* Default to returning the set of all CPUs. */ 5086 if (setsize != sizeof(cpuset_t)) 5087 return (EINVAL); 5088 *cpuset = all_cpus; 5089 return (0); 5090 default: 5091 return (EINVAL); 5092 } 5093 } 5094 5095 static kobj_method_t root_methods[] = { 5096 /* Device interface */ 5097 KOBJMETHOD(device_shutdown, bus_generic_shutdown), 5098 KOBJMETHOD(device_suspend, bus_generic_suspend), 5099 KOBJMETHOD(device_resume, root_resume), 5100 5101 /* Bus interface */ 5102 KOBJMETHOD(bus_print_child, root_print_child), 5103 KOBJMETHOD(bus_read_ivar, bus_generic_read_ivar), 5104 KOBJMETHOD(bus_write_ivar, bus_generic_write_ivar), 5105 KOBJMETHOD(bus_setup_intr, root_setup_intr), 5106 KOBJMETHOD(bus_child_present, root_child_present), 5107 KOBJMETHOD(bus_get_cpus, root_get_cpus), 5108 5109 KOBJMETHOD_END 5110 }; 5111 5112 static driver_t root_driver = { 5113 "root", 5114 root_methods, 5115 1, /* no softc */ 5116 }; 5117 5118 device_t root_bus; 5119 devclass_t root_devclass; 5120 5121 static int 5122 root_bus_module_handler(module_t mod, int what, void* arg) 5123 { 5124 switch (what) { 5125 case MOD_LOAD: 5126 TAILQ_INIT(&bus_data_devices); 5127 kobj_class_compile((kobj_class_t) &root_driver); 5128 root_bus = make_device(NULL, "root", 0); 5129 root_bus->desc = "System root bus"; 5130 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver); 5131 root_bus->driver = &root_driver; 5132 root_bus->state = DS_ATTACHED; 5133 root_devclass = devclass_find_internal("root", NULL, FALSE); 5134 devinit(); 5135 return (0); 5136 5137 case MOD_SHUTDOWN: 5138 device_shutdown(root_bus); 5139 return (0); 5140 default: 5141 return (EOPNOTSUPP); 5142 } 5143 5144 return (0); 5145 } 5146 5147 static moduledata_t root_bus_mod = { 5148 "rootbus", 5149 root_bus_module_handler, 5150 NULL 5151 }; 5152 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 5153 5154 /** 5155 * @brief Automatically configure devices 5156 * 5157 * This function begins the autoconfiguration process by calling 5158 * device_probe_and_attach() for each child of the @c root0 device. 5159 */ 5160 void 5161 root_bus_configure(void) 5162 { 5163 5164 PDEBUG((".")); 5165 5166 /* Eventually this will be split up, but this is sufficient for now. */ 5167 bus_set_pass(BUS_PASS_DEFAULT); 5168 } 5169 5170 /** 5171 * @brief Module handler for registering device drivers 5172 * 5173 * This module handler is used to automatically register device 5174 * drivers when modules are loaded. If @p what is MOD_LOAD, it calls 5175 * devclass_add_driver() for the driver described by the 5176 * driver_module_data structure pointed to by @p arg 5177 */ 5178 int 5179 driver_module_handler(module_t mod, int what, void *arg) 5180 { 5181 struct driver_module_data *dmd; 5182 devclass_t bus_devclass; 5183 kobj_class_t driver; 5184 int error, pass; 5185 5186 dmd = (struct driver_module_data *)arg; 5187 bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE); 5188 error = 0; 5189 5190 switch (what) { 5191 case MOD_LOAD: 5192 if (dmd->dmd_chainevh) 5193 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5194 5195 pass = dmd->dmd_pass; 5196 driver = dmd->dmd_driver; 5197 PDEBUG(("Loading module: driver %s on bus %s (pass %d)", 5198 DRIVERNAME(driver), dmd->dmd_busname, pass)); 5199 error = devclass_add_driver(bus_devclass, driver, pass, 5200 dmd->dmd_devclass); 5201 break; 5202 5203 case MOD_UNLOAD: 5204 PDEBUG(("Unloading module: driver %s from bus %s", 5205 DRIVERNAME(dmd->dmd_driver), 5206 dmd->dmd_busname)); 5207 error = devclass_delete_driver(bus_devclass, 5208 dmd->dmd_driver); 5209 5210 if (!error && dmd->dmd_chainevh) 5211 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5212 break; 5213 case MOD_QUIESCE: 5214 PDEBUG(("Quiesce module: driver %s from bus %s", 5215 DRIVERNAME(dmd->dmd_driver), 5216 dmd->dmd_busname)); 5217 error = devclass_quiesce_driver(bus_devclass, 5218 dmd->dmd_driver); 5219 5220 if (!error && dmd->dmd_chainevh) 5221 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5222 break; 5223 default: 5224 error = EOPNOTSUPP; 5225 break; 5226 } 5227 5228 return (error); 5229 } 5230 5231 /** 5232 * @brief Enumerate all hinted devices for this bus. 5233 * 5234 * Walks through the hints for this bus and calls the bus_hinted_child 5235 * routine for each one it fines. It searches first for the specific 5236 * bus that's being probed for hinted children (eg isa0), and then for 5237 * generic children (eg isa). 5238 * 5239 * @param dev bus device to enumerate 5240 */ 5241 void 5242 bus_enumerate_hinted_children(device_t bus) 5243 { 5244 int i; 5245 const char *dname, *busname; 5246 int dunit; 5247 5248 /* 5249 * enumerate all devices on the specific bus 5250 */ 5251 busname = device_get_nameunit(bus); 5252 i = 0; 5253 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0) 5254 BUS_HINTED_CHILD(bus, dname, dunit); 5255 5256 /* 5257 * and all the generic ones. 5258 */ 5259 busname = device_get_name(bus); 5260 i = 0; 5261 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0) 5262 BUS_HINTED_CHILD(bus, dname, dunit); 5263 } 5264 5265 #ifdef BUS_DEBUG 5266 5267 /* the _short versions avoid iteration by not calling anything that prints 5268 * more than oneliners. I love oneliners. 5269 */ 5270 5271 static void 5272 print_device_short(device_t dev, int indent) 5273 { 5274 if (!dev) 5275 return; 5276 5277 indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s%s%s,%sivars,%ssoftc,busy=%d\n", 5278 dev->unit, dev->desc, 5279 (dev->parent? "":"no "), 5280 (TAILQ_EMPTY(&dev->children)? "no ":""), 5281 (dev->flags&DF_ENABLED? "enabled,":"disabled,"), 5282 (dev->flags&DF_FIXEDCLASS? "fixed,":""), 5283 (dev->flags&DF_WILDCARD? "wildcard,":""), 5284 (dev->flags&DF_DESCMALLOCED? "descmalloced,":""), 5285 (dev->flags&DF_REBID? "rebiddable,":""), 5286 (dev->flags&DF_SUSPENDED? "suspended,":""), 5287 (dev->ivars? "":"no "), 5288 (dev->softc? "":"no "), 5289 dev->busy)); 5290 } 5291 5292 static void 5293 print_device(device_t dev, int indent) 5294 { 5295 if (!dev) 5296 return; 5297 5298 print_device_short(dev, indent); 5299 5300 indentprintf(("Parent:\n")); 5301 print_device_short(dev->parent, indent+1); 5302 indentprintf(("Driver:\n")); 5303 print_driver_short(dev->driver, indent+1); 5304 indentprintf(("Devclass:\n")); 5305 print_devclass_short(dev->devclass, indent+1); 5306 } 5307 5308 void 5309 print_device_tree_short(device_t dev, int indent) 5310 /* print the device and all its children (indented) */ 5311 { 5312 device_t child; 5313 5314 if (!dev) 5315 return; 5316 5317 print_device_short(dev, indent); 5318 5319 TAILQ_FOREACH(child, &dev->children, link) { 5320 print_device_tree_short(child, indent+1); 5321 } 5322 } 5323 5324 void 5325 print_device_tree(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(dev, indent); 5334 5335 TAILQ_FOREACH(child, &dev->children, link) { 5336 print_device_tree(child, indent+1); 5337 } 5338 } 5339 5340 static void 5341 print_driver_short(driver_t *driver, int indent) 5342 { 5343 if (!driver) 5344 return; 5345 5346 indentprintf(("driver %s: softc size = %zd\n", 5347 driver->name, driver->size)); 5348 } 5349 5350 static void 5351 print_driver(driver_t *driver, int indent) 5352 { 5353 if (!driver) 5354 return; 5355 5356 print_driver_short(driver, indent); 5357 } 5358 5359 static void 5360 print_driver_list(driver_list_t drivers, int indent) 5361 { 5362 driverlink_t driver; 5363 5364 TAILQ_FOREACH(driver, &drivers, link) { 5365 print_driver(driver->driver, indent); 5366 } 5367 } 5368 5369 static void 5370 print_devclass_short(devclass_t dc, int indent) 5371 { 5372 if ( !dc ) 5373 return; 5374 5375 indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit)); 5376 } 5377 5378 static void 5379 print_devclass(devclass_t dc, int indent) 5380 { 5381 int i; 5382 5383 if ( !dc ) 5384 return; 5385 5386 print_devclass_short(dc, indent); 5387 indentprintf(("Drivers:\n")); 5388 print_driver_list(dc->drivers, indent+1); 5389 5390 indentprintf(("Devices:\n")); 5391 for (i = 0; i < dc->maxunit; i++) 5392 if (dc->devices[i]) 5393 print_device(dc->devices[i], indent+1); 5394 } 5395 5396 void 5397 print_devclass_list_short(void) 5398 { 5399 devclass_t dc; 5400 5401 printf("Short listing of devclasses, drivers & devices:\n"); 5402 TAILQ_FOREACH(dc, &devclasses, link) { 5403 print_devclass_short(dc, 0); 5404 } 5405 } 5406 5407 void 5408 print_devclass_list(void) 5409 { 5410 devclass_t dc; 5411 5412 printf("Full listing of devclasses, drivers & devices:\n"); 5413 TAILQ_FOREACH(dc, &devclasses, link) { 5414 print_devclass(dc, 0); 5415 } 5416 } 5417 5418 #endif 5419 5420 /* 5421 * User-space access to the device tree. 5422 * 5423 * We implement a small set of nodes: 5424 * 5425 * hw.bus Single integer read method to obtain the 5426 * current generation count. 5427 * hw.bus.devices Reads the entire device tree in flat space. 5428 * hw.bus.rman Resource manager interface 5429 * 5430 * We might like to add the ability to scan devclasses and/or drivers to 5431 * determine what else is currently loaded/available. 5432 */ 5433 5434 static int 5435 sysctl_bus(SYSCTL_HANDLER_ARGS) 5436 { 5437 struct u_businfo ubus; 5438 5439 ubus.ub_version = BUS_USER_VERSION; 5440 ubus.ub_generation = bus_data_generation; 5441 5442 return (SYSCTL_OUT(req, &ubus, sizeof(ubus))); 5443 } 5444 SYSCTL_NODE(_hw_bus, OID_AUTO, info, CTLFLAG_RW, sysctl_bus, 5445 "bus-related data"); 5446 5447 static int 5448 sysctl_devices(SYSCTL_HANDLER_ARGS) 5449 { 5450 int *name = (int *)arg1; 5451 u_int namelen = arg2; 5452 int index; 5453 device_t dev; 5454 struct u_device *udev; 5455 int error; 5456 char *walker, *ep; 5457 5458 if (namelen != 2) 5459 return (EINVAL); 5460 5461 if (bus_data_generation_check(name[0])) 5462 return (EINVAL); 5463 5464 index = name[1]; 5465 5466 /* 5467 * Scan the list of devices, looking for the requested index. 5468 */ 5469 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 5470 if (index-- == 0) 5471 break; 5472 } 5473 if (dev == NULL) 5474 return (ENOENT); 5475 5476 /* 5477 * Populate the return item, careful not to overflow the buffer. 5478 */ 5479 udev = malloc(sizeof(*udev), M_BUS, M_WAITOK | M_ZERO); 5480 if (udev == NULL) 5481 return (ENOMEM); 5482 udev->dv_handle = (uintptr_t)dev; 5483 udev->dv_parent = (uintptr_t)dev->parent; 5484 udev->dv_devflags = dev->devflags; 5485 udev->dv_flags = dev->flags; 5486 udev->dv_state = dev->state; 5487 walker = udev->dv_fields; 5488 ep = walker + sizeof(udev->dv_fields); 5489 #define CP(src) \ 5490 if ((src) == NULL) \ 5491 *walker++ = '\0'; \ 5492 else { \ 5493 strlcpy(walker, (src), ep - walker); \ 5494 walker += strlen(walker) + 1; \ 5495 } \ 5496 if (walker >= ep) \ 5497 break; 5498 5499 do { 5500 CP(dev->nameunit); 5501 CP(dev->desc); 5502 CP(dev->driver != NULL ? dev->driver->name : NULL); 5503 bus_child_pnpinfo_str(dev, walker, ep - walker); 5504 walker += strlen(walker) + 1; 5505 if (walker >= ep) 5506 break; 5507 bus_child_location_str(dev, walker, ep - walker); 5508 walker += strlen(walker) + 1; 5509 if (walker >= ep) 5510 break; 5511 *walker++ = '\0'; 5512 } while (0); 5513 #undef CP 5514 error = SYSCTL_OUT(req, udev, sizeof(*udev)); 5515 free(udev, M_BUS); 5516 return (error); 5517 } 5518 5519 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, CTLFLAG_RD, sysctl_devices, 5520 "system device tree"); 5521 5522 int 5523 bus_data_generation_check(int generation) 5524 { 5525 if (generation != bus_data_generation) 5526 return (1); 5527 5528 /* XXX generate optimised lists here? */ 5529 return (0); 5530 } 5531 5532 void 5533 bus_data_generation_update(void) 5534 { 5535 bus_data_generation++; 5536 } 5537 5538 int 5539 bus_free_resource(device_t dev, int type, struct resource *r) 5540 { 5541 if (r == NULL) 5542 return (0); 5543 return (bus_release_resource(dev, type, rman_get_rid(r), r)); 5544 } 5545 5546 device_t 5547 device_lookup_by_name(const char *name) 5548 { 5549 device_t dev; 5550 5551 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 5552 if (dev->nameunit != NULL && strcmp(dev->nameunit, name) == 0) 5553 return (dev); 5554 } 5555 return (NULL); 5556 } 5557 5558 /* 5559 * /dev/devctl2 implementation. The existing /dev/devctl device has 5560 * implicit semantics on open, so it could not be reused for this. 5561 * Another option would be to call this /dev/bus? 5562 */ 5563 static int 5564 find_device(struct devreq *req, device_t *devp) 5565 { 5566 device_t dev; 5567 5568 /* 5569 * First, ensure that the name is nul terminated. 5570 */ 5571 if (memchr(req->dr_name, '\0', sizeof(req->dr_name)) == NULL) 5572 return (EINVAL); 5573 5574 /* 5575 * Second, try to find an attached device whose name matches 5576 * 'name'. 5577 */ 5578 dev = device_lookup_by_name(req->dr_name); 5579 if (dev != NULL) { 5580 *devp = dev; 5581 return (0); 5582 } 5583 5584 /* Finally, give device enumerators a chance. */ 5585 dev = NULL; 5586 EVENTHANDLER_DIRECT_INVOKE(dev_lookup, req->dr_name, &dev); 5587 if (dev == NULL) 5588 return (ENOENT); 5589 *devp = dev; 5590 return (0); 5591 } 5592 5593 static bool 5594 driver_exists(device_t bus, const char *driver) 5595 { 5596 devclass_t dc; 5597 5598 for (dc = bus->devclass; dc != NULL; dc = dc->parent) { 5599 if (devclass_find_driver_internal(dc, driver) != NULL) 5600 return (true); 5601 } 5602 return (false); 5603 } 5604 5605 static void 5606 device_gen_nomatch(device_t dev) 5607 { 5608 device_t child; 5609 5610 if (dev->flags & DF_NEEDNOMATCH && 5611 dev->state == DS_NOTPRESENT) { 5612 BUS_PROBE_NOMATCH(dev->parent, dev); 5613 devnomatch(dev); 5614 dev->flags |= DF_DONENOMATCH; 5615 } 5616 dev->flags &= ~DF_NEEDNOMATCH; 5617 TAILQ_FOREACH(child, &dev->children, link) { 5618 device_gen_nomatch(child); 5619 } 5620 } 5621 5622 static void 5623 device_do_deferred_actions(void) 5624 { 5625 devclass_t dc; 5626 driverlink_t dl; 5627 5628 /* 5629 * Walk through the devclasses to find all the drivers we've tagged as 5630 * deferred during the freeze and call the driver added routines. They 5631 * have already been added to the lists in the background, so the driver 5632 * added routines that trigger a probe will have all the right bidders 5633 * for the probe auction. 5634 */ 5635 TAILQ_FOREACH(dc, &devclasses, link) { 5636 TAILQ_FOREACH(dl, &dc->drivers, link) { 5637 if (dl->flags & DL_DEFERRED_PROBE) { 5638 devclass_driver_added(dc, dl->driver); 5639 dl->flags &= ~DL_DEFERRED_PROBE; 5640 } 5641 } 5642 } 5643 5644 /* 5645 * We also defer no-match events during a freeze. Walk the tree and 5646 * generate all the pent-up events that are still relevant. 5647 */ 5648 device_gen_nomatch(root_bus); 5649 bus_data_generation_update(); 5650 } 5651 5652 static int 5653 devctl2_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag, 5654 struct thread *td) 5655 { 5656 struct devreq *req; 5657 device_t dev; 5658 int error, old; 5659 5660 /* Locate the device to control. */ 5661 mtx_lock(&Giant); 5662 req = (struct devreq *)data; 5663 switch (cmd) { 5664 case DEV_ATTACH: 5665 case DEV_DETACH: 5666 case DEV_ENABLE: 5667 case DEV_DISABLE: 5668 case DEV_SUSPEND: 5669 case DEV_RESUME: 5670 case DEV_SET_DRIVER: 5671 case DEV_CLEAR_DRIVER: 5672 case DEV_RESCAN: 5673 case DEV_DELETE: 5674 case DEV_RESET: 5675 error = priv_check(td, PRIV_DRIVER); 5676 if (error == 0) 5677 error = find_device(req, &dev); 5678 break; 5679 case DEV_FREEZE: 5680 case DEV_THAW: 5681 error = priv_check(td, PRIV_DRIVER); 5682 break; 5683 default: 5684 error = ENOTTY; 5685 break; 5686 } 5687 if (error) { 5688 mtx_unlock(&Giant); 5689 return (error); 5690 } 5691 5692 /* Perform the requested operation. */ 5693 switch (cmd) { 5694 case DEV_ATTACH: 5695 if (device_is_attached(dev) && (dev->flags & DF_REBID) == 0) 5696 error = EBUSY; 5697 else if (!device_is_enabled(dev)) 5698 error = ENXIO; 5699 else 5700 error = device_probe_and_attach(dev); 5701 break; 5702 case DEV_DETACH: 5703 if (!device_is_attached(dev)) { 5704 error = ENXIO; 5705 break; 5706 } 5707 if (!(req->dr_flags & DEVF_FORCE_DETACH)) { 5708 error = device_quiesce(dev); 5709 if (error) 5710 break; 5711 } 5712 error = device_detach(dev); 5713 break; 5714 case DEV_ENABLE: 5715 if (device_is_enabled(dev)) { 5716 error = EBUSY; 5717 break; 5718 } 5719 5720 /* 5721 * If the device has been probed but not attached (e.g. 5722 * when it has been disabled by a loader hint), just 5723 * attach the device rather than doing a full probe. 5724 */ 5725 device_enable(dev); 5726 if (device_is_alive(dev)) { 5727 /* 5728 * If the device was disabled via a hint, clear 5729 * the hint. 5730 */ 5731 if (resource_disabled(dev->driver->name, dev->unit)) 5732 resource_unset_value(dev->driver->name, 5733 dev->unit, "disabled"); 5734 error = device_attach(dev); 5735 } else 5736 error = device_probe_and_attach(dev); 5737 break; 5738 case DEV_DISABLE: 5739 if (!device_is_enabled(dev)) { 5740 error = ENXIO; 5741 break; 5742 } 5743 5744 if (!(req->dr_flags & DEVF_FORCE_DETACH)) { 5745 error = device_quiesce(dev); 5746 if (error) 5747 break; 5748 } 5749 5750 /* 5751 * Force DF_FIXEDCLASS on around detach to preserve 5752 * the existing name. 5753 */ 5754 old = dev->flags; 5755 dev->flags |= DF_FIXEDCLASS; 5756 error = device_detach(dev); 5757 if (!(old & DF_FIXEDCLASS)) 5758 dev->flags &= ~DF_FIXEDCLASS; 5759 if (error == 0) 5760 device_disable(dev); 5761 break; 5762 case DEV_SUSPEND: 5763 if (device_is_suspended(dev)) { 5764 error = EBUSY; 5765 break; 5766 } 5767 if (device_get_parent(dev) == NULL) { 5768 error = EINVAL; 5769 break; 5770 } 5771 error = BUS_SUSPEND_CHILD(device_get_parent(dev), dev); 5772 break; 5773 case DEV_RESUME: 5774 if (!device_is_suspended(dev)) { 5775 error = EINVAL; 5776 break; 5777 } 5778 if (device_get_parent(dev) == NULL) { 5779 error = EINVAL; 5780 break; 5781 } 5782 error = BUS_RESUME_CHILD(device_get_parent(dev), dev); 5783 break; 5784 case DEV_SET_DRIVER: { 5785 devclass_t dc; 5786 char driver[128]; 5787 5788 error = copyinstr(req->dr_data, driver, sizeof(driver), NULL); 5789 if (error) 5790 break; 5791 if (driver[0] == '\0') { 5792 error = EINVAL; 5793 break; 5794 } 5795 if (dev->devclass != NULL && 5796 strcmp(driver, dev->devclass->name) == 0) 5797 /* XXX: Could possibly force DF_FIXEDCLASS on? */ 5798 break; 5799 5800 /* 5801 * Scan drivers for this device's bus looking for at 5802 * least one matching driver. 5803 */ 5804 if (dev->parent == NULL) { 5805 error = EINVAL; 5806 break; 5807 } 5808 if (!driver_exists(dev->parent, driver)) { 5809 error = ENOENT; 5810 break; 5811 } 5812 dc = devclass_create(driver); 5813 if (dc == NULL) { 5814 error = ENOMEM; 5815 break; 5816 } 5817 5818 /* Detach device if necessary. */ 5819 if (device_is_attached(dev)) { 5820 if (req->dr_flags & DEVF_SET_DRIVER_DETACH) 5821 error = device_detach(dev); 5822 else 5823 error = EBUSY; 5824 if (error) 5825 break; 5826 } 5827 5828 /* Clear any previously-fixed device class and unit. */ 5829 if (dev->flags & DF_FIXEDCLASS) 5830 devclass_delete_device(dev->devclass, dev); 5831 dev->flags |= DF_WILDCARD; 5832 dev->unit = -1; 5833 5834 /* Force the new device class. */ 5835 error = devclass_add_device(dc, dev); 5836 if (error) 5837 break; 5838 dev->flags |= DF_FIXEDCLASS; 5839 error = device_probe_and_attach(dev); 5840 break; 5841 } 5842 case DEV_CLEAR_DRIVER: 5843 if (!(dev->flags & DF_FIXEDCLASS)) { 5844 error = 0; 5845 break; 5846 } 5847 if (device_is_attached(dev)) { 5848 if (req->dr_flags & DEVF_CLEAR_DRIVER_DETACH) 5849 error = device_detach(dev); 5850 else 5851 error = EBUSY; 5852 if (error) 5853 break; 5854 } 5855 5856 dev->flags &= ~DF_FIXEDCLASS; 5857 dev->flags |= DF_WILDCARD; 5858 devclass_delete_device(dev->devclass, dev); 5859 error = device_probe_and_attach(dev); 5860 break; 5861 case DEV_RESCAN: 5862 if (!device_is_attached(dev)) { 5863 error = ENXIO; 5864 break; 5865 } 5866 error = BUS_RESCAN(dev); 5867 break; 5868 case DEV_DELETE: { 5869 device_t parent; 5870 5871 parent = device_get_parent(dev); 5872 if (parent == NULL) { 5873 error = EINVAL; 5874 break; 5875 } 5876 if (!(req->dr_flags & DEVF_FORCE_DELETE)) { 5877 if (bus_child_present(dev) != 0) { 5878 error = EBUSY; 5879 break; 5880 } 5881 } 5882 5883 error = device_delete_child(parent, dev); 5884 break; 5885 } 5886 case DEV_FREEZE: 5887 if (device_frozen) 5888 error = EBUSY; 5889 else 5890 device_frozen = true; 5891 break; 5892 case DEV_THAW: 5893 if (!device_frozen) 5894 error = EBUSY; 5895 else { 5896 device_do_deferred_actions(); 5897 device_frozen = false; 5898 } 5899 break; 5900 case DEV_RESET: 5901 if ((req->dr_flags & ~(DEVF_RESET_DETACH)) != 0) { 5902 error = EINVAL; 5903 break; 5904 } 5905 error = BUS_RESET_CHILD(device_get_parent(dev), dev, 5906 req->dr_flags); 5907 break; 5908 } 5909 mtx_unlock(&Giant); 5910 return (error); 5911 } 5912 5913 static struct cdevsw devctl2_cdevsw = { 5914 .d_version = D_VERSION, 5915 .d_ioctl = devctl2_ioctl, 5916 .d_name = "devctl2", 5917 }; 5918 5919 static void 5920 devctl2_init(void) 5921 { 5922 5923 make_dev_credf(MAKEDEV_ETERNAL, &devctl2_cdevsw, 0, NULL, 5924 UID_ROOT, GID_WHEEL, 0600, "devctl2"); 5925 } 5926 5927 /* 5928 * APIs to manage deprecation and obsolescence. 5929 */ 5930 static int obsolete_panic = 0; 5931 SYSCTL_INT(_debug, OID_AUTO, obsolete_panic, CTLFLAG_RWTUN, &obsolete_panic, 0, 5932 "Panic when obsolete features are used (0 = never, 1 = if osbolete, " 5933 "2 = if deprecated)"); 5934 5935 static void 5936 gone_panic(int major, int running, const char *msg) 5937 { 5938 5939 switch (obsolete_panic) 5940 { 5941 case 0: 5942 return; 5943 case 1: 5944 if (running < major) 5945 return; 5946 /* FALLTHROUGH */ 5947 default: 5948 panic("%s", msg); 5949 } 5950 } 5951 5952 void 5953 _gone_in(int major, const char *msg) 5954 { 5955 5956 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg); 5957 if (P_OSREL_MAJOR(__FreeBSD_version) >= major) 5958 printf("Obsolete code will removed soon: %s\n", msg); 5959 else 5960 printf("Deprecated code (to be removed in FreeBSD %d): %s\n", 5961 major, msg); 5962 } 5963 5964 void 5965 _gone_in_dev(device_t dev, int major, const char *msg) 5966 { 5967 5968 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg); 5969 if (P_OSREL_MAJOR(__FreeBSD_version) >= major) 5970 device_printf(dev, 5971 "Obsolete code will removed soon: %s\n", msg); 5972 else 5973 device_printf(dev, 5974 "Deprecated code (to be removed in FreeBSD %d): %s\n", 5975 major, msg); 5976 } 5977 5978 #ifdef DDB 5979 DB_SHOW_COMMAND(device, db_show_device) 5980 { 5981 device_t dev; 5982 5983 if (!have_addr) 5984 return; 5985 5986 dev = (device_t)addr; 5987 5988 db_printf("name: %s\n", device_get_nameunit(dev)); 5989 db_printf(" driver: %s\n", DRIVERNAME(dev->driver)); 5990 db_printf(" class: %s\n", DEVCLANAME(dev->devclass)); 5991 db_printf(" addr: %p\n", dev); 5992 db_printf(" parent: %p\n", dev->parent); 5993 db_printf(" softc: %p\n", dev->softc); 5994 db_printf(" ivars: %p\n", dev->ivars); 5995 } 5996 5997 DB_SHOW_ALL_COMMAND(devices, db_show_all_devices) 5998 { 5999 device_t dev; 6000 6001 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 6002 db_show_device((db_expr_t)dev, true, count, modif); 6003 } 6004 } 6005 #endif 6006