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