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