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 /* 2088 * DragonFly style loader.conf hinting 2089 */ 2090 ksnprintf(buf, sizeof(buf), "%s%d.%s", name, unit, resname); 2091 if ((env = kgetenv(buf)) != NULL) { 2092 *result = strtol(env, NULL, 0); 2093 return(0); 2094 } 2095 2096 /* 2097 * Also support FreeBSD style loader.conf hinting 2098 */ 2099 ksnprintf(buf, sizeof(buf), "hint.%s.%d.%s", name, unit, resname); 2100 if ((env = kgetenv(buf)) != NULL) { 2101 *result = strtol(env, NULL, 0); 2102 return(0); 2103 } 2104 2105 return (ENOENT); 2106 } 2107 2108 int 2109 resource_int_value(const char *name, int unit, const char *resname, int *result) 2110 { 2111 struct config_resource *res; 2112 long kvalue = 0; 2113 int error; 2114 2115 if (resource_kenv(name, unit, resname, &kvalue) == 0) { 2116 *result = (int)kvalue; 2117 return 0; 2118 } 2119 if ((error = resource_find(name, unit, resname, &res)) != 0) 2120 return(error); 2121 if (res->type != RES_INT) 2122 return(EFTYPE); 2123 *result = res->u.intval; 2124 return(0); 2125 } 2126 2127 int 2128 resource_long_value(const char *name, int unit, const char *resname, 2129 long *result) 2130 { 2131 struct config_resource *res; 2132 long kvalue; 2133 int error; 2134 2135 if (resource_kenv(name, unit, resname, &kvalue) == 0) { 2136 *result = kvalue; 2137 return 0; 2138 } 2139 if ((error = resource_find(name, unit, resname, &res)) != 0) 2140 return(error); 2141 if (res->type != RES_LONG) 2142 return(EFTYPE); 2143 *result = res->u.longval; 2144 return(0); 2145 } 2146 2147 int 2148 resource_string_value(const char *name, int unit, const char *resname, 2149 const char **result) 2150 { 2151 int error; 2152 struct config_resource *res; 2153 char buf[64]; 2154 const char *env; 2155 2156 /* 2157 * DragonFly style loader.conf hinting 2158 */ 2159 ksnprintf(buf, sizeof(buf), "%s%d.%s", name, unit, resname); 2160 if ((env = kgetenv(buf)) != NULL) { 2161 *result = env; 2162 return 0; 2163 } 2164 2165 /* 2166 * Also support FreeBSD style loader.conf hinting 2167 */ 2168 ksnprintf(buf, sizeof(buf), "hint.%s.%d.%s", name, unit, resname); 2169 if ((env = kgetenv(buf)) != NULL) { 2170 *result = env; 2171 return 0; 2172 } 2173 2174 if ((error = resource_find(name, unit, resname, &res)) != 0) 2175 return(error); 2176 if (res->type != RES_STRING) 2177 return(EFTYPE); 2178 *result = res->u.stringval; 2179 return(0); 2180 } 2181 2182 int 2183 resource_query_string(int i, const char *resname, const char *value) 2184 { 2185 if (i < 0) 2186 i = 0; 2187 else 2188 i = i + 1; 2189 for (; i < devtab_count; i++) 2190 if (resource_match_string(i, resname, value) >= 0) 2191 return(i); 2192 return(-1); 2193 } 2194 2195 int 2196 resource_locate(int i, const char *resname) 2197 { 2198 if (i < 0) 2199 i = 0; 2200 else 2201 i = i + 1; 2202 for (; i < devtab_count; i++) 2203 if (!strcmp(devtab[i].name, resname)) 2204 return(i); 2205 return(-1); 2206 } 2207 2208 int 2209 resource_count(void) 2210 { 2211 return(devtab_count); 2212 } 2213 2214 char * 2215 resource_query_name(int i) 2216 { 2217 return(devtab[i].name); 2218 } 2219 2220 int 2221 resource_query_unit(int i) 2222 { 2223 return(devtab[i].unit); 2224 } 2225 2226 static int 2227 resource_create(const char *name, int unit, const char *resname, 2228 resource_type type, struct config_resource **result) 2229 { 2230 int i, j; 2231 struct config_resource *res = NULL; 2232 2233 for (i = 0; i < devtab_count; i++) 2234 if (!strcmp(devtab[i].name, name) && devtab[i].unit == unit) { 2235 res = devtab[i].resources; 2236 break; 2237 } 2238 if (res == NULL) { 2239 i = resource_new_name(name, unit); 2240 if (i < 0) 2241 return(ENOMEM); 2242 res = devtab[i].resources; 2243 } 2244 for (j = 0; j < devtab[i].resource_count; j++, res++) 2245 if (!strcmp(res->name, resname)) { 2246 *result = res; 2247 return(0); 2248 } 2249 j = resource_new_resname(i, resname, type); 2250 if (j < 0) 2251 return(ENOMEM); 2252 res = &devtab[i].resources[j]; 2253 *result = res; 2254 return(0); 2255 } 2256 2257 int 2258 resource_set_int(const char *name, int unit, const char *resname, int value) 2259 { 2260 int error; 2261 struct config_resource *res; 2262 2263 error = resource_create(name, unit, resname, RES_INT, &res); 2264 if (error) 2265 return(error); 2266 if (res->type != RES_INT) 2267 return(EFTYPE); 2268 res->u.intval = value; 2269 return(0); 2270 } 2271 2272 int 2273 resource_set_long(const char *name, int unit, const char *resname, long value) 2274 { 2275 int error; 2276 struct config_resource *res; 2277 2278 error = resource_create(name, unit, resname, RES_LONG, &res); 2279 if (error) 2280 return(error); 2281 if (res->type != RES_LONG) 2282 return(EFTYPE); 2283 res->u.longval = value; 2284 return(0); 2285 } 2286 2287 int 2288 resource_set_string(const char *name, int unit, const char *resname, 2289 const char *value) 2290 { 2291 int error; 2292 struct config_resource *res; 2293 2294 error = resource_create(name, unit, resname, RES_STRING, &res); 2295 if (error) 2296 return(error); 2297 if (res->type != RES_STRING) 2298 return(EFTYPE); 2299 if (res->u.stringval) 2300 kfree(res->u.stringval, M_TEMP); 2301 res->u.stringval = kmalloc(strlen(value) + 1, M_TEMP, M_INTWAIT); 2302 if (res->u.stringval == NULL) 2303 return(ENOMEM); 2304 strcpy(res->u.stringval, value); 2305 return(0); 2306 } 2307 2308 static void 2309 resource_cfgload(void *dummy __unused) 2310 { 2311 struct config_resource *res, *cfgres; 2312 int i, j; 2313 int error; 2314 char *name, *resname; 2315 int unit; 2316 resource_type type; 2317 char *stringval; 2318 int config_devtab_count; 2319 2320 config_devtab_count = devtab_count; 2321 devtab = NULL; 2322 devtab_count = 0; 2323 2324 for (i = 0; i < config_devtab_count; i++) { 2325 name = config_devtab[i].name; 2326 unit = config_devtab[i].unit; 2327 2328 for (j = 0; j < config_devtab[i].resource_count; j++) { 2329 cfgres = config_devtab[i].resources; 2330 resname = cfgres[j].name; 2331 type = cfgres[j].type; 2332 error = resource_create(name, unit, resname, type, 2333 &res); 2334 if (error) { 2335 kprintf("create resource %s%d: error %d\n", 2336 name, unit, error); 2337 continue; 2338 } 2339 if (res->type != type) { 2340 kprintf("type mismatch %s%d: %d != %d\n", 2341 name, unit, res->type, type); 2342 continue; 2343 } 2344 switch (type) { 2345 case RES_INT: 2346 res->u.intval = cfgres[j].u.intval; 2347 break; 2348 case RES_LONG: 2349 res->u.longval = cfgres[j].u.longval; 2350 break; 2351 case RES_STRING: 2352 if (res->u.stringval) 2353 kfree(res->u.stringval, M_TEMP); 2354 stringval = cfgres[j].u.stringval; 2355 res->u.stringval = kmalloc(strlen(stringval) + 1, 2356 M_TEMP, M_INTWAIT); 2357 if (res->u.stringval == NULL) 2358 break; 2359 strcpy(res->u.stringval, stringval); 2360 break; 2361 default: 2362 panic("unknown resource type %d", type); 2363 } 2364 } 2365 } 2366 } 2367 SYSINIT(cfgload, SI_BOOT1_POST, SI_ORDER_ANY + 50, resource_cfgload, 0); 2368 2369 2370 /*======================================*/ 2371 /* 2372 * Some useful method implementations to make life easier for bus drivers. 2373 */ 2374 2375 void 2376 resource_list_init(struct resource_list *rl) 2377 { 2378 SLIST_INIT(rl); 2379 } 2380 2381 void 2382 resource_list_free(struct resource_list *rl) 2383 { 2384 struct resource_list_entry *rle; 2385 2386 while ((rle = SLIST_FIRST(rl)) != NULL) { 2387 if (rle->res) 2388 panic("resource_list_free: resource entry is busy"); 2389 SLIST_REMOVE_HEAD(rl, link); 2390 kfree(rle, M_BUS); 2391 } 2392 } 2393 2394 void 2395 resource_list_add(struct resource_list *rl, int type, int rid, 2396 u_long start, u_long end, u_long count, int cpuid) 2397 { 2398 struct resource_list_entry *rle; 2399 2400 rle = resource_list_find(rl, type, rid); 2401 if (rle == NULL) { 2402 rle = kmalloc(sizeof(struct resource_list_entry), M_BUS, 2403 M_INTWAIT); 2404 SLIST_INSERT_HEAD(rl, rle, link); 2405 rle->type = type; 2406 rle->rid = rid; 2407 rle->res = NULL; 2408 rle->cpuid = -1; 2409 } 2410 2411 if (rle->res) 2412 panic("resource_list_add: resource entry is busy"); 2413 2414 rle->start = start; 2415 rle->end = end; 2416 rle->count = count; 2417 2418 if (cpuid != -1) { 2419 if (rle->cpuid != -1 && rle->cpuid != cpuid) { 2420 panic("resource_list_add: moving from cpu%d -> cpu%d", 2421 rle->cpuid, cpuid); 2422 } 2423 rle->cpuid = cpuid; 2424 } 2425 } 2426 2427 struct resource_list_entry* 2428 resource_list_find(struct resource_list *rl, 2429 int type, int rid) 2430 { 2431 struct resource_list_entry *rle; 2432 2433 SLIST_FOREACH(rle, rl, link) 2434 if (rle->type == type && rle->rid == rid) 2435 return(rle); 2436 return(NULL); 2437 } 2438 2439 void 2440 resource_list_delete(struct resource_list *rl, 2441 int type, int rid) 2442 { 2443 struct resource_list_entry *rle = resource_list_find(rl, type, rid); 2444 2445 if (rle) { 2446 if (rle->res != NULL) 2447 panic("resource_list_delete: resource has not been released"); 2448 SLIST_REMOVE(rl, rle, resource_list_entry, link); 2449 kfree(rle, M_BUS); 2450 } 2451 } 2452 2453 struct resource * 2454 resource_list_alloc(struct resource_list *rl, 2455 device_t bus, device_t child, 2456 int type, int *rid, 2457 u_long start, u_long end, 2458 u_long count, u_int flags, int cpuid) 2459 { 2460 struct resource_list_entry *rle = NULL; 2461 int passthrough = (device_get_parent(child) != bus); 2462 int isdefault = (start == 0UL && end == ~0UL); 2463 2464 if (passthrough) { 2465 return(BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 2466 type, rid, 2467 start, end, count, flags, cpuid)); 2468 } 2469 2470 rle = resource_list_find(rl, type, *rid); 2471 2472 if (!rle) 2473 return(0); /* no resource of that type/rid */ 2474 2475 if (rle->res) 2476 panic("resource_list_alloc: resource entry is busy"); 2477 2478 if (isdefault) { 2479 start = rle->start; 2480 count = max(count, rle->count); 2481 end = max(rle->end, start + count - 1); 2482 } 2483 cpuid = rle->cpuid; 2484 2485 rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child, 2486 type, rid, start, end, count, 2487 flags, cpuid); 2488 2489 /* 2490 * Record the new range. 2491 */ 2492 if (rle->res) { 2493 rle->start = rman_get_start(rle->res); 2494 rle->end = rman_get_end(rle->res); 2495 rle->count = count; 2496 } 2497 2498 return(rle->res); 2499 } 2500 2501 int 2502 resource_list_release(struct resource_list *rl, 2503 device_t bus, device_t child, 2504 int type, int rid, struct resource *res) 2505 { 2506 struct resource_list_entry *rle = NULL; 2507 int passthrough = (device_get_parent(child) != bus); 2508 int error; 2509 2510 if (passthrough) { 2511 return(BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 2512 type, rid, res)); 2513 } 2514 2515 rle = resource_list_find(rl, type, rid); 2516 2517 if (!rle) 2518 panic("resource_list_release: can't find resource"); 2519 if (!rle->res) 2520 panic("resource_list_release: resource entry is not busy"); 2521 2522 error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child, 2523 type, rid, res); 2524 if (error) 2525 return(error); 2526 2527 rle->res = NULL; 2528 return(0); 2529 } 2530 2531 int 2532 resource_list_print_type(struct resource_list *rl, const char *name, int type, 2533 const char *format) 2534 { 2535 struct resource_list_entry *rle; 2536 int printed, retval; 2537 2538 printed = 0; 2539 retval = 0; 2540 /* Yes, this is kinda cheating */ 2541 SLIST_FOREACH(rle, rl, link) { 2542 if (rle->type == type) { 2543 if (printed == 0) 2544 retval += kprintf(" %s ", name); 2545 else 2546 retval += kprintf(","); 2547 printed++; 2548 retval += kprintf(format, rle->start); 2549 if (rle->count > 1) { 2550 retval += kprintf("-"); 2551 retval += kprintf(format, rle->start + 2552 rle->count - 1); 2553 } 2554 } 2555 } 2556 return(retval); 2557 } 2558 2559 /* 2560 * Generic driver/device identify functions. These will install a device 2561 * rendezvous point under the parent using the same name as the driver 2562 * name, which will at a later time be probed and attached. 2563 * 2564 * These functions are used when the parent does not 'scan' its bus for 2565 * matching devices, or for the particular devices using these functions, 2566 * or when the device is a pseudo or synthesized device (such as can be 2567 * found under firewire and ppbus). 2568 */ 2569 int 2570 bus_generic_identify(driver_t *driver, device_t parent) 2571 { 2572 if (parent->state == DS_ATTACHED) 2573 return (0); 2574 BUS_ADD_CHILD(parent, parent, 0, driver->name, -1); 2575 return (0); 2576 } 2577 2578 int 2579 bus_generic_identify_sameunit(driver_t *driver, device_t parent) 2580 { 2581 if (parent->state == DS_ATTACHED) 2582 return (0); 2583 BUS_ADD_CHILD(parent, parent, 0, driver->name, device_get_unit(parent)); 2584 return (0); 2585 } 2586 2587 /* 2588 * Call DEVICE_IDENTIFY for each driver. 2589 */ 2590 int 2591 bus_generic_probe(device_t dev) 2592 { 2593 devclass_t dc = dev->devclass; 2594 driverlink_t dl; 2595 2596 TAILQ_FOREACH(dl, &dc->drivers, link) { 2597 DEVICE_IDENTIFY(dl->driver, dev); 2598 } 2599 2600 return(0); 2601 } 2602 2603 /* 2604 * This is an aweful hack due to the isa bus and autoconf code not 2605 * probing the ISA devices until after everything else has configured. 2606 * The ISA bus did a dummy attach long ago so we have to set it back 2607 * to an earlier state so the probe thinks its the initial probe and 2608 * not a bus rescan. 2609 * 2610 * XXX remove by properly defering the ISA bus scan. 2611 */ 2612 int 2613 bus_generic_probe_hack(device_t dev) 2614 { 2615 if (dev->state == DS_ATTACHED) { 2616 dev->state = DS_ALIVE; 2617 bus_generic_probe(dev); 2618 dev->state = DS_ATTACHED; 2619 } 2620 return (0); 2621 } 2622 2623 int 2624 bus_generic_attach(device_t dev) 2625 { 2626 device_t child; 2627 2628 TAILQ_FOREACH(child, &dev->children, link) { 2629 device_probe_and_attach(child); 2630 } 2631 2632 return(0); 2633 } 2634 2635 int 2636 bus_generic_detach(device_t dev) 2637 { 2638 device_t child; 2639 int error; 2640 2641 if (dev->state != DS_ATTACHED) 2642 return(EBUSY); 2643 2644 TAILQ_FOREACH(child, &dev->children, link) 2645 if ((error = device_detach(child)) != 0) 2646 return(error); 2647 2648 return 0; 2649 } 2650 2651 int 2652 bus_generic_shutdown(device_t dev) 2653 { 2654 device_t child; 2655 2656 TAILQ_FOREACH(child, &dev->children, link) 2657 device_shutdown(child); 2658 2659 return(0); 2660 } 2661 2662 int 2663 bus_generic_suspend(device_t dev) 2664 { 2665 int error; 2666 device_t child, child2; 2667 2668 TAILQ_FOREACH(child, &dev->children, link) { 2669 error = DEVICE_SUSPEND(child); 2670 if (error) { 2671 for (child2 = TAILQ_FIRST(&dev->children); 2672 child2 && child2 != child; 2673 child2 = TAILQ_NEXT(child2, link)) 2674 DEVICE_RESUME(child2); 2675 return(error); 2676 } 2677 } 2678 return(0); 2679 } 2680 2681 int 2682 bus_generic_resume(device_t dev) 2683 { 2684 device_t child; 2685 2686 TAILQ_FOREACH(child, &dev->children, link) 2687 DEVICE_RESUME(child); 2688 /* if resume fails, there's nothing we can usefully do... */ 2689 2690 return(0); 2691 } 2692 2693 int 2694 bus_print_child_header(device_t dev, device_t child) 2695 { 2696 int retval = 0; 2697 2698 if (device_get_desc(child)) 2699 retval += device_printf(child, "<%s>", device_get_desc(child)); 2700 else 2701 retval += kprintf("%s", device_get_nameunit(child)); 2702 if (bootverbose) { 2703 if (child->state != DS_ATTACHED) 2704 kprintf(" [tentative]"); 2705 else 2706 kprintf(" [attached!]"); 2707 } 2708 return(retval); 2709 } 2710 2711 int 2712 bus_print_child_footer(device_t dev, device_t child) 2713 { 2714 return(kprintf(" on %s\n", device_get_nameunit(dev))); 2715 } 2716 2717 device_t 2718 bus_generic_add_child(device_t dev, device_t child, int order, 2719 const char *name, int unit) 2720 { 2721 if (dev->parent) 2722 dev = BUS_ADD_CHILD(dev->parent, child, order, name, unit); 2723 else 2724 dev = device_add_child_ordered(child, order, name, unit); 2725 return(dev); 2726 2727 } 2728 2729 int 2730 bus_generic_print_child(device_t dev, device_t child) 2731 { 2732 int retval = 0; 2733 2734 retval += bus_print_child_header(dev, child); 2735 retval += bus_print_child_footer(dev, child); 2736 2737 return(retval); 2738 } 2739 2740 int 2741 bus_generic_read_ivar(device_t dev, device_t child, int index, 2742 uintptr_t * result) 2743 { 2744 int error; 2745 2746 if (dev->parent) 2747 error = BUS_READ_IVAR(dev->parent, child, index, result); 2748 else 2749 error = ENOENT; 2750 return (error); 2751 } 2752 2753 int 2754 bus_generic_write_ivar(device_t dev, device_t child, int index, 2755 uintptr_t value) 2756 { 2757 int error; 2758 2759 if (dev->parent) 2760 error = BUS_WRITE_IVAR(dev->parent, child, index, value); 2761 else 2762 error = ENOENT; 2763 return (error); 2764 } 2765 2766 /* 2767 * Resource list are used for iterations, do not recurse. 2768 */ 2769 struct resource_list * 2770 bus_generic_get_resource_list(device_t dev, device_t child) 2771 { 2772 return (NULL); 2773 } 2774 2775 void 2776 bus_generic_driver_added(device_t dev, driver_t *driver) 2777 { 2778 device_t child; 2779 2780 DEVICE_IDENTIFY(driver, dev); 2781 TAILQ_FOREACH(child, &dev->children, link) { 2782 if (child->state == DS_NOTPRESENT) 2783 device_probe_and_attach(child); 2784 } 2785 } 2786 2787 int 2788 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq, 2789 int flags, driver_intr_t *intr, void *arg, void **cookiep, 2790 lwkt_serialize_t serializer, const char *desc) 2791 { 2792 /* Propagate up the bus hierarchy until someone handles it. */ 2793 if (dev->parent) { 2794 return BUS_SETUP_INTR(dev->parent, child, irq, flags, 2795 intr, arg, cookiep, serializer, desc); 2796 } else { 2797 return EINVAL; 2798 } 2799 } 2800 2801 int 2802 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq, 2803 void *cookie) 2804 { 2805 /* Propagate up the bus hierarchy until someone handles it. */ 2806 if (dev->parent) 2807 return(BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie)); 2808 else 2809 return(EINVAL); 2810 } 2811 2812 int 2813 bus_generic_disable_intr(device_t dev, device_t child, void *cookie) 2814 { 2815 if (dev->parent) 2816 return(BUS_DISABLE_INTR(dev->parent, child, cookie)); 2817 else 2818 return(0); 2819 } 2820 2821 void 2822 bus_generic_enable_intr(device_t dev, device_t child, void *cookie) 2823 { 2824 if (dev->parent) 2825 BUS_ENABLE_INTR(dev->parent, child, cookie); 2826 } 2827 2828 int 2829 bus_generic_config_intr(device_t dev, device_t child, int irq, enum intr_trigger trig, 2830 enum intr_polarity pol) 2831 { 2832 /* Propagate up the bus hierarchy until someone handles it. */ 2833 if (dev->parent) 2834 return(BUS_CONFIG_INTR(dev->parent, child, irq, trig, pol)); 2835 else 2836 return(EINVAL); 2837 } 2838 2839 struct resource * 2840 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid, 2841 u_long start, u_long end, u_long count, u_int flags, int cpuid) 2842 { 2843 /* Propagate up the bus hierarchy until someone handles it. */ 2844 if (dev->parent) 2845 return(BUS_ALLOC_RESOURCE(dev->parent, child, type, rid, 2846 start, end, count, flags, cpuid)); 2847 else 2848 return(NULL); 2849 } 2850 2851 int 2852 bus_generic_release_resource(device_t dev, device_t child, int type, int rid, 2853 struct resource *r) 2854 { 2855 /* Propagate up the bus hierarchy until someone handles it. */ 2856 if (dev->parent) 2857 return(BUS_RELEASE_RESOURCE(dev->parent, child, type, rid, r)); 2858 else 2859 return(EINVAL); 2860 } 2861 2862 int 2863 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid, 2864 struct resource *r) 2865 { 2866 /* Propagate up the bus hierarchy until someone handles it. */ 2867 if (dev->parent) 2868 return(BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid, r)); 2869 else 2870 return(EINVAL); 2871 } 2872 2873 int 2874 bus_generic_deactivate_resource(device_t dev, device_t child, int type, 2875 int rid, struct resource *r) 2876 { 2877 /* Propagate up the bus hierarchy until someone handles it. */ 2878 if (dev->parent) 2879 return(BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid, 2880 r)); 2881 else 2882 return(EINVAL); 2883 } 2884 2885 int 2886 bus_generic_get_resource(device_t dev, device_t child, int type, int rid, 2887 u_long *startp, u_long *countp) 2888 { 2889 int error; 2890 2891 error = ENOENT; 2892 if (dev->parent) { 2893 error = BUS_GET_RESOURCE(dev->parent, child, type, rid, 2894 startp, countp); 2895 } 2896 return (error); 2897 } 2898 2899 int 2900 bus_generic_set_resource(device_t dev, device_t child, int type, int rid, 2901 u_long start, u_long count, int cpuid) 2902 { 2903 int error; 2904 2905 error = EINVAL; 2906 if (dev->parent) { 2907 error = BUS_SET_RESOURCE(dev->parent, child, type, rid, 2908 start, count, cpuid); 2909 } 2910 return (error); 2911 } 2912 2913 void 2914 bus_generic_delete_resource(device_t dev, device_t child, int type, int rid) 2915 { 2916 if (dev->parent) 2917 BUS_DELETE_RESOURCE(dev, child, type, rid); 2918 } 2919 2920 /** 2921 * @brief Helper function for implementing BUS_GET_DMA_TAG(). 2922 * 2923 * This simple implementation of BUS_GET_DMA_TAG() simply calls the 2924 * BUS_GET_DMA_TAG() method of the parent of @p dev. 2925 */ 2926 bus_dma_tag_t 2927 bus_generic_get_dma_tag(device_t dev, device_t child) 2928 { 2929 2930 /* Propagate up the bus hierarchy until someone handles it. */ 2931 if (dev->parent != NULL) 2932 return (BUS_GET_DMA_TAG(dev->parent, child)); 2933 return (NULL); 2934 } 2935 2936 int 2937 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid, 2938 u_long *startp, u_long *countp) 2939 { 2940 struct resource_list *rl = NULL; 2941 struct resource_list_entry *rle = NULL; 2942 2943 rl = BUS_GET_RESOURCE_LIST(dev, child); 2944 if (!rl) 2945 return(EINVAL); 2946 2947 rle = resource_list_find(rl, type, rid); 2948 if (!rle) 2949 return(ENOENT); 2950 2951 if (startp) 2952 *startp = rle->start; 2953 if (countp) 2954 *countp = rle->count; 2955 2956 return(0); 2957 } 2958 2959 int 2960 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid, 2961 u_long start, u_long count, int cpuid) 2962 { 2963 struct resource_list *rl = NULL; 2964 2965 rl = BUS_GET_RESOURCE_LIST(dev, child); 2966 if (!rl) 2967 return(EINVAL); 2968 2969 resource_list_add(rl, type, rid, start, (start + count - 1), count, 2970 cpuid); 2971 2972 return(0); 2973 } 2974 2975 void 2976 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid) 2977 { 2978 struct resource_list *rl = NULL; 2979 2980 rl = BUS_GET_RESOURCE_LIST(dev, child); 2981 if (!rl) 2982 return; 2983 2984 resource_list_delete(rl, type, rid); 2985 } 2986 2987 int 2988 bus_generic_rl_release_resource(device_t dev, device_t child, int type, 2989 int rid, struct resource *r) 2990 { 2991 struct resource_list *rl = NULL; 2992 2993 rl = BUS_GET_RESOURCE_LIST(dev, child); 2994 if (!rl) 2995 return(EINVAL); 2996 2997 return(resource_list_release(rl, dev, child, type, rid, r)); 2998 } 2999 3000 struct resource * 3001 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type, 3002 int *rid, u_long start, u_long end, u_long count, u_int flags, int cpuid) 3003 { 3004 struct resource_list *rl = NULL; 3005 3006 rl = BUS_GET_RESOURCE_LIST(dev, child); 3007 if (!rl) 3008 return(NULL); 3009 3010 return(resource_list_alloc(rl, dev, child, type, rid, 3011 start, end, count, flags, cpuid)); 3012 } 3013 3014 int 3015 bus_generic_child_present(device_t bus, device_t child) 3016 { 3017 return(BUS_CHILD_PRESENT(device_get_parent(bus), bus)); 3018 } 3019 3020 3021 /* 3022 * Some convenience functions to make it easier for drivers to use the 3023 * resource-management functions. All these really do is hide the 3024 * indirection through the parent's method table, making for slightly 3025 * less-wordy code. In the future, it might make sense for this code 3026 * to maintain some sort of a list of resources allocated by each device. 3027 */ 3028 int 3029 bus_alloc_resources(device_t dev, struct resource_spec *rs, 3030 struct resource **res) 3031 { 3032 int i; 3033 3034 for (i = 0; rs[i].type != -1; i++) 3035 res[i] = NULL; 3036 for (i = 0; rs[i].type != -1; i++) { 3037 res[i] = bus_alloc_resource_any(dev, 3038 rs[i].type, &rs[i].rid, rs[i].flags); 3039 if (res[i] == NULL) { 3040 bus_release_resources(dev, rs, res); 3041 return (ENXIO); 3042 } 3043 } 3044 return (0); 3045 } 3046 3047 void 3048 bus_release_resources(device_t dev, const struct resource_spec *rs, 3049 struct resource **res) 3050 { 3051 int i; 3052 3053 for (i = 0; rs[i].type != -1; i++) 3054 if (res[i] != NULL) { 3055 bus_release_resource( 3056 dev, rs[i].type, rs[i].rid, res[i]); 3057 res[i] = NULL; 3058 } 3059 } 3060 3061 struct resource * 3062 bus_alloc_resource(device_t dev, int type, int *rid, u_long start, u_long end, 3063 u_long count, u_int flags) 3064 { 3065 if (dev->parent == NULL) 3066 return(0); 3067 return(BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end, 3068 count, flags, -1)); 3069 } 3070 3071 struct resource * 3072 bus_alloc_legacy_irq_resource(device_t dev, int *rid, u_long irq, u_int flags) 3073 { 3074 if (dev->parent == NULL) 3075 return(0); 3076 return BUS_ALLOC_RESOURCE(dev->parent, dev, SYS_RES_IRQ, rid, 3077 irq, irq, 1, flags, machintr_legacy_intr_cpuid(irq)); 3078 } 3079 3080 int 3081 bus_activate_resource(device_t dev, int type, int rid, struct resource *r) 3082 { 3083 if (dev->parent == NULL) 3084 return(EINVAL); 3085 return(BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 3086 } 3087 3088 int 3089 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r) 3090 { 3091 if (dev->parent == NULL) 3092 return(EINVAL); 3093 return(BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r)); 3094 } 3095 3096 int 3097 bus_release_resource(device_t dev, int type, int rid, struct resource *r) 3098 { 3099 if (dev->parent == NULL) 3100 return(EINVAL); 3101 return(BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r)); 3102 } 3103 3104 int 3105 bus_setup_intr_descr(device_t dev, struct resource *r, int flags, 3106 driver_intr_t handler, void *arg, void **cookiep, 3107 lwkt_serialize_t serializer, const char *desc) 3108 { 3109 if (dev->parent == NULL) 3110 return EINVAL; 3111 return BUS_SETUP_INTR(dev->parent, dev, r, flags, handler, arg, 3112 cookiep, serializer, desc); 3113 } 3114 3115 int 3116 bus_setup_intr(device_t dev, struct resource *r, int flags, 3117 driver_intr_t handler, void *arg, void **cookiep, 3118 lwkt_serialize_t serializer) 3119 { 3120 return bus_setup_intr_descr(dev, r, flags, handler, arg, cookiep, 3121 serializer, NULL); 3122 } 3123 3124 int 3125 bus_teardown_intr(device_t dev, struct resource *r, void *cookie) 3126 { 3127 if (dev->parent == NULL) 3128 return(EINVAL); 3129 return(BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie)); 3130 } 3131 3132 void 3133 bus_enable_intr(device_t dev, void *cookie) 3134 { 3135 if (dev->parent) 3136 BUS_ENABLE_INTR(dev->parent, dev, cookie); 3137 } 3138 3139 int 3140 bus_disable_intr(device_t dev, void *cookie) 3141 { 3142 if (dev->parent) 3143 return(BUS_DISABLE_INTR(dev->parent, dev, cookie)); 3144 else 3145 return(0); 3146 } 3147 3148 int 3149 bus_set_resource(device_t dev, int type, int rid, 3150 u_long start, u_long count, int cpuid) 3151 { 3152 return(BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid, 3153 start, count, cpuid)); 3154 } 3155 3156 int 3157 bus_get_resource(device_t dev, int type, int rid, 3158 u_long *startp, u_long *countp) 3159 { 3160 return(BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 3161 startp, countp)); 3162 } 3163 3164 u_long 3165 bus_get_resource_start(device_t dev, int type, int rid) 3166 { 3167 u_long start, count; 3168 int error; 3169 3170 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 3171 &start, &count); 3172 if (error) 3173 return(0); 3174 return(start); 3175 } 3176 3177 u_long 3178 bus_get_resource_count(device_t dev, int type, int rid) 3179 { 3180 u_long start, count; 3181 int error; 3182 3183 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid, 3184 &start, &count); 3185 if (error) 3186 return(0); 3187 return(count); 3188 } 3189 3190 void 3191 bus_delete_resource(device_t dev, int type, int rid) 3192 { 3193 BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid); 3194 } 3195 3196 int 3197 bus_child_present(device_t child) 3198 { 3199 return (BUS_CHILD_PRESENT(device_get_parent(child), child)); 3200 } 3201 3202 int 3203 bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen) 3204 { 3205 device_t parent; 3206 3207 parent = device_get_parent(child); 3208 if (parent == NULL) { 3209 *buf = '\0'; 3210 return (0); 3211 } 3212 return (BUS_CHILD_PNPINFO_STR(parent, child, buf, buflen)); 3213 } 3214 3215 int 3216 bus_child_location_str(device_t child, char *buf, size_t buflen) 3217 { 3218 device_t parent; 3219 3220 parent = device_get_parent(child); 3221 if (parent == NULL) { 3222 *buf = '\0'; 3223 return (0); 3224 } 3225 return (BUS_CHILD_LOCATION_STR(parent, child, buf, buflen)); 3226 } 3227 3228 /** 3229 * @brief Wrapper function for BUS_GET_DMA_TAG(). 3230 * 3231 * This function simply calls the BUS_GET_DMA_TAG() method of the 3232 * parent of @p dev. 3233 */ 3234 bus_dma_tag_t 3235 bus_get_dma_tag(device_t dev) 3236 { 3237 device_t parent; 3238 3239 parent = device_get_parent(dev); 3240 if (parent == NULL) 3241 return (NULL); 3242 return (BUS_GET_DMA_TAG(parent, dev)); 3243 } 3244 3245 static int 3246 root_print_child(device_t dev, device_t child) 3247 { 3248 return(0); 3249 } 3250 3251 static int 3252 root_setup_intr(device_t dev, device_t child, driver_intr_t *intr, void *arg, 3253 void **cookiep, lwkt_serialize_t serializer, const char *desc) 3254 { 3255 /* 3256 * If an interrupt mapping gets to here something bad has happened. 3257 */ 3258 panic("root_setup_intr"); 3259 } 3260 3261 /* 3262 * If we get here, assume that the device is permanant and really is 3263 * present in the system. Removable bus drivers are expected to intercept 3264 * this call long before it gets here. We return -1 so that drivers that 3265 * really care can check vs -1 or some ERRNO returned higher in the food 3266 * chain. 3267 */ 3268 static int 3269 root_child_present(device_t dev, device_t child) 3270 { 3271 return(-1); 3272 } 3273 3274 /* 3275 * XXX NOTE! other defaults may be set in bus_if.m 3276 */ 3277 static kobj_method_t root_methods[] = { 3278 /* Device interface */ 3279 KOBJMETHOD(device_shutdown, bus_generic_shutdown), 3280 KOBJMETHOD(device_suspend, bus_generic_suspend), 3281 KOBJMETHOD(device_resume, bus_generic_resume), 3282 3283 /* Bus interface */ 3284 KOBJMETHOD(bus_add_child, bus_generic_add_child), 3285 KOBJMETHOD(bus_print_child, root_print_child), 3286 KOBJMETHOD(bus_read_ivar, bus_generic_read_ivar), 3287 KOBJMETHOD(bus_write_ivar, bus_generic_write_ivar), 3288 KOBJMETHOD(bus_setup_intr, root_setup_intr), 3289 KOBJMETHOD(bus_child_present, root_child_present), 3290 3291 KOBJMETHOD_END 3292 }; 3293 3294 static driver_t root_driver = { 3295 "root", 3296 root_methods, 3297 1, /* no softc */ 3298 }; 3299 3300 device_t root_bus; 3301 devclass_t root_devclass; 3302 3303 static int 3304 root_bus_module_handler(module_t mod, int what, void* arg) 3305 { 3306 switch (what) { 3307 case MOD_LOAD: 3308 TAILQ_INIT(&bus_data_devices); 3309 root_bus = make_device(NULL, "root", 0); 3310 root_bus->desc = "System root bus"; 3311 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver); 3312 root_bus->driver = &root_driver; 3313 root_bus->state = DS_ALIVE; 3314 root_devclass = devclass_find_internal("root", NULL, FALSE); 3315 devinit(); 3316 return(0); 3317 3318 case MOD_SHUTDOWN: 3319 device_shutdown(root_bus); 3320 return(0); 3321 default: 3322 return(0); 3323 } 3324 } 3325 3326 static moduledata_t root_bus_mod = { 3327 "rootbus", 3328 root_bus_module_handler, 3329 0 3330 }; 3331 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 3332 3333 void 3334 root_bus_configure(void) 3335 { 3336 int warncount; 3337 device_t dev; 3338 3339 PDEBUG((".")); 3340 3341 /* 3342 * handle device_identify based device attachments to the root_bus 3343 * (typically nexus). 3344 */ 3345 bus_generic_probe(root_bus); 3346 3347 /* 3348 * Probe and attach the devices under root_bus. 3349 */ 3350 TAILQ_FOREACH(dev, &root_bus->children, link) { 3351 device_probe_and_attach(dev); 3352 } 3353 3354 /* 3355 * Wait for all asynchronous attaches to complete. If we don't 3356 * our legacy ISA bus scan could steal device unit numbers or 3357 * even I/O ports. 3358 */ 3359 warncount = 10; 3360 if (numasyncthreads) 3361 kprintf("Waiting for async drivers to attach\n"); 3362 while (numasyncthreads > 0) { 3363 if (tsleep(&numasyncthreads, 0, "rootbus", hz) == EWOULDBLOCK) 3364 --warncount; 3365 if (warncount == 0) { 3366 kprintf("Warning: Still waiting for %d " 3367 "drivers to attach\n", numasyncthreads); 3368 } else if (warncount == -30) { 3369 kprintf("Giving up on %d drivers\n", numasyncthreads); 3370 break; 3371 } 3372 } 3373 root_bus->state = DS_ATTACHED; 3374 } 3375 3376 int 3377 driver_module_handler(module_t mod, int what, void *arg) 3378 { 3379 int error; 3380 struct driver_module_data *dmd; 3381 devclass_t bus_devclass; 3382 kobj_class_t driver; 3383 const char *parentname; 3384 3385 dmd = (struct driver_module_data *)arg; 3386 bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE); 3387 error = 0; 3388 3389 switch (what) { 3390 case MOD_LOAD: 3391 if (dmd->dmd_chainevh) 3392 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 3393 3394 driver = dmd->dmd_driver; 3395 PDEBUG(("Loading module: driver %s on bus %s", 3396 DRIVERNAME(driver), dmd->dmd_busname)); 3397 3398 /* 3399 * If the driver has any base classes, make the 3400 * devclass inherit from the devclass of the driver's 3401 * first base class. This will allow the system to 3402 * search for drivers in both devclasses for children 3403 * of a device using this driver. 3404 */ 3405 if (driver->baseclasses) 3406 parentname = driver->baseclasses[0]->name; 3407 else 3408 parentname = NULL; 3409 *dmd->dmd_devclass = devclass_find_internal(driver->name, 3410 parentname, TRUE); 3411 3412 error = devclass_add_driver(bus_devclass, driver); 3413 if (error) 3414 break; 3415 break; 3416 3417 case MOD_UNLOAD: 3418 PDEBUG(("Unloading module: driver %s from bus %s", 3419 DRIVERNAME(dmd->dmd_driver), dmd->dmd_busname)); 3420 error = devclass_delete_driver(bus_devclass, dmd->dmd_driver); 3421 3422 if (!error && dmd->dmd_chainevh) 3423 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg); 3424 break; 3425 } 3426 3427 return (error); 3428 } 3429 3430 #ifdef BUS_DEBUG 3431 3432 /* 3433 * The _short versions avoid iteration by not calling anything that prints 3434 * more than oneliners. I love oneliners. 3435 */ 3436 3437 static void 3438 print_device_short(device_t dev, int indent) 3439 { 3440 if (!dev) 3441 return; 3442 3443 indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s,%sivars,%ssoftc,busy=%d\n", 3444 dev->unit, dev->desc, 3445 (dev->parent? "":"no "), 3446 (TAILQ_EMPTY(&dev->children)? "no ":""), 3447 (dev->flags&DF_ENABLED? "enabled,":"disabled,"), 3448 (dev->flags&DF_FIXEDCLASS? "fixed,":""), 3449 (dev->flags&DF_WILDCARD? "wildcard,":""), 3450 (dev->flags&DF_DESCMALLOCED? "descmalloced,":""), 3451 (dev->ivars? "":"no "), 3452 (dev->softc? "":"no "), 3453 dev->busy)); 3454 } 3455 3456 static void 3457 print_device(device_t dev, int indent) 3458 { 3459 if (!dev) 3460 return; 3461 3462 print_device_short(dev, indent); 3463 3464 indentprintf(("Parent:\n")); 3465 print_device_short(dev->parent, indent+1); 3466 indentprintf(("Driver:\n")); 3467 print_driver_short(dev->driver, indent+1); 3468 indentprintf(("Devclass:\n")); 3469 print_devclass_short(dev->devclass, indent+1); 3470 } 3471 3472 /* 3473 * Print the device and all its children (indented). 3474 */ 3475 void 3476 print_device_tree_short(device_t dev, int indent) 3477 { 3478 device_t child; 3479 3480 if (!dev) 3481 return; 3482 3483 print_device_short(dev, indent); 3484 3485 TAILQ_FOREACH(child, &dev->children, link) 3486 print_device_tree_short(child, indent+1); 3487 } 3488 3489 /* 3490 * Print the device and all its children (indented). 3491 */ 3492 void 3493 print_device_tree(device_t dev, int indent) 3494 { 3495 device_t child; 3496 3497 if (!dev) 3498 return; 3499 3500 print_device(dev, indent); 3501 3502 TAILQ_FOREACH(child, &dev->children, link) 3503 print_device_tree(child, indent+1); 3504 } 3505 3506 static void 3507 print_driver_short(driver_t *driver, int indent) 3508 { 3509 if (!driver) 3510 return; 3511 3512 indentprintf(("driver %s: softc size = %zu\n", 3513 driver->name, driver->size)); 3514 } 3515 3516 static void 3517 print_driver(driver_t *driver, int indent) 3518 { 3519 if (!driver) 3520 return; 3521 3522 print_driver_short(driver, indent); 3523 } 3524 3525 3526 static void 3527 print_driver_list(driver_list_t drivers, int indent) 3528 { 3529 driverlink_t driver; 3530 3531 TAILQ_FOREACH(driver, &drivers, link) 3532 print_driver(driver->driver, indent); 3533 } 3534 3535 static void 3536 print_devclass_short(devclass_t dc, int indent) 3537 { 3538 if (!dc) 3539 return; 3540 3541 indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit)); 3542 } 3543 3544 static void 3545 print_devclass(devclass_t dc, int indent) 3546 { 3547 int i; 3548 3549 if (!dc) 3550 return; 3551 3552 print_devclass_short(dc, indent); 3553 indentprintf(("Drivers:\n")); 3554 print_driver_list(dc->drivers, indent+1); 3555 3556 indentprintf(("Devices:\n")); 3557 for (i = 0; i < dc->maxunit; i++) 3558 if (dc->devices[i]) 3559 print_device(dc->devices[i], indent+1); 3560 } 3561 3562 void 3563 print_devclass_list_short(void) 3564 { 3565 devclass_t dc; 3566 3567 kprintf("Short listing of devclasses, drivers & devices:\n"); 3568 TAILQ_FOREACH(dc, &devclasses, link) { 3569 print_devclass_short(dc, 0); 3570 } 3571 } 3572 3573 void 3574 print_devclass_list(void) 3575 { 3576 devclass_t dc; 3577 3578 kprintf("Full listing of devclasses, drivers & devices:\n"); 3579 TAILQ_FOREACH(dc, &devclasses, link) { 3580 print_devclass(dc, 0); 3581 } 3582 } 3583 3584 #endif 3585 3586 /* 3587 * Check to see if a device is disabled via a disabled hint. 3588 */ 3589 int 3590 resource_disabled(const char *name, int unit) 3591 { 3592 int error, value; 3593 3594 error = resource_int_value(name, unit, "disabled", &value); 3595 if (error) 3596 return(0); 3597 return(value); 3598 } 3599 3600 /* 3601 * User-space access to the device tree. 3602 * 3603 * We implement a small set of nodes: 3604 * 3605 * hw.bus Single integer read method to obtain the 3606 * current generation count. 3607 * hw.bus.devices Reads the entire device tree in flat space. 3608 * hw.bus.rman Resource manager interface 3609 * 3610 * We might like to add the ability to scan devclasses and/or drivers to 3611 * determine what else is currently loaded/available. 3612 */ 3613 3614 static int 3615 sysctl_bus(SYSCTL_HANDLER_ARGS) 3616 { 3617 struct u_businfo ubus; 3618 3619 ubus.ub_version = BUS_USER_VERSION; 3620 ubus.ub_generation = bus_data_generation; 3621 3622 return (SYSCTL_OUT(req, &ubus, sizeof(ubus))); 3623 } 3624 SYSCTL_NODE(_hw_bus, OID_AUTO, info, CTLFLAG_RW, sysctl_bus, 3625 "bus-related data"); 3626 3627 static int 3628 sysctl_devices(SYSCTL_HANDLER_ARGS) 3629 { 3630 int *name = (int *)arg1; 3631 u_int namelen = arg2; 3632 int index; 3633 device_t dev; 3634 struct u_device udev; /* XXX this is a bit big */ 3635 int error; 3636 3637 if (namelen != 2) 3638 return (EINVAL); 3639 3640 if (bus_data_generation_check(name[0])) 3641 return (EINVAL); 3642 3643 index = name[1]; 3644 3645 /* 3646 * Scan the list of devices, looking for the requested index. 3647 */ 3648 TAILQ_FOREACH(dev, &bus_data_devices, devlink) { 3649 if (index-- == 0) 3650 break; 3651 } 3652 if (dev == NULL) 3653 return (ENOENT); 3654 3655 /* 3656 * Populate the return array. 3657 */ 3658 bzero(&udev, sizeof(udev)); 3659 udev.dv_handle = (uintptr_t)dev; 3660 udev.dv_parent = (uintptr_t)dev->parent; 3661 if (dev->nameunit != NULL) 3662 strlcpy(udev.dv_name, dev->nameunit, sizeof(udev.dv_name)); 3663 if (dev->desc != NULL) 3664 strlcpy(udev.dv_desc, dev->desc, sizeof(udev.dv_desc)); 3665 if (dev->driver != NULL && dev->driver->name != NULL) 3666 strlcpy(udev.dv_drivername, dev->driver->name, 3667 sizeof(udev.dv_drivername)); 3668 bus_child_pnpinfo_str(dev, udev.dv_pnpinfo, sizeof(udev.dv_pnpinfo)); 3669 bus_child_location_str(dev, udev.dv_location, sizeof(udev.dv_location)); 3670 udev.dv_devflags = dev->devflags; 3671 udev.dv_flags = dev->flags; 3672 udev.dv_state = dev->state; 3673 error = SYSCTL_OUT(req, &udev, sizeof(udev)); 3674 return (error); 3675 } 3676 3677 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, CTLFLAG_RD, sysctl_devices, 3678 "system device tree"); 3679 3680 int 3681 bus_data_generation_check(int generation) 3682 { 3683 if (generation != bus_data_generation) 3684 return (1); 3685 3686 /* XXX generate optimised lists here? */ 3687 return (0); 3688 } 3689 3690 void 3691 bus_data_generation_update(void) 3692 { 3693 bus_data_generation++; 3694 } 3695 3696 const char * 3697 intr_str_polarity(enum intr_polarity pola) 3698 { 3699 switch (pola) { 3700 case INTR_POLARITY_LOW: 3701 return "low"; 3702 3703 case INTR_POLARITY_HIGH: 3704 return "high"; 3705 3706 case INTR_POLARITY_CONFORM: 3707 return "conform"; 3708 } 3709 return "unknown"; 3710 } 3711 3712 const char * 3713 intr_str_trigger(enum intr_trigger trig) 3714 { 3715 switch (trig) { 3716 case INTR_TRIGGER_EDGE: 3717 return "edge"; 3718 3719 case INTR_TRIGGER_LEVEL: 3720 return "level"; 3721 3722 case INTR_TRIGGER_CONFORM: 3723 return "conform"; 3724 } 3725 return "unknown"; 3726 } 3727 3728 int 3729 device_getenv_int(device_t dev, const char *knob, int def) 3730 { 3731 char env[128]; 3732 3733 /* Deprecated; for compat */ 3734 ksnprintf(env, sizeof(env), "hw.%s.%s", device_get_nameunit(dev), knob); 3735 kgetenv_int(env, &def); 3736 3737 /* Prefer dev.driver.unit.knob */ 3738 ksnprintf(env, sizeof(env), "dev.%s.%d.%s", 3739 device_get_name(dev), device_get_unit(dev), knob); 3740 kgetenv_int(env, &def); 3741 3742 return def; 3743 } 3744 3745 void 3746 device_getenv_string(device_t dev, const char *knob, char * __restrict data, 3747 int dlen, const char * __restrict def) 3748 { 3749 char env[128]; 3750 3751 strlcpy(data, def, dlen); 3752 3753 /* Deprecated; for compat */ 3754 ksnprintf(env, sizeof(env), "hw.%s.%s", device_get_nameunit(dev), knob); 3755 kgetenv_string(env, data, dlen); 3756 3757 /* Prefer dev.driver.unit.knob */ 3758 ksnprintf(env, sizeof(env), "dev.%s.%d.%s", 3759 device_get_name(dev), device_get_unit(dev), knob); 3760 kgetenv_string(env, data, dlen); 3761 } 3762