1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 1997,1998,2003 Doug Rabson 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include "opt_bus.h" 33 #include "opt_ddb.h" 34 35 #include <sys/param.h> 36 #include <sys/conf.h> 37 #include <sys/domainset.h> 38 #include <sys/eventhandler.h> 39 #include <sys/filio.h> 40 #include <sys/lock.h> 41 #include <sys/kernel.h> 42 #include <sys/kobj.h> 43 #include <sys/limits.h> 44 #include <sys/malloc.h> 45 #include <sys/module.h> 46 #include <sys/mutex.h> 47 #include <sys/poll.h> 48 #include <sys/priv.h> 49 #include <sys/proc.h> 50 #include <sys/condvar.h> 51 #include <sys/queue.h> 52 #include <machine/bus.h> 53 #include <sys/random.h> 54 #include <sys/rman.h> 55 #include <sys/sbuf.h> 56 #include <sys/selinfo.h> 57 #include <sys/signalvar.h> 58 #include <sys/smp.h> 59 #include <sys/sysctl.h> 60 #include <sys/systm.h> 61 #include <sys/uio.h> 62 #include <sys/bus.h> 63 #include <sys/cpuset.h> 64 65 #include <net/vnet.h> 66 67 #include <machine/cpu.h> 68 #include <machine/stdarg.h> 69 70 #include <vm/uma.h> 71 #include <vm/vm.h> 72 73 #include <ddb/ddb.h> 74 75 SYSCTL_NODE(_hw, OID_AUTO, bus, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 76 NULL); 77 SYSCTL_ROOT_NODE(OID_AUTO, dev, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 78 NULL); 79 80 /* 81 * Used to attach drivers to devclasses. 82 */ 83 typedef struct driverlink *driverlink_t; 84 struct driverlink { 85 kobj_class_t driver; 86 TAILQ_ENTRY(driverlink) link; /* list of drivers in devclass */ 87 int pass; 88 int flags; 89 #define DL_DEFERRED_PROBE 1 /* Probe deferred on this */ 90 TAILQ_ENTRY(driverlink) passlink; 91 }; 92 93 /* 94 * Forward declarations 95 */ 96 typedef TAILQ_HEAD(devclass_list, devclass) devclass_list_t; 97 typedef TAILQ_HEAD(driver_list, driverlink) driver_list_t; 98 typedef TAILQ_HEAD(device_list, device) device_list_t; 99 100 struct devclass { 101 TAILQ_ENTRY(devclass) link; 102 devclass_t parent; /* parent in devclass hierarchy */ 103 driver_list_t drivers; /* bus devclasses store drivers for bus */ 104 char *name; 105 device_t *devices; /* array of devices indexed by unit */ 106 int maxunit; /* size of devices array */ 107 int flags; 108 #define DC_HAS_CHILDREN 1 109 110 struct sysctl_ctx_list sysctl_ctx; 111 struct sysctl_oid *sysctl_tree; 112 }; 113 114 /** 115 * @brief Implementation of device. 116 */ 117 struct device { 118 /* 119 * A device is a kernel object. The first field must be the 120 * current ops table for the object. 121 */ 122 KOBJ_FIELDS; 123 124 /* 125 * Device hierarchy. 126 */ 127 TAILQ_ENTRY(device) link; /**< list of devices in parent */ 128 TAILQ_ENTRY(device) devlink; /**< global device list membership */ 129 device_t parent; /**< parent of this device */ 130 device_list_t children; /**< list of child devices */ 131 132 /* 133 * Details of this device. 134 */ 135 driver_t *driver; /**< current driver */ 136 devclass_t devclass; /**< current device class */ 137 int unit; /**< current unit number */ 138 char* nameunit; /**< name+unit e.g. foodev0 */ 139 char* desc; /**< driver specific description */ 140 int busy; /**< count of calls to device_busy() */ 141 device_state_t state; /**< current device state */ 142 uint32_t devflags; /**< api level flags for device_get_flags() */ 143 u_int flags; /**< internal device flags */ 144 u_int order; /**< order from device_add_child_ordered() */ 145 void *ivars; /**< instance variables */ 146 void *softc; /**< current driver's variables */ 147 148 struct sysctl_ctx_list sysctl_ctx; /**< state for sysctl variables */ 149 struct sysctl_oid *sysctl_tree; /**< state for sysctl variables */ 150 }; 151 152 static MALLOC_DEFINE(M_BUS, "bus", "Bus data structures"); 153 static MALLOC_DEFINE(M_BUS_SC, "bus-sc", "Bus data structures, softc"); 154 155 EVENTHANDLER_LIST_DEFINE(device_attach); 156 EVENTHANDLER_LIST_DEFINE(device_detach); 157 EVENTHANDLER_LIST_DEFINE(dev_lookup); 158 159 static void devctl2_init(void); 160 static bool device_frozen; 161 162 #define DRIVERNAME(d) ((d)? d->name : "no driver") 163 #define DEVCLANAME(d) ((d)? d->name : "no devclass") 164 165 #ifdef BUS_DEBUG 166 167 static int bus_debug = 1; 168 SYSCTL_INT(_debug, OID_AUTO, bus_debug, CTLFLAG_RWTUN, &bus_debug, 0, 169 "Bus debug level"); 170 171 #define PDEBUG(a) if (bus_debug) {printf("%s:%d: ", __func__, __LINE__), printf a; printf("\n");} 172 #define DEVICENAME(d) ((d)? device_get_name(d): "no device") 173 174 /** 175 * Produce the indenting, indent*2 spaces plus a '.' ahead of that to 176 * prevent syslog from deleting initial spaces 177 */ 178 #define indentprintf(p) do { int iJ; printf("."); for (iJ=0; iJ<indent; iJ++) printf(" "); printf p ; } while (0) 179 180 static void print_device_short(device_t dev, int indent); 181 static void print_device(device_t dev, int indent); 182 void print_device_tree_short(device_t dev, int indent); 183 void print_device_tree(device_t dev, int indent); 184 static void print_driver_short(driver_t *driver, int indent); 185 static void print_driver(driver_t *driver, int indent); 186 static void print_driver_list(driver_list_t drivers, int indent); 187 static void print_devclass_short(devclass_t dc, int indent); 188 static void print_devclass(devclass_t dc, int indent); 189 void print_devclass_list_short(void); 190 void print_devclass_list(void); 191 192 #else 193 /* Make the compiler ignore the function calls */ 194 #define PDEBUG(a) /* nop */ 195 #define DEVICENAME(d) /* nop */ 196 197 #define print_device_short(d,i) /* nop */ 198 #define print_device(d,i) /* nop */ 199 #define print_device_tree_short(d,i) /* nop */ 200 #define print_device_tree(d,i) /* nop */ 201 #define print_driver_short(d,i) /* nop */ 202 #define print_driver(d,i) /* nop */ 203 #define print_driver_list(d,i) /* nop */ 204 #define print_devclass_short(d,i) /* nop */ 205 #define print_devclass(d,i) /* nop */ 206 #define print_devclass_list_short() /* nop */ 207 #define print_devclass_list() /* nop */ 208 #endif 209 210 /* 211 * dev sysctl tree 212 */ 213 214 enum { 215 DEVCLASS_SYSCTL_PARENT, 216 }; 217 218 static int 219 devclass_sysctl_handler(SYSCTL_HANDLER_ARGS) 220 { 221 devclass_t dc = (devclass_t)arg1; 222 const char *value; 223 224 switch (arg2) { 225 case DEVCLASS_SYSCTL_PARENT: 226 value = dc->parent ? dc->parent->name : ""; 227 break; 228 default: 229 return (EINVAL); 230 } 231 return (SYSCTL_OUT_STR(req, value)); 232 } 233 234 static void 235 devclass_sysctl_init(devclass_t dc) 236 { 237 238 if (dc->sysctl_tree != NULL) 239 return; 240 sysctl_ctx_init(&dc->sysctl_ctx); 241 dc->sysctl_tree = SYSCTL_ADD_NODE(&dc->sysctl_ctx, 242 SYSCTL_STATIC_CHILDREN(_dev), OID_AUTO, dc->name, 243 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, ""); 244 SYSCTL_ADD_PROC(&dc->sysctl_ctx, SYSCTL_CHILDREN(dc->sysctl_tree), 245 OID_AUTO, "%parent", 246 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, 247 dc, DEVCLASS_SYSCTL_PARENT, devclass_sysctl_handler, "A", 248 "parent class"); 249 } 250 251 enum { 252 DEVICE_SYSCTL_DESC, 253 DEVICE_SYSCTL_DRIVER, 254 DEVICE_SYSCTL_LOCATION, 255 DEVICE_SYSCTL_PNPINFO, 256 DEVICE_SYSCTL_PARENT, 257 }; 258 259 static int 260 device_sysctl_handler(SYSCTL_HANDLER_ARGS) 261 { 262 device_t dev = (device_t)arg1; 263 const char *value; 264 char *buf; 265 int error; 266 267 buf = NULL; 268 switch (arg2) { 269 case DEVICE_SYSCTL_DESC: 270 value = dev->desc ? dev->desc : ""; 271 break; 272 case DEVICE_SYSCTL_DRIVER: 273 value = dev->driver ? dev->driver->name : ""; 274 break; 275 case DEVICE_SYSCTL_LOCATION: 276 value = buf = malloc(1024, M_BUS, M_WAITOK | M_ZERO); 277 bus_child_location_str(dev, buf, 1024); 278 break; 279 case DEVICE_SYSCTL_PNPINFO: 280 value = buf = malloc(1024, M_BUS, M_WAITOK | M_ZERO); 281 bus_child_pnpinfo_str(dev, buf, 1024); 282 break; 283 case DEVICE_SYSCTL_PARENT: 284 value = dev->parent ? dev->parent->nameunit : ""; 285 break; 286 default: 287 return (EINVAL); 288 } 289 error = SYSCTL_OUT_STR(req, value); 290 if (buf != NULL) 291 free(buf, M_BUS); 292 return (error); 293 } 294 295 static void 296 device_sysctl_init(device_t dev) 297 { 298 devclass_t dc = dev->devclass; 299 int domain; 300 301 if (dev->sysctl_tree != NULL) 302 return; 303 devclass_sysctl_init(dc); 304 sysctl_ctx_init(&dev->sysctl_ctx); 305 dev->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&dev->sysctl_ctx, 306 SYSCTL_CHILDREN(dc->sysctl_tree), OID_AUTO, 307 dev->nameunit + strlen(dc->name), 308 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "", "device_index"); 309 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 310 OID_AUTO, "%desc", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, 311 dev, DEVICE_SYSCTL_DESC, device_sysctl_handler, "A", 312 "device description"); 313 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 314 OID_AUTO, "%driver", 315 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, 316 dev, DEVICE_SYSCTL_DRIVER, device_sysctl_handler, "A", 317 "device driver name"); 318 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 319 OID_AUTO, "%location", 320 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, 321 dev, DEVICE_SYSCTL_LOCATION, device_sysctl_handler, "A", 322 "device location relative to parent"); 323 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 324 OID_AUTO, "%pnpinfo", 325 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, 326 dev, DEVICE_SYSCTL_PNPINFO, device_sysctl_handler, "A", 327 "device identification"); 328 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 329 OID_AUTO, "%parent", 330 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NEEDGIANT, 331 dev, DEVICE_SYSCTL_PARENT, device_sysctl_handler, "A", 332 "parent device"); 333 if (bus_get_domain(dev, &domain) == 0) 334 SYSCTL_ADD_INT(&dev->sysctl_ctx, 335 SYSCTL_CHILDREN(dev->sysctl_tree), OID_AUTO, "%domain", 336 CTLFLAG_RD, NULL, domain, "NUMA domain"); 337 } 338 339 static void 340 device_sysctl_update(device_t dev) 341 { 342 devclass_t dc = dev->devclass; 343 344 if (dev->sysctl_tree == NULL) 345 return; 346 sysctl_rename_oid(dev->sysctl_tree, dev->nameunit + strlen(dc->name)); 347 } 348 349 static void 350 device_sysctl_fini(device_t dev) 351 { 352 if (dev->sysctl_tree == NULL) 353 return; 354 sysctl_ctx_free(&dev->sysctl_ctx); 355 dev->sysctl_tree = NULL; 356 } 357 358 /* 359 * /dev/devctl implementation 360 */ 361 362 /* 363 * This design allows only one reader for /dev/devctl. This is not desirable 364 * in the long run, but will get a lot of hair out of this implementation. 365 * Maybe we should make this device a clonable device. 366 * 367 * Also note: we specifically do not attach a device to the device_t tree 368 * to avoid potential chicken and egg problems. One could argue that all 369 * of this belongs to the root node. One could also further argue that the 370 * sysctl interface that we have not might more properly be an ioctl 371 * interface, but at this stage of the game, I'm not inclined to rock that 372 * boat. 373 * 374 * I'm also not sure that the SIGIO support is done correctly or not, as 375 * I copied it from a driver that had SIGIO support that likely hasn't been 376 * tested since 3.4 or 2.2.8! 377 */ 378 379 /* Deprecated way to adjust queue length */ 380 static int sysctl_devctl_disable(SYSCTL_HANDLER_ARGS); 381 SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_disable, CTLTYPE_INT | CTLFLAG_RWTUN | 382 CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_disable, "I", 383 "devctl disable -- deprecated"); 384 385 #define DEVCTL_DEFAULT_QUEUE_LEN 1000 386 static int sysctl_devctl_queue(SYSCTL_HANDLER_ARGS); 387 static int devctl_queue_length = DEVCTL_DEFAULT_QUEUE_LEN; 388 SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_queue, CTLTYPE_INT | CTLFLAG_RWTUN | 389 CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_queue, "I", "devctl queue length"); 390 391 static d_open_t devopen; 392 static d_close_t devclose; 393 static d_read_t devread; 394 static d_ioctl_t devioctl; 395 static d_poll_t devpoll; 396 static d_kqfilter_t devkqfilter; 397 398 static struct cdevsw dev_cdevsw = { 399 .d_version = D_VERSION, 400 .d_open = devopen, 401 .d_close = devclose, 402 .d_read = devread, 403 .d_ioctl = devioctl, 404 .d_poll = devpoll, 405 .d_kqfilter = devkqfilter, 406 .d_name = "devctl", 407 }; 408 409 struct dev_event_info 410 { 411 char *dei_data; 412 TAILQ_ENTRY(dev_event_info) dei_link; 413 }; 414 415 TAILQ_HEAD(devq, dev_event_info); 416 417 static struct dev_softc 418 { 419 int inuse; 420 int nonblock; 421 int queued; 422 int async; 423 struct mtx mtx; 424 struct cv cv; 425 struct selinfo sel; 426 struct devq devq; 427 struct sigio *sigio; 428 } devsoftc; 429 430 static void filt_devctl_detach(struct knote *kn); 431 static int filt_devctl_read(struct knote *kn, long hint); 432 433 struct filterops devctl_rfiltops = { 434 .f_isfd = 1, 435 .f_detach = filt_devctl_detach, 436 .f_event = filt_devctl_read, 437 }; 438 439 static struct cdev *devctl_dev; 440 441 static void 442 devinit(void) 443 { 444 devctl_dev = make_dev_credf(MAKEDEV_ETERNAL, &dev_cdevsw, 0, NULL, 445 UID_ROOT, GID_WHEEL, 0600, "devctl"); 446 mtx_init(&devsoftc.mtx, "dev mtx", "devd", MTX_DEF); 447 cv_init(&devsoftc.cv, "dev cv"); 448 TAILQ_INIT(&devsoftc.devq); 449 knlist_init_mtx(&devsoftc.sel.si_note, &devsoftc.mtx); 450 devctl2_init(); 451 } 452 453 static int 454 devopen(struct cdev *dev, int oflags, int devtype, struct thread *td) 455 { 456 457 mtx_lock(&devsoftc.mtx); 458 if (devsoftc.inuse) { 459 mtx_unlock(&devsoftc.mtx); 460 return (EBUSY); 461 } 462 /* move to init */ 463 devsoftc.inuse = 1; 464 mtx_unlock(&devsoftc.mtx); 465 return (0); 466 } 467 468 static int 469 devclose(struct cdev *dev, int fflag, int devtype, struct thread *td) 470 { 471 472 mtx_lock(&devsoftc.mtx); 473 devsoftc.inuse = 0; 474 devsoftc.nonblock = 0; 475 devsoftc.async = 0; 476 cv_broadcast(&devsoftc.cv); 477 funsetown(&devsoftc.sigio); 478 mtx_unlock(&devsoftc.mtx); 479 return (0); 480 } 481 482 /* 483 * The read channel for this device is used to report changes to 484 * userland in realtime. We are required to free the data as well as 485 * the n1 object because we allocate them separately. Also note that 486 * we return one record at a time. If you try to read this device a 487 * character at a time, you will lose the rest of the data. Listening 488 * programs are expected to cope. 489 */ 490 static int 491 devread(struct cdev *dev, struct uio *uio, int ioflag) 492 { 493 struct dev_event_info *n1; 494 int rv; 495 496 mtx_lock(&devsoftc.mtx); 497 while (TAILQ_EMPTY(&devsoftc.devq)) { 498 if (devsoftc.nonblock) { 499 mtx_unlock(&devsoftc.mtx); 500 return (EAGAIN); 501 } 502 rv = cv_wait_sig(&devsoftc.cv, &devsoftc.mtx); 503 if (rv) { 504 /* 505 * Need to translate ERESTART to EINTR here? -- jake 506 */ 507 mtx_unlock(&devsoftc.mtx); 508 return (rv); 509 } 510 } 511 n1 = TAILQ_FIRST(&devsoftc.devq); 512 TAILQ_REMOVE(&devsoftc.devq, n1, dei_link); 513 devsoftc.queued--; 514 mtx_unlock(&devsoftc.mtx); 515 rv = uiomove(n1->dei_data, strlen(n1->dei_data), uio); 516 free(n1->dei_data, M_BUS); 517 free(n1, M_BUS); 518 return (rv); 519 } 520 521 static int 522 devioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td) 523 { 524 switch (cmd) { 525 526 case FIONBIO: 527 if (*(int*)data) 528 devsoftc.nonblock = 1; 529 else 530 devsoftc.nonblock = 0; 531 return (0); 532 case FIOASYNC: 533 if (*(int*)data) 534 devsoftc.async = 1; 535 else 536 devsoftc.async = 0; 537 return (0); 538 case FIOSETOWN: 539 return fsetown(*(int *)data, &devsoftc.sigio); 540 case FIOGETOWN: 541 *(int *)data = fgetown(&devsoftc.sigio); 542 return (0); 543 544 /* (un)Support for other fcntl() calls. */ 545 case FIOCLEX: 546 case FIONCLEX: 547 case FIONREAD: 548 default: 549 break; 550 } 551 return (ENOTTY); 552 } 553 554 static int 555 devpoll(struct cdev *dev, int events, struct thread *td) 556 { 557 int revents = 0; 558 559 mtx_lock(&devsoftc.mtx); 560 if (events & (POLLIN | POLLRDNORM)) { 561 if (!TAILQ_EMPTY(&devsoftc.devq)) 562 revents = events & (POLLIN | POLLRDNORM); 563 else 564 selrecord(td, &devsoftc.sel); 565 } 566 mtx_unlock(&devsoftc.mtx); 567 568 return (revents); 569 } 570 571 static int 572 devkqfilter(struct cdev *dev, struct knote *kn) 573 { 574 int error; 575 576 if (kn->kn_filter == EVFILT_READ) { 577 kn->kn_fop = &devctl_rfiltops; 578 knlist_add(&devsoftc.sel.si_note, kn, 0); 579 error = 0; 580 } else 581 error = EINVAL; 582 return (error); 583 } 584 585 static void 586 filt_devctl_detach(struct knote *kn) 587 { 588 589 knlist_remove(&devsoftc.sel.si_note, kn, 0); 590 } 591 592 static int 593 filt_devctl_read(struct knote *kn, long hint) 594 { 595 kn->kn_data = devsoftc.queued; 596 return (kn->kn_data != 0); 597 } 598 599 /** 600 * @brief Return whether the userland process is running 601 */ 602 boolean_t 603 devctl_process_running(void) 604 { 605 return (devsoftc.inuse == 1); 606 } 607 608 /** 609 * @brief Queue data to be read from the devctl device 610 * 611 * Generic interface to queue data to the devctl device. It is 612 * assumed that @p data is properly formatted. It is further assumed 613 * that @p data is allocated using the M_BUS malloc type. 614 */ 615 void 616 devctl_queue_data_f(char *data, int flags) 617 { 618 struct dev_event_info *n1 = NULL, *n2 = NULL; 619 620 if (strlen(data) == 0) 621 goto out; 622 if (devctl_queue_length == 0) 623 goto out; 624 n1 = malloc(sizeof(*n1), M_BUS, flags); 625 if (n1 == NULL) 626 goto out; 627 n1->dei_data = data; 628 mtx_lock(&devsoftc.mtx); 629 if (devctl_queue_length == 0) { 630 mtx_unlock(&devsoftc.mtx); 631 free(n1->dei_data, M_BUS); 632 free(n1, M_BUS); 633 return; 634 } 635 /* Leave at least one spot in the queue... */ 636 while (devsoftc.queued > devctl_queue_length - 1) { 637 n2 = TAILQ_FIRST(&devsoftc.devq); 638 TAILQ_REMOVE(&devsoftc.devq, n2, dei_link); 639 free(n2->dei_data, M_BUS); 640 free(n2, M_BUS); 641 devsoftc.queued--; 642 } 643 TAILQ_INSERT_TAIL(&devsoftc.devq, n1, dei_link); 644 devsoftc.queued++; 645 cv_broadcast(&devsoftc.cv); 646 KNOTE_LOCKED(&devsoftc.sel.si_note, 0); 647 mtx_unlock(&devsoftc.mtx); 648 selwakeup(&devsoftc.sel); 649 if (devsoftc.async && devsoftc.sigio != NULL) 650 pgsigio(&devsoftc.sigio, SIGIO, 0); 651 return; 652 out: 653 /* 654 * We have to free data on all error paths since the caller 655 * assumes it will be free'd when this item is dequeued. 656 */ 657 free(data, M_BUS); 658 return; 659 } 660 661 void 662 devctl_queue_data(char *data) 663 { 664 665 devctl_queue_data_f(data, M_NOWAIT); 666 } 667 668 /** 669 * @brief Send a 'notification' to userland, using standard ways 670 */ 671 void 672 devctl_notify_f(const char *system, const char *subsystem, const char *type, 673 const char *data, int flags) 674 { 675 int len = 0; 676 char *msg; 677 678 if (system == NULL) 679 return; /* BOGUS! Must specify system. */ 680 if (subsystem == NULL) 681 return; /* BOGUS! Must specify subsystem. */ 682 if (type == NULL) 683 return; /* BOGUS! Must specify type. */ 684 len += strlen(" system=") + strlen(system); 685 len += strlen(" subsystem=") + strlen(subsystem); 686 len += strlen(" type=") + strlen(type); 687 /* add in the data message plus newline. */ 688 if (data != NULL) 689 len += strlen(data); 690 len += 3; /* '!', '\n', and NUL */ 691 msg = malloc(len, M_BUS, flags); 692 if (msg == NULL) 693 return; /* Drop it on the floor */ 694 if (data != NULL) 695 snprintf(msg, len, "!system=%s subsystem=%s type=%s %s\n", 696 system, subsystem, type, data); 697 else 698 snprintf(msg, len, "!system=%s subsystem=%s type=%s\n", 699 system, subsystem, type); 700 devctl_queue_data_f(msg, flags); 701 } 702 703 void 704 devctl_notify(const char *system, const char *subsystem, const char *type, 705 const char *data) 706 { 707 708 devctl_notify_f(system, subsystem, type, data, M_NOWAIT); 709 } 710 711 /* 712 * Common routine that tries to make sending messages as easy as possible. 713 * We allocate memory for the data, copy strings into that, but do not 714 * free it unless there's an error. The dequeue part of the driver should 715 * free the data. We don't send data when the device is disabled. We do 716 * send data, even when we have no listeners, because we wish to avoid 717 * races relating to startup and restart of listening applications. 718 * 719 * devaddq is designed to string together the type of event, with the 720 * object of that event, plus the plug and play info and location info 721 * for that event. This is likely most useful for devices, but less 722 * useful for other consumers of this interface. Those should use 723 * the devctl_queue_data() interface instead. 724 */ 725 static void 726 devaddq(const char *type, const char *what, device_t dev) 727 { 728 char *data = NULL; 729 char *loc = NULL; 730 char *pnp = NULL; 731 const char *parstr; 732 733 if (!devctl_queue_length)/* Rare race, but lost races safely discard */ 734 return; 735 data = malloc(1024, M_BUS, M_NOWAIT); 736 if (data == NULL) 737 goto bad; 738 739 /* get the bus specific location of this device */ 740 loc = malloc(1024, M_BUS, M_NOWAIT); 741 if (loc == NULL) 742 goto bad; 743 *loc = '\0'; 744 bus_child_location_str(dev, loc, 1024); 745 746 /* Get the bus specific pnp info of this device */ 747 pnp = malloc(1024, M_BUS, M_NOWAIT); 748 if (pnp == NULL) 749 goto bad; 750 *pnp = '\0'; 751 bus_child_pnpinfo_str(dev, pnp, 1024); 752 753 /* Get the parent of this device, or / if high enough in the tree. */ 754 if (device_get_parent(dev) == NULL) 755 parstr = "."; /* Or '/' ? */ 756 else 757 parstr = device_get_nameunit(device_get_parent(dev)); 758 /* String it all together. */ 759 snprintf(data, 1024, "%s%s at %s %s on %s\n", type, what, loc, pnp, 760 parstr); 761 free(loc, M_BUS); 762 free(pnp, M_BUS); 763 devctl_queue_data(data); 764 return; 765 bad: 766 free(pnp, M_BUS); 767 free(loc, M_BUS); 768 free(data, M_BUS); 769 return; 770 } 771 772 /* 773 * A device was added to the tree. We are called just after it successfully 774 * attaches (that is, probe and attach success for this device). No call 775 * is made if a device is merely parented into the tree. See devnomatch 776 * if probe fails. If attach fails, no notification is sent (but maybe 777 * we should have a different message for this). 778 */ 779 static void 780 devadded(device_t dev) 781 { 782 devaddq("+", device_get_nameunit(dev), dev); 783 } 784 785 /* 786 * A device was removed from the tree. We are called just before this 787 * happens. 788 */ 789 static void 790 devremoved(device_t dev) 791 { 792 devaddq("-", device_get_nameunit(dev), dev); 793 } 794 795 /* 796 * Called when there's no match for this device. This is only called 797 * the first time that no match happens, so we don't keep getting this 798 * message. Should that prove to be undesirable, we can change it. 799 * This is called when all drivers that can attach to a given bus 800 * decline to accept this device. Other errors may not be detected. 801 */ 802 static void 803 devnomatch(device_t dev) 804 { 805 devaddq("?", "", dev); 806 } 807 808 static int 809 sysctl_devctl_disable(SYSCTL_HANDLER_ARGS) 810 { 811 struct dev_event_info *n1; 812 int dis, error; 813 814 dis = (devctl_queue_length == 0); 815 error = sysctl_handle_int(oidp, &dis, 0, req); 816 if (error || !req->newptr) 817 return (error); 818 if (mtx_initialized(&devsoftc.mtx)) 819 mtx_lock(&devsoftc.mtx); 820 if (dis) { 821 while (!TAILQ_EMPTY(&devsoftc.devq)) { 822 n1 = TAILQ_FIRST(&devsoftc.devq); 823 TAILQ_REMOVE(&devsoftc.devq, n1, dei_link); 824 free(n1->dei_data, M_BUS); 825 free(n1, M_BUS); 826 } 827 devsoftc.queued = 0; 828 devctl_queue_length = 0; 829 } else { 830 devctl_queue_length = DEVCTL_DEFAULT_QUEUE_LEN; 831 } 832 if (mtx_initialized(&devsoftc.mtx)) 833 mtx_unlock(&devsoftc.mtx); 834 return (0); 835 } 836 837 static int 838 sysctl_devctl_queue(SYSCTL_HANDLER_ARGS) 839 { 840 struct dev_event_info *n1; 841 int q, error; 842 843 q = devctl_queue_length; 844 error = sysctl_handle_int(oidp, &q, 0, req); 845 if (error || !req->newptr) 846 return (error); 847 if (q < 0) 848 return (EINVAL); 849 if (mtx_initialized(&devsoftc.mtx)) 850 mtx_lock(&devsoftc.mtx); 851 devctl_queue_length = q; 852 while (devsoftc.queued > devctl_queue_length) { 853 n1 = TAILQ_FIRST(&devsoftc.devq); 854 TAILQ_REMOVE(&devsoftc.devq, n1, dei_link); 855 free(n1->dei_data, M_BUS); 856 free(n1, M_BUS); 857 devsoftc.queued--; 858 } 859 if (mtx_initialized(&devsoftc.mtx)) 860 mtx_unlock(&devsoftc.mtx); 861 return (0); 862 } 863 864 /** 865 * @brief safely quotes strings that might have double quotes in them. 866 * 867 * The devctl protocol relies on quoted strings having matching quotes. 868 * This routine quotes any internal quotes so the resulting string 869 * is safe to pass to snprintf to construct, for example pnp info strings. 870 * Strings are always terminated with a NUL, but may be truncated if longer 871 * than @p len bytes after quotes. 872 * 873 * @param sb sbuf to place the characters into 874 * @param src Original buffer. 875 */ 876 void 877 devctl_safe_quote_sb(struct sbuf *sb, const char *src) 878 { 879 880 while (*src != '\0') { 881 if (*src == '"' || *src == '\\') 882 sbuf_putc(sb, '\\'); 883 sbuf_putc(sb, *src++); 884 } 885 } 886 887 /* End of /dev/devctl code */ 888 889 static TAILQ_HEAD(,device) bus_data_devices; 890 static int bus_data_generation = 1; 891 892 static kobj_method_t null_methods[] = { 893 KOBJMETHOD_END 894 }; 895 896 DEFINE_CLASS(null, null_methods, 0); 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 there is an "at" hint for a unit then skip it. */ 1674 if (resource_string_value(dc->name, unit, "at", &s) == 1675 0) 1676 continue; 1677 1678 /* If this device slot is already in use, skip it. */ 1679 if (unit < dc->maxunit && dc->devices[unit] != NULL) 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 int hasclass = (child->devclass != NULL); 2110 2111 GIANT_REQUIRED; 2112 2113 dc = dev->devclass; 2114 if (!dc) 2115 panic("device_probe_child: parent device has no devclass"); 2116 2117 /* 2118 * If the state is already probed, then return. However, don't 2119 * return if we can rebid this object. 2120 */ 2121 if (child->state == DS_ALIVE && (child->flags & DF_REBID) == 0) 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 /* Reset flags and devclass before the next probe. */ 2162 child->devflags = 0; 2163 if (!hasclass) 2164 (void)device_set_devclass(child, NULL); 2165 2166 /* 2167 * If the driver returns SUCCESS, there can be 2168 * no higher match for this device. 2169 */ 2170 if (result == 0) { 2171 best = dl; 2172 pri = 0; 2173 break; 2174 } 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 /* 2221 * If we found a driver, change state and initialise the devclass. 2222 */ 2223 /* XXX What happens if we rebid and got no best? */ 2224 if (best) { 2225 /* 2226 * If this device was attached, and we were asked to 2227 * rescan, and it is a different driver, then we have 2228 * to detach the old driver and reattach this new one. 2229 * Note, we don't have to check for DF_REBID here 2230 * because if the state is > DS_ALIVE, we know it must 2231 * be. 2232 * 2233 * This assumes that all DF_REBID drivers can have 2234 * their probe routine called at any time and that 2235 * they are idempotent as well as completely benign in 2236 * normal operations. 2237 * 2238 * We also have to make sure that the detach 2239 * succeeded, otherwise we fail the operation (or 2240 * maybe it should just fail silently? I'm torn). 2241 */ 2242 if (child->state > DS_ALIVE && best->driver != child->driver) 2243 if ((result = device_detach(dev)) != 0) 2244 return (result); 2245 2246 /* Set the winning driver, devclass, and flags. */ 2247 if (!child->devclass) { 2248 result = device_set_devclass(child, best->driver->name); 2249 if (result != 0) 2250 return (result); 2251 } 2252 result = device_set_driver(child, best->driver); 2253 if (result != 0) 2254 return (result); 2255 resource_int_value(best->driver->name, child->unit, 2256 "flags", &child->devflags); 2257 2258 if (pri < 0) { 2259 /* 2260 * A bit bogus. Call the probe method again to make 2261 * sure that we have the right description. 2262 */ 2263 DEVICE_PROBE(child); 2264 #if 0 2265 child->flags |= DF_REBID; 2266 #endif 2267 } else 2268 child->flags &= ~DF_REBID; 2269 child->state = DS_ALIVE; 2270 2271 bus_data_generation_update(); 2272 return (0); 2273 } 2274 2275 return (ENXIO); 2276 } 2277 2278 /** 2279 * @brief Return the parent of a device 2280 */ 2281 device_t 2282 device_get_parent(device_t dev) 2283 { 2284 return (dev->parent); 2285 } 2286 2287 /** 2288 * @brief Get a list of children of a device 2289 * 2290 * An array containing a list of all the children of the given device 2291 * is allocated and returned in @p *devlistp. The number of devices 2292 * in the array is returned in @p *devcountp. The caller should free 2293 * the array using @c free(p, M_TEMP). 2294 * 2295 * @param dev the device to examine 2296 * @param devlistp points at location for array pointer return 2297 * value 2298 * @param devcountp points at location for array size return value 2299 * 2300 * @retval 0 success 2301 * @retval ENOMEM the array allocation failed 2302 */ 2303 int 2304 device_get_children(device_t dev, device_t **devlistp, int *devcountp) 2305 { 2306 int count; 2307 device_t child; 2308 device_t *list; 2309 2310 count = 0; 2311 TAILQ_FOREACH(child, &dev->children, link) { 2312 count++; 2313 } 2314 if (count == 0) { 2315 *devlistp = NULL; 2316 *devcountp = 0; 2317 return (0); 2318 } 2319 2320 list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO); 2321 if (!list) 2322 return (ENOMEM); 2323 2324 count = 0; 2325 TAILQ_FOREACH(child, &dev->children, link) { 2326 list[count] = child; 2327 count++; 2328 } 2329 2330 *devlistp = list; 2331 *devcountp = count; 2332 2333 return (0); 2334 } 2335 2336 /** 2337 * @brief Return the current driver for the device or @c NULL if there 2338 * is no driver currently attached 2339 */ 2340 driver_t * 2341 device_get_driver(device_t dev) 2342 { 2343 return (dev->driver); 2344 } 2345 2346 /** 2347 * @brief Return the current devclass for the device or @c NULL if 2348 * there is none. 2349 */ 2350 devclass_t 2351 device_get_devclass(device_t dev) 2352 { 2353 return (dev->devclass); 2354 } 2355 2356 /** 2357 * @brief Return the name of the device's devclass or @c NULL if there 2358 * is none. 2359 */ 2360 const char * 2361 device_get_name(device_t dev) 2362 { 2363 if (dev != NULL && dev->devclass) 2364 return (devclass_get_name(dev->devclass)); 2365 return (NULL); 2366 } 2367 2368 /** 2369 * @brief Return a string containing the device's devclass name 2370 * followed by an ascii representation of the device's unit number 2371 * (e.g. @c "foo2"). 2372 */ 2373 const char * 2374 device_get_nameunit(device_t dev) 2375 { 2376 return (dev->nameunit); 2377 } 2378 2379 /** 2380 * @brief Return the device's unit number. 2381 */ 2382 int 2383 device_get_unit(device_t dev) 2384 { 2385 return (dev->unit); 2386 } 2387 2388 /** 2389 * @brief Return the device's description string 2390 */ 2391 const char * 2392 device_get_desc(device_t dev) 2393 { 2394 return (dev->desc); 2395 } 2396 2397 /** 2398 * @brief Return the device's flags 2399 */ 2400 uint32_t 2401 device_get_flags(device_t dev) 2402 { 2403 return (dev->devflags); 2404 } 2405 2406 struct sysctl_ctx_list * 2407 device_get_sysctl_ctx(device_t dev) 2408 { 2409 return (&dev->sysctl_ctx); 2410 } 2411 2412 struct sysctl_oid * 2413 device_get_sysctl_tree(device_t dev) 2414 { 2415 return (dev->sysctl_tree); 2416 } 2417 2418 /** 2419 * @brief Print the name of the device followed by a colon and a space 2420 * 2421 * @returns the number of characters printed 2422 */ 2423 int 2424 device_print_prettyname(device_t dev) 2425 { 2426 const char *name = device_get_name(dev); 2427 2428 if (name == NULL) 2429 return (printf("unknown: ")); 2430 return (printf("%s%d: ", name, device_get_unit(dev))); 2431 } 2432 2433 /** 2434 * @brief Print the name of the device followed by a colon, a space 2435 * and the result of calling vprintf() with the value of @p fmt and 2436 * the following arguments. 2437 * 2438 * @returns the number of characters printed 2439 */ 2440 int 2441 device_printf(device_t dev, const char * fmt, ...) 2442 { 2443 char buf[128]; 2444 struct sbuf sb; 2445 const char *name; 2446 va_list ap; 2447 size_t retval; 2448 2449 retval = 0; 2450 2451 sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN); 2452 sbuf_set_drain(&sb, sbuf_printf_drain, &retval); 2453 2454 name = device_get_name(dev); 2455 2456 if (name == NULL) 2457 sbuf_cat(&sb, "unknown: "); 2458 else 2459 sbuf_printf(&sb, "%s%d: ", name, device_get_unit(dev)); 2460 2461 va_start(ap, fmt); 2462 sbuf_vprintf(&sb, fmt, ap); 2463 va_end(ap); 2464 2465 sbuf_finish(&sb); 2466 sbuf_delete(&sb); 2467 2468 return (retval); 2469 } 2470 2471 /** 2472 * @internal 2473 */ 2474 static void 2475 device_set_desc_internal(device_t dev, const char* desc, int copy) 2476 { 2477 if (dev->desc && (dev->flags & DF_DESCMALLOCED)) { 2478 free(dev->desc, M_BUS); 2479 dev->flags &= ~DF_DESCMALLOCED; 2480 dev->desc = NULL; 2481 } 2482 2483 if (copy && desc) { 2484 dev->desc = malloc(strlen(desc) + 1, M_BUS, M_NOWAIT); 2485 if (dev->desc) { 2486 strcpy(dev->desc, desc); 2487 dev->flags |= DF_DESCMALLOCED; 2488 } 2489 } else { 2490 /* Avoid a -Wcast-qual warning */ 2491 dev->desc = (char *)(uintptr_t) desc; 2492 } 2493 2494 bus_data_generation_update(); 2495 } 2496 2497 /** 2498 * @brief Set the device's description 2499 * 2500 * The value of @c desc should be a string constant that will not 2501 * change (at least until the description is changed in a subsequent 2502 * call to device_set_desc() or device_set_desc_copy()). 2503 */ 2504 void 2505 device_set_desc(device_t dev, const char* desc) 2506 { 2507 device_set_desc_internal(dev, desc, FALSE); 2508 } 2509 2510 /** 2511 * @brief Set the device's description 2512 * 2513 * The string pointed to by @c desc is copied. Use this function if 2514 * the device description is generated, (e.g. with sprintf()). 2515 */ 2516 void 2517 device_set_desc_copy(device_t dev, const char* desc) 2518 { 2519 device_set_desc_internal(dev, desc, TRUE); 2520 } 2521 2522 /** 2523 * @brief Set the device's flags 2524 */ 2525 void 2526 device_set_flags(device_t dev, uint32_t flags) 2527 { 2528 dev->devflags = flags; 2529 } 2530 2531 /** 2532 * @brief Return the device's softc field 2533 * 2534 * The softc is allocated and zeroed when a driver is attached, based 2535 * on the size field of the driver. 2536 */ 2537 void * 2538 device_get_softc(device_t dev) 2539 { 2540 return (dev->softc); 2541 } 2542 2543 /** 2544 * @brief Set the device's softc field 2545 * 2546 * Most drivers do not need to use this since the softc is allocated 2547 * automatically when the driver is attached. 2548 */ 2549 void 2550 device_set_softc(device_t dev, void *softc) 2551 { 2552 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) 2553 free_domain(dev->softc, M_BUS_SC); 2554 dev->softc = softc; 2555 if (dev->softc) 2556 dev->flags |= DF_EXTERNALSOFTC; 2557 else 2558 dev->flags &= ~DF_EXTERNALSOFTC; 2559 } 2560 2561 /** 2562 * @brief Free claimed softc 2563 * 2564 * Most drivers do not need to use this since the softc is freed 2565 * automatically when the driver is detached. 2566 */ 2567 void 2568 device_free_softc(void *softc) 2569 { 2570 free_domain(softc, M_BUS_SC); 2571 } 2572 2573 /** 2574 * @brief Claim softc 2575 * 2576 * This function can be used to let the driver free the automatically 2577 * allocated softc using "device_free_softc()". This function is 2578 * useful when the driver is refcounting the softc and the softc 2579 * cannot be freed when the "device_detach" method is called. 2580 */ 2581 void 2582 device_claim_softc(device_t dev) 2583 { 2584 if (dev->softc) 2585 dev->flags |= DF_EXTERNALSOFTC; 2586 else 2587 dev->flags &= ~DF_EXTERNALSOFTC; 2588 } 2589 2590 /** 2591 * @brief Get the device's ivars field 2592 * 2593 * The ivars field is used by the parent device to store per-device 2594 * state (e.g. the physical location of the device or a list of 2595 * resources). 2596 */ 2597 void * 2598 device_get_ivars(device_t dev) 2599 { 2600 2601 KASSERT(dev != NULL, ("device_get_ivars(NULL, ...)")); 2602 return (dev->ivars); 2603 } 2604 2605 /** 2606 * @brief Set the device's ivars field 2607 */ 2608 void 2609 device_set_ivars(device_t dev, void * ivars) 2610 { 2611 2612 KASSERT(dev != NULL, ("device_set_ivars(NULL, ...)")); 2613 dev->ivars = ivars; 2614 } 2615 2616 /** 2617 * @brief Return the device's state 2618 */ 2619 device_state_t 2620 device_get_state(device_t dev) 2621 { 2622 return (dev->state); 2623 } 2624 2625 /** 2626 * @brief Set the DF_ENABLED flag for the device 2627 */ 2628 void 2629 device_enable(device_t dev) 2630 { 2631 dev->flags |= DF_ENABLED; 2632 } 2633 2634 /** 2635 * @brief Clear the DF_ENABLED flag for the device 2636 */ 2637 void 2638 device_disable(device_t dev) 2639 { 2640 dev->flags &= ~DF_ENABLED; 2641 } 2642 2643 /** 2644 * @brief Increment the busy counter for the device 2645 */ 2646 void 2647 device_busy(device_t dev) 2648 { 2649 if (dev->state < DS_ATTACHING) 2650 panic("device_busy: called for unattached device"); 2651 if (dev->busy == 0 && dev->parent) 2652 device_busy(dev->parent); 2653 dev->busy++; 2654 if (dev->state == DS_ATTACHED) 2655 dev->state = DS_BUSY; 2656 } 2657 2658 /** 2659 * @brief Decrement the busy counter for the device 2660 */ 2661 void 2662 device_unbusy(device_t dev) 2663 { 2664 if (dev->busy != 0 && dev->state != DS_BUSY && 2665 dev->state != DS_ATTACHING) 2666 panic("device_unbusy: called for non-busy device %s", 2667 device_get_nameunit(dev)); 2668 dev->busy--; 2669 if (dev->busy == 0) { 2670 if (dev->parent) 2671 device_unbusy(dev->parent); 2672 if (dev->state == DS_BUSY) 2673 dev->state = DS_ATTACHED; 2674 } 2675 } 2676 2677 /** 2678 * @brief Set the DF_QUIET flag for the device 2679 */ 2680 void 2681 device_quiet(device_t dev) 2682 { 2683 dev->flags |= DF_QUIET; 2684 } 2685 2686 /** 2687 * @brief Set the DF_QUIET_CHILDREN flag for the device 2688 */ 2689 void 2690 device_quiet_children(device_t dev) 2691 { 2692 dev->flags |= DF_QUIET_CHILDREN; 2693 } 2694 2695 /** 2696 * @brief Clear the DF_QUIET flag for the device 2697 */ 2698 void 2699 device_verbose(device_t dev) 2700 { 2701 dev->flags &= ~DF_QUIET; 2702 } 2703 2704 /** 2705 * @brief Return non-zero if the DF_QUIET_CHIDLREN flag is set on the device 2706 */ 2707 int 2708 device_has_quiet_children(device_t dev) 2709 { 2710 return ((dev->flags & DF_QUIET_CHILDREN) != 0); 2711 } 2712 2713 /** 2714 * @brief Return non-zero if the DF_QUIET flag is set on the device 2715 */ 2716 int 2717 device_is_quiet(device_t dev) 2718 { 2719 return ((dev->flags & DF_QUIET) != 0); 2720 } 2721 2722 /** 2723 * @brief Return non-zero if the DF_ENABLED flag is set on the device 2724 */ 2725 int 2726 device_is_enabled(device_t dev) 2727 { 2728 return ((dev->flags & DF_ENABLED) != 0); 2729 } 2730 2731 /** 2732 * @brief Return non-zero if the device was successfully probed 2733 */ 2734 int 2735 device_is_alive(device_t dev) 2736 { 2737 return (dev->state >= DS_ALIVE); 2738 } 2739 2740 /** 2741 * @brief Return non-zero if the device currently has a driver 2742 * attached to it 2743 */ 2744 int 2745 device_is_attached(device_t dev) 2746 { 2747 return (dev->state >= DS_ATTACHED); 2748 } 2749 2750 /** 2751 * @brief Return non-zero if the device is currently suspended. 2752 */ 2753 int 2754 device_is_suspended(device_t dev) 2755 { 2756 return ((dev->flags & DF_SUSPENDED) != 0); 2757 } 2758 2759 /** 2760 * @brief Set the devclass of a device 2761 * @see devclass_add_device(). 2762 */ 2763 int 2764 device_set_devclass(device_t dev, const char *classname) 2765 { 2766 devclass_t dc; 2767 int error; 2768 2769 if (!classname) { 2770 if (dev->devclass) 2771 devclass_delete_device(dev->devclass, dev); 2772 return (0); 2773 } 2774 2775 if (dev->devclass) { 2776 printf("device_set_devclass: device class already set\n"); 2777 return (EINVAL); 2778 } 2779 2780 dc = devclass_find_internal(classname, NULL, TRUE); 2781 if (!dc) 2782 return (ENOMEM); 2783 2784 error = devclass_add_device(dc, dev); 2785 2786 bus_data_generation_update(); 2787 return (error); 2788 } 2789 2790 /** 2791 * @brief Set the devclass of a device and mark the devclass fixed. 2792 * @see device_set_devclass() 2793 */ 2794 int 2795 device_set_devclass_fixed(device_t dev, const char *classname) 2796 { 2797 int error; 2798 2799 if (classname == NULL) 2800 return (EINVAL); 2801 2802 error = device_set_devclass(dev, classname); 2803 if (error) 2804 return (error); 2805 dev->flags |= DF_FIXEDCLASS; 2806 return (0); 2807 } 2808 2809 /** 2810 * @brief Query the device to determine if it's of a fixed devclass 2811 * @see device_set_devclass_fixed() 2812 */ 2813 bool 2814 device_is_devclass_fixed(device_t dev) 2815 { 2816 return ((dev->flags & DF_FIXEDCLASS) != 0); 2817 } 2818 2819 /** 2820 * @brief Set the driver of a device 2821 * 2822 * @retval 0 success 2823 * @retval EBUSY the device already has a driver attached 2824 * @retval ENOMEM a memory allocation failure occurred 2825 */ 2826 int 2827 device_set_driver(device_t dev, driver_t *driver) 2828 { 2829 int domain; 2830 struct domainset *policy; 2831 2832 if (dev->state >= DS_ATTACHED) 2833 return (EBUSY); 2834 2835 if (dev->driver == driver) 2836 return (0); 2837 2838 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) { 2839 free_domain(dev->softc, M_BUS_SC); 2840 dev->softc = NULL; 2841 } 2842 device_set_desc(dev, NULL); 2843 kobj_delete((kobj_t) dev, NULL); 2844 dev->driver = driver; 2845 if (driver) { 2846 kobj_init((kobj_t) dev, (kobj_class_t) driver); 2847 if (!(dev->flags & DF_EXTERNALSOFTC) && driver->size > 0) { 2848 if (bus_get_domain(dev, &domain) == 0) 2849 policy = DOMAINSET_PREF(domain); 2850 else 2851 policy = DOMAINSET_RR(); 2852 dev->softc = malloc_domainset(driver->size, M_BUS_SC, 2853 policy, M_NOWAIT | M_ZERO); 2854 if (!dev->softc) { 2855 kobj_delete((kobj_t) dev, NULL); 2856 kobj_init((kobj_t) dev, &null_class); 2857 dev->driver = NULL; 2858 return (ENOMEM); 2859 } 2860 } 2861 } else { 2862 kobj_init((kobj_t) dev, &null_class); 2863 } 2864 2865 bus_data_generation_update(); 2866 return (0); 2867 } 2868 2869 /** 2870 * @brief Probe a device, and return this status. 2871 * 2872 * This function is the core of the device autoconfiguration 2873 * system. Its purpose is to select a suitable driver for a device and 2874 * then call that driver to initialise the hardware appropriately. The 2875 * driver is selected by calling the DEVICE_PROBE() method of a set of 2876 * candidate drivers and then choosing the driver which returned the 2877 * best value. This driver is then attached to the device using 2878 * device_attach(). 2879 * 2880 * The set of suitable drivers is taken from the list of drivers in 2881 * the parent device's devclass. If the device was originally created 2882 * with a specific class name (see device_add_child()), only drivers 2883 * with that name are probed, otherwise all drivers in the devclass 2884 * are probed. If no drivers return successful probe values in the 2885 * parent devclass, the search continues in the parent of that 2886 * devclass (see devclass_get_parent()) if any. 2887 * 2888 * @param dev the device to initialise 2889 * 2890 * @retval 0 success 2891 * @retval ENXIO no driver was found 2892 * @retval ENOMEM memory allocation failure 2893 * @retval non-zero some other unix error code 2894 * @retval -1 Device already attached 2895 */ 2896 int 2897 device_probe(device_t dev) 2898 { 2899 int error; 2900 2901 GIANT_REQUIRED; 2902 2903 if (dev->state >= DS_ALIVE && (dev->flags & DF_REBID) == 0) 2904 return (-1); 2905 2906 if (!(dev->flags & DF_ENABLED)) { 2907 if (bootverbose && device_get_name(dev) != NULL) { 2908 device_print_prettyname(dev); 2909 printf("not probed (disabled)\n"); 2910 } 2911 return (-1); 2912 } 2913 if ((error = device_probe_child(dev->parent, dev)) != 0) { 2914 if (bus_current_pass == BUS_PASS_DEFAULT && 2915 !(dev->flags & DF_DONENOMATCH)) { 2916 BUS_PROBE_NOMATCH(dev->parent, dev); 2917 devnomatch(dev); 2918 dev->flags |= DF_DONENOMATCH; 2919 } 2920 return (error); 2921 } 2922 return (0); 2923 } 2924 2925 /** 2926 * @brief Probe a device and attach a driver if possible 2927 * 2928 * calls device_probe() and attaches if that was successful. 2929 */ 2930 int 2931 device_probe_and_attach(device_t dev) 2932 { 2933 int error; 2934 2935 GIANT_REQUIRED; 2936 2937 error = device_probe(dev); 2938 if (error == -1) 2939 return (0); 2940 else if (error != 0) 2941 return (error); 2942 2943 CURVNET_SET_QUIET(vnet0); 2944 error = device_attach(dev); 2945 CURVNET_RESTORE(); 2946 return error; 2947 } 2948 2949 /** 2950 * @brief Attach a device driver to a device 2951 * 2952 * This function is a wrapper around the DEVICE_ATTACH() driver 2953 * method. In addition to calling DEVICE_ATTACH(), it initialises the 2954 * device's sysctl tree, optionally prints a description of the device 2955 * and queues a notification event for user-based device management 2956 * services. 2957 * 2958 * Normally this function is only called internally from 2959 * device_probe_and_attach(). 2960 * 2961 * @param dev the device to initialise 2962 * 2963 * @retval 0 success 2964 * @retval ENXIO no driver was found 2965 * @retval ENOMEM memory allocation failure 2966 * @retval non-zero some other unix error code 2967 */ 2968 int 2969 device_attach(device_t dev) 2970 { 2971 uint64_t attachtime; 2972 uint16_t attachentropy; 2973 int error; 2974 2975 if (resource_disabled(dev->driver->name, dev->unit)) { 2976 device_disable(dev); 2977 if (bootverbose) 2978 device_printf(dev, "disabled via hints entry\n"); 2979 return (ENXIO); 2980 } 2981 2982 device_sysctl_init(dev); 2983 if (!device_is_quiet(dev)) 2984 device_print_child(dev->parent, dev); 2985 attachtime = get_cyclecount(); 2986 dev->state = DS_ATTACHING; 2987 if ((error = DEVICE_ATTACH(dev)) != 0) { 2988 printf("device_attach: %s%d attach returned %d\n", 2989 dev->driver->name, dev->unit, error); 2990 if (!(dev->flags & DF_FIXEDCLASS)) 2991 devclass_delete_device(dev->devclass, dev); 2992 (void)device_set_driver(dev, NULL); 2993 device_sysctl_fini(dev); 2994 KASSERT(dev->busy == 0, ("attach failed but busy")); 2995 dev->state = DS_NOTPRESENT; 2996 return (error); 2997 } 2998 dev->flags |= DF_ATTACHED_ONCE; 2999 /* We only need the low bits of this time, but ranges from tens to thousands 3000 * have been seen, so keep 2 bytes' worth. 3001 */ 3002 attachentropy = (uint16_t)(get_cyclecount() - attachtime); 3003 random_harvest_direct(&attachentropy, sizeof(attachentropy), RANDOM_ATTACH); 3004 device_sysctl_update(dev); 3005 if (dev->busy) 3006 dev->state = DS_BUSY; 3007 else 3008 dev->state = DS_ATTACHED; 3009 dev->flags &= ~DF_DONENOMATCH; 3010 EVENTHANDLER_DIRECT_INVOKE(device_attach, dev); 3011 devadded(dev); 3012 return (0); 3013 } 3014 3015 /** 3016 * @brief Detach a driver from a device 3017 * 3018 * This function is a wrapper around the DEVICE_DETACH() driver 3019 * method. If the call to DEVICE_DETACH() succeeds, it calls 3020 * BUS_CHILD_DETACHED() for the parent of @p dev, queues a 3021 * notification event for user-based device management services and 3022 * cleans up the device's sysctl tree. 3023 * 3024 * @param dev the device to un-initialise 3025 * 3026 * @retval 0 success 3027 * @retval ENXIO no driver was found 3028 * @retval ENOMEM memory allocation failure 3029 * @retval non-zero some other unix error code 3030 */ 3031 int 3032 device_detach(device_t dev) 3033 { 3034 int error; 3035 3036 GIANT_REQUIRED; 3037 3038 PDEBUG(("%s", DEVICENAME(dev))); 3039 if (dev->state == DS_BUSY) 3040 return (EBUSY); 3041 if (dev->state == DS_ATTACHING) { 3042 device_printf(dev, "device in attaching state! Deferring detach.\n"); 3043 return (EBUSY); 3044 } 3045 if (dev->state != DS_ATTACHED) 3046 return (0); 3047 3048 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, EVHDEV_DETACH_BEGIN); 3049 if ((error = DEVICE_DETACH(dev)) != 0) { 3050 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, 3051 EVHDEV_DETACH_FAILED); 3052 return (error); 3053 } else { 3054 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, 3055 EVHDEV_DETACH_COMPLETE); 3056 } 3057 devremoved(dev); 3058 if (!device_is_quiet(dev)) 3059 device_printf(dev, "detached\n"); 3060 if (dev->parent) 3061 BUS_CHILD_DETACHED(dev->parent, dev); 3062 3063 if (!(dev->flags & DF_FIXEDCLASS)) 3064 devclass_delete_device(dev->devclass, dev); 3065 3066 device_verbose(dev); 3067 dev->state = DS_NOTPRESENT; 3068 (void)device_set_driver(dev, NULL); 3069 device_sysctl_fini(dev); 3070 3071 return (0); 3072 } 3073 3074 /** 3075 * @brief Tells a driver to quiesce itself. 3076 * 3077 * This function is a wrapper around the DEVICE_QUIESCE() driver 3078 * method. If the call to DEVICE_QUIESCE() succeeds. 3079 * 3080 * @param dev the device to quiesce 3081 * 3082 * @retval 0 success 3083 * @retval ENXIO no driver was found 3084 * @retval ENOMEM memory allocation failure 3085 * @retval non-zero some other unix error code 3086 */ 3087 int 3088 device_quiesce(device_t dev) 3089 { 3090 3091 PDEBUG(("%s", DEVICENAME(dev))); 3092 if (dev->state == DS_BUSY) 3093 return (EBUSY); 3094 if (dev->state != DS_ATTACHED) 3095 return (0); 3096 3097 return (DEVICE_QUIESCE(dev)); 3098 } 3099 3100 /** 3101 * @brief Notify a device of system shutdown 3102 * 3103 * This function calls the DEVICE_SHUTDOWN() driver method if the 3104 * device currently has an attached driver. 3105 * 3106 * @returns the value returned by DEVICE_SHUTDOWN() 3107 */ 3108 int 3109 device_shutdown(device_t dev) 3110 { 3111 if (dev->state < DS_ATTACHED) 3112 return (0); 3113 return (DEVICE_SHUTDOWN(dev)); 3114 } 3115 3116 /** 3117 * @brief Set the unit number of a device 3118 * 3119 * This function can be used to override the unit number used for a 3120 * device (e.g. to wire a device to a pre-configured unit number). 3121 */ 3122 int 3123 device_set_unit(device_t dev, int unit) 3124 { 3125 devclass_t dc; 3126 int err; 3127 3128 dc = device_get_devclass(dev); 3129 if (unit < dc->maxunit && dc->devices[unit]) 3130 return (EBUSY); 3131 err = devclass_delete_device(dc, dev); 3132 if (err) 3133 return (err); 3134 dev->unit = unit; 3135 err = devclass_add_device(dc, dev); 3136 if (err) 3137 return (err); 3138 3139 bus_data_generation_update(); 3140 return (0); 3141 } 3142 3143 /*======================================*/ 3144 /* 3145 * Some useful method implementations to make life easier for bus drivers. 3146 */ 3147 3148 void 3149 resource_init_map_request_impl(struct resource_map_request *args, size_t sz) 3150 { 3151 3152 bzero(args, sz); 3153 args->size = sz; 3154 args->memattr = VM_MEMATTR_UNCACHEABLE; 3155 } 3156 3157 /** 3158 * @brief Initialise a resource list. 3159 * 3160 * @param rl the resource list to initialise 3161 */ 3162 void 3163 resource_list_init(struct resource_list *rl) 3164 { 3165 STAILQ_INIT(rl); 3166 } 3167 3168 /** 3169 * @brief Reclaim memory used by a resource list. 3170 * 3171 * This function frees the memory for all resource entries on the list 3172 * (if any). 3173 * 3174 * @param rl the resource list to free 3175 */ 3176 void 3177 resource_list_free(struct resource_list *rl) 3178 { 3179 struct resource_list_entry *rle; 3180 3181 while ((rle = STAILQ_FIRST(rl)) != NULL) { 3182 if (rle->res) 3183 panic("resource_list_free: resource entry is busy"); 3184 STAILQ_REMOVE_HEAD(rl, link); 3185 free(rle, M_BUS); 3186 } 3187 } 3188 3189 /** 3190 * @brief Add a resource entry. 3191 * 3192 * This function adds a resource entry using the given @p type, @p 3193 * start, @p end and @p count values. A rid value is chosen by 3194 * searching sequentially for the first unused rid starting at zero. 3195 * 3196 * @param rl the resource list to edit 3197 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3198 * @param start the start address of the resource 3199 * @param end the end address of the resource 3200 * @param count XXX end-start+1 3201 */ 3202 int 3203 resource_list_add_next(struct resource_list *rl, int type, rman_res_t start, 3204 rman_res_t end, rman_res_t count) 3205 { 3206 int rid; 3207 3208 rid = 0; 3209 while (resource_list_find(rl, type, rid) != NULL) 3210 rid++; 3211 resource_list_add(rl, type, rid, start, end, count); 3212 return (rid); 3213 } 3214 3215 /** 3216 * @brief Add or modify a resource entry. 3217 * 3218 * If an existing entry exists with the same type and rid, it will be 3219 * modified using the given values of @p start, @p end and @p 3220 * count. If no entry exists, a new one will be created using the 3221 * given values. The resource list entry that matches is then returned. 3222 * 3223 * @param rl the resource list to edit 3224 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3225 * @param rid the resource identifier 3226 * @param start the start address of the resource 3227 * @param end the end address of the resource 3228 * @param count XXX end-start+1 3229 */ 3230 struct resource_list_entry * 3231 resource_list_add(struct resource_list *rl, int type, int rid, 3232 rman_res_t start, rman_res_t end, rman_res_t count) 3233 { 3234 struct resource_list_entry *rle; 3235 3236 rle = resource_list_find(rl, type, rid); 3237 if (!rle) { 3238 rle = malloc(sizeof(struct resource_list_entry), M_BUS, 3239 M_NOWAIT); 3240 if (!rle) 3241 panic("resource_list_add: can't record entry"); 3242 STAILQ_INSERT_TAIL(rl, rle, link); 3243 rle->type = type; 3244 rle->rid = rid; 3245 rle->res = NULL; 3246 rle->flags = 0; 3247 } 3248 3249 if (rle->res) 3250 panic("resource_list_add: resource entry is busy"); 3251 3252 rle->start = start; 3253 rle->end = end; 3254 rle->count = count; 3255 return (rle); 3256 } 3257 3258 /** 3259 * @brief Determine if a resource entry is busy. 3260 * 3261 * Returns true if a resource entry is busy meaning that it has an 3262 * associated resource that is not an unallocated "reserved" resource. 3263 * 3264 * @param rl the resource list to search 3265 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3266 * @param rid the resource identifier 3267 * 3268 * @returns Non-zero if the entry is busy, zero otherwise. 3269 */ 3270 int 3271 resource_list_busy(struct resource_list *rl, int type, int rid) 3272 { 3273 struct resource_list_entry *rle; 3274 3275 rle = resource_list_find(rl, type, rid); 3276 if (rle == NULL || rle->res == NULL) 3277 return (0); 3278 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == RLE_RESERVED) { 3279 KASSERT(!(rman_get_flags(rle->res) & RF_ACTIVE), 3280 ("reserved resource is active")); 3281 return (0); 3282 } 3283 return (1); 3284 } 3285 3286 /** 3287 * @brief Determine if a resource entry is reserved. 3288 * 3289 * Returns true if a resource entry is reserved meaning that it has an 3290 * associated "reserved" resource. The resource can either be 3291 * allocated or unallocated. 3292 * 3293 * @param rl the resource list to search 3294 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3295 * @param rid the resource identifier 3296 * 3297 * @returns Non-zero if the entry is reserved, zero otherwise. 3298 */ 3299 int 3300 resource_list_reserved(struct resource_list *rl, int type, int rid) 3301 { 3302 struct resource_list_entry *rle; 3303 3304 rle = resource_list_find(rl, type, rid); 3305 if (rle != NULL && rle->flags & RLE_RESERVED) 3306 return (1); 3307 return (0); 3308 } 3309 3310 /** 3311 * @brief Find a resource entry by type and rid. 3312 * 3313 * @param rl the resource list to search 3314 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3315 * @param rid the resource identifier 3316 * 3317 * @returns the resource entry pointer or NULL if there is no such 3318 * entry. 3319 */ 3320 struct resource_list_entry * 3321 resource_list_find(struct resource_list *rl, int type, int rid) 3322 { 3323 struct resource_list_entry *rle; 3324 3325 STAILQ_FOREACH(rle, rl, link) { 3326 if (rle->type == type && rle->rid == rid) 3327 return (rle); 3328 } 3329 return (NULL); 3330 } 3331 3332 /** 3333 * @brief Delete a resource entry. 3334 * 3335 * @param rl the resource list to edit 3336 * @param type the resource entry type (e.g. SYS_RES_MEMORY) 3337 * @param rid the resource identifier 3338 */ 3339 void 3340 resource_list_delete(struct resource_list *rl, int type, int rid) 3341 { 3342 struct resource_list_entry *rle = resource_list_find(rl, type, rid); 3343 3344 if (rle) { 3345 if (rle->res != NULL) 3346 panic("resource_list_delete: resource has not been released"); 3347 STAILQ_REMOVE(rl, rle, resource_list_entry, link); 3348 free(rle, M_BUS); 3349 } 3350 } 3351 3352 /** 3353 * @brief Allocate a reserved resource 3354 * 3355 * This can be used by buses to force the allocation of resources 3356 * that are always active in the system even if they are not allocated 3357 * by a driver (e.g. PCI BARs). This function is usually called when 3358 * adding a new child to the bus. The resource is allocated from the 3359 * parent bus when it is reserved. The resource list entry is marked 3360 * with RLE_RESERVED to note that it is a reserved resource. 3361 * 3362 * Subsequent attempts to allocate the resource with 3363 * resource_list_alloc() will succeed the first time and will set 3364 * RLE_ALLOCATED to note that it has been allocated. When a reserved 3365 * resource that has been allocated is released with 3366 * resource_list_release() the resource RLE_ALLOCATED is cleared, but 3367 * the actual resource remains allocated. The resource can be released to 3368 * the parent bus by calling resource_list_unreserve(). 3369 * 3370 * @param rl the resource list to allocate from 3371 * @param bus the parent device of @p child 3372 * @param child the device for which the resource is being reserved 3373 * @param type the type of resource to allocate 3374 * @param rid a pointer to the resource identifier 3375 * @param start hint at the start of the resource range - pass 3376 * @c 0 for any start address 3377 * @param end hint at the end of the resource range - pass 3378 * @c ~0 for any end address 3379 * @param count hint at the size of range required - pass @c 1 3380 * for any size 3381 * @param flags any extra flags to control the resource 3382 * allocation - see @c RF_XXX flags in 3383 * <sys/rman.h> for details 3384 * 3385 * @returns the resource which was allocated or @c NULL if no 3386 * resource could be allocated 3387 */ 3388 struct resource * 3389 resource_list_reserve(struct resource_list *rl, device_t bus, device_t child, 3390 int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 3391 { 3392 struct resource_list_entry *rle = NULL; 3393 int passthrough = (device_get_parent(child) != bus); 3394 struct resource *r; 3395 3396 if (passthrough) 3397 panic( 3398 "resource_list_reserve() should only be called for direct children"); 3399 if (flags & RF_ACTIVE) 3400 panic( 3401 "resource_list_reserve() should only reserve inactive resources"); 3402 3403 r = resource_list_alloc(rl, bus, child, type, rid, start, end, count, 3404 flags); 3405 if (r != NULL) { 3406 rle = resource_list_find(rl, type, *rid); 3407 rle->flags |= RLE_RESERVED; 3408 } 3409 return (r); 3410 } 3411 3412 /** 3413 * @brief Helper function for implementing BUS_ALLOC_RESOURCE() 3414 * 3415 * Implement BUS_ALLOC_RESOURCE() by looking up a resource from the list 3416 * and passing the allocation up to the parent of @p bus. This assumes 3417 * that the first entry of @c device_get_ivars(child) is a struct 3418 * resource_list. This also handles 'passthrough' allocations where a 3419 * child is a remote descendant of bus by passing the allocation up to 3420 * the parent of bus. 3421 * 3422 * Typically, a bus driver would store a list of child resources 3423 * somewhere in the child device's ivars (see device_get_ivars()) and 3424 * its implementation of BUS_ALLOC_RESOURCE() would find that list and 3425 * then call resource_list_alloc() to perform the allocation. 3426 * 3427 * @param rl the resource list to allocate from 3428 * @param bus the parent device of @p child 3429 * @param child the device which is requesting an allocation 3430 * @param type the type of resource to allocate 3431 * @param rid a pointer to the resource identifier 3432 * @param start hint at the start of the resource range - pass 3433 * @c 0 for any start address 3434 * @param end hint at the end of the resource range - pass 3435 * @c ~0 for any end address 3436 * @param count hint at the size of range required - pass @c 1 3437 * for any size 3438 * @param flags any extra flags to control the resource 3439 * allocation - see @c RF_XXX flags in 3440 * <sys/rman.h> for details 3441 * 3442 * @returns the resource which was allocated or @c NULL if no 3443 * resource could be allocated 3444 */ 3445 struct resource * 3446 resource_list_alloc(struct resource_list *rl, device_t bus, device_t child, 3447 int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 3448 { 3449 struct resource_list_entry *rle = NULL; 3450 int passthrough = (device_get_parent(child) != bus); 3451 int isdefault = RMAN_IS_DEFAULT_RANGE(start, end); 3452 3453 if (passthrough) { 3454 return (BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 3455 type, rid, start, end, count, flags)); 3456 } 3457 3458 rle = resource_list_find(rl, type, *rid); 3459 3460 if (!rle) 3461 return (NULL); /* no resource of that type/rid */ 3462 3463 if (rle->res) { 3464 if (rle->flags & RLE_RESERVED) { 3465 if (rle->flags & RLE_ALLOCATED) 3466 return (NULL); 3467 if ((flags & RF_ACTIVE) && 3468 bus_activate_resource(child, type, *rid, 3469 rle->res) != 0) 3470 return (NULL); 3471 rle->flags |= RLE_ALLOCATED; 3472 return (rle->res); 3473 } 3474 device_printf(bus, 3475 "resource entry %#x type %d for child %s is busy\n", *rid, 3476 type, device_get_nameunit(child)); 3477 return (NULL); 3478 } 3479 3480 if (isdefault) { 3481 start = rle->start; 3482 count = ulmax(count, rle->count); 3483 end = ulmax(rle->end, start + count - 1); 3484 } 3485 3486 rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 3487 type, rid, start, end, count, flags); 3488 3489 /* 3490 * Record the new range. 3491 */ 3492 if (rle->res) { 3493 rle->start = rman_get_start(rle->res); 3494 rle->end = rman_get_end(rle->res); 3495 rle->count = count; 3496 } 3497 3498 return (rle->res); 3499 } 3500 3501 /** 3502 * @brief Helper function for implementing BUS_RELEASE_RESOURCE() 3503 * 3504 * Implement BUS_RELEASE_RESOURCE() using a resource list. Normally 3505 * used with resource_list_alloc(). 3506 * 3507 * @param rl the resource list which was allocated from 3508 * @param bus the parent device of @p child 3509 * @param child the device which is requesting a release 3510 * @param type the type of resource to release 3511 * @param rid the resource identifier 3512 * @param res the resource to release 3513 * 3514 * @retval 0 success 3515 * @retval non-zero a standard unix error code indicating what 3516 * error condition prevented the operation 3517 */ 3518 int 3519 resource_list_release(struct resource_list *rl, device_t bus, device_t child, 3520 int type, int rid, struct resource *res) 3521 { 3522 struct resource_list_entry *rle = NULL; 3523 int passthrough = (device_get_parent(child) != bus); 3524 int error; 3525 3526 if (passthrough) { 3527 return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 3528 type, rid, res)); 3529 } 3530 3531 rle = resource_list_find(rl, type, rid); 3532 3533 if (!rle) 3534 panic("resource_list_release: can't find resource"); 3535 if (!rle->res) 3536 panic("resource_list_release: resource entry is not busy"); 3537 if (rle->flags & RLE_RESERVED) { 3538 if (rle->flags & RLE_ALLOCATED) { 3539 if (rman_get_flags(res) & RF_ACTIVE) { 3540 error = bus_deactivate_resource(child, type, 3541 rid, res); 3542 if (error) 3543 return (error); 3544 } 3545 rle->flags &= ~RLE_ALLOCATED; 3546 return (0); 3547 } 3548 return (EINVAL); 3549 } 3550 3551 error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 3552 type, rid, res); 3553 if (error) 3554 return (error); 3555 3556 rle->res = NULL; 3557 return (0); 3558 } 3559 3560 /** 3561 * @brief Release all active resources of a given type 3562 * 3563 * Release all active resources of a specified type. This is intended 3564 * to be used to cleanup resources leaked by a driver after detach or 3565 * a failed attach. 3566 * 3567 * @param rl the resource list which was allocated from 3568 * @param bus the parent device of @p child 3569 * @param child the device whose active resources are being released 3570 * @param type the type of resources to release 3571 * 3572 * @retval 0 success 3573 * @retval EBUSY at least one resource was active 3574 */ 3575 int 3576 resource_list_release_active(struct resource_list *rl, device_t bus, 3577 device_t child, int type) 3578 { 3579 struct resource_list_entry *rle; 3580 int error, retval; 3581 3582 retval = 0; 3583 STAILQ_FOREACH(rle, rl, link) { 3584 if (rle->type != type) 3585 continue; 3586 if (rle->res == NULL) 3587 continue; 3588 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == 3589 RLE_RESERVED) 3590 continue; 3591 retval = EBUSY; 3592 error = resource_list_release(rl, bus, child, type, 3593 rman_get_rid(rle->res), rle->res); 3594 if (error != 0) 3595 device_printf(bus, 3596 "Failed to release active resource: %d\n", error); 3597 } 3598 return (retval); 3599 } 3600 3601 /** 3602 * @brief Fully release a reserved resource 3603 * 3604 * Fully releases a resource reserved via resource_list_reserve(). 3605 * 3606 * @param rl the resource list which was allocated from 3607 * @param bus the parent device of @p child 3608 * @param child the device whose reserved resource is being released 3609 * @param type the type of resource to release 3610 * @param rid the resource identifier 3611 * @param res the resource to release 3612 * 3613 * @retval 0 success 3614 * @retval non-zero a standard unix error code indicating what 3615 * error condition prevented the operation 3616 */ 3617 int 3618 resource_list_unreserve(struct resource_list *rl, device_t bus, device_t child, 3619 int type, int rid) 3620 { 3621 struct resource_list_entry *rle = NULL; 3622 int passthrough = (device_get_parent(child) != bus); 3623 3624 if (passthrough) 3625 panic( 3626 "resource_list_unreserve() should only be called for direct children"); 3627 3628 rle = resource_list_find(rl, type, rid); 3629 3630 if (!rle) 3631 panic("resource_list_unreserve: can't find resource"); 3632 if (!(rle->flags & RLE_RESERVED)) 3633 return (EINVAL); 3634 if (rle->flags & RLE_ALLOCATED) 3635 return (EBUSY); 3636 rle->flags &= ~RLE_RESERVED; 3637 return (resource_list_release(rl, bus, child, type, rid, rle->res)); 3638 } 3639 3640 /** 3641 * @brief Print a description of resources in a resource list 3642 * 3643 * Print all resources of a specified type, for use in BUS_PRINT_CHILD(). 3644 * The name is printed if at least one resource of the given type is available. 3645 * The format is used to print resource start and end. 3646 * 3647 * @param rl the resource list to print 3648 * @param name the name of @p type, e.g. @c "memory" 3649 * @param type type type of resource entry to print 3650 * @param format printf(9) format string to print resource 3651 * start and end values 3652 * 3653 * @returns the number of characters printed 3654 */ 3655 int 3656 resource_list_print_type(struct resource_list *rl, const char *name, int type, 3657 const char *format) 3658 { 3659 struct resource_list_entry *rle; 3660 int printed, retval; 3661 3662 printed = 0; 3663 retval = 0; 3664 /* Yes, this is kinda cheating */ 3665 STAILQ_FOREACH(rle, rl, link) { 3666 if (rle->type == type) { 3667 if (printed == 0) 3668 retval += printf(" %s ", name); 3669 else 3670 retval += printf(","); 3671 printed++; 3672 retval += printf(format, rle->start); 3673 if (rle->count > 1) { 3674 retval += printf("-"); 3675 retval += printf(format, rle->start + 3676 rle->count - 1); 3677 } 3678 } 3679 } 3680 return (retval); 3681 } 3682 3683 /** 3684 * @brief Releases all the resources in a list. 3685 * 3686 * @param rl The resource list to purge. 3687 * 3688 * @returns nothing 3689 */ 3690 void 3691 resource_list_purge(struct resource_list *rl) 3692 { 3693 struct resource_list_entry *rle; 3694 3695 while ((rle = STAILQ_FIRST(rl)) != NULL) { 3696 if (rle->res) 3697 bus_release_resource(rman_get_device(rle->res), 3698 rle->type, rle->rid, rle->res); 3699 STAILQ_REMOVE_HEAD(rl, link); 3700 free(rle, M_BUS); 3701 } 3702 } 3703 3704 device_t 3705 bus_generic_add_child(device_t dev, u_int order, const char *name, int unit) 3706 { 3707 3708 return (device_add_child_ordered(dev, order, name, unit)); 3709 } 3710 3711 /** 3712 * @brief Helper function for implementing DEVICE_PROBE() 3713 * 3714 * This function can be used to help implement the DEVICE_PROBE() for 3715 * a bus (i.e. a device which has other devices attached to it). It 3716 * calls the DEVICE_IDENTIFY() method of each driver in the device's 3717 * devclass. 3718 */ 3719 int 3720 bus_generic_probe(device_t dev) 3721 { 3722 devclass_t dc = dev->devclass; 3723 driverlink_t dl; 3724 3725 TAILQ_FOREACH(dl, &dc->drivers, link) { 3726 /* 3727 * If this driver's pass is too high, then ignore it. 3728 * For most drivers in the default pass, this will 3729 * never be true. For early-pass drivers they will 3730 * only call the identify routines of eligible drivers 3731 * when this routine is called. Drivers for later 3732 * passes should have their identify routines called 3733 * on early-pass buses during BUS_NEW_PASS(). 3734 */ 3735 if (dl->pass > bus_current_pass) 3736 continue; 3737 DEVICE_IDENTIFY(dl->driver, dev); 3738 } 3739 3740 return (0); 3741 } 3742 3743 /** 3744 * @brief Helper function for implementing DEVICE_ATTACH() 3745 * 3746 * This function can be used to help implement the DEVICE_ATTACH() for 3747 * a bus. It calls device_probe_and_attach() for each of the device's 3748 * children. 3749 */ 3750 int 3751 bus_generic_attach(device_t dev) 3752 { 3753 device_t child; 3754 3755 TAILQ_FOREACH(child, &dev->children, link) { 3756 device_probe_and_attach(child); 3757 } 3758 3759 return (0); 3760 } 3761 3762 /** 3763 * @brief Helper function for delaying attaching children 3764 * 3765 * Many buses can't run transactions on the bus which children need to probe and 3766 * attach until after interrupts and/or timers are running. This function 3767 * delays their attach until interrupts and timers are enabled. 3768 */ 3769 int 3770 bus_delayed_attach_children(device_t dev) 3771 { 3772 /* Probe and attach the bus children when interrupts are available */ 3773 config_intrhook_oneshot((ich_func_t)bus_generic_attach, dev); 3774 3775 return (0); 3776 } 3777 3778 /** 3779 * @brief Helper function for implementing DEVICE_DETACH() 3780 * 3781 * This function can be used to help implement the DEVICE_DETACH() for 3782 * a bus. It calls device_detach() for each of the device's 3783 * children. 3784 */ 3785 int 3786 bus_generic_detach(device_t dev) 3787 { 3788 device_t child; 3789 int error; 3790 3791 if (dev->state != DS_ATTACHED) 3792 return (EBUSY); 3793 3794 /* 3795 * Detach children in the reverse order. 3796 * See bus_generic_suspend for details. 3797 */ 3798 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3799 if ((error = device_detach(child)) != 0) 3800 return (error); 3801 } 3802 3803 return (0); 3804 } 3805 3806 /** 3807 * @brief Helper function for implementing DEVICE_SHUTDOWN() 3808 * 3809 * This function can be used to help implement the DEVICE_SHUTDOWN() 3810 * for a bus. It calls device_shutdown() for each of the device's 3811 * children. 3812 */ 3813 int 3814 bus_generic_shutdown(device_t dev) 3815 { 3816 device_t child; 3817 3818 /* 3819 * Shut down children in the reverse order. 3820 * See bus_generic_suspend for details. 3821 */ 3822 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3823 device_shutdown(child); 3824 } 3825 3826 return (0); 3827 } 3828 3829 /** 3830 * @brief Default function for suspending a child device. 3831 * 3832 * This function is to be used by a bus's DEVICE_SUSPEND_CHILD(). 3833 */ 3834 int 3835 bus_generic_suspend_child(device_t dev, device_t child) 3836 { 3837 int error; 3838 3839 error = DEVICE_SUSPEND(child); 3840 3841 if (error == 0) 3842 child->flags |= DF_SUSPENDED; 3843 3844 return (error); 3845 } 3846 3847 /** 3848 * @brief Default function for resuming a child device. 3849 * 3850 * This function is to be used by a bus's DEVICE_RESUME_CHILD(). 3851 */ 3852 int 3853 bus_generic_resume_child(device_t dev, device_t child) 3854 { 3855 3856 DEVICE_RESUME(child); 3857 child->flags &= ~DF_SUSPENDED; 3858 3859 return (0); 3860 } 3861 3862 /** 3863 * @brief Helper function for implementing DEVICE_SUSPEND() 3864 * 3865 * This function can be used to help implement the DEVICE_SUSPEND() 3866 * for a bus. It calls DEVICE_SUSPEND() for each of the device's 3867 * children. If any call to DEVICE_SUSPEND() fails, the suspend 3868 * operation is aborted and any devices which were suspended are 3869 * resumed immediately by calling their DEVICE_RESUME() methods. 3870 */ 3871 int 3872 bus_generic_suspend(device_t dev) 3873 { 3874 int error; 3875 device_t child; 3876 3877 /* 3878 * Suspend children in the reverse order. 3879 * For most buses all children are equal, so the order does not matter. 3880 * Other buses, such as acpi, carefully order their child devices to 3881 * express implicit dependencies between them. For such buses it is 3882 * safer to bring down devices in the reverse order. 3883 */ 3884 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3885 error = BUS_SUSPEND_CHILD(dev, child); 3886 if (error != 0) { 3887 child = TAILQ_NEXT(child, link); 3888 if (child != NULL) { 3889 TAILQ_FOREACH_FROM(child, &dev->children, link) 3890 BUS_RESUME_CHILD(dev, child); 3891 } 3892 return (error); 3893 } 3894 } 3895 return (0); 3896 } 3897 3898 /** 3899 * @brief Helper function for implementing DEVICE_RESUME() 3900 * 3901 * This function can be used to help implement the DEVICE_RESUME() for 3902 * a bus. It calls DEVICE_RESUME() on each of the device's children. 3903 */ 3904 int 3905 bus_generic_resume(device_t dev) 3906 { 3907 device_t child; 3908 3909 TAILQ_FOREACH(child, &dev->children, link) { 3910 BUS_RESUME_CHILD(dev, child); 3911 /* if resume fails, there's nothing we can usefully do... */ 3912 } 3913 return (0); 3914 } 3915 3916 /** 3917 * @brief Helper function for implementing BUS_RESET_POST 3918 * 3919 * Bus can use this function to implement common operations of 3920 * re-attaching or resuming the children after the bus itself was 3921 * reset, and after restoring bus-unique state of children. 3922 * 3923 * @param dev The bus 3924 * #param flags DEVF_RESET_* 3925 */ 3926 int 3927 bus_helper_reset_post(device_t dev, int flags) 3928 { 3929 device_t child; 3930 int error, error1; 3931 3932 error = 0; 3933 TAILQ_FOREACH(child, &dev->children,link) { 3934 BUS_RESET_POST(dev, child); 3935 error1 = (flags & DEVF_RESET_DETACH) != 0 ? 3936 device_probe_and_attach(child) : 3937 BUS_RESUME_CHILD(dev, child); 3938 if (error == 0 && error1 != 0) 3939 error = error1; 3940 } 3941 return (error); 3942 } 3943 3944 static void 3945 bus_helper_reset_prepare_rollback(device_t dev, device_t child, int flags) 3946 { 3947 3948 child = TAILQ_NEXT(child, link); 3949 if (child == NULL) 3950 return; 3951 TAILQ_FOREACH_FROM(child, &dev->children,link) { 3952 BUS_RESET_POST(dev, child); 3953 if ((flags & DEVF_RESET_DETACH) != 0) 3954 device_probe_and_attach(child); 3955 else 3956 BUS_RESUME_CHILD(dev, child); 3957 } 3958 } 3959 3960 /** 3961 * @brief Helper function for implementing BUS_RESET_PREPARE 3962 * 3963 * Bus can use this function to implement common operations of 3964 * detaching or suspending the children before the bus itself is 3965 * reset, and then save bus-unique state of children that must 3966 * persists around reset. 3967 * 3968 * @param dev The bus 3969 * #param flags DEVF_RESET_* 3970 */ 3971 int 3972 bus_helper_reset_prepare(device_t dev, int flags) 3973 { 3974 device_t child; 3975 int error; 3976 3977 if (dev->state != DS_ATTACHED) 3978 return (EBUSY); 3979 3980 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) { 3981 if ((flags & DEVF_RESET_DETACH) != 0) { 3982 error = device_get_state(child) == DS_ATTACHED ? 3983 device_detach(child) : 0; 3984 } else { 3985 error = BUS_SUSPEND_CHILD(dev, child); 3986 } 3987 if (error == 0) { 3988 error = BUS_RESET_PREPARE(dev, child); 3989 if (error != 0) { 3990 if ((flags & DEVF_RESET_DETACH) != 0) 3991 device_probe_and_attach(child); 3992 else 3993 BUS_RESUME_CHILD(dev, child); 3994 } 3995 } 3996 if (error != 0) { 3997 bus_helper_reset_prepare_rollback(dev, child, flags); 3998 return (error); 3999 } 4000 } 4001 return (0); 4002 } 4003 4004 /** 4005 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4006 * 4007 * This function prints the first part of the ascii representation of 4008 * @p child, including its name, unit and description (if any - see 4009 * device_set_desc()). 4010 * 4011 * @returns the number of characters printed 4012 */ 4013 int 4014 bus_print_child_header(device_t dev, device_t child) 4015 { 4016 int retval = 0; 4017 4018 if (device_get_desc(child)) { 4019 retval += device_printf(child, "<%s>", device_get_desc(child)); 4020 } else { 4021 retval += printf("%s", device_get_nameunit(child)); 4022 } 4023 4024 return (retval); 4025 } 4026 4027 /** 4028 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4029 * 4030 * This function prints the last part of the ascii representation of 4031 * @p child, which consists of the string @c " on " followed by the 4032 * name and unit of the @p dev. 4033 * 4034 * @returns the number of characters printed 4035 */ 4036 int 4037 bus_print_child_footer(device_t dev, device_t child) 4038 { 4039 return (printf(" on %s\n", device_get_nameunit(dev))); 4040 } 4041 4042 /** 4043 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4044 * 4045 * This function prints out the VM domain for the given device. 4046 * 4047 * @returns the number of characters printed 4048 */ 4049 int 4050 bus_print_child_domain(device_t dev, device_t child) 4051 { 4052 int domain; 4053 4054 /* No domain? Don't print anything */ 4055 if (BUS_GET_DOMAIN(dev, child, &domain) != 0) 4056 return (0); 4057 4058 return (printf(" numa-domain %d", domain)); 4059 } 4060 4061 /** 4062 * @brief Helper function for implementing BUS_PRINT_CHILD(). 4063 * 4064 * This function simply calls bus_print_child_header() followed by 4065 * bus_print_child_footer(). 4066 * 4067 * @returns the number of characters printed 4068 */ 4069 int 4070 bus_generic_print_child(device_t dev, device_t child) 4071 { 4072 int retval = 0; 4073 4074 retval += bus_print_child_header(dev, child); 4075 retval += bus_print_child_domain(dev, child); 4076 retval += bus_print_child_footer(dev, child); 4077 4078 return (retval); 4079 } 4080 4081 /** 4082 * @brief Stub function for implementing BUS_READ_IVAR(). 4083 * 4084 * @returns ENOENT 4085 */ 4086 int 4087 bus_generic_read_ivar(device_t dev, device_t child, int index, 4088 uintptr_t * result) 4089 { 4090 return (ENOENT); 4091 } 4092 4093 /** 4094 * @brief Stub function for implementing BUS_WRITE_IVAR(). 4095 * 4096 * @returns ENOENT 4097 */ 4098 int 4099 bus_generic_write_ivar(device_t dev, device_t child, int index, 4100 uintptr_t value) 4101 { 4102 return (ENOENT); 4103 } 4104 4105 /** 4106 * @brief Stub function for implementing BUS_GET_RESOURCE_LIST(). 4107 * 4108 * @returns NULL 4109 */ 4110 struct resource_list * 4111 bus_generic_get_resource_list(device_t dev, device_t child) 4112 { 4113 return (NULL); 4114 } 4115 4116 /** 4117 * @brief Helper function for implementing BUS_DRIVER_ADDED(). 4118 * 4119 * This implementation of BUS_DRIVER_ADDED() simply calls the driver's 4120 * DEVICE_IDENTIFY() method to allow it to add new children to the bus 4121 * and then calls device_probe_and_attach() for each unattached child. 4122 */ 4123 void 4124 bus_generic_driver_added(device_t dev, driver_t *driver) 4125 { 4126 device_t child; 4127 4128 DEVICE_IDENTIFY(driver, dev); 4129 TAILQ_FOREACH(child, &dev->children, link) { 4130 if (child->state == DS_NOTPRESENT || 4131 (child->flags & DF_REBID)) 4132 device_probe_and_attach(child); 4133 } 4134 } 4135 4136 /** 4137 * @brief Helper function for implementing BUS_NEW_PASS(). 4138 * 4139 * This implementing of BUS_NEW_PASS() first calls the identify 4140 * routines for any drivers that probe at the current pass. Then it 4141 * walks the list of devices for this bus. If a device is already 4142 * attached, then it calls BUS_NEW_PASS() on that device. If the 4143 * device is not already attached, it attempts to attach a driver to 4144 * it. 4145 */ 4146 void 4147 bus_generic_new_pass(device_t dev) 4148 { 4149 driverlink_t dl; 4150 devclass_t dc; 4151 device_t child; 4152 4153 dc = dev->devclass; 4154 TAILQ_FOREACH(dl, &dc->drivers, link) { 4155 if (dl->pass == bus_current_pass) 4156 DEVICE_IDENTIFY(dl->driver, dev); 4157 } 4158 TAILQ_FOREACH(child, &dev->children, link) { 4159 if (child->state >= DS_ATTACHED) 4160 BUS_NEW_PASS(child); 4161 else if (child->state == DS_NOTPRESENT) 4162 device_probe_and_attach(child); 4163 } 4164 } 4165 4166 /** 4167 * @brief Helper function for implementing BUS_SETUP_INTR(). 4168 * 4169 * This simple implementation of BUS_SETUP_INTR() simply calls the 4170 * BUS_SETUP_INTR() method of the parent of @p dev. 4171 */ 4172 int 4173 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq, 4174 int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg, 4175 void **cookiep) 4176 { 4177 /* Propagate up the bus hierarchy until someone handles it. */ 4178 if (dev->parent) 4179 return (BUS_SETUP_INTR(dev->parent, child, irq, flags, 4180 filter, intr, arg, cookiep)); 4181 return (EINVAL); 4182 } 4183 4184 /** 4185 * @brief Helper function for implementing BUS_TEARDOWN_INTR(). 4186 * 4187 * This simple implementation of BUS_TEARDOWN_INTR() simply calls the 4188 * BUS_TEARDOWN_INTR() method of the parent of @p dev. 4189 */ 4190 int 4191 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq, 4192 void *cookie) 4193 { 4194 /* Propagate up the bus hierarchy until someone handles it. */ 4195 if (dev->parent) 4196 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie)); 4197 return (EINVAL); 4198 } 4199 4200 /** 4201 * @brief Helper function for implementing BUS_SUSPEND_INTR(). 4202 * 4203 * This simple implementation of BUS_SUSPEND_INTR() simply calls the 4204 * BUS_SUSPEND_INTR() method of the parent of @p dev. 4205 */ 4206 int 4207 bus_generic_suspend_intr(device_t dev, device_t child, struct resource *irq) 4208 { 4209 /* Propagate up the bus hierarchy until someone handles it. */ 4210 if (dev->parent) 4211 return (BUS_SUSPEND_INTR(dev->parent, child, irq)); 4212 return (EINVAL); 4213 } 4214 4215 /** 4216 * @brief Helper function for implementing BUS_RESUME_INTR(). 4217 * 4218 * This simple implementation of BUS_RESUME_INTR() simply calls the 4219 * BUS_RESUME_INTR() method of the parent of @p dev. 4220 */ 4221 int 4222 bus_generic_resume_intr(device_t dev, device_t child, struct resource *irq) 4223 { 4224 /* Propagate up the bus hierarchy until someone handles it. */ 4225 if (dev->parent) 4226 return (BUS_RESUME_INTR(dev->parent, child, irq)); 4227 return (EINVAL); 4228 } 4229 4230 /** 4231 * @brief Helper function for implementing BUS_ADJUST_RESOURCE(). 4232 * 4233 * This simple implementation of BUS_ADJUST_RESOURCE() simply calls the 4234 * BUS_ADJUST_RESOURCE() method of the parent of @p dev. 4235 */ 4236 int 4237 bus_generic_adjust_resource(device_t dev, device_t child, int type, 4238 struct resource *r, rman_res_t start, rman_res_t end) 4239 { 4240 /* Propagate up the bus hierarchy until someone handles it. */ 4241 if (dev->parent) 4242 return (BUS_ADJUST_RESOURCE(dev->parent, child, type, r, start, 4243 end)); 4244 return (EINVAL); 4245 } 4246 4247 /** 4248 * @brief Helper function for implementing BUS_ALLOC_RESOURCE(). 4249 * 4250 * This simple implementation of BUS_ALLOC_RESOURCE() simply calls the 4251 * BUS_ALLOC_RESOURCE() method of the parent of @p dev. 4252 */ 4253 struct resource * 4254 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid, 4255 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 4256 { 4257 /* Propagate up the bus hierarchy until someone handles it. */ 4258 if (dev->parent) 4259 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid, 4260 start, end, count, flags)); 4261 return (NULL); 4262 } 4263 4264 /** 4265 * @brief Helper function for implementing BUS_RELEASE_RESOURCE(). 4266 * 4267 * This simple implementation of BUS_RELEASE_RESOURCE() simply calls the 4268 * BUS_RELEASE_RESOURCE() method of the parent of @p dev. 4269 */ 4270 int 4271 bus_generic_release_resource(device_t dev, device_t child, int type, int rid, 4272 struct resource *r) 4273 { 4274 /* Propagate up the bus hierarchy until someone handles it. */ 4275 if (dev->parent) 4276 return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid, 4277 r)); 4278 return (EINVAL); 4279 } 4280 4281 /** 4282 * @brief Helper function for implementing BUS_ACTIVATE_RESOURCE(). 4283 * 4284 * This simple implementation of BUS_ACTIVATE_RESOURCE() simply calls the 4285 * BUS_ACTIVATE_RESOURCE() method of the parent of @p dev. 4286 */ 4287 int 4288 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid, 4289 struct resource *r) 4290 { 4291 /* Propagate up the bus hierarchy until someone handles it. */ 4292 if (dev->parent) 4293 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid, 4294 r)); 4295 return (EINVAL); 4296 } 4297 4298 /** 4299 * @brief Helper function for implementing BUS_DEACTIVATE_RESOURCE(). 4300 * 4301 * This simple implementation of BUS_DEACTIVATE_RESOURCE() simply calls the 4302 * BUS_DEACTIVATE_RESOURCE() method of the parent of @p dev. 4303 */ 4304 int 4305 bus_generic_deactivate_resource(device_t dev, device_t child, int type, 4306 int rid, struct resource *r) 4307 { 4308 /* Propagate up the bus hierarchy until someone handles it. */ 4309 if (dev->parent) 4310 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid, 4311 r)); 4312 return (EINVAL); 4313 } 4314 4315 /** 4316 * @brief Helper function for implementing BUS_MAP_RESOURCE(). 4317 * 4318 * This simple implementation of BUS_MAP_RESOURCE() simply calls the 4319 * BUS_MAP_RESOURCE() method of the parent of @p dev. 4320 */ 4321 int 4322 bus_generic_map_resource(device_t dev, device_t child, int type, 4323 struct resource *r, struct resource_map_request *args, 4324 struct resource_map *map) 4325 { 4326 /* Propagate up the bus hierarchy until someone handles it. */ 4327 if (dev->parent) 4328 return (BUS_MAP_RESOURCE(dev->parent, child, type, r, args, 4329 map)); 4330 return (EINVAL); 4331 } 4332 4333 /** 4334 * @brief Helper function for implementing BUS_UNMAP_RESOURCE(). 4335 * 4336 * This simple implementation of BUS_UNMAP_RESOURCE() simply calls the 4337 * BUS_UNMAP_RESOURCE() method of the parent of @p dev. 4338 */ 4339 int 4340 bus_generic_unmap_resource(device_t dev, device_t child, int type, 4341 struct resource *r, struct resource_map *map) 4342 { 4343 /* Propagate up the bus hierarchy until someone handles it. */ 4344 if (dev->parent) 4345 return (BUS_UNMAP_RESOURCE(dev->parent, child, type, r, map)); 4346 return (EINVAL); 4347 } 4348 4349 /** 4350 * @brief Helper function for implementing BUS_BIND_INTR(). 4351 * 4352 * This simple implementation of BUS_BIND_INTR() simply calls the 4353 * BUS_BIND_INTR() method of the parent of @p dev. 4354 */ 4355 int 4356 bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq, 4357 int cpu) 4358 { 4359 4360 /* Propagate up the bus hierarchy until someone handles it. */ 4361 if (dev->parent) 4362 return (BUS_BIND_INTR(dev->parent, child, irq, cpu)); 4363 return (EINVAL); 4364 } 4365 4366 /** 4367 * @brief Helper function for implementing BUS_CONFIG_INTR(). 4368 * 4369 * This simple implementation of BUS_CONFIG_INTR() simply calls the 4370 * BUS_CONFIG_INTR() method of the parent of @p dev. 4371 */ 4372 int 4373 bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig, 4374 enum intr_polarity pol) 4375 { 4376 4377 /* Propagate up the bus hierarchy until someone handles it. */ 4378 if (dev->parent) 4379 return (BUS_CONFIG_INTR(dev->parent, irq, trig, pol)); 4380 return (EINVAL); 4381 } 4382 4383 /** 4384 * @brief Helper function for implementing BUS_DESCRIBE_INTR(). 4385 * 4386 * This simple implementation of BUS_DESCRIBE_INTR() simply calls the 4387 * BUS_DESCRIBE_INTR() method of the parent of @p dev. 4388 */ 4389 int 4390 bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq, 4391 void *cookie, const char *descr) 4392 { 4393 4394 /* Propagate up the bus hierarchy until someone handles it. */ 4395 if (dev->parent) 4396 return (BUS_DESCRIBE_INTR(dev->parent, child, irq, cookie, 4397 descr)); 4398 return (EINVAL); 4399 } 4400 4401 /** 4402 * @brief Helper function for implementing BUS_GET_CPUS(). 4403 * 4404 * This simple implementation of BUS_GET_CPUS() simply calls the 4405 * BUS_GET_CPUS() method of the parent of @p dev. 4406 */ 4407 int 4408 bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op, 4409 size_t setsize, cpuset_t *cpuset) 4410 { 4411 4412 /* Propagate up the bus hierarchy until someone handles it. */ 4413 if (dev->parent != NULL) 4414 return (BUS_GET_CPUS(dev->parent, child, op, setsize, cpuset)); 4415 return (EINVAL); 4416 } 4417 4418 /** 4419 * @brief Helper function for implementing BUS_GET_DMA_TAG(). 4420 * 4421 * This simple implementation of BUS_GET_DMA_TAG() simply calls the 4422 * BUS_GET_DMA_TAG() method of the parent of @p dev. 4423 */ 4424 bus_dma_tag_t 4425 bus_generic_get_dma_tag(device_t dev, device_t child) 4426 { 4427 4428 /* Propagate up the bus hierarchy until someone handles it. */ 4429 if (dev->parent != NULL) 4430 return (BUS_GET_DMA_TAG(dev->parent, child)); 4431 return (NULL); 4432 } 4433 4434 /** 4435 * @brief Helper function for implementing BUS_GET_BUS_TAG(). 4436 * 4437 * This simple implementation of BUS_GET_BUS_TAG() simply calls the 4438 * BUS_GET_BUS_TAG() method of the parent of @p dev. 4439 */ 4440 bus_space_tag_t 4441 bus_generic_get_bus_tag(device_t dev, device_t child) 4442 { 4443 4444 /* Propagate up the bus hierarchy until someone handles it. */ 4445 if (dev->parent != NULL) 4446 return (BUS_GET_BUS_TAG(dev->parent, child)); 4447 return ((bus_space_tag_t)0); 4448 } 4449 4450 /** 4451 * @brief Helper function for implementing BUS_GET_RESOURCE(). 4452 * 4453 * This implementation of BUS_GET_RESOURCE() uses the 4454 * resource_list_find() function to do most of the work. It calls 4455 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4456 * search. 4457 */ 4458 int 4459 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid, 4460 rman_res_t *startp, rman_res_t *countp) 4461 { 4462 struct resource_list * rl = NULL; 4463 struct resource_list_entry * rle = NULL; 4464 4465 rl = BUS_GET_RESOURCE_LIST(dev, child); 4466 if (!rl) 4467 return (EINVAL); 4468 4469 rle = resource_list_find(rl, type, rid); 4470 if (!rle) 4471 return (ENOENT); 4472 4473 if (startp) 4474 *startp = rle->start; 4475 if (countp) 4476 *countp = rle->count; 4477 4478 return (0); 4479 } 4480 4481 /** 4482 * @brief Helper function for implementing BUS_SET_RESOURCE(). 4483 * 4484 * This implementation of BUS_SET_RESOURCE() uses the 4485 * resource_list_add() function to do most of the work. It calls 4486 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4487 * edit. 4488 */ 4489 int 4490 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid, 4491 rman_res_t start, rman_res_t count) 4492 { 4493 struct resource_list * rl = NULL; 4494 4495 rl = BUS_GET_RESOURCE_LIST(dev, child); 4496 if (!rl) 4497 return (EINVAL); 4498 4499 resource_list_add(rl, type, rid, start, (start + count - 1), count); 4500 4501 return (0); 4502 } 4503 4504 /** 4505 * @brief Helper function for implementing BUS_DELETE_RESOURCE(). 4506 * 4507 * This implementation of BUS_DELETE_RESOURCE() uses the 4508 * resource_list_delete() function to do most of the work. It calls 4509 * BUS_GET_RESOURCE_LIST() to find a suitable resource list to 4510 * edit. 4511 */ 4512 void 4513 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid) 4514 { 4515 struct resource_list * rl = NULL; 4516 4517 rl = BUS_GET_RESOURCE_LIST(dev, child); 4518 if (!rl) 4519 return; 4520 4521 resource_list_delete(rl, type, rid); 4522 4523 return; 4524 } 4525 4526 /** 4527 * @brief Helper function for implementing BUS_RELEASE_RESOURCE(). 4528 * 4529 * This implementation of BUS_RELEASE_RESOURCE() uses the 4530 * resource_list_release() function to do most of the work. It calls 4531 * BUS_GET_RESOURCE_LIST() to find a suitable resource list. 4532 */ 4533 int 4534 bus_generic_rl_release_resource(device_t dev, device_t child, int type, 4535 int rid, struct resource *r) 4536 { 4537 struct resource_list * rl = NULL; 4538 4539 if (device_get_parent(child) != dev) 4540 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, 4541 type, rid, r)); 4542 4543 rl = BUS_GET_RESOURCE_LIST(dev, child); 4544 if (!rl) 4545 return (EINVAL); 4546 4547 return (resource_list_release(rl, dev, child, type, rid, r)); 4548 } 4549 4550 /** 4551 * @brief Helper function for implementing BUS_ALLOC_RESOURCE(). 4552 * 4553 * This implementation of BUS_ALLOC_RESOURCE() uses the 4554 * resource_list_alloc() function to do most of the work. It calls 4555 * BUS_GET_RESOURCE_LIST() to find a suitable resource list. 4556 */ 4557 struct resource * 4558 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type, 4559 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 4560 { 4561 struct resource_list * rl = NULL; 4562 4563 if (device_get_parent(child) != dev) 4564 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child, 4565 type, rid, start, end, count, flags)); 4566 4567 rl = BUS_GET_RESOURCE_LIST(dev, child); 4568 if (!rl) 4569 return (NULL); 4570 4571 return (resource_list_alloc(rl, dev, child, type, rid, 4572 start, end, count, flags)); 4573 } 4574 4575 /** 4576 * @brief Helper function for implementing BUS_CHILD_PRESENT(). 4577 * 4578 * This simple implementation of BUS_CHILD_PRESENT() simply calls the 4579 * BUS_CHILD_PRESENT() method of the parent of @p dev. 4580 */ 4581 int 4582 bus_generic_child_present(device_t dev, device_t child) 4583 { 4584 return (BUS_CHILD_PRESENT(device_get_parent(dev), dev)); 4585 } 4586 4587 int 4588 bus_generic_get_domain(device_t dev, device_t child, int *domain) 4589 { 4590 4591 if (dev->parent) 4592 return (BUS_GET_DOMAIN(dev->parent, dev, domain)); 4593 4594 return (ENOENT); 4595 } 4596 4597 /** 4598 * @brief Helper function for implementing BUS_RESCAN(). 4599 * 4600 * This null implementation of BUS_RESCAN() always fails to indicate 4601 * the bus does not support rescanning. 4602 */ 4603 int 4604 bus_null_rescan(device_t dev) 4605 { 4606 4607 return (ENXIO); 4608 } 4609 4610 /* 4611 * Some convenience functions to make it easier for drivers to use the 4612 * resource-management functions. All these really do is hide the 4613 * indirection through the parent's method table, making for slightly 4614 * less-wordy code. In the future, it might make sense for this code 4615 * to maintain some sort of a list of resources allocated by each device. 4616 */ 4617 4618 int 4619 bus_alloc_resources(device_t dev, struct resource_spec *rs, 4620 struct resource **res) 4621 { 4622 int i; 4623 4624 for (i = 0; rs[i].type != -1; i++) 4625 res[i] = NULL; 4626 for (i = 0; rs[i].type != -1; i++) { 4627 res[i] = bus_alloc_resource_any(dev, 4628 rs[i].type, &rs[i].rid, rs[i].flags); 4629 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) { 4630 bus_release_resources(dev, rs, res); 4631 return (ENXIO); 4632 } 4633 } 4634 return (0); 4635 } 4636 4637 void 4638 bus_release_resources(device_t dev, const struct resource_spec *rs, 4639 struct resource **res) 4640 { 4641 int i; 4642 4643 for (i = 0; rs[i].type != -1; i++) 4644 if (res[i] != NULL) { 4645 bus_release_resource( 4646 dev, rs[i].type, rs[i].rid, res[i]); 4647 res[i] = NULL; 4648 } 4649 } 4650 4651 /** 4652 * @brief Wrapper function for BUS_ALLOC_RESOURCE(). 4653 * 4654 * This function simply calls the BUS_ALLOC_RESOURCE() method of the 4655 * parent of @p dev. 4656 */ 4657 struct resource * 4658 bus_alloc_resource(device_t dev, int type, int *rid, rman_res_t start, 4659 rman_res_t end, rman_res_t count, u_int flags) 4660 { 4661 struct resource *res; 4662 4663 if (dev->parent == NULL) 4664 return (NULL); 4665 res = BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end, 4666 count, flags); 4667 return (res); 4668 } 4669 4670 /** 4671 * @brief Wrapper function for BUS_ADJUST_RESOURCE(). 4672 * 4673 * This function simply calls the BUS_ADJUST_RESOURCE() method of the 4674 * parent of @p dev. 4675 */ 4676 int 4677 bus_adjust_resource(device_t dev, int type, struct resource *r, rman_res_t start, 4678 rman_res_t end) 4679 { 4680 if (dev->parent == NULL) 4681 return (EINVAL); 4682 return (BUS_ADJUST_RESOURCE(dev->parent, dev, type, r, start, end)); 4683 } 4684 4685 /** 4686 * @brief Wrapper function for BUS_ACTIVATE_RESOURCE(). 4687 * 4688 * This function simply calls the BUS_ACTIVATE_RESOURCE() method of the 4689 * parent of @p dev. 4690 */ 4691 int 4692 bus_activate_resource(device_t dev, int type, int rid, struct resource *r) 4693 { 4694 if (dev->parent == NULL) 4695 return (EINVAL); 4696 return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 4697 } 4698 4699 /** 4700 * @brief Wrapper function for BUS_DEACTIVATE_RESOURCE(). 4701 * 4702 * This function simply calls the BUS_DEACTIVATE_RESOURCE() method of the 4703 * parent of @p dev. 4704 */ 4705 int 4706 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r) 4707 { 4708 if (dev->parent == NULL) 4709 return (EINVAL); 4710 return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 4711 } 4712 4713 /** 4714 * @brief Wrapper function for BUS_MAP_RESOURCE(). 4715 * 4716 * This function simply calls the BUS_MAP_RESOURCE() method of the 4717 * parent of @p dev. 4718 */ 4719 int 4720 bus_map_resource(device_t dev, int type, struct resource *r, 4721 struct resource_map_request *args, struct resource_map *map) 4722 { 4723 if (dev->parent == NULL) 4724 return (EINVAL); 4725 return (BUS_MAP_RESOURCE(dev->parent, dev, type, r, args, map)); 4726 } 4727 4728 /** 4729 * @brief Wrapper function for BUS_UNMAP_RESOURCE(). 4730 * 4731 * This function simply calls the BUS_UNMAP_RESOURCE() method of the 4732 * parent of @p dev. 4733 */ 4734 int 4735 bus_unmap_resource(device_t dev, int type, struct resource *r, 4736 struct resource_map *map) 4737 { 4738 if (dev->parent == NULL) 4739 return (EINVAL); 4740 return (BUS_UNMAP_RESOURCE(dev->parent, dev, type, r, map)); 4741 } 4742 4743 /** 4744 * @brief Wrapper function for BUS_RELEASE_RESOURCE(). 4745 * 4746 * This function simply calls the BUS_RELEASE_RESOURCE() method of the 4747 * parent of @p dev. 4748 */ 4749 int 4750 bus_release_resource(device_t dev, int type, int rid, struct resource *r) 4751 { 4752 int rv; 4753 4754 if (dev->parent == NULL) 4755 return (EINVAL); 4756 rv = BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r); 4757 return (rv); 4758 } 4759 4760 /** 4761 * @brief Wrapper function for BUS_SETUP_INTR(). 4762 * 4763 * This function simply calls the BUS_SETUP_INTR() method of the 4764 * parent of @p dev. 4765 */ 4766 int 4767 bus_setup_intr(device_t dev, struct resource *r, int flags, 4768 driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep) 4769 { 4770 int error; 4771 4772 if (dev->parent == NULL) 4773 return (EINVAL); 4774 error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler, 4775 arg, cookiep); 4776 if (error != 0) 4777 return (error); 4778 if (handler != NULL && !(flags & INTR_MPSAFE)) 4779 device_printf(dev, "[GIANT-LOCKED]\n"); 4780 return (0); 4781 } 4782 4783 /** 4784 * @brief Wrapper function for BUS_TEARDOWN_INTR(). 4785 * 4786 * This function simply calls the BUS_TEARDOWN_INTR() method of the 4787 * parent of @p dev. 4788 */ 4789 int 4790 bus_teardown_intr(device_t dev, struct resource *r, void *cookie) 4791 { 4792 if (dev->parent == NULL) 4793 return (EINVAL); 4794 return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie)); 4795 } 4796 4797 /** 4798 * @brief Wrapper function for BUS_SUSPEND_INTR(). 4799 * 4800 * This function simply calls the BUS_SUSPEND_INTR() method of the 4801 * parent of @p dev. 4802 */ 4803 int 4804 bus_suspend_intr(device_t dev, struct resource *r) 4805 { 4806 if (dev->parent == NULL) 4807 return (EINVAL); 4808 return (BUS_SUSPEND_INTR(dev->parent, dev, r)); 4809 } 4810 4811 /** 4812 * @brief Wrapper function for BUS_RESUME_INTR(). 4813 * 4814 * This function simply calls the BUS_RESUME_INTR() method of the 4815 * parent of @p dev. 4816 */ 4817 int 4818 bus_resume_intr(device_t dev, struct resource *r) 4819 { 4820 if (dev->parent == NULL) 4821 return (EINVAL); 4822 return (BUS_RESUME_INTR(dev->parent, dev, r)); 4823 } 4824 4825 /** 4826 * @brief Wrapper function for BUS_BIND_INTR(). 4827 * 4828 * This function simply calls the BUS_BIND_INTR() method of the 4829 * parent of @p dev. 4830 */ 4831 int 4832 bus_bind_intr(device_t dev, struct resource *r, int cpu) 4833 { 4834 if (dev->parent == NULL) 4835 return (EINVAL); 4836 return (BUS_BIND_INTR(dev->parent, dev, r, cpu)); 4837 } 4838 4839 /** 4840 * @brief Wrapper function for BUS_DESCRIBE_INTR(). 4841 * 4842 * This function first formats the requested description into a 4843 * temporary buffer and then calls the BUS_DESCRIBE_INTR() method of 4844 * the parent of @p dev. 4845 */ 4846 int 4847 bus_describe_intr(device_t dev, struct resource *irq, void *cookie, 4848 const char *fmt, ...) 4849 { 4850 va_list ap; 4851 char descr[MAXCOMLEN + 1]; 4852 4853 if (dev->parent == NULL) 4854 return (EINVAL); 4855 va_start(ap, fmt); 4856 vsnprintf(descr, sizeof(descr), fmt, ap); 4857 va_end(ap); 4858 return (BUS_DESCRIBE_INTR(dev->parent, dev, irq, cookie, descr)); 4859 } 4860 4861 /** 4862 * @brief Wrapper function for BUS_SET_RESOURCE(). 4863 * 4864 * This function simply calls the BUS_SET_RESOURCE() method of the 4865 * parent of @p dev. 4866 */ 4867 int 4868 bus_set_resource(device_t dev, int type, int rid, 4869 rman_res_t start, rman_res_t count) 4870 { 4871 return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid, 4872 start, count)); 4873 } 4874 4875 /** 4876 * @brief Wrapper function for BUS_GET_RESOURCE(). 4877 * 4878 * This function simply calls the BUS_GET_RESOURCE() method of the 4879 * parent of @p dev. 4880 */ 4881 int 4882 bus_get_resource(device_t dev, int type, int rid, 4883 rman_res_t *startp, rman_res_t *countp) 4884 { 4885 return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4886 startp, countp)); 4887 } 4888 4889 /** 4890 * @brief Wrapper function for BUS_GET_RESOURCE(). 4891 * 4892 * This function simply calls the BUS_GET_RESOURCE() method of the 4893 * parent of @p dev and returns the start value. 4894 */ 4895 rman_res_t 4896 bus_get_resource_start(device_t dev, int type, int rid) 4897 { 4898 rman_res_t start; 4899 rman_res_t count; 4900 int error; 4901 4902 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4903 &start, &count); 4904 if (error) 4905 return (0); 4906 return (start); 4907 } 4908 4909 /** 4910 * @brief Wrapper function for BUS_GET_RESOURCE(). 4911 * 4912 * This function simply calls the BUS_GET_RESOURCE() method of the 4913 * parent of @p dev and returns the count value. 4914 */ 4915 rman_res_t 4916 bus_get_resource_count(device_t dev, int type, int rid) 4917 { 4918 rman_res_t start; 4919 rman_res_t count; 4920 int error; 4921 4922 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 4923 &start, &count); 4924 if (error) 4925 return (0); 4926 return (count); 4927 } 4928 4929 /** 4930 * @brief Wrapper function for BUS_DELETE_RESOURCE(). 4931 * 4932 * This function simply calls the BUS_DELETE_RESOURCE() method of the 4933 * parent of @p dev. 4934 */ 4935 void 4936 bus_delete_resource(device_t dev, int type, int rid) 4937 { 4938 BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid); 4939 } 4940 4941 /** 4942 * @brief Wrapper function for BUS_CHILD_PRESENT(). 4943 * 4944 * This function simply calls the BUS_CHILD_PRESENT() method of the 4945 * parent of @p dev. 4946 */ 4947 int 4948 bus_child_present(device_t child) 4949 { 4950 return (BUS_CHILD_PRESENT(device_get_parent(child), child)); 4951 } 4952 4953 /** 4954 * @brief Wrapper function for BUS_CHILD_PNPINFO_STR(). 4955 * 4956 * This function simply calls the BUS_CHILD_PNPINFO_STR() method of the 4957 * parent of @p dev. 4958 */ 4959 int 4960 bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen) 4961 { 4962 device_t parent; 4963 4964 parent = device_get_parent(child); 4965 if (parent == NULL) { 4966 *buf = '\0'; 4967 return (0); 4968 } 4969 return (BUS_CHILD_PNPINFO_STR(parent, child, buf, buflen)); 4970 } 4971 4972 /** 4973 * @brief Wrapper function for BUS_CHILD_LOCATION_STR(). 4974 * 4975 * This function simply calls the BUS_CHILD_LOCATION_STR() method of the 4976 * parent of @p dev. 4977 */ 4978 int 4979 bus_child_location_str(device_t child, char *buf, size_t buflen) 4980 { 4981 device_t parent; 4982 4983 parent = device_get_parent(child); 4984 if (parent == NULL) { 4985 *buf = '\0'; 4986 return (0); 4987 } 4988 return (BUS_CHILD_LOCATION_STR(parent, child, buf, buflen)); 4989 } 4990 4991 /** 4992 * @brief Wrapper function for BUS_GET_CPUS(). 4993 * 4994 * This function simply calls the BUS_GET_CPUS() method of the 4995 * parent of @p dev. 4996 */ 4997 int 4998 bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, cpuset_t *cpuset) 4999 { 5000 device_t parent; 5001 5002 parent = device_get_parent(dev); 5003 if (parent == NULL) 5004 return (EINVAL); 5005 return (BUS_GET_CPUS(parent, dev, op, setsize, cpuset)); 5006 } 5007 5008 /** 5009 * @brief Wrapper function for BUS_GET_DMA_TAG(). 5010 * 5011 * This function simply calls the BUS_GET_DMA_TAG() method of the 5012 * parent of @p dev. 5013 */ 5014 bus_dma_tag_t 5015 bus_get_dma_tag(device_t dev) 5016 { 5017 device_t parent; 5018 5019 parent = device_get_parent(dev); 5020 if (parent == NULL) 5021 return (NULL); 5022 return (BUS_GET_DMA_TAG(parent, dev)); 5023 } 5024 5025 /** 5026 * @brief Wrapper function for BUS_GET_BUS_TAG(). 5027 * 5028 * This function simply calls the BUS_GET_BUS_TAG() method of the 5029 * parent of @p dev. 5030 */ 5031 bus_space_tag_t 5032 bus_get_bus_tag(device_t dev) 5033 { 5034 device_t parent; 5035 5036 parent = device_get_parent(dev); 5037 if (parent == NULL) 5038 return ((bus_space_tag_t)0); 5039 return (BUS_GET_BUS_TAG(parent, dev)); 5040 } 5041 5042 /** 5043 * @brief Wrapper function for BUS_GET_DOMAIN(). 5044 * 5045 * This function simply calls the BUS_GET_DOMAIN() method of the 5046 * parent of @p dev. 5047 */ 5048 int 5049 bus_get_domain(device_t dev, int *domain) 5050 { 5051 return (BUS_GET_DOMAIN(device_get_parent(dev), dev, domain)); 5052 } 5053 5054 /* Resume all devices and then notify userland that we're up again. */ 5055 static int 5056 root_resume(device_t dev) 5057 { 5058 int error; 5059 5060 error = bus_generic_resume(dev); 5061 if (error == 0) 5062 devctl_notify("kern", "power", "resume", NULL); 5063 return (error); 5064 } 5065 5066 static int 5067 root_print_child(device_t dev, device_t child) 5068 { 5069 int retval = 0; 5070 5071 retval += bus_print_child_header(dev, child); 5072 retval += printf("\n"); 5073 5074 return (retval); 5075 } 5076 5077 static int 5078 root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags, 5079 driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep) 5080 { 5081 /* 5082 * If an interrupt mapping gets to here something bad has happened. 5083 */ 5084 panic("root_setup_intr"); 5085 } 5086 5087 /* 5088 * If we get here, assume that the device is permanent and really is 5089 * present in the system. Removable bus drivers are expected to intercept 5090 * this call long before it gets here. We return -1 so that drivers that 5091 * really care can check vs -1 or some ERRNO returned higher in the food 5092 * chain. 5093 */ 5094 static int 5095 root_child_present(device_t dev, device_t child) 5096 { 5097 return (-1); 5098 } 5099 5100 static int 5101 root_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize, 5102 cpuset_t *cpuset) 5103 { 5104 5105 switch (op) { 5106 case INTR_CPUS: 5107 /* Default to returning the set of all CPUs. */ 5108 if (setsize != sizeof(cpuset_t)) 5109 return (EINVAL); 5110 *cpuset = all_cpus; 5111 return (0); 5112 default: 5113 return (EINVAL); 5114 } 5115 } 5116 5117 static kobj_method_t root_methods[] = { 5118 /* Device interface */ 5119 KOBJMETHOD(device_shutdown, bus_generic_shutdown), 5120 KOBJMETHOD(device_suspend, bus_generic_suspend), 5121 KOBJMETHOD(device_resume, root_resume), 5122 5123 /* Bus interface */ 5124 KOBJMETHOD(bus_print_child, root_print_child), 5125 KOBJMETHOD(bus_read_ivar, bus_generic_read_ivar), 5126 KOBJMETHOD(bus_write_ivar, bus_generic_write_ivar), 5127 KOBJMETHOD(bus_setup_intr, root_setup_intr), 5128 KOBJMETHOD(bus_child_present, root_child_present), 5129 KOBJMETHOD(bus_get_cpus, root_get_cpus), 5130 5131 KOBJMETHOD_END 5132 }; 5133 5134 static driver_t root_driver = { 5135 "root", 5136 root_methods, 5137 1, /* no softc */ 5138 }; 5139 5140 device_t root_bus; 5141 devclass_t root_devclass; 5142 5143 static int 5144 root_bus_module_handler(module_t mod, int what, void* arg) 5145 { 5146 switch (what) { 5147 case MOD_LOAD: 5148 TAILQ_INIT(&bus_data_devices); 5149 kobj_class_compile((kobj_class_t) &root_driver); 5150 root_bus = make_device(NULL, "root", 0); 5151 root_bus->desc = "System root bus"; 5152 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver); 5153 root_bus->driver = &root_driver; 5154 root_bus->state = DS_ATTACHED; 5155 root_devclass = devclass_find_internal("root", NULL, FALSE); 5156 devinit(); 5157 return (0); 5158 5159 case MOD_SHUTDOWN: 5160 device_shutdown(root_bus); 5161 return (0); 5162 default: 5163 return (EOPNOTSUPP); 5164 } 5165 5166 return (0); 5167 } 5168 5169 static moduledata_t root_bus_mod = { 5170 "rootbus", 5171 root_bus_module_handler, 5172 NULL 5173 }; 5174 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 5175 5176 /** 5177 * @brief Automatically configure devices 5178 * 5179 * This function begins the autoconfiguration process by calling 5180 * device_probe_and_attach() for each child of the @c root0 device. 5181 */ 5182 void 5183 root_bus_configure(void) 5184 { 5185 5186 PDEBUG((".")); 5187 5188 /* Eventually this will be split up, but this is sufficient for now. */ 5189 bus_set_pass(BUS_PASS_DEFAULT); 5190 } 5191 5192 /** 5193 * @brief Module handler for registering device drivers 5194 * 5195 * This module handler is used to automatically register device 5196 * drivers when modules are loaded. If @p what is MOD_LOAD, it calls 5197 * devclass_add_driver() for the driver described by the 5198 * driver_module_data structure pointed to by @p arg 5199 */ 5200 int 5201 driver_module_handler(module_t mod, int what, void *arg) 5202 { 5203 struct driver_module_data *dmd; 5204 devclass_t bus_devclass; 5205 kobj_class_t driver; 5206 int error, pass; 5207 5208 dmd = (struct driver_module_data *)arg; 5209 bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE); 5210 error = 0; 5211 5212 switch (what) { 5213 case MOD_LOAD: 5214 if (dmd->dmd_chainevh) 5215 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5216 5217 pass = dmd->dmd_pass; 5218 driver = dmd->dmd_driver; 5219 PDEBUG(("Loading module: driver %s on bus %s (pass %d)", 5220 DRIVERNAME(driver), dmd->dmd_busname, pass)); 5221 error = devclass_add_driver(bus_devclass, driver, pass, 5222 dmd->dmd_devclass); 5223 break; 5224 5225 case MOD_UNLOAD: 5226 PDEBUG(("Unloading module: driver %s from bus %s", 5227 DRIVERNAME(dmd->dmd_driver), 5228 dmd->dmd_busname)); 5229 error = devclass_delete_driver(bus_devclass, 5230 dmd->dmd_driver); 5231 5232 if (!error && dmd->dmd_chainevh) 5233 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5234 break; 5235 case MOD_QUIESCE: 5236 PDEBUG(("Quiesce module: driver %s from bus %s", 5237 DRIVERNAME(dmd->dmd_driver), 5238 dmd->dmd_busname)); 5239 error = devclass_quiesce_driver(bus_devclass, 5240 dmd->dmd_driver); 5241 5242 if (!error && dmd->dmd_chainevh) 5243 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 5244 break; 5245 default: 5246 error = EOPNOTSUPP; 5247 break; 5248 } 5249 5250 return (error); 5251 } 5252 5253 /** 5254 * @brief Enumerate all hinted devices for this bus. 5255 * 5256 * Walks through the hints for this bus and calls the bus_hinted_child 5257 * routine for each one it fines. It searches first for the specific 5258 * bus that's being probed for hinted children (eg isa0), and then for 5259 * generic children (eg isa). 5260 * 5261 * @param dev bus device to enumerate 5262 */ 5263 void 5264 bus_enumerate_hinted_children(device_t bus) 5265 { 5266 int i; 5267 const char *dname, *busname; 5268 int dunit; 5269 5270 /* 5271 * enumerate all devices on the specific bus 5272 */ 5273 busname = device_get_nameunit(bus); 5274 i = 0; 5275 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0) 5276 BUS_HINTED_CHILD(bus, dname, dunit); 5277 5278 /* 5279 * and all the generic ones. 5280 */ 5281 busname = device_get_name(bus); 5282 i = 0; 5283 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0) 5284 BUS_HINTED_CHILD(bus, dname, dunit); 5285 } 5286 5287 #ifdef BUS_DEBUG 5288 5289 /* the _short versions avoid iteration by not calling anything that prints 5290 * more than oneliners. I love oneliners. 5291 */ 5292 5293 static void 5294 print_device_short(device_t dev, int indent) 5295 { 5296 if (!dev) 5297 return; 5298 5299 indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s%s%s,%sivars,%ssoftc,busy=%d\n", 5300 dev->unit, dev->desc, 5301 (dev->parent? "":"no "), 5302 (TAILQ_EMPTY(&dev->children)? "no ":""), 5303 (dev->flags&DF_ENABLED? "enabled,":"disabled,"), 5304 (dev->flags&DF_FIXEDCLASS? "fixed,":""), 5305 (dev->flags&DF_WILDCARD? "wildcard,":""), 5306 (dev->flags&DF_DESCMALLOCED? "descmalloced,":""), 5307 (dev->flags&DF_REBID? "rebiddable,":""), 5308 (dev->flags&DF_SUSPENDED? "suspended,":""), 5309 (dev->ivars? "":"no "), 5310 (dev->softc? "":"no "), 5311 dev->busy)); 5312 } 5313 5314 static void 5315 print_device(device_t dev, int indent) 5316 { 5317 if (!dev) 5318 return; 5319 5320 print_device_short(dev, indent); 5321 5322 indentprintf(("Parent:\n")); 5323 print_device_short(dev->parent, indent+1); 5324 indentprintf(("Driver:\n")); 5325 print_driver_short(dev->driver, indent+1); 5326 indentprintf(("Devclass:\n")); 5327 print_devclass_short(dev->devclass, indent+1); 5328 } 5329 5330 void 5331 print_device_tree_short(device_t dev, int indent) 5332 /* print the device and all its children (indented) */ 5333 { 5334 device_t child; 5335 5336 if (!dev) 5337 return; 5338 5339 print_device_short(dev, indent); 5340 5341 TAILQ_FOREACH(child, &dev->children, link) { 5342 print_device_tree_short(child, indent+1); 5343 } 5344 } 5345 5346 void 5347 print_device_tree(device_t dev, int indent) 5348 /* print the device and all its children (indented) */ 5349 { 5350 device_t child; 5351 5352 if (!dev) 5353 return; 5354 5355 print_device(dev, indent); 5356 5357 TAILQ_FOREACH(child, &dev->children, link) { 5358 print_device_tree(child, indent+1); 5359 } 5360 } 5361 5362 static void 5363 print_driver_short(driver_t *driver, int indent) 5364 { 5365 if (!driver) 5366 return; 5367 5368 indentprintf(("driver %s: softc size = %zd\n", 5369 driver->name, driver->size)); 5370 } 5371 5372 static void 5373 print_driver(driver_t *driver, int indent) 5374 { 5375 if (!driver) 5376 return; 5377 5378 print_driver_short(driver, indent); 5379 } 5380 5381 static void 5382 print_driver_list(driver_list_t drivers, int indent) 5383 { 5384 driverlink_t driver; 5385 5386 TAILQ_FOREACH(driver, &drivers, link) { 5387 print_driver(driver->driver, indent); 5388 } 5389 } 5390 5391 static void 5392 print_devclass_short(devclass_t dc, int indent) 5393 { 5394 if ( !dc ) 5395 return; 5396 5397 indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit)); 5398 } 5399 5400 static void 5401 print_devclass(devclass_t dc, int indent) 5402 { 5403 int i; 5404 5405 if ( !dc ) 5406 return; 5407 5408 print_devclass_short(dc, indent); 5409 indentprintf(("Drivers:\n")); 5410 print_driver_list(dc->drivers, indent+1); 5411 5412 indentprintf(("Devices:\n")); 5413 for (i = 0; i < dc->maxunit; i++) 5414 if (dc->devices[i]) 5415 print_device(dc->devices[i], indent+1); 5416 } 5417 5418 void 5419 print_devclass_list_short(void) 5420 { 5421 devclass_t dc; 5422 5423 printf("Short listing of devclasses, drivers & devices:\n"); 5424 TAILQ_FOREACH(dc, &devclasses, link) { 5425 print_devclass_short(dc, 0); 5426 } 5427 } 5428 5429 void 5430 print_devclass_list(void) 5431 { 5432 devclass_t dc; 5433 5434 printf("Full listing of devclasses, drivers & devices:\n"); 5435 TAILQ_FOREACH(dc, &devclasses, link) { 5436 print_devclass(dc, 0); 5437 } 5438 } 5439 5440 #endif 5441 5442 /* 5443 * User-space access to the device tree. 5444 * 5445 * We implement a small set of nodes: 5446 * 5447 * hw.bus Single integer read method to obtain the 5448 * current generation count. 5449 * hw.bus.devices Reads the entire device tree in flat space. 5450 * hw.bus.rman Resource manager interface 5451 * 5452 * We might like to add the ability to scan devclasses and/or drivers to 5453 * determine what else is currently loaded/available. 5454 */ 5455 5456 static int 5457 sysctl_bus_info(SYSCTL_HANDLER_ARGS) 5458 { 5459 struct u_businfo ubus; 5460 5461 ubus.ub_version = BUS_USER_VERSION; 5462 ubus.ub_generation = bus_data_generation; 5463 5464 return (SYSCTL_OUT(req, &ubus, sizeof(ubus))); 5465 } 5466 SYSCTL_PROC(_hw_bus, OID_AUTO, info, CTLTYPE_STRUCT | CTLFLAG_RD | 5467 CTLFLAG_MPSAFE, NULL, 0, sysctl_bus_info, "S,u_businfo", 5468 "bus-related data"); 5469 5470 static int 5471 sysctl_devices(SYSCTL_HANDLER_ARGS) 5472 { 5473 int *name = (int *)arg1; 5474 u_int namelen = arg2; 5475 int index; 5476 device_t dev; 5477 struct u_device *udev; 5478 int error; 5479 char *walker, *ep; 5480 5481 if (namelen != 2) 5482 return (EINVAL); 5483 5484 if (bus_data_generation_check(name[0])) 5485 return (EINVAL); 5486 5487 index = name[1]; 5488 5489 /* 5490 * Scan the list of devices, looking for the requested index. 5491 */ 5492 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 5493 if (index-- == 0) 5494 break; 5495 } 5496 if (dev == NULL) 5497 return (ENOENT); 5498 5499 /* 5500 * Populate the return item, careful not to overflow the buffer. 5501 */ 5502 udev = malloc(sizeof(*udev), M_BUS, M_WAITOK | M_ZERO); 5503 if (udev == NULL) 5504 return (ENOMEM); 5505 udev->dv_handle = (uintptr_t)dev; 5506 udev->dv_parent = (uintptr_t)dev->parent; 5507 udev->dv_devflags = dev->devflags; 5508 udev->dv_flags = dev->flags; 5509 udev->dv_state = dev->state; 5510 walker = udev->dv_fields; 5511 ep = walker + sizeof(udev->dv_fields); 5512 #define CP(src) \ 5513 if ((src) == NULL) \ 5514 *walker++ = '\0'; \ 5515 else { \ 5516 strlcpy(walker, (src), ep - walker); \ 5517 walker += strlen(walker) + 1; \ 5518 } \ 5519 if (walker >= ep) \ 5520 break; 5521 5522 do { 5523 CP(dev->nameunit); 5524 CP(dev->desc); 5525 CP(dev->driver != NULL ? dev->driver->name : NULL); 5526 bus_child_pnpinfo_str(dev, walker, ep - walker); 5527 walker += strlen(walker) + 1; 5528 if (walker >= ep) 5529 break; 5530 bus_child_location_str(dev, walker, ep - walker); 5531 walker += strlen(walker) + 1; 5532 if (walker >= ep) 5533 break; 5534 *walker++ = '\0'; 5535 } while (0); 5536 #undef CP 5537 error = SYSCTL_OUT(req, udev, sizeof(*udev)); 5538 free(udev, M_BUS); 5539 return (error); 5540 } 5541 5542 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, 5543 CTLFLAG_RD | CTLFLAG_NEEDGIANT, sysctl_devices, 5544 "system device tree"); 5545 5546 int 5547 bus_data_generation_check(int generation) 5548 { 5549 if (generation != bus_data_generation) 5550 return (1); 5551 5552 /* XXX generate optimised lists here? */ 5553 return (0); 5554 } 5555 5556 void 5557 bus_data_generation_update(void) 5558 { 5559 5560 atomic_add_int(&bus_data_generation, 1); 5561 } 5562 5563 int 5564 bus_free_resource(device_t dev, int type, struct resource *r) 5565 { 5566 if (r == NULL) 5567 return (0); 5568 return (bus_release_resource(dev, type, rman_get_rid(r), r)); 5569 } 5570 5571 device_t 5572 device_lookup_by_name(const char *name) 5573 { 5574 device_t dev; 5575 5576 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 5577 if (dev->nameunit != NULL && strcmp(dev->nameunit, name) == 0) 5578 return (dev); 5579 } 5580 return (NULL); 5581 } 5582 5583 /* 5584 * /dev/devctl2 implementation. The existing /dev/devctl device has 5585 * implicit semantics on open, so it could not be reused for this. 5586 * Another option would be to call this /dev/bus? 5587 */ 5588 static int 5589 find_device(struct devreq *req, device_t *devp) 5590 { 5591 device_t dev; 5592 5593 /* 5594 * First, ensure that the name is nul terminated. 5595 */ 5596 if (memchr(req->dr_name, '\0', sizeof(req->dr_name)) == NULL) 5597 return (EINVAL); 5598 5599 /* 5600 * Second, try to find an attached device whose name matches 5601 * 'name'. 5602 */ 5603 dev = device_lookup_by_name(req->dr_name); 5604 if (dev != NULL) { 5605 *devp = dev; 5606 return (0); 5607 } 5608 5609 /* Finally, give device enumerators a chance. */ 5610 dev = NULL; 5611 EVENTHANDLER_DIRECT_INVOKE(dev_lookup, req->dr_name, &dev); 5612 if (dev == NULL) 5613 return (ENOENT); 5614 *devp = dev; 5615 return (0); 5616 } 5617 5618 static bool 5619 driver_exists(device_t bus, const char *driver) 5620 { 5621 devclass_t dc; 5622 5623 for (dc = bus->devclass; dc != NULL; dc = dc->parent) { 5624 if (devclass_find_driver_internal(dc, driver) != NULL) 5625 return (true); 5626 } 5627 return (false); 5628 } 5629 5630 static void 5631 device_gen_nomatch(device_t dev) 5632 { 5633 device_t child; 5634 5635 if (dev->flags & DF_NEEDNOMATCH && 5636 dev->state == DS_NOTPRESENT) { 5637 BUS_PROBE_NOMATCH(dev->parent, dev); 5638 devnomatch(dev); 5639 dev->flags |= DF_DONENOMATCH; 5640 } 5641 dev->flags &= ~DF_NEEDNOMATCH; 5642 TAILQ_FOREACH(child, &dev->children, link) { 5643 device_gen_nomatch(child); 5644 } 5645 } 5646 5647 static void 5648 device_do_deferred_actions(void) 5649 { 5650 devclass_t dc; 5651 driverlink_t dl; 5652 5653 /* 5654 * Walk through the devclasses to find all the drivers we've tagged as 5655 * deferred during the freeze and call the driver added routines. They 5656 * have already been added to the lists in the background, so the driver 5657 * added routines that trigger a probe will have all the right bidders 5658 * for the probe auction. 5659 */ 5660 TAILQ_FOREACH(dc, &devclasses, link) { 5661 TAILQ_FOREACH(dl, &dc->drivers, link) { 5662 if (dl->flags & DL_DEFERRED_PROBE) { 5663 devclass_driver_added(dc, dl->driver); 5664 dl->flags &= ~DL_DEFERRED_PROBE; 5665 } 5666 } 5667 } 5668 5669 /* 5670 * We also defer no-match events during a freeze. Walk the tree and 5671 * generate all the pent-up events that are still relevant. 5672 */ 5673 device_gen_nomatch(root_bus); 5674 bus_data_generation_update(); 5675 } 5676 5677 static int 5678 devctl2_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag, 5679 struct thread *td) 5680 { 5681 struct devreq *req; 5682 device_t dev; 5683 int error, old; 5684 5685 /* Locate the device to control. */ 5686 mtx_lock(&Giant); 5687 req = (struct devreq *)data; 5688 switch (cmd) { 5689 case DEV_ATTACH: 5690 case DEV_DETACH: 5691 case DEV_ENABLE: 5692 case DEV_DISABLE: 5693 case DEV_SUSPEND: 5694 case DEV_RESUME: 5695 case DEV_SET_DRIVER: 5696 case DEV_CLEAR_DRIVER: 5697 case DEV_RESCAN: 5698 case DEV_DELETE: 5699 case DEV_RESET: 5700 error = priv_check(td, PRIV_DRIVER); 5701 if (error == 0) 5702 error = find_device(req, &dev); 5703 break; 5704 case DEV_FREEZE: 5705 case DEV_THAW: 5706 error = priv_check(td, PRIV_DRIVER); 5707 break; 5708 default: 5709 error = ENOTTY; 5710 break; 5711 } 5712 if (error) { 5713 mtx_unlock(&Giant); 5714 return (error); 5715 } 5716 5717 /* Perform the requested operation. */ 5718 switch (cmd) { 5719 case DEV_ATTACH: 5720 if (device_is_attached(dev) && (dev->flags & DF_REBID) == 0) 5721 error = EBUSY; 5722 else if (!device_is_enabled(dev)) 5723 error = ENXIO; 5724 else 5725 error = device_probe_and_attach(dev); 5726 break; 5727 case DEV_DETACH: 5728 if (!device_is_attached(dev)) { 5729 error = ENXIO; 5730 break; 5731 } 5732 if (!(req->dr_flags & DEVF_FORCE_DETACH)) { 5733 error = device_quiesce(dev); 5734 if (error) 5735 break; 5736 } 5737 error = device_detach(dev); 5738 break; 5739 case DEV_ENABLE: 5740 if (device_is_enabled(dev)) { 5741 error = EBUSY; 5742 break; 5743 } 5744 5745 /* 5746 * If the device has been probed but not attached (e.g. 5747 * when it has been disabled by a loader hint), just 5748 * attach the device rather than doing a full probe. 5749 */ 5750 device_enable(dev); 5751 if (device_is_alive(dev)) { 5752 /* 5753 * If the device was disabled via a hint, clear 5754 * the hint. 5755 */ 5756 if (resource_disabled(dev->driver->name, dev->unit)) 5757 resource_unset_value(dev->driver->name, 5758 dev->unit, "disabled"); 5759 error = device_attach(dev); 5760 } else 5761 error = device_probe_and_attach(dev); 5762 break; 5763 case DEV_DISABLE: 5764 if (!device_is_enabled(dev)) { 5765 error = ENXIO; 5766 break; 5767 } 5768 5769 if (!(req->dr_flags & DEVF_FORCE_DETACH)) { 5770 error = device_quiesce(dev); 5771 if (error) 5772 break; 5773 } 5774 5775 /* 5776 * Force DF_FIXEDCLASS on around detach to preserve 5777 * the existing name. 5778 */ 5779 old = dev->flags; 5780 dev->flags |= DF_FIXEDCLASS; 5781 error = device_detach(dev); 5782 if (!(old & DF_FIXEDCLASS)) 5783 dev->flags &= ~DF_FIXEDCLASS; 5784 if (error == 0) 5785 device_disable(dev); 5786 break; 5787 case DEV_SUSPEND: 5788 if (device_is_suspended(dev)) { 5789 error = EBUSY; 5790 break; 5791 } 5792 if (device_get_parent(dev) == NULL) { 5793 error = EINVAL; 5794 break; 5795 } 5796 error = BUS_SUSPEND_CHILD(device_get_parent(dev), dev); 5797 break; 5798 case DEV_RESUME: 5799 if (!device_is_suspended(dev)) { 5800 error = EINVAL; 5801 break; 5802 } 5803 if (device_get_parent(dev) == NULL) { 5804 error = EINVAL; 5805 break; 5806 } 5807 error = BUS_RESUME_CHILD(device_get_parent(dev), dev); 5808 break; 5809 case DEV_SET_DRIVER: { 5810 devclass_t dc; 5811 char driver[128]; 5812 5813 error = copyinstr(req->dr_data, driver, sizeof(driver), NULL); 5814 if (error) 5815 break; 5816 if (driver[0] == '\0') { 5817 error = EINVAL; 5818 break; 5819 } 5820 if (dev->devclass != NULL && 5821 strcmp(driver, dev->devclass->name) == 0) 5822 /* XXX: Could possibly force DF_FIXEDCLASS on? */ 5823 break; 5824 5825 /* 5826 * Scan drivers for this device's bus looking for at 5827 * least one matching driver. 5828 */ 5829 if (dev->parent == NULL) { 5830 error = EINVAL; 5831 break; 5832 } 5833 if (!driver_exists(dev->parent, driver)) { 5834 error = ENOENT; 5835 break; 5836 } 5837 dc = devclass_create(driver); 5838 if (dc == NULL) { 5839 error = ENOMEM; 5840 break; 5841 } 5842 5843 /* Detach device if necessary. */ 5844 if (device_is_attached(dev)) { 5845 if (req->dr_flags & DEVF_SET_DRIVER_DETACH) 5846 error = device_detach(dev); 5847 else 5848 error = EBUSY; 5849 if (error) 5850 break; 5851 } 5852 5853 /* Clear any previously-fixed device class and unit. */ 5854 if (dev->flags & DF_FIXEDCLASS) 5855 devclass_delete_device(dev->devclass, dev); 5856 dev->flags |= DF_WILDCARD; 5857 dev->unit = -1; 5858 5859 /* Force the new device class. */ 5860 error = devclass_add_device(dc, dev); 5861 if (error) 5862 break; 5863 dev->flags |= DF_FIXEDCLASS; 5864 error = device_probe_and_attach(dev); 5865 break; 5866 } 5867 case DEV_CLEAR_DRIVER: 5868 if (!(dev->flags & DF_FIXEDCLASS)) { 5869 error = 0; 5870 break; 5871 } 5872 if (device_is_attached(dev)) { 5873 if (req->dr_flags & DEVF_CLEAR_DRIVER_DETACH) 5874 error = device_detach(dev); 5875 else 5876 error = EBUSY; 5877 if (error) 5878 break; 5879 } 5880 5881 dev->flags &= ~DF_FIXEDCLASS; 5882 dev->flags |= DF_WILDCARD; 5883 devclass_delete_device(dev->devclass, dev); 5884 error = device_probe_and_attach(dev); 5885 break; 5886 case DEV_RESCAN: 5887 if (!device_is_attached(dev)) { 5888 error = ENXIO; 5889 break; 5890 } 5891 error = BUS_RESCAN(dev); 5892 break; 5893 case DEV_DELETE: { 5894 device_t parent; 5895 5896 parent = device_get_parent(dev); 5897 if (parent == NULL) { 5898 error = EINVAL; 5899 break; 5900 } 5901 if (!(req->dr_flags & DEVF_FORCE_DELETE)) { 5902 if (bus_child_present(dev) != 0) { 5903 error = EBUSY; 5904 break; 5905 } 5906 } 5907 5908 error = device_delete_child(parent, dev); 5909 break; 5910 } 5911 case DEV_FREEZE: 5912 if (device_frozen) 5913 error = EBUSY; 5914 else 5915 device_frozen = true; 5916 break; 5917 case DEV_THAW: 5918 if (!device_frozen) 5919 error = EBUSY; 5920 else { 5921 device_do_deferred_actions(); 5922 device_frozen = false; 5923 } 5924 break; 5925 case DEV_RESET: 5926 if ((req->dr_flags & ~(DEVF_RESET_DETACH)) != 0) { 5927 error = EINVAL; 5928 break; 5929 } 5930 error = BUS_RESET_CHILD(device_get_parent(dev), dev, 5931 req->dr_flags); 5932 break; 5933 } 5934 mtx_unlock(&Giant); 5935 return (error); 5936 } 5937 5938 static struct cdevsw devctl2_cdevsw = { 5939 .d_version = D_VERSION, 5940 .d_ioctl = devctl2_ioctl, 5941 .d_name = "devctl2", 5942 }; 5943 5944 static void 5945 devctl2_init(void) 5946 { 5947 5948 make_dev_credf(MAKEDEV_ETERNAL, &devctl2_cdevsw, 0, NULL, 5949 UID_ROOT, GID_WHEEL, 0600, "devctl2"); 5950 } 5951 5952 /* 5953 * APIs to manage deprecation and obsolescence. 5954 */ 5955 static int obsolete_panic = 0; 5956 SYSCTL_INT(_debug, OID_AUTO, obsolete_panic, CTLFLAG_RWTUN, &obsolete_panic, 0, 5957 "Panic when obsolete features are used (0 = never, 1 = if osbolete, " 5958 "2 = if deprecated)"); 5959 5960 static void 5961 gone_panic(int major, int running, const char *msg) 5962 { 5963 5964 switch (obsolete_panic) 5965 { 5966 case 0: 5967 return; 5968 case 1: 5969 if (running < major) 5970 return; 5971 /* FALLTHROUGH */ 5972 default: 5973 panic("%s", msg); 5974 } 5975 } 5976 5977 void 5978 _gone_in(int major, const char *msg) 5979 { 5980 5981 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg); 5982 if (P_OSREL_MAJOR(__FreeBSD_version) >= major) 5983 printf("Obsolete code will be removed soon: %s\n", msg); 5984 else 5985 printf("Deprecated code (to be removed in FreeBSD %d): %s\n", 5986 major, msg); 5987 } 5988 5989 void 5990 _gone_in_dev(device_t dev, int major, const char *msg) 5991 { 5992 5993 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg); 5994 if (P_OSREL_MAJOR(__FreeBSD_version) >= major) 5995 device_printf(dev, 5996 "Obsolete code will be removed soon: %s\n", msg); 5997 else 5998 device_printf(dev, 5999 "Deprecated code (to be removed in FreeBSD %d): %s\n", 6000 major, msg); 6001 } 6002 6003 #ifdef DDB 6004 DB_SHOW_COMMAND(device, db_show_device) 6005 { 6006 device_t dev; 6007 6008 if (!have_addr) 6009 return; 6010 6011 dev = (device_t)addr; 6012 6013 db_printf("name: %s\n", device_get_nameunit(dev)); 6014 db_printf(" driver: %s\n", DRIVERNAME(dev->driver)); 6015 db_printf(" class: %s\n", DEVCLANAME(dev->devclass)); 6016 db_printf(" addr: %p\n", dev); 6017 db_printf(" parent: %p\n", dev->parent); 6018 db_printf(" softc: %p\n", dev->softc); 6019 db_printf(" ivars: %p\n", dev->ivars); 6020 } 6021 6022 DB_SHOW_ALL_COMMAND(devices, db_show_all_devices) 6023 { 6024 device_t dev; 6025 6026 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 6027 db_show_device((db_expr_t)dev, true, count, modif); 6028 } 6029 } 6030 #endif 6031