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