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