1 /* 2 * Copyright (c) 1997,1998 Doug Rabson 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD: src/sys/kern/subr_bus.c,v 1.54.2.9 2002/10/10 15:13:32 jhb Exp $ 27 */ 28 29 #include "opt_bus.h" 30 31 #include <sys/param.h> 32 #include <sys/queue.h> 33 #include <sys/malloc.h> 34 #include <sys/kernel.h> 35 #include <sys/module.h> 36 #include <sys/kobj.h> 37 #include <sys/bus_private.h> 38 #include <sys/sysctl.h> 39 #include <sys/systm.h> 40 #include <sys/bus.h> 41 #include <sys/rman.h> 42 #include <sys/device.h> 43 #include <sys/lock.h> 44 #include <sys/conf.h> 45 #include <sys/uio.h> 46 #include <sys/filio.h> 47 #include <sys/event.h> 48 #include <sys/signalvar.h> 49 #include <sys/machintr.h> 50 51 #include <machine/stdarg.h> /* for device_printf() */ 52 53 #include <sys/thread2.h> 54 #include <sys/mplock2.h> 55 56 SYSCTL_NODE(_hw, OID_AUTO, bus, CTLFLAG_RW, NULL, NULL); 57 SYSCTL_NODE(, OID_AUTO, dev, CTLFLAG_RW, NULL, NULL); 58 59 MALLOC_DEFINE(M_BUS, "bus", "Bus data structures"); 60 61 #ifdef BUS_DEBUG 62 #define PDEBUG(a) (kprintf("%s:%d: ", __func__, __LINE__), kprintf a, kprintf("\n")) 63 #define DEVICENAME(d) ((d)? device_get_name(d): "no device") 64 #define DRIVERNAME(d) ((d)? d->name : "no driver") 65 #define DEVCLANAME(d) ((d)? d->name : "no devclass") 66 67 /* Produce the indenting, indent*2 spaces plus a '.' ahead of that to 68 * prevent syslog from deleting initial spaces 69 */ 70 #define indentprintf(p) do { int iJ; kprintf("."); for (iJ=0; iJ<indent; iJ++) kprintf(" "); kprintf p ; } while(0) 71 72 static void print_device_short(device_t dev, int indent); 73 static void print_device(device_t dev, int indent); 74 void print_device_tree_short(device_t dev, int indent); 75 void print_device_tree(device_t dev, int indent); 76 static void print_driver_short(driver_t *driver, int indent); 77 static void print_driver(driver_t *driver, int indent); 78 static void print_driver_list(driver_list_t drivers, int indent); 79 static void print_devclass_short(devclass_t dc, int indent); 80 static void print_devclass(devclass_t dc, int indent); 81 void print_devclass_list_short(void); 82 void print_devclass_list(void); 83 84 #else 85 /* Make the compiler ignore the function calls */ 86 #define PDEBUG(a) /* nop */ 87 #define DEVICENAME(d) /* nop */ 88 #define DRIVERNAME(d) /* nop */ 89 #define DEVCLANAME(d) /* nop */ 90 91 #define print_device_short(d,i) /* nop */ 92 #define print_device(d,i) /* nop */ 93 #define print_device_tree_short(d,i) /* nop */ 94 #define print_device_tree(d,i) /* nop */ 95 #define print_driver_short(d,i) /* nop */ 96 #define print_driver(d,i) /* nop */ 97 #define print_driver_list(d,i) /* nop */ 98 #define print_devclass_short(d,i) /* nop */ 99 #define print_devclass(d,i) /* nop */ 100 #define print_devclass_list_short() /* nop */ 101 #define print_devclass_list() /* nop */ 102 #endif 103 104 /* 105 * dev sysctl tree 106 */ 107 108 enum { 109 DEVCLASS_SYSCTL_PARENT, 110 }; 111 112 static int 113 devclass_sysctl_handler(SYSCTL_HANDLER_ARGS) 114 { 115 devclass_t dc = (devclass_t)arg1; 116 const char *value; 117 118 switch (arg2) { 119 case DEVCLASS_SYSCTL_PARENT: 120 value = dc->parent ? dc->parent->name : ""; 121 break; 122 default: 123 return (EINVAL); 124 } 125 return (SYSCTL_OUT(req, value, strlen(value))); 126 } 127 128 static void 129 devclass_sysctl_init(devclass_t dc) 130 { 131 132 if (dc->sysctl_tree != NULL) 133 return; 134 sysctl_ctx_init(&dc->sysctl_ctx); 135 dc->sysctl_tree = SYSCTL_ADD_NODE(&dc->sysctl_ctx, 136 SYSCTL_STATIC_CHILDREN(_dev), OID_AUTO, dc->name, 137 CTLFLAG_RD, NULL, ""); 138 SYSCTL_ADD_PROC(&dc->sysctl_ctx, SYSCTL_CHILDREN(dc->sysctl_tree), 139 OID_AUTO, "%parent", CTLTYPE_STRING | CTLFLAG_RD, 140 dc, DEVCLASS_SYSCTL_PARENT, devclass_sysctl_handler, "A", 141 "parent class"); 142 } 143 144 enum { 145 DEVICE_SYSCTL_DESC, 146 DEVICE_SYSCTL_DRIVER, 147 DEVICE_SYSCTL_LOCATION, 148 DEVICE_SYSCTL_PNPINFO, 149 DEVICE_SYSCTL_PARENT, 150 }; 151 152 static int 153 device_sysctl_handler(SYSCTL_HANDLER_ARGS) 154 { 155 device_t dev = (device_t)arg1; 156 const char *value; 157 char *buf; 158 int error; 159 160 buf = NULL; 161 switch (arg2) { 162 case DEVICE_SYSCTL_DESC: 163 value = dev->desc ? dev->desc : ""; 164 break; 165 case DEVICE_SYSCTL_DRIVER: 166 value = dev->driver ? dev->driver->name : ""; 167 break; 168 case DEVICE_SYSCTL_LOCATION: 169 value = buf = kmalloc(1024, M_BUS, M_WAITOK | M_ZERO); 170 bus_child_location_str(dev, buf, 1024); 171 break; 172 case DEVICE_SYSCTL_PNPINFO: 173 value = buf = kmalloc(1024, M_BUS, M_WAITOK | M_ZERO); 174 bus_child_pnpinfo_str(dev, buf, 1024); 175 break; 176 case DEVICE_SYSCTL_PARENT: 177 value = dev->parent ? dev->parent->nameunit : ""; 178 break; 179 default: 180 return (EINVAL); 181 } 182 error = SYSCTL_OUT(req, value, strlen(value)); 183 if (buf != NULL) 184 kfree(buf, M_BUS); 185 return (error); 186 } 187 188 static void 189 device_sysctl_init(device_t dev) 190 { 191 devclass_t dc = dev->devclass; 192 193 if (dev->sysctl_tree != NULL) 194 return; 195 devclass_sysctl_init(dc); 196 sysctl_ctx_init(&dev->sysctl_ctx); 197 dev->sysctl_tree = SYSCTL_ADD_NODE(&dev->sysctl_ctx, 198 SYSCTL_CHILDREN(dc->sysctl_tree), OID_AUTO, 199 dev->nameunit + strlen(dc->name), 200 CTLFLAG_RD, NULL, ""); 201 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 202 OID_AUTO, "%desc", CTLTYPE_STRING | CTLFLAG_RD, 203 dev, DEVICE_SYSCTL_DESC, device_sysctl_handler, "A", 204 "device description"); 205 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 206 OID_AUTO, "%driver", CTLTYPE_STRING | CTLFLAG_RD, 207 dev, DEVICE_SYSCTL_DRIVER, device_sysctl_handler, "A", 208 "device driver name"); 209 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 210 OID_AUTO, "%location", CTLTYPE_STRING | CTLFLAG_RD, 211 dev, DEVICE_SYSCTL_LOCATION, device_sysctl_handler, "A", 212 "device location relative to parent"); 213 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 214 OID_AUTO, "%pnpinfo", CTLTYPE_STRING | CTLFLAG_RD, 215 dev, DEVICE_SYSCTL_PNPINFO, device_sysctl_handler, "A", 216 "device identification"); 217 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree), 218 OID_AUTO, "%parent", CTLTYPE_STRING | CTLFLAG_RD, 219 dev, DEVICE_SYSCTL_PARENT, device_sysctl_handler, "A", 220 "parent device"); 221 } 222 223 static void 224 device_sysctl_update(device_t dev) 225 { 226 devclass_t dc = dev->devclass; 227 228 if (dev->sysctl_tree == NULL) 229 return; 230 sysctl_rename_oid(dev->sysctl_tree, dev->nameunit + strlen(dc->name)); 231 } 232 233 static void 234 device_sysctl_fini(device_t dev) 235 { 236 if (dev->sysctl_tree == NULL) 237 return; 238 sysctl_ctx_free(&dev->sysctl_ctx); 239 dev->sysctl_tree = NULL; 240 } 241 242 static void device_attach_async(device_t dev); 243 static void device_attach_thread(void *arg); 244 static int device_doattach(device_t dev); 245 246 static int do_async_attach = 0; 247 static int numasyncthreads; 248 TUNABLE_INT("kern.do_async_attach", &do_async_attach); 249 250 /* 251 * /dev/devctl implementation 252 */ 253 254 /* 255 * This design allows only one reader for /dev/devctl. This is not desirable 256 * in the long run, but will get a lot of hair out of this implementation. 257 * Maybe we should make this device a clonable device. 258 * 259 * Also note: we specifically do not attach a device to the device_t tree 260 * to avoid potential chicken and egg problems. One could argue that all 261 * of this belongs to the root node. One could also further argue that the 262 * sysctl interface that we have not might more properly be an ioctl 263 * interface, but at this stage of the game, I'm not inclined to rock that 264 * boat. 265 * 266 * I'm also not sure that the SIGIO support is done correctly or not, as 267 * I copied it from a driver that had SIGIO support that likely hasn't been 268 * tested since 3.4 or 2.2.8! 269 */ 270 271 static int sysctl_devctl_disable(SYSCTL_HANDLER_ARGS); 272 static int devctl_disable = 0; 273 TUNABLE_INT("hw.bus.devctl_disable", &devctl_disable); 274 SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_disable, CTLTYPE_INT | CTLFLAG_RW, 0, 0, 275 sysctl_devctl_disable, "I", "devctl disable"); 276 277 static d_open_t devopen; 278 static d_close_t devclose; 279 static d_read_t devread; 280 static d_ioctl_t devioctl; 281 static d_kqfilter_t devkqfilter; 282 283 static struct dev_ops devctl_ops = { 284 { "devctl", 0, 0 }, 285 .d_open = devopen, 286 .d_close = devclose, 287 .d_read = devread, 288 .d_ioctl = devioctl, 289 .d_kqfilter = devkqfilter 290 }; 291 292 struct dev_event_info 293 { 294 char *dei_data; 295 TAILQ_ENTRY(dev_event_info) dei_link; 296 }; 297 298 TAILQ_HEAD(devq, dev_event_info); 299 300 static struct dev_softc 301 { 302 int inuse; 303 int nonblock; 304 struct lock lock; 305 struct kqinfo kq; 306 struct devq devq; 307 struct proc *async_proc; 308 } devsoftc; 309 310 static void 311 devinit(void) 312 { 313 make_dev(&devctl_ops, 0, UID_ROOT, GID_WHEEL, 0600, "devctl"); 314 lockinit(&devsoftc.lock, "dev mtx", 0, 0); 315 TAILQ_INIT(&devsoftc.devq); 316 } 317 318 static int 319 devopen(struct dev_open_args *ap) 320 { 321 if (devsoftc.inuse) 322 return (EBUSY); 323 /* move to init */ 324 devsoftc.inuse = 1; 325 devsoftc.nonblock = 0; 326 devsoftc.async_proc = NULL; 327 return (0); 328 } 329 330 static int 331 devclose(struct dev_close_args *ap) 332 { 333 devsoftc.inuse = 0; 334 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 335 wakeup(&devsoftc); 336 lockmgr(&devsoftc.lock, LK_RELEASE); 337 338 return (0); 339 } 340 341 /* 342 * The read channel for this device is used to report changes to 343 * userland in realtime. We are required to free the data as well as 344 * the n1 object because we allocate them separately. Also note that 345 * we return one record at a time. If you try to read this device a 346 * character at a time, you will lose the rest of the data. Listening 347 * programs are expected to cope. 348 */ 349 static int 350 devread(struct dev_read_args *ap) 351 { 352 struct uio *uio = ap->a_uio; 353 struct dev_event_info *n1; 354 int rv; 355 356 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 357 while (TAILQ_EMPTY(&devsoftc.devq)) { 358 if (devsoftc.nonblock) { 359 lockmgr(&devsoftc.lock, LK_RELEASE); 360 return (EAGAIN); 361 } 362 tsleep_interlock(&devsoftc, PCATCH); 363 lockmgr(&devsoftc.lock, LK_RELEASE); 364 rv = tsleep(&devsoftc, PCATCH | PINTERLOCKED, "devctl", 0); 365 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 366 if (rv) { 367 /* 368 * Need to translate ERESTART to EINTR here? -- jake 369 */ 370 lockmgr(&devsoftc.lock, LK_RELEASE); 371 return (rv); 372 } 373 } 374 n1 = TAILQ_FIRST(&devsoftc.devq); 375 TAILQ_REMOVE(&devsoftc.devq, n1, dei_link); 376 lockmgr(&devsoftc.lock, LK_RELEASE); 377 rv = uiomove(n1->dei_data, strlen(n1->dei_data), uio); 378 kfree(n1->dei_data, M_BUS); 379 kfree(n1, M_BUS); 380 return (rv); 381 } 382 383 static int 384 devioctl(struct dev_ioctl_args *ap) 385 { 386 switch (ap->a_cmd) { 387 388 case FIONBIO: 389 if (*(int*)ap->a_data) 390 devsoftc.nonblock = 1; 391 else 392 devsoftc.nonblock = 0; 393 return (0); 394 case FIOASYNC: 395 if (*(int*)ap->a_data) 396 devsoftc.async_proc = curproc; 397 else 398 devsoftc.async_proc = NULL; 399 return (0); 400 401 /* (un)Support for other fcntl() calls. */ 402 case FIOCLEX: 403 case FIONCLEX: 404 case FIONREAD: 405 case FIOSETOWN: 406 case FIOGETOWN: 407 default: 408 break; 409 } 410 return (ENOTTY); 411 } 412 413 static void dev_filter_detach(struct knote *); 414 static int dev_filter_read(struct knote *, long); 415 416 static struct filterops dev_filtops = 417 { FILTEROP_ISFD, NULL, dev_filter_detach, dev_filter_read }; 418 419 static int 420 devkqfilter(struct dev_kqfilter_args *ap) 421 { 422 struct knote *kn = ap->a_kn; 423 struct klist *klist; 424 425 ap->a_result = 0; 426 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 427 428 switch (kn->kn_filter) { 429 case EVFILT_READ: 430 kn->kn_fop = &dev_filtops; 431 break; 432 default: 433 ap->a_result = EOPNOTSUPP; 434 lockmgr(&devsoftc.lock, LK_RELEASE); 435 return (0); 436 } 437 438 klist = &devsoftc.kq.ki_note; 439 knote_insert(klist, kn); 440 441 lockmgr(&devsoftc.lock, LK_RELEASE); 442 443 return (0); 444 } 445 446 static void 447 dev_filter_detach(struct knote *kn) 448 { 449 struct klist *klist; 450 451 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 452 klist = &devsoftc.kq.ki_note; 453 knote_remove(klist, kn); 454 lockmgr(&devsoftc.lock, LK_RELEASE); 455 } 456 457 static int 458 dev_filter_read(struct knote *kn, long hint) 459 { 460 int ready = 0; 461 462 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 463 if (!TAILQ_EMPTY(&devsoftc.devq)) 464 ready = 1; 465 lockmgr(&devsoftc.lock, LK_RELEASE); 466 467 return (ready); 468 } 469 470 471 /** 472 * @brief Return whether the userland process is running 473 */ 474 boolean_t 475 devctl_process_running(void) 476 { 477 return (devsoftc.inuse == 1); 478 } 479 480 /** 481 * @brief Queue data to be read from the devctl device 482 * 483 * Generic interface to queue data to the devctl device. It is 484 * assumed that @p data is properly formatted. It is further assumed 485 * that @p data is allocated using the M_BUS malloc type. 486 */ 487 void 488 devctl_queue_data(char *data) 489 { 490 struct dev_event_info *n1 = NULL; 491 struct proc *p; 492 493 n1 = kmalloc(sizeof(*n1), M_BUS, M_NOWAIT); 494 if (n1 == NULL) 495 return; 496 n1->dei_data = data; 497 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 498 TAILQ_INSERT_TAIL(&devsoftc.devq, n1, dei_link); 499 wakeup(&devsoftc); 500 lockmgr(&devsoftc.lock, LK_RELEASE); 501 KNOTE(&devsoftc.kq.ki_note, 0); 502 p = devsoftc.async_proc; 503 if (p != NULL) 504 ksignal(p, SIGIO); 505 } 506 507 /** 508 * @brief Send a 'notification' to userland, using standard ways 509 */ 510 void 511 devctl_notify(const char *system, const char *subsystem, const char *type, 512 const char *data) 513 { 514 int len = 0; 515 char *msg; 516 517 if (system == NULL) 518 return; /* BOGUS! Must specify system. */ 519 if (subsystem == NULL) 520 return; /* BOGUS! Must specify subsystem. */ 521 if (type == NULL) 522 return; /* BOGUS! Must specify type. */ 523 len += strlen(" system=") + strlen(system); 524 len += strlen(" subsystem=") + strlen(subsystem); 525 len += strlen(" type=") + strlen(type); 526 /* add in the data message plus newline. */ 527 if (data != NULL) 528 len += strlen(data); 529 len += 3; /* '!', '\n', and NUL */ 530 msg = kmalloc(len, M_BUS, M_NOWAIT); 531 if (msg == NULL) 532 return; /* Drop it on the floor */ 533 if (data != NULL) 534 ksnprintf(msg, len, "!system=%s subsystem=%s type=%s %s\n", 535 system, subsystem, type, data); 536 else 537 ksnprintf(msg, len, "!system=%s subsystem=%s type=%s\n", 538 system, subsystem, type); 539 devctl_queue_data(msg); 540 } 541 542 /* 543 * Common routine that tries to make sending messages as easy as possible. 544 * We allocate memory for the data, copy strings into that, but do not 545 * free it unless there's an error. The dequeue part of the driver should 546 * free the data. We don't send data when the device is disabled. We do 547 * send data, even when we have no listeners, because we wish to avoid 548 * races relating to startup and restart of listening applications. 549 * 550 * devaddq is designed to string together the type of event, with the 551 * object of that event, plus the plug and play info and location info 552 * for that event. This is likely most useful for devices, but less 553 * useful for other consumers of this interface. Those should use 554 * the devctl_queue_data() interface instead. 555 */ 556 static void 557 devaddq(const char *type, const char *what, device_t dev) 558 { 559 char *data = NULL; 560 char *loc = NULL; 561 char *pnp = NULL; 562 const char *parstr; 563 564 if (devctl_disable) 565 return; 566 data = kmalloc(1024, M_BUS, M_NOWAIT); 567 if (data == NULL) 568 goto bad; 569 570 /* get the bus specific location of this device */ 571 loc = kmalloc(1024, M_BUS, M_NOWAIT); 572 if (loc == NULL) 573 goto bad; 574 *loc = '\0'; 575 bus_child_location_str(dev, loc, 1024); 576 577 /* Get the bus specific pnp info of this device */ 578 pnp = kmalloc(1024, M_BUS, M_NOWAIT); 579 if (pnp == NULL) 580 goto bad; 581 *pnp = '\0'; 582 bus_child_pnpinfo_str(dev, pnp, 1024); 583 584 /* Get the parent of this device, or / if high enough in the tree. */ 585 if (device_get_parent(dev) == NULL) 586 parstr = "."; /* Or '/' ? */ 587 else 588 parstr = device_get_nameunit(device_get_parent(dev)); 589 /* String it all together. */ 590 ksnprintf(data, 1024, "%s%s at %s %s on %s\n", type, what, loc, pnp, 591 parstr); 592 kfree(loc, M_BUS); 593 kfree(pnp, M_BUS); 594 devctl_queue_data(data); 595 return; 596 bad: 597 kfree(pnp, M_BUS); 598 kfree(loc, M_BUS); 599 kfree(data, M_BUS); 600 return; 601 } 602 603 /* 604 * A device was added to the tree. We are called just after it successfully 605 * attaches (that is, probe and attach success for this device). No call 606 * is made if a device is merely parented into the tree. See devnomatch 607 * if probe fails. If attach fails, no notification is sent (but maybe 608 * we should have a different message for this). 609 */ 610 static void 611 devadded(device_t dev) 612 { 613 char *pnp = NULL; 614 char *tmp = NULL; 615 616 pnp = kmalloc(1024, M_BUS, M_NOWAIT); 617 if (pnp == NULL) 618 goto fail; 619 tmp = kmalloc(1024, M_BUS, M_NOWAIT); 620 if (tmp == NULL) 621 goto fail; 622 *pnp = '\0'; 623 bus_child_pnpinfo_str(dev, pnp, 1024); 624 ksnprintf(tmp, 1024, "%s %s", device_get_nameunit(dev), pnp); 625 devaddq("+", tmp, dev); 626 fail: 627 if (pnp != NULL) 628 kfree(pnp, M_BUS); 629 if (tmp != NULL) 630 kfree(tmp, M_BUS); 631 return; 632 } 633 634 /* 635 * A device was removed from the tree. We are called just before this 636 * happens. 637 */ 638 static void 639 devremoved(device_t dev) 640 { 641 char *pnp = NULL; 642 char *tmp = NULL; 643 644 pnp = kmalloc(1024, M_BUS, M_NOWAIT); 645 if (pnp == NULL) 646 goto fail; 647 tmp = kmalloc(1024, M_BUS, M_NOWAIT); 648 if (tmp == NULL) 649 goto fail; 650 *pnp = '\0'; 651 bus_child_pnpinfo_str(dev, pnp, 1024); 652 ksnprintf(tmp, 1024, "%s %s", device_get_nameunit(dev), pnp); 653 devaddq("-", tmp, dev); 654 fail: 655 if (pnp != NULL) 656 kfree(pnp, M_BUS); 657 if (tmp != NULL) 658 kfree(tmp, M_BUS); 659 return; 660 } 661 662 /* 663 * Called when there's no match for this device. This is only called 664 * the first time that no match happens, so we don't keep getitng this 665 * message. Should that prove to be undesirable, we can change it. 666 * This is called when all drivers that can attach to a given bus 667 * decline to accept this device. Other errrors may not be detected. 668 */ 669 static void 670 devnomatch(device_t dev) 671 { 672 devaddq("?", "", dev); 673 } 674 675 static int 676 sysctl_devctl_disable(SYSCTL_HANDLER_ARGS) 677 { 678 struct dev_event_info *n1; 679 int dis, error; 680 681 dis = devctl_disable; 682 error = sysctl_handle_int(oidp, &dis, 0, req); 683 if (error || !req->newptr) 684 return (error); 685 lockmgr(&devsoftc.lock, LK_EXCLUSIVE); 686 devctl_disable = dis; 687 if (dis) { 688 while (!TAILQ_EMPTY(&devsoftc.devq)) { 689 n1 = TAILQ_FIRST(&devsoftc.devq); 690 TAILQ_REMOVE(&devsoftc.devq, n1, dei_link); 691 kfree(n1->dei_data, M_BUS); 692 kfree(n1, M_BUS); 693 } 694 } 695 lockmgr(&devsoftc.lock, LK_RELEASE); 696 return (0); 697 } 698 699 /* End of /dev/devctl code */ 700 701 TAILQ_HEAD(,device) bus_data_devices; 702 static int bus_data_generation = 1; 703 704 kobj_method_t null_methods[] = { 705 { 0, 0 } 706 }; 707 708 DEFINE_CLASS(null, null_methods, 0); 709 710 /* 711 * Devclass implementation 712 */ 713 714 static devclass_list_t devclasses = TAILQ_HEAD_INITIALIZER(devclasses); 715 716 static devclass_t 717 devclass_find_internal(const char *classname, const char *parentname, 718 int create) 719 { 720 devclass_t dc; 721 722 PDEBUG(("looking for %s", classname)); 723 if (classname == NULL) 724 return(NULL); 725 726 TAILQ_FOREACH(dc, &devclasses, link) 727 if (!strcmp(dc->name, classname)) 728 break; 729 730 if (create && !dc) { 731 PDEBUG(("creating %s", classname)); 732 dc = kmalloc(sizeof(struct devclass) + strlen(classname) + 1, 733 M_BUS, M_INTWAIT | M_ZERO); 734 dc->parent = NULL; 735 dc->name = (char*) (dc + 1); 736 strcpy(dc->name, classname); 737 dc->devices = NULL; 738 dc->maxunit = 0; 739 TAILQ_INIT(&dc->drivers); 740 TAILQ_INSERT_TAIL(&devclasses, dc, link); 741 742 bus_data_generation_update(); 743 744 } 745 746 /* 747 * If a parent class is specified, then set that as our parent so 748 * that this devclass will support drivers for the parent class as 749 * well. If the parent class has the same name don't do this though 750 * as it creates a cycle that can trigger an infinite loop in 751 * device_probe_child() if a device exists for which there is no 752 * suitable driver. 753 */ 754 if (parentname && dc && !dc->parent && 755 strcmp(classname, parentname) != 0) 756 dc->parent = devclass_find_internal(parentname, NULL, FALSE); 757 758 return(dc); 759 } 760 761 devclass_t 762 devclass_create(const char *classname) 763 { 764 return(devclass_find_internal(classname, NULL, TRUE)); 765 } 766 767 devclass_t 768 devclass_find(const char *classname) 769 { 770 return(devclass_find_internal(classname, NULL, FALSE)); 771 } 772 773 device_t 774 devclass_find_unit(const char *classname, int unit) 775 { 776 devclass_t dc; 777 778 if ((dc = devclass_find(classname)) != NULL) 779 return(devclass_get_device(dc, unit)); 780 return (NULL); 781 } 782 783 int 784 devclass_add_driver(devclass_t dc, driver_t *driver) 785 { 786 driverlink_t dl; 787 device_t dev; 788 int i; 789 790 PDEBUG(("%s", DRIVERNAME(driver))); 791 792 dl = kmalloc(sizeof *dl, M_BUS, M_INTWAIT | M_ZERO); 793 794 /* 795 * Compile the driver's methods. Also increase the reference count 796 * so that the class doesn't get freed when the last instance 797 * goes. This means we can safely use static methods and avoids a 798 * double-free in devclass_delete_driver. 799 */ 800 kobj_class_instantiate(driver); 801 802 /* 803 * Make sure the devclass which the driver is implementing exists. 804 */ 805 devclass_find_internal(driver->name, NULL, TRUE); 806 807 dl->driver = driver; 808 TAILQ_INSERT_TAIL(&dc->drivers, dl, link); 809 810 /* 811 * Call BUS_DRIVER_ADDED for any existing busses in this class, 812 * but only if the bus has already been attached (otherwise we 813 * might probe too early). 814 * 815 * This is what will cause a newly loaded module to be associated 816 * with hardware. bus_generic_driver_added() is typically what ends 817 * up being called. 818 */ 819 for (i = 0; i < dc->maxunit; i++) { 820 if ((dev = dc->devices[i]) != NULL) { 821 if (dev->state >= DS_ATTACHED) 822 BUS_DRIVER_ADDED(dev, driver); 823 } 824 } 825 826 bus_data_generation_update(); 827 return(0); 828 } 829 830 int 831 devclass_delete_driver(devclass_t busclass, driver_t *driver) 832 { 833 devclass_t dc = devclass_find(driver->name); 834 driverlink_t dl; 835 device_t dev; 836 int i; 837 int error; 838 839 PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass))); 840 841 if (!dc) 842 return(0); 843 844 /* 845 * Find the link structure in the bus' list of drivers. 846 */ 847 TAILQ_FOREACH(dl, &busclass->drivers, link) 848 if (dl->driver == driver) 849 break; 850 851 if (!dl) { 852 PDEBUG(("%s not found in %s list", driver->name, busclass->name)); 853 return(ENOENT); 854 } 855 856 /* 857 * Disassociate from any devices. We iterate through all the 858 * devices in the devclass of the driver and detach any which are 859 * using the driver and which have a parent in the devclass which 860 * we are deleting from. 861 * 862 * Note that since a driver can be in multiple devclasses, we 863 * should not detach devices which are not children of devices in 864 * the affected devclass. 865 */ 866 for (i = 0; i < dc->maxunit; i++) 867 if (dc->devices[i]) { 868 dev = dc->devices[i]; 869 if (dev->driver == driver && dev->parent && 870 dev->parent->devclass == busclass) { 871 if ((error = device_detach(dev)) != 0) 872 return(error); 873 device_set_driver(dev, NULL); 874 } 875 } 876 877 TAILQ_REMOVE(&busclass->drivers, dl, link); 878 kfree(dl, M_BUS); 879 880 kobj_class_uninstantiate(driver); 881 882 bus_data_generation_update(); 883 return(0); 884 } 885 886 static driverlink_t 887 devclass_find_driver_internal(devclass_t dc, const char *classname) 888 { 889 driverlink_t dl; 890 891 PDEBUG(("%s in devclass %s", classname, DEVCLANAME(dc))); 892 893 TAILQ_FOREACH(dl, &dc->drivers, link) 894 if (!strcmp(dl->driver->name, classname)) 895 return(dl); 896 897 PDEBUG(("not found")); 898 return(NULL); 899 } 900 901 kobj_class_t 902 devclass_find_driver(devclass_t dc, const char *classname) 903 { 904 driverlink_t dl; 905 906 dl = devclass_find_driver_internal(dc, classname); 907 if (dl) 908 return(dl->driver); 909 else 910 return(NULL); 911 } 912 913 const char * 914 devclass_get_name(devclass_t dc) 915 { 916 return(dc->name); 917 } 918 919 device_t 920 devclass_get_device(devclass_t dc, int unit) 921 { 922 if (dc == NULL || unit < 0 || unit >= dc->maxunit) 923 return(NULL); 924 return(dc->devices[unit]); 925 } 926 927 void * 928 devclass_get_softc(devclass_t dc, int unit) 929 { 930 device_t dev; 931 932 dev = devclass_get_device(dc, unit); 933 if (!dev) 934 return(NULL); 935 936 return(device_get_softc(dev)); 937 } 938 939 int 940 devclass_get_devices(devclass_t dc, device_t **devlistp, int *devcountp) 941 { 942 int i; 943 int count; 944 device_t *list; 945 946 count = 0; 947 for (i = 0; i < dc->maxunit; i++) 948 if (dc->devices[i]) 949 count++; 950 951 list = kmalloc(count * sizeof(device_t), M_TEMP, M_INTWAIT | M_ZERO); 952 953 count = 0; 954 for (i = 0; i < dc->maxunit; i++) 955 if (dc->devices[i]) { 956 list[count] = dc->devices[i]; 957 count++; 958 } 959 960 *devlistp = list; 961 *devcountp = count; 962 963 return(0); 964 } 965 966 /** 967 * @brief Get a list of drivers in the devclass 968 * 969 * An array containing a list of pointers to all the drivers in the 970 * given devclass is allocated and returned in @p *listp. The number 971 * of drivers in the array is returned in @p *countp. The caller should 972 * free the array using @c free(p, M_TEMP). 973 * 974 * @param dc the devclass to examine 975 * @param listp gives location for array pointer return value 976 * @param countp gives location for number of array elements 977 * return value 978 * 979 * @retval 0 success 980 * @retval ENOMEM the array allocation failed 981 */ 982 int 983 devclass_get_drivers(devclass_t dc, driver_t ***listp, int *countp) 984 { 985 driverlink_t dl; 986 driver_t **list; 987 int count; 988 989 count = 0; 990 TAILQ_FOREACH(dl, &dc->drivers, link) 991 count++; 992 list = kmalloc(count * sizeof(driver_t *), M_TEMP, M_NOWAIT); 993 if (list == NULL) 994 return (ENOMEM); 995 996 count = 0; 997 TAILQ_FOREACH(dl, &dc->drivers, link) { 998 list[count] = dl->driver; 999 count++; 1000 } 1001 *listp = list; 1002 *countp = count; 1003 1004 return (0); 1005 } 1006 1007 /** 1008 * @brief Get the number of devices in a devclass 1009 * 1010 * @param dc the devclass to examine 1011 */ 1012 int 1013 devclass_get_count(devclass_t dc) 1014 { 1015 int count, i; 1016 1017 count = 0; 1018 for (i = 0; i < dc->maxunit; i++) 1019 if (dc->devices[i]) 1020 count++; 1021 return (count); 1022 } 1023 1024 int 1025 devclass_get_maxunit(devclass_t dc) 1026 { 1027 return(dc->maxunit); 1028 } 1029 1030 void 1031 devclass_set_parent(devclass_t dc, devclass_t pdc) 1032 { 1033 dc->parent = pdc; 1034 } 1035 1036 devclass_t 1037 devclass_get_parent(devclass_t dc) 1038 { 1039 return(dc->parent); 1040 } 1041 1042 static int 1043 devclass_alloc_unit(devclass_t dc, int *unitp) 1044 { 1045 int unit = *unitp; 1046 1047 PDEBUG(("unit %d in devclass %s", unit, DEVCLANAME(dc))); 1048 1049 /* If we have been given a wired unit number, check for existing device */ 1050 if (unit != -1) { 1051 if (unit >= 0 && unit < dc->maxunit && 1052 dc->devices[unit] != NULL) { 1053 if (bootverbose) 1054 kprintf("%s-: %s%d exists, using next available unit number\n", 1055 dc->name, dc->name, unit); 1056 /* find the next available slot */ 1057 while (++unit < dc->maxunit && dc->devices[unit] != NULL) 1058 ; 1059 } 1060 } else { 1061 /* Unwired device, find the next available slot for it */ 1062 unit = 0; 1063 while (unit < dc->maxunit && dc->devices[unit] != NULL) 1064 unit++; 1065 } 1066 1067 /* 1068 * We've selected a unit beyond the length of the table, so let's 1069 * extend the table to make room for all units up to and including 1070 * this one. 1071 */ 1072 if (unit >= dc->maxunit) { 1073 device_t *newlist; 1074 int newsize; 1075 1076 newsize = (unit + 1); 1077 newlist = kmalloc(sizeof(device_t) * newsize, M_BUS, 1078 M_INTWAIT | M_ZERO); 1079 if (newlist == NULL) 1080 return(ENOMEM); 1081 bcopy(dc->devices, newlist, sizeof(device_t) * dc->maxunit); 1082 if (dc->devices) 1083 kfree(dc->devices, M_BUS); 1084 dc->devices = newlist; 1085 dc->maxunit = newsize; 1086 } 1087 PDEBUG(("now: unit %d in devclass %s", unit, DEVCLANAME(dc))); 1088 1089 *unitp = unit; 1090 return(0); 1091 } 1092 1093 static int 1094 devclass_add_device(devclass_t dc, device_t dev) 1095 { 1096 int buflen, error; 1097 1098 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc))); 1099 1100 buflen = strlen(dc->name) + 5; 1101 dev->nameunit = kmalloc(buflen, M_BUS, M_INTWAIT | M_ZERO); 1102 if (dev->nameunit == NULL) 1103 return(ENOMEM); 1104 1105 if ((error = devclass_alloc_unit(dc, &dev->unit)) != 0) { 1106 kfree(dev->nameunit, M_BUS); 1107 dev->nameunit = NULL; 1108 return(error); 1109 } 1110 dc->devices[dev->unit] = dev; 1111 dev->devclass = dc; 1112 ksnprintf(dev->nameunit, buflen, "%s%d", dc->name, dev->unit); 1113 1114 return(0); 1115 } 1116 1117 static int 1118 devclass_delete_device(devclass_t dc, device_t dev) 1119 { 1120 if (!dc || !dev) 1121 return(0); 1122 1123 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc))); 1124 1125 if (dev->devclass != dc || dc->devices[dev->unit] != dev) 1126 panic("devclass_delete_device: inconsistent device class"); 1127 dc->devices[dev->unit] = NULL; 1128 if (dev->flags & DF_WILDCARD) 1129 dev->unit = -1; 1130 dev->devclass = NULL; 1131 kfree(dev->nameunit, M_BUS); 1132 dev->nameunit = NULL; 1133 1134 return(0); 1135 } 1136 1137 static device_t 1138 make_device(device_t parent, const char *name, int unit) 1139 { 1140 device_t dev; 1141 devclass_t dc; 1142 1143 PDEBUG(("%s at %s as unit %d", name, DEVICENAME(parent), unit)); 1144 1145 if (name != NULL) { 1146 dc = devclass_find_internal(name, NULL, TRUE); 1147 if (!dc) { 1148 kprintf("make_device: can't find device class %s\n", name); 1149 return(NULL); 1150 } 1151 } else 1152 dc = NULL; 1153 1154 dev = kmalloc(sizeof(struct device), M_BUS, M_INTWAIT | M_ZERO); 1155 if (!dev) 1156 return(0); 1157 1158 dev->parent = parent; 1159 TAILQ_INIT(&dev->children); 1160 kobj_init((kobj_t) dev, &null_class); 1161 dev->driver = NULL; 1162 dev->devclass = NULL; 1163 dev->unit = unit; 1164 dev->nameunit = NULL; 1165 dev->desc = NULL; 1166 dev->busy = 0; 1167 dev->devflags = 0; 1168 dev->flags = DF_ENABLED; 1169 dev->order = 0; 1170 if (unit == -1) 1171 dev->flags |= DF_WILDCARD; 1172 if (name) { 1173 dev->flags |= DF_FIXEDCLASS; 1174 if (devclass_add_device(dc, dev) != 0) { 1175 kobj_delete((kobj_t)dev, M_BUS); 1176 return(NULL); 1177 } 1178 } 1179 dev->ivars = NULL; 1180 dev->softc = NULL; 1181 1182 dev->state = DS_NOTPRESENT; 1183 1184 TAILQ_INSERT_TAIL(&bus_data_devices, dev, devlink); 1185 bus_data_generation_update(); 1186 1187 return(dev); 1188 } 1189 1190 static int 1191 device_print_child(device_t dev, device_t child) 1192 { 1193 int retval = 0; 1194 1195 if (device_is_alive(child)) 1196 retval += BUS_PRINT_CHILD(dev, child); 1197 else 1198 retval += device_printf(child, " not found\n"); 1199 1200 return(retval); 1201 } 1202 1203 device_t 1204 device_add_child(device_t dev, const char *name, int unit) 1205 { 1206 return device_add_child_ordered(dev, 0, name, unit); 1207 } 1208 1209 device_t 1210 device_add_child_ordered(device_t dev, int order, const char *name, int unit) 1211 { 1212 device_t child; 1213 device_t place; 1214 1215 PDEBUG(("%s at %s with order %d as unit %d", name, DEVICENAME(dev), 1216 order, unit)); 1217 1218 child = make_device(dev, name, unit); 1219 if (child == NULL) 1220 return child; 1221 child->order = order; 1222 1223 TAILQ_FOREACH(place, &dev->children, link) 1224 if (place->order > order) 1225 break; 1226 1227 if (place) { 1228 /* 1229 * The device 'place' is the first device whose order is 1230 * greater than the new child. 1231 */ 1232 TAILQ_INSERT_BEFORE(place, child, link); 1233 } else { 1234 /* 1235 * The new child's order is greater or equal to the order of 1236 * any existing device. Add the child to the tail of the list. 1237 */ 1238 TAILQ_INSERT_TAIL(&dev->children, child, link); 1239 } 1240 1241 bus_data_generation_update(); 1242 return(child); 1243 } 1244 1245 int 1246 device_delete_child(device_t dev, device_t child) 1247 { 1248 int error; 1249 device_t grandchild; 1250 1251 PDEBUG(("%s from %s", DEVICENAME(child), DEVICENAME(dev))); 1252 1253 /* remove children first */ 1254 while ( (grandchild = TAILQ_FIRST(&child->children)) ) { 1255 error = device_delete_child(child, grandchild); 1256 if (error) 1257 return(error); 1258 } 1259 1260 if ((error = device_detach(child)) != 0) 1261 return(error); 1262 if (child->devclass) 1263 devclass_delete_device(child->devclass, child); 1264 TAILQ_REMOVE(&dev->children, child, link); 1265 TAILQ_REMOVE(&bus_data_devices, child, devlink); 1266 device_set_desc(child, NULL); 1267 kobj_delete((kobj_t)child, M_BUS); 1268 1269 bus_data_generation_update(); 1270 return(0); 1271 } 1272 1273 /** 1274 * @brief Delete all children devices of the given device, if any. 1275 * 1276 * This function deletes all children devices of the given device, if 1277 * any, using the device_delete_child() function for each device it 1278 * finds. If a child device cannot be deleted, this function will 1279 * return an error code. 1280 * 1281 * @param dev the parent device 1282 * 1283 * @retval 0 success 1284 * @retval non-zero a device would not detach 1285 */ 1286 int 1287 device_delete_children(device_t dev) 1288 { 1289 device_t child; 1290 int error; 1291 1292 PDEBUG(("Deleting all children of %s", DEVICENAME(dev))); 1293 1294 error = 0; 1295 1296 while ((child = TAILQ_FIRST(&dev->children)) != NULL) { 1297 error = device_delete_child(dev, child); 1298 if (error) { 1299 PDEBUG(("Failed deleting %s", DEVICENAME(child))); 1300 break; 1301 } 1302 } 1303 return (error); 1304 } 1305 1306 /** 1307 * @brief Find a device given a unit number 1308 * 1309 * This is similar to devclass_get_devices() but only searches for 1310 * devices which have @p dev as a parent. 1311 * 1312 * @param dev the parent device to search 1313 * @param unit the unit number to search for. If the unit is -1, 1314 * return the first child of @p dev which has name 1315 * @p classname (that is, the one with the lowest unit.) 1316 * 1317 * @returns the device with the given unit number or @c 1318 * NULL if there is no such device 1319 */ 1320 device_t 1321 device_find_child(device_t dev, const char *classname, int unit) 1322 { 1323 devclass_t dc; 1324 device_t child; 1325 1326 dc = devclass_find(classname); 1327 if (!dc) 1328 return(NULL); 1329 1330 if (unit != -1) { 1331 child = devclass_get_device(dc, unit); 1332 if (child && child->parent == dev) 1333 return (child); 1334 } else { 1335 for (unit = 0; unit < devclass_get_maxunit(dc); unit++) { 1336 child = devclass_get_device(dc, unit); 1337 if (child && child->parent == dev) 1338 return (child); 1339 } 1340 } 1341 return(NULL); 1342 } 1343 1344 static driverlink_t 1345 first_matching_driver(devclass_t dc, device_t dev) 1346 { 1347 if (dev->devclass) 1348 return(devclass_find_driver_internal(dc, dev->devclass->name)); 1349 else 1350 return(TAILQ_FIRST(&dc->drivers)); 1351 } 1352 1353 static driverlink_t 1354 next_matching_driver(devclass_t dc, device_t dev, driverlink_t last) 1355 { 1356 if (dev->devclass) { 1357 driverlink_t dl; 1358 for (dl = TAILQ_NEXT(last, link); dl; dl = TAILQ_NEXT(dl, link)) 1359 if (!strcmp(dev->devclass->name, dl->driver->name)) 1360 return(dl); 1361 return(NULL); 1362 } else 1363 return(TAILQ_NEXT(last, link)); 1364 } 1365 1366 int 1367 device_probe_child(device_t dev, device_t child) 1368 { 1369 devclass_t dc; 1370 driverlink_t best = NULL; 1371 driverlink_t dl; 1372 int result, pri = 0; 1373 int hasclass = (child->devclass != NULL); 1374 1375 dc = dev->devclass; 1376 if (!dc) 1377 panic("device_probe_child: parent device has no devclass"); 1378 1379 if (child->state == DS_ALIVE) 1380 return(0); 1381 1382 for (; dc; dc = dc->parent) { 1383 for (dl = first_matching_driver(dc, child); dl; 1384 dl = next_matching_driver(dc, child, dl)) { 1385 PDEBUG(("Trying %s", DRIVERNAME(dl->driver))); 1386 device_set_driver(child, dl->driver); 1387 if (!hasclass) 1388 device_set_devclass(child, dl->driver->name); 1389 result = DEVICE_PROBE(child); 1390 if (!hasclass) 1391 device_set_devclass(child, 0); 1392 1393 /* 1394 * If the driver returns SUCCESS, there can be 1395 * no higher match for this device. 1396 */ 1397 if (result == 0) { 1398 best = dl; 1399 pri = 0; 1400 break; 1401 } 1402 1403 /* 1404 * The driver returned an error so it 1405 * certainly doesn't match. 1406 */ 1407 if (result > 0) { 1408 device_set_driver(child, 0); 1409 continue; 1410 } 1411 1412 /* 1413 * A priority lower than SUCCESS, remember the 1414 * best matching driver. Initialise the value 1415 * of pri for the first match. 1416 */ 1417 if (best == NULL || result > pri) { 1418 best = dl; 1419 pri = result; 1420 continue; 1421 } 1422 } 1423 /* 1424 * If we have unambiguous match in this devclass, 1425 * don't look in the parent. 1426 */ 1427 if (best && pri == 0) 1428 break; 1429 } 1430 1431 /* 1432 * If we found a driver, change state and initialise the devclass. 1433 */ 1434 if (best) { 1435 if (!child->devclass) 1436 device_set_devclass(child, best->driver->name); 1437 device_set_driver(child, best->driver); 1438 if (pri < 0) { 1439 /* 1440 * A bit bogus. Call the probe method again to make 1441 * sure that we have the right description. 1442 */ 1443 DEVICE_PROBE(child); 1444 } 1445 1446 bus_data_generation_update(); 1447 child->state = DS_ALIVE; 1448 return(0); 1449 } 1450 1451 return(ENXIO); 1452 } 1453 1454 device_t 1455 device_get_parent(device_t dev) 1456 { 1457 return dev->parent; 1458 } 1459 1460 int 1461 device_get_children(device_t dev, device_t **devlistp, int *devcountp) 1462 { 1463 int count; 1464 device_t child; 1465 device_t *list; 1466 1467 count = 0; 1468 TAILQ_FOREACH(child, &dev->children, link) 1469 count++; 1470 1471 list = kmalloc(count * sizeof(device_t), M_TEMP, M_INTWAIT | M_ZERO); 1472 1473 count = 0; 1474 TAILQ_FOREACH(child, &dev->children, link) { 1475 list[count] = child; 1476 count++; 1477 } 1478 1479 *devlistp = list; 1480 *devcountp = count; 1481 1482 return(0); 1483 } 1484 1485 driver_t * 1486 device_get_driver(device_t dev) 1487 { 1488 return(dev->driver); 1489 } 1490 1491 devclass_t 1492 device_get_devclass(device_t dev) 1493 { 1494 return(dev->devclass); 1495 } 1496 1497 const char * 1498 device_get_name(device_t dev) 1499 { 1500 if (dev->devclass) 1501 return devclass_get_name(dev->devclass); 1502 return(NULL); 1503 } 1504 1505 const char * 1506 device_get_nameunit(device_t dev) 1507 { 1508 return(dev->nameunit); 1509 } 1510 1511 int 1512 device_get_unit(device_t dev) 1513 { 1514 return(dev->unit); 1515 } 1516 1517 const char * 1518 device_get_desc(device_t dev) 1519 { 1520 return(dev->desc); 1521 } 1522 1523 uint32_t 1524 device_get_flags(device_t dev) 1525 { 1526 return(dev->devflags); 1527 } 1528 1529 struct sysctl_ctx_list * 1530 device_get_sysctl_ctx(device_t dev) 1531 { 1532 return (&dev->sysctl_ctx); 1533 } 1534 1535 struct sysctl_oid * 1536 device_get_sysctl_tree(device_t dev) 1537 { 1538 return (dev->sysctl_tree); 1539 } 1540 1541 int 1542 device_print_prettyname(device_t dev) 1543 { 1544 const char *name = device_get_name(dev); 1545 1546 if (name == NULL) 1547 return kprintf("unknown: "); 1548 else 1549 return kprintf("%s%d: ", name, device_get_unit(dev)); 1550 } 1551 1552 int 1553 device_printf(device_t dev, const char * fmt, ...) 1554 { 1555 __va_list ap; 1556 int retval; 1557 1558 retval = device_print_prettyname(dev); 1559 __va_start(ap, fmt); 1560 retval += kvprintf(fmt, ap); 1561 __va_end(ap); 1562 return retval; 1563 } 1564 1565 static void 1566 device_set_desc_internal(device_t dev, const char* desc, int copy) 1567 { 1568 if (dev->desc && (dev->flags & DF_DESCMALLOCED)) { 1569 kfree(dev->desc, M_BUS); 1570 dev->flags &= ~DF_DESCMALLOCED; 1571 dev->desc = NULL; 1572 } 1573 1574 if (copy && desc) { 1575 dev->desc = kmalloc(strlen(desc) + 1, M_BUS, M_INTWAIT); 1576 if (dev->desc) { 1577 strcpy(dev->desc, desc); 1578 dev->flags |= DF_DESCMALLOCED; 1579 } 1580 } else { 1581 /* Avoid a -Wcast-qual warning */ 1582 dev->desc = (char *)(uintptr_t) desc; 1583 } 1584 1585 bus_data_generation_update(); 1586 } 1587 1588 void 1589 device_set_desc(device_t dev, const char* desc) 1590 { 1591 device_set_desc_internal(dev, desc, FALSE); 1592 } 1593 1594 void 1595 device_set_desc_copy(device_t dev, const char* desc) 1596 { 1597 device_set_desc_internal(dev, desc, TRUE); 1598 } 1599 1600 void 1601 device_set_flags(device_t dev, uint32_t flags) 1602 { 1603 dev->devflags = flags; 1604 } 1605 1606 void * 1607 device_get_softc(device_t dev) 1608 { 1609 return dev->softc; 1610 } 1611 1612 void 1613 device_set_softc(device_t dev, void *softc) 1614 { 1615 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) 1616 kfree(dev->softc, M_BUS); 1617 dev->softc = softc; 1618 if (dev->softc) 1619 dev->flags |= DF_EXTERNALSOFTC; 1620 else 1621 dev->flags &= ~DF_EXTERNALSOFTC; 1622 } 1623 1624 void 1625 device_set_async_attach(device_t dev, int enable) 1626 { 1627 if (enable) 1628 dev->flags |= DF_ASYNCPROBE; 1629 else 1630 dev->flags &= ~DF_ASYNCPROBE; 1631 } 1632 1633 void * 1634 device_get_ivars(device_t dev) 1635 { 1636 return dev->ivars; 1637 } 1638 1639 void 1640 device_set_ivars(device_t dev, void * ivars) 1641 { 1642 if (!dev) 1643 return; 1644 1645 dev->ivars = ivars; 1646 } 1647 1648 device_state_t 1649 device_get_state(device_t dev) 1650 { 1651 return(dev->state); 1652 } 1653 1654 void 1655 device_enable(device_t dev) 1656 { 1657 dev->flags |= DF_ENABLED; 1658 } 1659 1660 void 1661 device_disable(device_t dev) 1662 { 1663 dev->flags &= ~DF_ENABLED; 1664 } 1665 1666 /* 1667 * YYY cannot block 1668 */ 1669 void 1670 device_busy(device_t dev) 1671 { 1672 if (dev->state < DS_ATTACHED) 1673 panic("device_busy: called for unattached device"); 1674 if (dev->busy == 0 && dev->parent) 1675 device_busy(dev->parent); 1676 dev->busy++; 1677 dev->state = DS_BUSY; 1678 } 1679 1680 /* 1681 * YYY cannot block 1682 */ 1683 void 1684 device_unbusy(device_t dev) 1685 { 1686 if (dev->state != DS_BUSY) 1687 panic("device_unbusy: called for non-busy device"); 1688 dev->busy--; 1689 if (dev->busy == 0) { 1690 if (dev->parent) 1691 device_unbusy(dev->parent); 1692 dev->state = DS_ATTACHED; 1693 } 1694 } 1695 1696 void 1697 device_quiet(device_t dev) 1698 { 1699 dev->flags |= DF_QUIET; 1700 } 1701 1702 void 1703 device_verbose(device_t dev) 1704 { 1705 dev->flags &= ~DF_QUIET; 1706 } 1707 1708 int 1709 device_is_quiet(device_t dev) 1710 { 1711 return((dev->flags & DF_QUIET) != 0); 1712 } 1713 1714 int 1715 device_is_enabled(device_t dev) 1716 { 1717 return((dev->flags & DF_ENABLED) != 0); 1718 } 1719 1720 int 1721 device_is_alive(device_t dev) 1722 { 1723 return(dev->state >= DS_ALIVE); 1724 } 1725 1726 int 1727 device_is_attached(device_t dev) 1728 { 1729 return(dev->state >= DS_ATTACHED); 1730 } 1731 1732 int 1733 device_set_devclass(device_t dev, const char *classname) 1734 { 1735 devclass_t dc; 1736 int error; 1737 1738 if (!classname) { 1739 if (dev->devclass) 1740 devclass_delete_device(dev->devclass, dev); 1741 return(0); 1742 } 1743 1744 if (dev->devclass) { 1745 kprintf("device_set_devclass: device class already set\n"); 1746 return(EINVAL); 1747 } 1748 1749 dc = devclass_find_internal(classname, NULL, TRUE); 1750 if (!dc) 1751 return(ENOMEM); 1752 1753 error = devclass_add_device(dc, dev); 1754 1755 bus_data_generation_update(); 1756 return(error); 1757 } 1758 1759 int 1760 device_set_driver(device_t dev, driver_t *driver) 1761 { 1762 if (dev->state >= DS_ATTACHED) 1763 return(EBUSY); 1764 1765 if (dev->driver == driver) 1766 return(0); 1767 1768 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) { 1769 kfree(dev->softc, M_BUS); 1770 dev->softc = NULL; 1771 } 1772 kobj_delete((kobj_t) dev, 0); 1773 dev->driver = driver; 1774 if (driver) { 1775 kobj_init((kobj_t) dev, (kobj_class_t) driver); 1776 if (!(dev->flags & DF_EXTERNALSOFTC)) 1777 dev->softc = kmalloc(driver->size, M_BUS, 1778 M_INTWAIT | M_ZERO); 1779 } else { 1780 kobj_init((kobj_t) dev, &null_class); 1781 } 1782 1783 bus_data_generation_update(); 1784 return(0); 1785 } 1786 1787 int 1788 device_probe_and_attach(device_t dev) 1789 { 1790 device_t bus = dev->parent; 1791 int error = 0; 1792 1793 if (dev->state >= DS_ALIVE) 1794 return(0); 1795 1796 if ((dev->flags & DF_ENABLED) == 0) { 1797 if (bootverbose) { 1798 device_print_prettyname(dev); 1799 kprintf("not probed (disabled)\n"); 1800 } 1801 return(0); 1802 } 1803 1804 error = device_probe_child(bus, dev); 1805 if (error) { 1806 if (!(dev->flags & DF_DONENOMATCH)) { 1807 BUS_PROBE_NOMATCH(bus, dev); 1808 devnomatch(dev); 1809 dev->flags |= DF_DONENOMATCH; 1810 } 1811 return(error); 1812 } 1813 1814 /* 1815 * Output the exact device chain prior to the attach in case the 1816 * system locks up during attach, and generate the full info after 1817 * the attach so correct irq and other information is displayed. 1818 */ 1819 if (bootverbose && !device_is_quiet(dev)) { 1820 device_t tmp; 1821 1822 kprintf("%s", device_get_nameunit(dev)); 1823 for (tmp = dev->parent; tmp; tmp = tmp->parent) 1824 kprintf(".%s", device_get_nameunit(tmp)); 1825 kprintf("\n"); 1826 } 1827 if (!device_is_quiet(dev)) 1828 device_print_child(bus, dev); 1829 if ((dev->flags & DF_ASYNCPROBE) && do_async_attach) { 1830 kprintf("%s: probing asynchronously\n", 1831 device_get_nameunit(dev)); 1832 dev->state = DS_INPROGRESS; 1833 device_attach_async(dev); 1834 error = 0; 1835 } else { 1836 error = device_doattach(dev); 1837 } 1838 return(error); 1839 } 1840 1841 /* 1842 * Device is known to be alive, do the attach asynchronously. 1843 * However, serialize the attaches with the mp lock. 1844 */ 1845 static void 1846 device_attach_async(device_t dev) 1847 { 1848 thread_t td; 1849 1850 atomic_add_int(&numasyncthreads, 1); 1851 lwkt_create(device_attach_thread, dev, &td, NULL, 1852 0, 0, "%s", (dev->desc ? dev->desc : "devattach")); 1853 } 1854 1855 static void 1856 device_attach_thread(void *arg) 1857 { 1858 device_t dev = arg; 1859 1860 (void)device_doattach(dev); 1861 atomic_subtract_int(&numasyncthreads, 1); 1862 wakeup(&numasyncthreads); 1863 } 1864 1865 /* 1866 * Device is known to be alive, do the attach (synchronous or asynchronous) 1867 */ 1868 static int 1869 device_doattach(device_t dev) 1870 { 1871 device_t bus = dev->parent; 1872 int hasclass = (dev->devclass != NULL); 1873 int error; 1874 1875 device_sysctl_init(dev); 1876 error = DEVICE_ATTACH(dev); 1877 if (error == 0) { 1878 dev->state = DS_ATTACHED; 1879 if (bootverbose && !device_is_quiet(dev)) 1880 device_print_child(bus, dev); 1881 device_sysctl_update(dev); 1882 devadded(dev); 1883 } else { 1884 kprintf("device_probe_and_attach: %s%d attach returned %d\n", 1885 dev->driver->name, dev->unit, error); 1886 /* Unset the class that was set in device_probe_child */ 1887 if (!hasclass) 1888 device_set_devclass(dev, 0); 1889 device_set_driver(dev, NULL); 1890 dev->state = DS_NOTPRESENT; 1891 device_sysctl_fini(dev); 1892 } 1893 return(error); 1894 } 1895 1896 int 1897 device_detach(device_t dev) 1898 { 1899 int error; 1900 1901 PDEBUG(("%s", DEVICENAME(dev))); 1902 if (dev->state == DS_BUSY) 1903 return(EBUSY); 1904 if (dev->state != DS_ATTACHED) 1905 return(0); 1906 1907 if ((error = DEVICE_DETACH(dev)) != 0) 1908 return(error); 1909 devremoved(dev); 1910 device_printf(dev, "detached\n"); 1911 if (dev->parent) 1912 BUS_CHILD_DETACHED(dev->parent, dev); 1913 1914 if (!(dev->flags & DF_FIXEDCLASS)) 1915 devclass_delete_device(dev->devclass, dev); 1916 1917 dev->state = DS_NOTPRESENT; 1918 device_set_driver(dev, NULL); 1919 device_sysctl_fini(dev); 1920 1921 return(0); 1922 } 1923 1924 int 1925 device_shutdown(device_t dev) 1926 { 1927 if (dev->state < DS_ATTACHED) 1928 return 0; 1929 PDEBUG(("%s", DEVICENAME(dev))); 1930 return DEVICE_SHUTDOWN(dev); 1931 } 1932 1933 int 1934 device_set_unit(device_t dev, int unit) 1935 { 1936 devclass_t dc; 1937 int err; 1938 1939 dc = device_get_devclass(dev); 1940 if (unit < dc->maxunit && dc->devices[unit]) 1941 return(EBUSY); 1942 err = devclass_delete_device(dc, dev); 1943 if (err) 1944 return(err); 1945 dev->unit = unit; 1946 err = devclass_add_device(dc, dev); 1947 if (err) 1948 return(err); 1949 1950 bus_data_generation_update(); 1951 return(0); 1952 } 1953 1954 /*======================================*/ 1955 /* 1956 * Access functions for device resources. 1957 */ 1958 1959 /* Supplied by config(8) in ioconf.c */ 1960 extern struct config_device config_devtab[]; 1961 extern int devtab_count; 1962 1963 /* Runtime version */ 1964 struct config_device *devtab = config_devtab; 1965 1966 static int 1967 resource_new_name(const char *name, int unit) 1968 { 1969 struct config_device *new; 1970 1971 new = kmalloc((devtab_count + 1) * sizeof(*new), M_TEMP, 1972 M_INTWAIT | M_ZERO); 1973 if (devtab && devtab_count > 0) 1974 bcopy(devtab, new, devtab_count * sizeof(*new)); 1975 new[devtab_count].name = kmalloc(strlen(name) + 1, M_TEMP, M_INTWAIT); 1976 if (new[devtab_count].name == NULL) { 1977 kfree(new, M_TEMP); 1978 return(-1); 1979 } 1980 strcpy(new[devtab_count].name, name); 1981 new[devtab_count].unit = unit; 1982 new[devtab_count].resource_count = 0; 1983 new[devtab_count].resources = NULL; 1984 if (devtab && devtab != config_devtab) 1985 kfree(devtab, M_TEMP); 1986 devtab = new; 1987 return devtab_count++; 1988 } 1989 1990 static int 1991 resource_new_resname(int j, const char *resname, resource_type type) 1992 { 1993 struct config_resource *new; 1994 int i; 1995 1996 i = devtab[j].resource_count; 1997 new = kmalloc((i + 1) * sizeof(*new), M_TEMP, M_INTWAIT | M_ZERO); 1998 if (devtab[j].resources && i > 0) 1999 bcopy(devtab[j].resources, new, i * sizeof(*new)); 2000 new[i].name = kmalloc(strlen(resname) + 1, M_TEMP, M_INTWAIT); 2001 if (new[i].name == NULL) { 2002 kfree(new, M_TEMP); 2003 return(-1); 2004 } 2005 strcpy(new[i].name, resname); 2006 new[i].type = type; 2007 if (devtab[j].resources) 2008 kfree(devtab[j].resources, M_TEMP); 2009 devtab[j].resources = new; 2010 devtab[j].resource_count = i + 1; 2011 return(i); 2012 } 2013 2014 static int 2015 resource_match_string(int i, const char *resname, const char *value) 2016 { 2017 int j; 2018 struct config_resource *res; 2019 2020 for (j = 0, res = devtab[i].resources; 2021 j < devtab[i].resource_count; j++, res++) 2022 if (!strcmp(res->name, resname) 2023 && res->type == RES_STRING 2024 && !strcmp(res->u.stringval, value)) 2025 return(j); 2026 return(-1); 2027 } 2028 2029 static int 2030 resource_find(const char *name, int unit, const char *resname, 2031 struct config_resource **result) 2032 { 2033 int i, j; 2034 struct config_resource *res; 2035 2036 /* 2037 * First check specific instances, then generic. 2038 */ 2039 for (i = 0; i < devtab_count; i++) { 2040 if (devtab[i].unit < 0) 2041 continue; 2042 if (!strcmp(devtab[i].name, name) && devtab[i].unit == unit) { 2043 res = devtab[i].resources; 2044 for (j = 0; j < devtab[i].resource_count; j++, res++) 2045 if (!strcmp(res->name, resname)) { 2046 *result = res; 2047 return(0); 2048 } 2049 } 2050 } 2051 for (i = 0; i < devtab_count; i++) { 2052 if (devtab[i].unit >= 0) 2053 continue; 2054 /* XXX should this `&& devtab[i].unit == unit' be here? */ 2055 /* XXX if so, then the generic match does nothing */ 2056 if (!strcmp(devtab[i].name, name) && devtab[i].unit == unit) { 2057 res = devtab[i].resources; 2058 for (j = 0; j < devtab[i].resource_count; j++, res++) 2059 if (!strcmp(res->name, resname)) { 2060 *result = res; 2061 return(0); 2062 } 2063 } 2064 } 2065 return(ENOENT); 2066 } 2067 2068 static int 2069 resource_kenv(const char *name, int unit, const char *resname, long *result) 2070 { 2071 const char *env; 2072 char buf[64]; 2073 2074 ksnprintf(buf, sizeof(buf), "%s%d.%s", name, unit, resname); 2075 if ((env = kgetenv(buf)) != NULL) { 2076 *result = strtol(env, NULL, 0); 2077 return(0); 2078 } 2079 return (ENOENT); 2080 } 2081 2082 int 2083 resource_int_value(const char *name, int unit, const char *resname, int *result) 2084 { 2085 struct config_resource *res; 2086 long kvalue = 0; 2087 int error; 2088 2089 if (resource_kenv(name, unit, resname, &kvalue) == 0) { 2090 *result = (int)kvalue; 2091 return 0; 2092 } 2093 if ((error = resource_find(name, unit, resname, &res)) != 0) 2094 return(error); 2095 if (res->type != RES_INT) 2096 return(EFTYPE); 2097 *result = res->u.intval; 2098 return(0); 2099 } 2100 2101 int 2102 resource_long_value(const char *name, int unit, const char *resname, 2103 long *result) 2104 { 2105 struct config_resource *res; 2106 long kvalue; 2107 int error; 2108 2109 if (resource_kenv(name, unit, resname, &kvalue) == 0) { 2110 *result = kvalue; 2111 return 0; 2112 } 2113 if ((error = resource_find(name, unit, resname, &res)) != 0) 2114 return(error); 2115 if (res->type != RES_LONG) 2116 return(EFTYPE); 2117 *result = res->u.longval; 2118 return(0); 2119 } 2120 2121 int 2122 resource_string_value(const char *name, int unit, const char *resname, 2123 const char **result) 2124 { 2125 int error; 2126 struct config_resource *res; 2127 2128 if ((error = resource_find(name, unit, resname, &res)) != 0) 2129 return(error); 2130 if (res->type != RES_STRING) 2131 return(EFTYPE); 2132 *result = res->u.stringval; 2133 return(0); 2134 } 2135 2136 int 2137 resource_query_string(int i, const char *resname, const char *value) 2138 { 2139 if (i < 0) 2140 i = 0; 2141 else 2142 i = i + 1; 2143 for (; i < devtab_count; i++) 2144 if (resource_match_string(i, resname, value) >= 0) 2145 return(i); 2146 return(-1); 2147 } 2148 2149 int 2150 resource_locate(int i, const char *resname) 2151 { 2152 if (i < 0) 2153 i = 0; 2154 else 2155 i = i + 1; 2156 for (; i < devtab_count; i++) 2157 if (!strcmp(devtab[i].name, resname)) 2158 return(i); 2159 return(-1); 2160 } 2161 2162 int 2163 resource_count(void) 2164 { 2165 return(devtab_count); 2166 } 2167 2168 char * 2169 resource_query_name(int i) 2170 { 2171 return(devtab[i].name); 2172 } 2173 2174 int 2175 resource_query_unit(int i) 2176 { 2177 return(devtab[i].unit); 2178 } 2179 2180 static int 2181 resource_create(const char *name, int unit, const char *resname, 2182 resource_type type, struct config_resource **result) 2183 { 2184 int i, j; 2185 struct config_resource *res = NULL; 2186 2187 for (i = 0; i < devtab_count; i++) 2188 if (!strcmp(devtab[i].name, name) && devtab[i].unit == unit) { 2189 res = devtab[i].resources; 2190 break; 2191 } 2192 if (res == NULL) { 2193 i = resource_new_name(name, unit); 2194 if (i < 0) 2195 return(ENOMEM); 2196 res = devtab[i].resources; 2197 } 2198 for (j = 0; j < devtab[i].resource_count; j++, res++) 2199 if (!strcmp(res->name, resname)) { 2200 *result = res; 2201 return(0); 2202 } 2203 j = resource_new_resname(i, resname, type); 2204 if (j < 0) 2205 return(ENOMEM); 2206 res = &devtab[i].resources[j]; 2207 *result = res; 2208 return(0); 2209 } 2210 2211 int 2212 resource_set_int(const char *name, int unit, const char *resname, int value) 2213 { 2214 int error; 2215 struct config_resource *res; 2216 2217 error = resource_create(name, unit, resname, RES_INT, &res); 2218 if (error) 2219 return(error); 2220 if (res->type != RES_INT) 2221 return(EFTYPE); 2222 res->u.intval = value; 2223 return(0); 2224 } 2225 2226 int 2227 resource_set_long(const char *name, int unit, const char *resname, long value) 2228 { 2229 int error; 2230 struct config_resource *res; 2231 2232 error = resource_create(name, unit, resname, RES_LONG, &res); 2233 if (error) 2234 return(error); 2235 if (res->type != RES_LONG) 2236 return(EFTYPE); 2237 res->u.longval = value; 2238 return(0); 2239 } 2240 2241 int 2242 resource_set_string(const char *name, int unit, const char *resname, 2243 const char *value) 2244 { 2245 int error; 2246 struct config_resource *res; 2247 2248 error = resource_create(name, unit, resname, RES_STRING, &res); 2249 if (error) 2250 return(error); 2251 if (res->type != RES_STRING) 2252 return(EFTYPE); 2253 if (res->u.stringval) 2254 kfree(res->u.stringval, M_TEMP); 2255 res->u.stringval = kmalloc(strlen(value) + 1, M_TEMP, M_INTWAIT); 2256 if (res->u.stringval == NULL) 2257 return(ENOMEM); 2258 strcpy(res->u.stringval, value); 2259 return(0); 2260 } 2261 2262 static void 2263 resource_cfgload(void *dummy __unused) 2264 { 2265 struct config_resource *res, *cfgres; 2266 int i, j; 2267 int error; 2268 char *name, *resname; 2269 int unit; 2270 resource_type type; 2271 char *stringval; 2272 int config_devtab_count; 2273 2274 config_devtab_count = devtab_count; 2275 devtab = NULL; 2276 devtab_count = 0; 2277 2278 for (i = 0; i < config_devtab_count; i++) { 2279 name = config_devtab[i].name; 2280 unit = config_devtab[i].unit; 2281 2282 for (j = 0; j < config_devtab[i].resource_count; j++) { 2283 cfgres = config_devtab[i].resources; 2284 resname = cfgres[j].name; 2285 type = cfgres[j].type; 2286 error = resource_create(name, unit, resname, type, 2287 &res); 2288 if (error) { 2289 kprintf("create resource %s%d: error %d\n", 2290 name, unit, error); 2291 continue; 2292 } 2293 if (res->type != type) { 2294 kprintf("type mismatch %s%d: %d != %d\n", 2295 name, unit, res->type, type); 2296 continue; 2297 } 2298 switch (type) { 2299 case RES_INT: 2300 res->u.intval = cfgres[j].u.intval; 2301 break; 2302 case RES_LONG: 2303 res->u.longval = cfgres[j].u.longval; 2304 break; 2305 case RES_STRING: 2306 if (res->u.stringval) 2307 kfree(res->u.stringval, M_TEMP); 2308 stringval = cfgres[j].u.stringval; 2309 res->u.stringval = kmalloc(strlen(stringval) + 1, 2310 M_TEMP, M_INTWAIT); 2311 if (res->u.stringval == NULL) 2312 break; 2313 strcpy(res->u.stringval, stringval); 2314 break; 2315 default: 2316 panic("unknown resource type %d", type); 2317 } 2318 } 2319 } 2320 } 2321 SYSINIT(cfgload, SI_BOOT1_POST, SI_ORDER_ANY + 50, resource_cfgload, 0) 2322 2323 2324 /*======================================*/ 2325 /* 2326 * Some useful method implementations to make life easier for bus drivers. 2327 */ 2328 2329 void 2330 resource_list_init(struct resource_list *rl) 2331 { 2332 SLIST_INIT(rl); 2333 } 2334 2335 void 2336 resource_list_free(struct resource_list *rl) 2337 { 2338 struct resource_list_entry *rle; 2339 2340 while ((rle = SLIST_FIRST(rl)) != NULL) { 2341 if (rle->res) 2342 panic("resource_list_free: resource entry is busy"); 2343 SLIST_REMOVE_HEAD(rl, link); 2344 kfree(rle, M_BUS); 2345 } 2346 } 2347 2348 void 2349 resource_list_add(struct resource_list *rl, int type, int rid, 2350 u_long start, u_long end, u_long count, int cpuid) 2351 { 2352 struct resource_list_entry *rle; 2353 2354 rle = resource_list_find(rl, type, rid); 2355 if (rle == NULL) { 2356 rle = kmalloc(sizeof(struct resource_list_entry), M_BUS, 2357 M_INTWAIT); 2358 SLIST_INSERT_HEAD(rl, rle, link); 2359 rle->type = type; 2360 rle->rid = rid; 2361 rle->res = NULL; 2362 rle->cpuid = -1; 2363 } 2364 2365 if (rle->res) 2366 panic("resource_list_add: resource entry is busy"); 2367 2368 rle->start = start; 2369 rle->end = end; 2370 rle->count = count; 2371 2372 if (cpuid != -1) { 2373 if (rle->cpuid != -1 && rle->cpuid != cpuid) { 2374 panic("resource_list_add: moving from cpu%d -> cpu%d", 2375 rle->cpuid, cpuid); 2376 } 2377 rle->cpuid = cpuid; 2378 } 2379 } 2380 2381 struct resource_list_entry* 2382 resource_list_find(struct resource_list *rl, 2383 int type, int rid) 2384 { 2385 struct resource_list_entry *rle; 2386 2387 SLIST_FOREACH(rle, rl, link) 2388 if (rle->type == type && rle->rid == rid) 2389 return(rle); 2390 return(NULL); 2391 } 2392 2393 void 2394 resource_list_delete(struct resource_list *rl, 2395 int type, int rid) 2396 { 2397 struct resource_list_entry *rle = resource_list_find(rl, type, rid); 2398 2399 if (rle) { 2400 if (rle->res != NULL) 2401 panic("resource_list_delete: resource has not been released"); 2402 SLIST_REMOVE(rl, rle, resource_list_entry, link); 2403 kfree(rle, M_BUS); 2404 } 2405 } 2406 2407 struct resource * 2408 resource_list_alloc(struct resource_list *rl, 2409 device_t bus, device_t child, 2410 int type, int *rid, 2411 u_long start, u_long end, 2412 u_long count, u_int flags, int cpuid) 2413 { 2414 struct resource_list_entry *rle = NULL; 2415 int passthrough = (device_get_parent(child) != bus); 2416 int isdefault = (start == 0UL && end == ~0UL); 2417 2418 if (passthrough) { 2419 return(BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 2420 type, rid, 2421 start, end, count, flags, cpuid)); 2422 } 2423 2424 rle = resource_list_find(rl, type, *rid); 2425 2426 if (!rle) 2427 return(0); /* no resource of that type/rid */ 2428 2429 if (rle->res) 2430 panic("resource_list_alloc: resource entry is busy"); 2431 2432 if (isdefault) { 2433 start = rle->start; 2434 count = max(count, rle->count); 2435 end = max(rle->end, start + count - 1); 2436 } 2437 cpuid = rle->cpuid; 2438 2439 rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 2440 type, rid, start, end, count, 2441 flags, cpuid); 2442 2443 /* 2444 * Record the new range. 2445 */ 2446 if (rle->res) { 2447 rle->start = rman_get_start(rle->res); 2448 rle->end = rman_get_end(rle->res); 2449 rle->count = count; 2450 } 2451 2452 return(rle->res); 2453 } 2454 2455 int 2456 resource_list_release(struct resource_list *rl, 2457 device_t bus, device_t child, 2458 int type, int rid, struct resource *res) 2459 { 2460 struct resource_list_entry *rle = NULL; 2461 int passthrough = (device_get_parent(child) != bus); 2462 int error; 2463 2464 if (passthrough) { 2465 return(BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 2466 type, rid, res)); 2467 } 2468 2469 rle = resource_list_find(rl, type, rid); 2470 2471 if (!rle) 2472 panic("resource_list_release: can't find resource"); 2473 if (!rle->res) 2474 panic("resource_list_release: resource entry is not busy"); 2475 2476 error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 2477 type, rid, res); 2478 if (error) 2479 return(error); 2480 2481 rle->res = NULL; 2482 return(0); 2483 } 2484 2485 int 2486 resource_list_print_type(struct resource_list *rl, const char *name, int type, 2487 const char *format) 2488 { 2489 struct resource_list_entry *rle; 2490 int printed, retval; 2491 2492 printed = 0; 2493 retval = 0; 2494 /* Yes, this is kinda cheating */ 2495 SLIST_FOREACH(rle, rl, link) { 2496 if (rle->type == type) { 2497 if (printed == 0) 2498 retval += kprintf(" %s ", name); 2499 else 2500 retval += kprintf(","); 2501 printed++; 2502 retval += kprintf(format, rle->start); 2503 if (rle->count > 1) { 2504 retval += kprintf("-"); 2505 retval += kprintf(format, rle->start + 2506 rle->count - 1); 2507 } 2508 } 2509 } 2510 return(retval); 2511 } 2512 2513 /* 2514 * Generic driver/device identify functions. These will install a device 2515 * rendezvous point under the parent using the same name as the driver 2516 * name, which will at a later time be probed and attached. 2517 * 2518 * These functions are used when the parent does not 'scan' its bus for 2519 * matching devices, or for the particular devices using these functions, 2520 * or when the device is a pseudo or synthesized device (such as can be 2521 * found under firewire and ppbus). 2522 */ 2523 int 2524 bus_generic_identify(driver_t *driver, device_t parent) 2525 { 2526 if (parent->state == DS_ATTACHED) 2527 return (0); 2528 BUS_ADD_CHILD(parent, parent, 0, driver->name, -1); 2529 return (0); 2530 } 2531 2532 int 2533 bus_generic_identify_sameunit(driver_t *driver, device_t parent) 2534 { 2535 if (parent->state == DS_ATTACHED) 2536 return (0); 2537 BUS_ADD_CHILD(parent, parent, 0, driver->name, device_get_unit(parent)); 2538 return (0); 2539 } 2540 2541 /* 2542 * Call DEVICE_IDENTIFY for each driver. 2543 */ 2544 int 2545 bus_generic_probe(device_t dev) 2546 { 2547 devclass_t dc = dev->devclass; 2548 driverlink_t dl; 2549 2550 TAILQ_FOREACH(dl, &dc->drivers, link) { 2551 DEVICE_IDENTIFY(dl->driver, dev); 2552 } 2553 2554 return(0); 2555 } 2556 2557 /* 2558 * This is an aweful hack due to the isa bus and autoconf code not 2559 * probing the ISA devices until after everything else has configured. 2560 * The ISA bus did a dummy attach long ago so we have to set it back 2561 * to an earlier state so the probe thinks its the initial probe and 2562 * not a bus rescan. 2563 * 2564 * XXX remove by properly defering the ISA bus scan. 2565 */ 2566 int 2567 bus_generic_probe_hack(device_t dev) 2568 { 2569 if (dev->state == DS_ATTACHED) { 2570 dev->state = DS_ALIVE; 2571 bus_generic_probe(dev); 2572 dev->state = DS_ATTACHED; 2573 } 2574 return (0); 2575 } 2576 2577 int 2578 bus_generic_attach(device_t dev) 2579 { 2580 device_t child; 2581 2582 TAILQ_FOREACH(child, &dev->children, link) { 2583 device_probe_and_attach(child); 2584 } 2585 2586 return(0); 2587 } 2588 2589 int 2590 bus_generic_detach(device_t dev) 2591 { 2592 device_t child; 2593 int error; 2594 2595 if (dev->state != DS_ATTACHED) 2596 return(EBUSY); 2597 2598 TAILQ_FOREACH(child, &dev->children, link) 2599 if ((error = device_detach(child)) != 0) 2600 return(error); 2601 2602 return 0; 2603 } 2604 2605 int 2606 bus_generic_shutdown(device_t dev) 2607 { 2608 device_t child; 2609 2610 TAILQ_FOREACH(child, &dev->children, link) 2611 device_shutdown(child); 2612 2613 return(0); 2614 } 2615 2616 int 2617 bus_generic_suspend(device_t dev) 2618 { 2619 int error; 2620 device_t child, child2; 2621 2622 TAILQ_FOREACH(child, &dev->children, link) { 2623 error = DEVICE_SUSPEND(child); 2624 if (error) { 2625 for (child2 = TAILQ_FIRST(&dev->children); 2626 child2 && child2 != child; 2627 child2 = TAILQ_NEXT(child2, link)) 2628 DEVICE_RESUME(child2); 2629 return(error); 2630 } 2631 } 2632 return(0); 2633 } 2634 2635 int 2636 bus_generic_resume(device_t dev) 2637 { 2638 device_t child; 2639 2640 TAILQ_FOREACH(child, &dev->children, link) 2641 DEVICE_RESUME(child); 2642 /* if resume fails, there's nothing we can usefully do... */ 2643 2644 return(0); 2645 } 2646 2647 int 2648 bus_print_child_header(device_t dev, device_t child) 2649 { 2650 int retval = 0; 2651 2652 if (device_get_desc(child)) 2653 retval += device_printf(child, "<%s>", device_get_desc(child)); 2654 else 2655 retval += kprintf("%s", device_get_nameunit(child)); 2656 if (bootverbose) { 2657 if (child->state != DS_ATTACHED) 2658 kprintf(" [tentative]"); 2659 else 2660 kprintf(" [attached!]"); 2661 } 2662 return(retval); 2663 } 2664 2665 int 2666 bus_print_child_footer(device_t dev, device_t child) 2667 { 2668 return(kprintf(" on %s\n", device_get_nameunit(dev))); 2669 } 2670 2671 device_t 2672 bus_generic_add_child(device_t dev, device_t child, int order, 2673 const char *name, int unit) 2674 { 2675 if (dev->parent) 2676 dev = BUS_ADD_CHILD(dev->parent, child, order, name, unit); 2677 else 2678 dev = device_add_child_ordered(child, order, name, unit); 2679 return(dev); 2680 2681 } 2682 2683 int 2684 bus_generic_print_child(device_t dev, device_t child) 2685 { 2686 int retval = 0; 2687 2688 retval += bus_print_child_header(dev, child); 2689 retval += bus_print_child_footer(dev, child); 2690 2691 return(retval); 2692 } 2693 2694 int 2695 bus_generic_read_ivar(device_t dev, device_t child, int index, 2696 uintptr_t * result) 2697 { 2698 int error; 2699 2700 if (dev->parent) 2701 error = BUS_READ_IVAR(dev->parent, child, index, result); 2702 else 2703 error = ENOENT; 2704 return (error); 2705 } 2706 2707 int 2708 bus_generic_write_ivar(device_t dev, device_t child, int index, 2709 uintptr_t value) 2710 { 2711 int error; 2712 2713 if (dev->parent) 2714 error = BUS_WRITE_IVAR(dev->parent, child, index, value); 2715 else 2716 error = ENOENT; 2717 return (error); 2718 } 2719 2720 /* 2721 * Resource list are used for iterations, do not recurse. 2722 */ 2723 struct resource_list * 2724 bus_generic_get_resource_list(device_t dev, device_t child) 2725 { 2726 return (NULL); 2727 } 2728 2729 void 2730 bus_generic_driver_added(device_t dev, driver_t *driver) 2731 { 2732 device_t child; 2733 2734 DEVICE_IDENTIFY(driver, dev); 2735 TAILQ_FOREACH(child, &dev->children, link) { 2736 if (child->state == DS_NOTPRESENT) 2737 device_probe_and_attach(child); 2738 } 2739 } 2740 2741 int 2742 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq, 2743 int flags, driver_intr_t *intr, void *arg, void **cookiep, 2744 lwkt_serialize_t serializer, const char *desc) 2745 { 2746 /* Propagate up the bus hierarchy until someone handles it. */ 2747 if (dev->parent) { 2748 return BUS_SETUP_INTR(dev->parent, child, irq, flags, 2749 intr, arg, cookiep, serializer, desc); 2750 } else { 2751 return EINVAL; 2752 } 2753 } 2754 2755 int 2756 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq, 2757 void *cookie) 2758 { 2759 /* Propagate up the bus hierarchy until someone handles it. */ 2760 if (dev->parent) 2761 return(BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie)); 2762 else 2763 return(EINVAL); 2764 } 2765 2766 int 2767 bus_generic_disable_intr(device_t dev, device_t child, void *cookie) 2768 { 2769 if (dev->parent) 2770 return(BUS_DISABLE_INTR(dev->parent, child, cookie)); 2771 else 2772 return(0); 2773 } 2774 2775 void 2776 bus_generic_enable_intr(device_t dev, device_t child, void *cookie) 2777 { 2778 if (dev->parent) 2779 BUS_ENABLE_INTR(dev->parent, child, cookie); 2780 } 2781 2782 int 2783 bus_generic_config_intr(device_t dev, device_t child, int irq, enum intr_trigger trig, 2784 enum intr_polarity pol) 2785 { 2786 /* Propagate up the bus hierarchy until someone handles it. */ 2787 if (dev->parent) 2788 return(BUS_CONFIG_INTR(dev->parent, child, irq, trig, pol)); 2789 else 2790 return(EINVAL); 2791 } 2792 2793 struct resource * 2794 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid, 2795 u_long start, u_long end, u_long count, u_int flags, int cpuid) 2796 { 2797 /* Propagate up the bus hierarchy until someone handles it. */ 2798 if (dev->parent) 2799 return(BUS_ALLOC_RESOURCE(dev->parent, child, type, rid, 2800 start, end, count, flags, cpuid)); 2801 else 2802 return(NULL); 2803 } 2804 2805 int 2806 bus_generic_release_resource(device_t dev, device_t child, int type, int rid, 2807 struct resource *r) 2808 { 2809 /* Propagate up the bus hierarchy until someone handles it. */ 2810 if (dev->parent) 2811 return(BUS_RELEASE_RESOURCE(dev->parent, child, type, rid, r)); 2812 else 2813 return(EINVAL); 2814 } 2815 2816 int 2817 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid, 2818 struct resource *r) 2819 { 2820 /* Propagate up the bus hierarchy until someone handles it. */ 2821 if (dev->parent) 2822 return(BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid, r)); 2823 else 2824 return(EINVAL); 2825 } 2826 2827 int 2828 bus_generic_deactivate_resource(device_t dev, device_t child, int type, 2829 int rid, struct resource *r) 2830 { 2831 /* Propagate up the bus hierarchy until someone handles it. */ 2832 if (dev->parent) 2833 return(BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid, 2834 r)); 2835 else 2836 return(EINVAL); 2837 } 2838 2839 int 2840 bus_generic_get_resource(device_t dev, device_t child, int type, int rid, 2841 u_long *startp, u_long *countp) 2842 { 2843 int error; 2844 2845 error = ENOENT; 2846 if (dev->parent) { 2847 error = BUS_GET_RESOURCE(dev->parent, child, type, rid, 2848 startp, countp); 2849 } 2850 return (error); 2851 } 2852 2853 int 2854 bus_generic_set_resource(device_t dev, device_t child, int type, int rid, 2855 u_long start, u_long count, int cpuid) 2856 { 2857 int error; 2858 2859 error = EINVAL; 2860 if (dev->parent) { 2861 error = BUS_SET_RESOURCE(dev->parent, child, type, rid, 2862 start, count, cpuid); 2863 } 2864 return (error); 2865 } 2866 2867 void 2868 bus_generic_delete_resource(device_t dev, device_t child, int type, int rid) 2869 { 2870 if (dev->parent) 2871 BUS_DELETE_RESOURCE(dev, child, type, rid); 2872 } 2873 2874 /** 2875 * @brief Helper function for implementing BUS_GET_DMA_TAG(). 2876 * 2877 * This simple implementation of BUS_GET_DMA_TAG() simply calls the 2878 * BUS_GET_DMA_TAG() method of the parent of @p dev. 2879 */ 2880 bus_dma_tag_t 2881 bus_generic_get_dma_tag(device_t dev, device_t child) 2882 { 2883 2884 /* Propagate up the bus hierarchy until someone handles it. */ 2885 if (dev->parent != NULL) 2886 return (BUS_GET_DMA_TAG(dev->parent, child)); 2887 return (NULL); 2888 } 2889 2890 int 2891 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid, 2892 u_long *startp, u_long *countp) 2893 { 2894 struct resource_list *rl = NULL; 2895 struct resource_list_entry *rle = NULL; 2896 2897 rl = BUS_GET_RESOURCE_LIST(dev, child); 2898 if (!rl) 2899 return(EINVAL); 2900 2901 rle = resource_list_find(rl, type, rid); 2902 if (!rle) 2903 return(ENOENT); 2904 2905 if (startp) 2906 *startp = rle->start; 2907 if (countp) 2908 *countp = rle->count; 2909 2910 return(0); 2911 } 2912 2913 int 2914 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid, 2915 u_long start, u_long count, int cpuid) 2916 { 2917 struct resource_list *rl = NULL; 2918 2919 rl = BUS_GET_RESOURCE_LIST(dev, child); 2920 if (!rl) 2921 return(EINVAL); 2922 2923 resource_list_add(rl, type, rid, start, (start + count - 1), count, 2924 cpuid); 2925 2926 return(0); 2927 } 2928 2929 void 2930 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid) 2931 { 2932 struct resource_list *rl = NULL; 2933 2934 rl = BUS_GET_RESOURCE_LIST(dev, child); 2935 if (!rl) 2936 return; 2937 2938 resource_list_delete(rl, type, rid); 2939 } 2940 2941 int 2942 bus_generic_rl_release_resource(device_t dev, device_t child, int type, 2943 int rid, struct resource *r) 2944 { 2945 struct resource_list *rl = NULL; 2946 2947 rl = BUS_GET_RESOURCE_LIST(dev, child); 2948 if (!rl) 2949 return(EINVAL); 2950 2951 return(resource_list_release(rl, dev, child, type, rid, r)); 2952 } 2953 2954 struct resource * 2955 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type, 2956 int *rid, u_long start, u_long end, u_long count, u_int flags, int cpuid) 2957 { 2958 struct resource_list *rl = NULL; 2959 2960 rl = BUS_GET_RESOURCE_LIST(dev, child); 2961 if (!rl) 2962 return(NULL); 2963 2964 return(resource_list_alloc(rl, dev, child, type, rid, 2965 start, end, count, flags, cpuid)); 2966 } 2967 2968 int 2969 bus_generic_child_present(device_t bus, device_t child) 2970 { 2971 return(BUS_CHILD_PRESENT(device_get_parent(bus), bus)); 2972 } 2973 2974 2975 /* 2976 * Some convenience functions to make it easier for drivers to use the 2977 * resource-management functions. All these really do is hide the 2978 * indirection through the parent's method table, making for slightly 2979 * less-wordy code. In the future, it might make sense for this code 2980 * to maintain some sort of a list of resources allocated by each device. 2981 */ 2982 int 2983 bus_alloc_resources(device_t dev, struct resource_spec *rs, 2984 struct resource **res) 2985 { 2986 int i; 2987 2988 for (i = 0; rs[i].type != -1; i++) 2989 res[i] = NULL; 2990 for (i = 0; rs[i].type != -1; i++) { 2991 res[i] = bus_alloc_resource_any(dev, 2992 rs[i].type, &rs[i].rid, rs[i].flags); 2993 if (res[i] == NULL) { 2994 bus_release_resources(dev, rs, res); 2995 return (ENXIO); 2996 } 2997 } 2998 return (0); 2999 } 3000 3001 void 3002 bus_release_resources(device_t dev, const struct resource_spec *rs, 3003 struct resource **res) 3004 { 3005 int i; 3006 3007 for (i = 0; rs[i].type != -1; i++) 3008 if (res[i] != NULL) { 3009 bus_release_resource( 3010 dev, rs[i].type, rs[i].rid, res[i]); 3011 res[i] = NULL; 3012 } 3013 } 3014 3015 struct resource * 3016 bus_alloc_resource(device_t dev, int type, int *rid, u_long start, u_long end, 3017 u_long count, u_int flags) 3018 { 3019 if (dev->parent == NULL) 3020 return(0); 3021 return(BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end, 3022 count, flags, -1)); 3023 } 3024 3025 struct resource * 3026 bus_alloc_legacy_irq_resource(device_t dev, int *rid, u_long irq, u_int flags) 3027 { 3028 if (dev->parent == NULL) 3029 return(0); 3030 return BUS_ALLOC_RESOURCE(dev->parent, dev, SYS_RES_IRQ, rid, 3031 irq, irq, 1, flags, machintr_legacy_intr_cpuid(irq)); 3032 } 3033 3034 int 3035 bus_activate_resource(device_t dev, int type, int rid, struct resource *r) 3036 { 3037 if (dev->parent == NULL) 3038 return(EINVAL); 3039 return(BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 3040 } 3041 3042 int 3043 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r) 3044 { 3045 if (dev->parent == NULL) 3046 return(EINVAL); 3047 return(BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 3048 } 3049 3050 int 3051 bus_release_resource(device_t dev, int type, int rid, struct resource *r) 3052 { 3053 if (dev->parent == NULL) 3054 return(EINVAL); 3055 return(BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r)); 3056 } 3057 3058 int 3059 bus_setup_intr_descr(device_t dev, struct resource *r, int flags, 3060 driver_intr_t handler, void *arg, void **cookiep, 3061 lwkt_serialize_t serializer, const char *desc) 3062 { 3063 if (dev->parent == NULL) 3064 return EINVAL; 3065 return BUS_SETUP_INTR(dev->parent, dev, r, flags, handler, arg, 3066 cookiep, serializer, desc); 3067 } 3068 3069 int 3070 bus_setup_intr(device_t dev, struct resource *r, int flags, 3071 driver_intr_t handler, void *arg, void **cookiep, 3072 lwkt_serialize_t serializer) 3073 { 3074 return bus_setup_intr_descr(dev, r, flags, handler, arg, cookiep, 3075 serializer, NULL); 3076 } 3077 3078 int 3079 bus_teardown_intr(device_t dev, struct resource *r, void *cookie) 3080 { 3081 if (dev->parent == NULL) 3082 return(EINVAL); 3083 return(BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie)); 3084 } 3085 3086 void 3087 bus_enable_intr(device_t dev, void *cookie) 3088 { 3089 if (dev->parent) 3090 BUS_ENABLE_INTR(dev->parent, dev, cookie); 3091 } 3092 3093 int 3094 bus_disable_intr(device_t dev, void *cookie) 3095 { 3096 if (dev->parent) 3097 return(BUS_DISABLE_INTR(dev->parent, dev, cookie)); 3098 else 3099 return(0); 3100 } 3101 3102 int 3103 bus_set_resource(device_t dev, int type, int rid, 3104 u_long start, u_long count, int cpuid) 3105 { 3106 return(BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid, 3107 start, count, cpuid)); 3108 } 3109 3110 int 3111 bus_get_resource(device_t dev, int type, int rid, 3112 u_long *startp, u_long *countp) 3113 { 3114 return(BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 3115 startp, countp)); 3116 } 3117 3118 u_long 3119 bus_get_resource_start(device_t dev, int type, int rid) 3120 { 3121 u_long start, count; 3122 int error; 3123 3124 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 3125 &start, &count); 3126 if (error) 3127 return(0); 3128 return(start); 3129 } 3130 3131 u_long 3132 bus_get_resource_count(device_t dev, int type, int rid) 3133 { 3134 u_long start, count; 3135 int error; 3136 3137 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 3138 &start, &count); 3139 if (error) 3140 return(0); 3141 return(count); 3142 } 3143 3144 void 3145 bus_delete_resource(device_t dev, int type, int rid) 3146 { 3147 BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid); 3148 } 3149 3150 int 3151 bus_child_present(device_t child) 3152 { 3153 return (BUS_CHILD_PRESENT(device_get_parent(child), child)); 3154 } 3155 3156 int 3157 bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen) 3158 { 3159 device_t parent; 3160 3161 parent = device_get_parent(child); 3162 if (parent == NULL) { 3163 *buf = '\0'; 3164 return (0); 3165 } 3166 return (BUS_CHILD_PNPINFO_STR(parent, child, buf, buflen)); 3167 } 3168 3169 int 3170 bus_child_location_str(device_t child, char *buf, size_t buflen) 3171 { 3172 device_t parent; 3173 3174 parent = device_get_parent(child); 3175 if (parent == NULL) { 3176 *buf = '\0'; 3177 return (0); 3178 } 3179 return (BUS_CHILD_LOCATION_STR(parent, child, buf, buflen)); 3180 } 3181 3182 /** 3183 * @brief Wrapper function for BUS_GET_DMA_TAG(). 3184 * 3185 * This function simply calls the BUS_GET_DMA_TAG() method of the 3186 * parent of @p dev. 3187 */ 3188 bus_dma_tag_t 3189 bus_get_dma_tag(device_t dev) 3190 { 3191 device_t parent; 3192 3193 parent = device_get_parent(dev); 3194 if (parent == NULL) 3195 return (NULL); 3196 return (BUS_GET_DMA_TAG(parent, dev)); 3197 } 3198 3199 static int 3200 root_print_child(device_t dev, device_t child) 3201 { 3202 return(0); 3203 } 3204 3205 static int 3206 root_setup_intr(device_t dev, device_t child, driver_intr_t *intr, void *arg, 3207 void **cookiep, lwkt_serialize_t serializer, const char *desc) 3208 { 3209 /* 3210 * If an interrupt mapping gets to here something bad has happened. 3211 */ 3212 panic("root_setup_intr"); 3213 } 3214 3215 /* 3216 * If we get here, assume that the device is permanant and really is 3217 * present in the system. Removable bus drivers are expected to intercept 3218 * this call long before it gets here. We return -1 so that drivers that 3219 * really care can check vs -1 or some ERRNO returned higher in the food 3220 * chain. 3221 */ 3222 static int 3223 root_child_present(device_t dev, device_t child) 3224 { 3225 return(-1); 3226 } 3227 3228 /* 3229 * XXX NOTE! other defaults may be set in bus_if.m 3230 */ 3231 static kobj_method_t root_methods[] = { 3232 /* Device interface */ 3233 KOBJMETHOD(device_shutdown, bus_generic_shutdown), 3234 KOBJMETHOD(device_suspend, bus_generic_suspend), 3235 KOBJMETHOD(device_resume, bus_generic_resume), 3236 3237 /* Bus interface */ 3238 KOBJMETHOD(bus_add_child, bus_generic_add_child), 3239 KOBJMETHOD(bus_print_child, root_print_child), 3240 KOBJMETHOD(bus_read_ivar, bus_generic_read_ivar), 3241 KOBJMETHOD(bus_write_ivar, bus_generic_write_ivar), 3242 KOBJMETHOD(bus_setup_intr, root_setup_intr), 3243 KOBJMETHOD(bus_child_present, root_child_present), 3244 3245 KOBJMETHOD_END 3246 }; 3247 3248 static driver_t root_driver = { 3249 "root", 3250 root_methods, 3251 1, /* no softc */ 3252 }; 3253 3254 device_t root_bus; 3255 devclass_t root_devclass; 3256 3257 static int 3258 root_bus_module_handler(module_t mod, int what, void* arg) 3259 { 3260 switch (what) { 3261 case MOD_LOAD: 3262 TAILQ_INIT(&bus_data_devices); 3263 root_bus = make_device(NULL, "root", 0); 3264 root_bus->desc = "System root bus"; 3265 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver); 3266 root_bus->driver = &root_driver; 3267 root_bus->state = DS_ALIVE; 3268 root_devclass = devclass_find_internal("root", NULL, FALSE); 3269 devinit(); 3270 return(0); 3271 3272 case MOD_SHUTDOWN: 3273 device_shutdown(root_bus); 3274 return(0); 3275 default: 3276 return(0); 3277 } 3278 } 3279 3280 static moduledata_t root_bus_mod = { 3281 "rootbus", 3282 root_bus_module_handler, 3283 0 3284 }; 3285 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 3286 3287 void 3288 root_bus_configure(void) 3289 { 3290 int warncount; 3291 device_t dev; 3292 3293 PDEBUG((".")); 3294 3295 /* 3296 * handle device_identify based device attachments to the root_bus 3297 * (typically nexus). 3298 */ 3299 bus_generic_probe(root_bus); 3300 3301 /* 3302 * Probe and attach the devices under root_bus. 3303 */ 3304 TAILQ_FOREACH(dev, &root_bus->children, link) { 3305 device_probe_and_attach(dev); 3306 } 3307 3308 /* 3309 * Wait for all asynchronous attaches to complete. If we don't 3310 * our legacy ISA bus scan could steal device unit numbers or 3311 * even I/O ports. 3312 */ 3313 warncount = 10; 3314 if (numasyncthreads) 3315 kprintf("Waiting for async drivers to attach\n"); 3316 while (numasyncthreads > 0) { 3317 if (tsleep(&numasyncthreads, 0, "rootbus", hz) == EWOULDBLOCK) 3318 --warncount; 3319 if (warncount == 0) { 3320 kprintf("Warning: Still waiting for %d " 3321 "drivers to attach\n", numasyncthreads); 3322 } else if (warncount == -30) { 3323 kprintf("Giving up on %d drivers\n", numasyncthreads); 3324 break; 3325 } 3326 } 3327 root_bus->state = DS_ATTACHED; 3328 } 3329 3330 int 3331 driver_module_handler(module_t mod, int what, void *arg) 3332 { 3333 int error; 3334 struct driver_module_data *dmd; 3335 devclass_t bus_devclass; 3336 kobj_class_t driver; 3337 const char *parentname; 3338 3339 dmd = (struct driver_module_data *)arg; 3340 bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE); 3341 error = 0; 3342 3343 switch (what) { 3344 case MOD_LOAD: 3345 if (dmd->dmd_chainevh) 3346 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 3347 3348 driver = dmd->dmd_driver; 3349 PDEBUG(("Loading module: driver %s on bus %s", 3350 DRIVERNAME(driver), dmd->dmd_busname)); 3351 3352 /* 3353 * If the driver has any base classes, make the 3354 * devclass inherit from the devclass of the driver's 3355 * first base class. This will allow the system to 3356 * search for drivers in both devclasses for children 3357 * of a device using this driver. 3358 */ 3359 if (driver->baseclasses) 3360 parentname = driver->baseclasses[0]->name; 3361 else 3362 parentname = NULL; 3363 *dmd->dmd_devclass = devclass_find_internal(driver->name, 3364 parentname, TRUE); 3365 3366 error = devclass_add_driver(bus_devclass, driver); 3367 if (error) 3368 break; 3369 break; 3370 3371 case MOD_UNLOAD: 3372 PDEBUG(("Unloading module: driver %s from bus %s", 3373 DRIVERNAME(dmd->dmd_driver), dmd->dmd_busname)); 3374 error = devclass_delete_driver(bus_devclass, dmd->dmd_driver); 3375 3376 if (!error && dmd->dmd_chainevh) 3377 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 3378 break; 3379 } 3380 3381 return (error); 3382 } 3383 3384 #ifdef BUS_DEBUG 3385 3386 /* 3387 * The _short versions avoid iteration by not calling anything that prints 3388 * more than oneliners. I love oneliners. 3389 */ 3390 3391 static void 3392 print_device_short(device_t dev, int indent) 3393 { 3394 if (!dev) 3395 return; 3396 3397 indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s,%sivars,%ssoftc,busy=%d\n", 3398 dev->unit, dev->desc, 3399 (dev->parent? "":"no "), 3400 (TAILQ_EMPTY(&dev->children)? "no ":""), 3401 (dev->flags&DF_ENABLED? "enabled,":"disabled,"), 3402 (dev->flags&DF_FIXEDCLASS? "fixed,":""), 3403 (dev->flags&DF_WILDCARD? "wildcard,":""), 3404 (dev->flags&DF_DESCMALLOCED? "descmalloced,":""), 3405 (dev->ivars? "":"no "), 3406 (dev->softc? "":"no "), 3407 dev->busy)); 3408 } 3409 3410 static void 3411 print_device(device_t dev, int indent) 3412 { 3413 if (!dev) 3414 return; 3415 3416 print_device_short(dev, indent); 3417 3418 indentprintf(("Parent:\n")); 3419 print_device_short(dev->parent, indent+1); 3420 indentprintf(("Driver:\n")); 3421 print_driver_short(dev->driver, indent+1); 3422 indentprintf(("Devclass:\n")); 3423 print_devclass_short(dev->devclass, indent+1); 3424 } 3425 3426 /* 3427 * Print the device and all its children (indented). 3428 */ 3429 void 3430 print_device_tree_short(device_t dev, int indent) 3431 { 3432 device_t child; 3433 3434 if (!dev) 3435 return; 3436 3437 print_device_short(dev, indent); 3438 3439 TAILQ_FOREACH(child, &dev->children, link) 3440 print_device_tree_short(child, indent+1); 3441 } 3442 3443 /* 3444 * Print the device and all its children (indented). 3445 */ 3446 void 3447 print_device_tree(device_t dev, int indent) 3448 { 3449 device_t child; 3450 3451 if (!dev) 3452 return; 3453 3454 print_device(dev, indent); 3455 3456 TAILQ_FOREACH(child, &dev->children, link) 3457 print_device_tree(child, indent+1); 3458 } 3459 3460 static void 3461 print_driver_short(driver_t *driver, int indent) 3462 { 3463 if (!driver) 3464 return; 3465 3466 indentprintf(("driver %s: softc size = %zu\n", 3467 driver->name, driver->size)); 3468 } 3469 3470 static void 3471 print_driver(driver_t *driver, int indent) 3472 { 3473 if (!driver) 3474 return; 3475 3476 print_driver_short(driver, indent); 3477 } 3478 3479 3480 static void 3481 print_driver_list(driver_list_t drivers, int indent) 3482 { 3483 driverlink_t driver; 3484 3485 TAILQ_FOREACH(driver, &drivers, link) 3486 print_driver(driver->driver, indent); 3487 } 3488 3489 static void 3490 print_devclass_short(devclass_t dc, int indent) 3491 { 3492 if (!dc) 3493 return; 3494 3495 indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit)); 3496 } 3497 3498 static void 3499 print_devclass(devclass_t dc, int indent) 3500 { 3501 int i; 3502 3503 if (!dc) 3504 return; 3505 3506 print_devclass_short(dc, indent); 3507 indentprintf(("Drivers:\n")); 3508 print_driver_list(dc->drivers, indent+1); 3509 3510 indentprintf(("Devices:\n")); 3511 for (i = 0; i < dc->maxunit; i++) 3512 if (dc->devices[i]) 3513 print_device(dc->devices[i], indent+1); 3514 } 3515 3516 void 3517 print_devclass_list_short(void) 3518 { 3519 devclass_t dc; 3520 3521 kprintf("Short listing of devclasses, drivers & devices:\n"); 3522 TAILQ_FOREACH(dc, &devclasses, link) { 3523 print_devclass_short(dc, 0); 3524 } 3525 } 3526 3527 void 3528 print_devclass_list(void) 3529 { 3530 devclass_t dc; 3531 3532 kprintf("Full listing of devclasses, drivers & devices:\n"); 3533 TAILQ_FOREACH(dc, &devclasses, link) { 3534 print_devclass(dc, 0); 3535 } 3536 } 3537 3538 #endif 3539 3540 /* 3541 * Check to see if a device is disabled via a disabled hint. 3542 */ 3543 int 3544 resource_disabled(const char *name, int unit) 3545 { 3546 int error, value; 3547 3548 error = resource_int_value(name, unit, "disabled", &value); 3549 if (error) 3550 return(0); 3551 return(value); 3552 } 3553 3554 /* 3555 * User-space access to the device tree. 3556 * 3557 * We implement a small set of nodes: 3558 * 3559 * hw.bus Single integer read method to obtain the 3560 * current generation count. 3561 * hw.bus.devices Reads the entire device tree in flat space. 3562 * hw.bus.rman Resource manager interface 3563 * 3564 * We might like to add the ability to scan devclasses and/or drivers to 3565 * determine what else is currently loaded/available. 3566 */ 3567 3568 static int 3569 sysctl_bus(SYSCTL_HANDLER_ARGS) 3570 { 3571 struct u_businfo ubus; 3572 3573 ubus.ub_version = BUS_USER_VERSION; 3574 ubus.ub_generation = bus_data_generation; 3575 3576 return (SYSCTL_OUT(req, &ubus, sizeof(ubus))); 3577 } 3578 SYSCTL_NODE(_hw_bus, OID_AUTO, info, CTLFLAG_RW, sysctl_bus, 3579 "bus-related data"); 3580 3581 static int 3582 sysctl_devices(SYSCTL_HANDLER_ARGS) 3583 { 3584 int *name = (int *)arg1; 3585 u_int namelen = arg2; 3586 int index; 3587 struct device *dev; 3588 struct u_device udev; /* XXX this is a bit big */ 3589 int error; 3590 3591 if (namelen != 2) 3592 return (EINVAL); 3593 3594 if (bus_data_generation_check(name[0])) 3595 return (EINVAL); 3596 3597 index = name[1]; 3598 3599 /* 3600 * Scan the list of devices, looking for the requested index. 3601 */ 3602 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 3603 if (index-- == 0) 3604 break; 3605 } 3606 if (dev == NULL) 3607 return (ENOENT); 3608 3609 /* 3610 * Populate the return array. 3611 */ 3612 bzero(&udev, sizeof(udev)); 3613 udev.dv_handle = (uintptr_t)dev; 3614 udev.dv_parent = (uintptr_t)dev->parent; 3615 if (dev->nameunit != NULL) 3616 strlcpy(udev.dv_name, dev->nameunit, sizeof(udev.dv_name)); 3617 if (dev->desc != NULL) 3618 strlcpy(udev.dv_desc, dev->desc, sizeof(udev.dv_desc)); 3619 if (dev->driver != NULL && dev->driver->name != NULL) 3620 strlcpy(udev.dv_drivername, dev->driver->name, 3621 sizeof(udev.dv_drivername)); 3622 bus_child_pnpinfo_str(dev, udev.dv_pnpinfo, sizeof(udev.dv_pnpinfo)); 3623 bus_child_location_str(dev, udev.dv_location, sizeof(udev.dv_location)); 3624 udev.dv_devflags = dev->devflags; 3625 udev.dv_flags = dev->flags; 3626 udev.dv_state = dev->state; 3627 error = SYSCTL_OUT(req, &udev, sizeof(udev)); 3628 return (error); 3629 } 3630 3631 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, CTLFLAG_RD, sysctl_devices, 3632 "system device tree"); 3633 3634 int 3635 bus_data_generation_check(int generation) 3636 { 3637 if (generation != bus_data_generation) 3638 return (1); 3639 3640 /* XXX generate optimised lists here? */ 3641 return (0); 3642 } 3643 3644 void 3645 bus_data_generation_update(void) 3646 { 3647 bus_data_generation++; 3648 } 3649 3650 const char * 3651 intr_str_polarity(enum intr_polarity pola) 3652 { 3653 switch (pola) { 3654 case INTR_POLARITY_LOW: 3655 return "low"; 3656 3657 case INTR_POLARITY_HIGH: 3658 return "high"; 3659 3660 case INTR_POLARITY_CONFORM: 3661 return "conform"; 3662 } 3663 return "unknown"; 3664 } 3665 3666 const char * 3667 intr_str_trigger(enum intr_trigger trig) 3668 { 3669 switch (trig) { 3670 case INTR_TRIGGER_EDGE: 3671 return "edge"; 3672 3673 case INTR_TRIGGER_LEVEL: 3674 return "level"; 3675 3676 case INTR_TRIGGER_CONFORM: 3677 return "conform"; 3678 } 3679 return "unknown"; 3680 } 3681 3682 int 3683 device_getenv_int(device_t dev, const char *knob, int def) 3684 { 3685 char env[128]; 3686 3687 ksnprintf(env, sizeof(env), "hw.%s.%s", device_get_nameunit(dev), knob); 3688 kgetenv_int(env, &def); 3689 return def; 3690 } 3691