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