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