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