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