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