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