Lines Matching defs:dev
68 #include <dev/iommu/iommu.h>
74 SYSCTL_ROOT_NODE(OID_AUTO, dev, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
123 static void device_destroy_props(device_t dev);
195 static void print_device_short(device_t dev, int indent);
196 static void print_device(device_t dev, int indent);
197 void print_device_tree_short(device_t dev, int indent);
198 void print_device_tree(device_t dev, int indent);
226 * dev sysctl tree
278 device_t dev = (device_t)arg1;
289 sbuf_cat(&sb, dev->desc ? dev->desc : "");
292 sbuf_cat(&sb, dev->driver ? dev->driver->name : "");
295 bus_child_location(dev, &sb);
298 bus_child_pnpinfo(dev, &sb);
301 sbuf_cat(&sb, dev->parent ? dev->parent->nameunit : "");
305 error = device_get_prop(dev, DEV_PROP_NAME_IOMMU,
314 iommu_get_requester(dev, &rid);
331 device_sysctl_init(device_t dev)
333 devclass_t dc = dev->devclass;
336 if (dev->sysctl_tree != NULL)
339 sysctl_ctx_init(&dev->sysctl_ctx);
340 dev->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&dev->sysctl_ctx,
342 dev->nameunit + strlen(dc->name),
344 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
346 dev, DEVICE_SYSCTL_DESC, device_sysctl_handler, "A",
348 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
351 dev, DEVICE_SYSCTL_DRIVER, device_sysctl_handler, "A",
353 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
356 dev, DEVICE_SYSCTL_LOCATION, device_sysctl_handler, "A",
358 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
361 dev, DEVICE_SYSCTL_PNPINFO, device_sysctl_handler, "A",
363 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
366 dev, DEVICE_SYSCTL_PARENT, device_sysctl_handler, "A",
368 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
371 dev, DEVICE_SYSCTL_IOMMU, device_sysctl_handler, "A",
373 if (bus_get_domain(dev, &domain) == 0)
374 SYSCTL_ADD_INT(&dev->sysctl_ctx,
375 SYSCTL_CHILDREN(dev->sysctl_tree), OID_AUTO, "%domain",
380 device_sysctl_update(device_t dev)
382 devclass_t dc = dev->devclass;
384 if (dev->sysctl_tree == NULL)
386 sysctl_rename_oid(dev->sysctl_tree, dev->nameunit + strlen(dc->name));
390 device_sysctl_fini(device_t dev)
392 if (dev->sysctl_tree == NULL)
394 sysctl_ctx_free(&dev->sysctl_ctx);
395 dev->sysctl_tree = NULL;
680 device_handle_nomatch(device_t dev)
682 BUS_PROBE_NOMATCH(dev->parent, dev);
683 EVENTHANDLER_DIRECT_INVOKE(device_nomatch, dev);
684 dev->flags |= DF_DONENOMATCH;
776 device_t dev;
794 dev = dc->devices[i];
795 if (dev->driver == driver && dev->parent &&
796 dev->parent->devclass == busclass) {
797 if ((error = device_detach(dev)) != 0)
800 dev->flags &= ~DF_DONENOMATCH;
801 dev->flags |= DF_NEEDNOMATCH;
803 device_handle_nomatch(dev);
904 device_t dev;
939 dev = dc->devices[i];
940 if (dev->driver == driver && dev->parent &&
941 dev->parent->devclass == busclass) {
942 if ((error = device_quiesce(dev)) != 0)
1009 device_t dev;
1011 dev = devclass_get_device(dc, unit);
1012 if (!dev)
1015 return (device_get_softc(dev));
1209 devclass_alloc_unit(devclass_t dc, device_t dev, int *unitp)
1218 BUS_HINT_DEVICE_UNIT(device_get_parent(dev), dev, dc->name,
1289 * @param dev the device to add
1297 devclass_add_device(devclass_t dc, device_t dev)
1301 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
1306 dev->nameunit = malloc(buflen, M_BUS, M_NOWAIT|M_ZERO);
1307 if (!dev->nameunit)
1310 if ((error = devclass_alloc_unit(dc, dev, &dev->unit)) != 0) {
1311 free(dev->nameunit, M_BUS);
1312 dev->nameunit = NULL;
1315 dc->devices[dev->unit] = dev;
1316 dev->devclass = dc;
1317 snprintf(dev->nameunit, buflen, "%s%d", dc->name, dev->unit);
1330 * @param dev the device to delete
1335 devclass_delete_device(devclass_t dc, device_t dev)
1337 if (!dc || !dev)
1340 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
1342 if (dev->devclass != dc || dc->devices[dev->unit] != dev)
1344 dc->devices[dev->unit] = NULL;
1345 if (dev->flags & DF_WILDCARD)
1346 dev->unit = DEVICE_UNIT_ANY;
1347 dev->devclass = NULL;
1348 free(dev->nameunit, M_BUS);
1349 dev->nameunit = NULL;
1369 device_t dev;
1385 dev = malloc(sizeof(*dev), M_BUS, M_NOWAIT|M_ZERO);
1386 if (!dev)
1389 dev->parent = parent;
1390 TAILQ_INIT(&dev->children);
1391 kobj_init((kobj_t) dev, &null_class);
1392 dev->driver = NULL;
1393 dev->devclass = NULL;
1394 dev->unit = unit;
1395 dev->nameunit = NULL;
1396 dev->desc = NULL;
1397 dev->busy = 0;
1398 dev->devflags = 0;
1399 dev->flags = DF_ENABLED;
1400 dev->order = 0;
1402 dev->flags |= DF_WILDCARD;
1404 dev->flags |= DF_FIXEDCLASS;
1405 if (devclass_add_device(dc, dev)) {
1406 kobj_delete((kobj_t) dev, M_BUS);
1411 dev->flags |= DF_QUIET | DF_QUIET_CHILDREN;
1412 dev->ivars = NULL;
1413 dev->softc = NULL;
1414 LIST_INIT(&dev->props);
1416 dev->state = DS_NOTPRESENT;
1418 TAILQ_INSERT_TAIL(&bus_data_devices, dev, devlink);
1421 return (dev);
1429 device_print_child(device_t dev, device_t child)
1434 retval += BUS_PRINT_CHILD(dev, child);
1448 * @param dev the device which will be the parent of the
1458 device_add_child(device_t dev, const char *name, int unit)
1460 return (device_add_child_ordered(dev, 0, name, unit));
1470 * @param dev the device which will be the parent of the
1473 * children of @p dev - devices created using
1475 * dev's list of children
1484 device_add_child_ordered(device_t dev, u_int order, const char *name, int unit)
1490 name, DEVICENAME(dev), order, unit));
1494 child = make_device(dev, name, unit);
1499 TAILQ_FOREACH(place, &dev->children, link) {
1515 TAILQ_INSERT_TAIL(&dev->children, child, link);
1529 * @param dev the parent device
1536 device_delete_child(device_t dev, device_t child)
1541 PDEBUG(("%s from %s", DEVICENAME(child), DEVICENAME(dev)));
1557 device_destroy_props(dev);
1561 BUS_CHILD_DELETED(dev, child);
1562 TAILQ_REMOVE(&dev->children, child, link);
1578 * @param dev the parent device
1584 device_delete_children(device_t dev)
1589 PDEBUG(("Deleting all children of %s", DEVICENAME(dev)));
1593 while ((child = TAILQ_FIRST(&dev->children)) != NULL) {
1594 error = device_delete_child(dev, child);
1607 * devices which have @p dev as a parent.
1609 * @param dev the parent device to search
1611 * @c DEVICE_UNIT_ANY, return the first child of @p dev
1619 device_find_child(device_t dev, const char *classname, int unit)
1630 if (child && child->parent == dev)
1635 if (child && child->parent == dev)
1646 first_matching_driver(devclass_t dc, device_t dev)
1648 if (dev->devclass)
1649 return (devclass_find_driver_internal(dc, dev->devclass->name));
1657 next_matching_driver(devclass_t dc, device_t dev, driverlink_t last)
1659 if (dev->devclass) {
1662 if (!strcmp(dev->devclass->name, dl->driver->name))
1673 device_probe_child(device_t dev, device_t child)
1684 dc = dev->devclass;
1826 device_get_parent(device_t dev)
1828 return (dev->parent);
1839 * @param dev the device to examine
1848 device_get_children(device_t dev, device_t **devlistp, int *devcountp)
1855 TAILQ_FOREACH(child, &dev->children, link) {
1869 TAILQ_FOREACH(child, &dev->children, link) {
1885 device_get_driver(device_t dev)
1887 return (dev->driver);
1895 device_get_devclass(device_t dev)
1897 return (dev->devclass);
1905 device_get_name(device_t dev)
1907 if (dev != NULL && dev->devclass)
1908 return (devclass_get_name(dev->devclass));
1918 device_get_nameunit(device_t dev)
1920 return (dev->nameunit);
1927 device_get_unit(device_t dev)
1929 return (dev->unit);
1936 device_get_desc(device_t dev)
1938 return (dev->desc);
1945 device_get_flags(device_t dev)
1947 return (dev->devflags);
1951 device_get_sysctl_ctx(device_t dev)
1953 return (&dev->sysctl_ctx);
1957 device_get_sysctl_tree(device_t dev)
1959 return (dev->sysctl_tree);
1968 device_print_prettyname(device_t dev)
1970 const char *name = device_get_name(dev);
1974 return (printf("%s%d: ", name, device_get_unit(dev)));
1985 device_printf(device_t dev, const char * fmt, ...)
1998 name = device_get_name(dev);
2003 sbuf_printf(&sb, "%s%d: ", name, device_get_unit(dev));
2023 device_log(device_t dev, int pri, const char * fmt, ...)
2035 name = device_get_name(dev);
2040 sbuf_printf(&sb, "%s%d: ", name, device_get_unit(dev));
2060 device_set_desc_internal(device_t dev, const char *desc, bool allocated)
2062 if (dev->desc && (dev->flags & DF_DESCMALLOCED)) {
2063 free(dev->desc, M_BUS);
2064 dev->flags &= ~DF_DESCMALLOCED;
2065 dev->desc = NULL;
2069 dev->flags |= DF_DESCMALLOCED;
2070 dev->desc = __DECONST(char *, desc);
2083 device_set_desc(device_t dev, const char *desc)
2085 device_set_desc_internal(dev, desc, false);
2094 device_set_descf(device_t dev, const char *fmt, ...)
2102 device_set_desc_internal(dev, buf, true);
2112 device_set_desc_copy(device_t dev, const char *desc)
2117 device_set_desc_internal(dev, buf, true);
2124 device_set_flags(device_t dev, uint32_t flags)
2126 dev->devflags = flags;
2136 device_get_softc(device_t dev)
2138 return (dev->softc);
2148 device_set_softc(device_t dev, void *softc)
2150 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC))
2151 free(dev->softc, M_BUS_SC);
2152 dev->softc = softc;
2153 if (dev->softc)
2154 dev->flags |= DF_EXTERNALSOFTC;
2156 dev->flags &= ~DF_EXTERNALSOFTC;
2180 device_claim_softc(device_t dev)
2182 if (dev->softc)
2183 dev->flags |= DF_EXTERNALSOFTC;
2185 dev->flags &= ~DF_EXTERNALSOFTC;
2196 device_get_ivars(device_t dev)
2198 KASSERT(dev != NULL, ("device_get_ivars(NULL, ...)"));
2199 return (dev->ivars);
2206 device_set_ivars(device_t dev, void * ivars)
2208 KASSERT(dev != NULL, ("device_set_ivars(NULL, ...)"));
2209 dev->ivars = ivars;
2216 device_get_state(device_t dev)
2218 return (dev->state);
2225 device_enable(device_t dev)
2227 dev->flags |= DF_ENABLED;
2234 device_disable(device_t dev)
2236 dev->flags &= ~DF_ENABLED;
2243 device_busy(device_t dev)
2250 if (refcount_acquire(&dev->busy) == 0 && dev->parent != NULL)
2251 device_busy(dev->parent);
2258 device_unbusy(device_t dev)
2264 if (refcount_release(&dev->busy) && dev->parent != NULL)
2265 device_unbusy(dev->parent);
2272 device_quiet(device_t dev)
2274 dev->flags |= DF_QUIET;
2281 device_quiet_children(device_t dev)
2283 dev->flags |= DF_QUIET_CHILDREN;
2290 device_verbose(device_t dev)
2292 dev->flags &= ~DF_QUIET;
2296 device_get_property(device_t dev, const char *prop, void *val, size_t sz,
2299 device_t bus = device_get_parent(dev);
2318 return (BUS_GET_PROPERTY(bus, dev, prop, val, sz, type));
2322 device_has_property(device_t dev, const char *prop)
2324 return (device_get_property(dev, prop, NULL, 0, DEVICE_PROP_ANY) >= 0);
2331 device_has_quiet_children(device_t dev)
2333 return ((dev->flags & DF_QUIET_CHILDREN) != 0);
2340 device_is_quiet(device_t dev)
2342 return ((dev->flags & DF_QUIET) != 0);
2349 device_is_enabled(device_t dev)
2351 return ((dev->flags & DF_ENABLED) != 0);
2358 device_is_alive(device_t dev)
2360 return (dev->state >= DS_ALIVE);
2368 device_is_attached(device_t dev)
2370 return (dev->state >= DS_ATTACHED);
2377 device_is_suspended(device_t dev)
2379 return ((dev->flags & DF_SUSPENDED) != 0);
2387 device_set_devclass(device_t dev, const char *classname)
2393 if (dev->devclass)
2394 devclass_delete_device(dev->devclass, dev);
2398 if (dev->devclass) {
2407 error = devclass_add_device(dc, dev);
2418 device_set_devclass_fixed(device_t dev, const char *classname)
2425 error = device_set_devclass(dev, classname);
2428 dev->flags |= DF_FIXEDCLASS;
2437 device_is_devclass_fixed(device_t dev)
2439 return ((dev->flags & DF_FIXEDCLASS) != 0);
2450 device_set_driver(device_t dev, driver_t *driver)
2455 if (dev->state >= DS_ATTACHED)
2458 if (dev->driver == driver)
2461 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) {
2462 free(dev->softc, M_BUS_SC);
2463 dev->softc = NULL;
2465 device_set_desc(dev, NULL);
2466 kobj_delete((kobj_t) dev, NULL);
2467 dev->driver = driver;
2469 kobj_init((kobj_t) dev, (kobj_class_t) driver);
2470 if (!(dev->flags & DF_EXTERNALSOFTC) && driver->size > 0) {
2471 if (bus_get_domain(dev, &domain) == 0)
2475 dev->softc = malloc_domainset(driver->size, M_BUS_SC,
2477 if (!dev->softc) {
2478 kobj_delete((kobj_t) dev, NULL);
2479 kobj_init((kobj_t) dev, &null_class);
2480 dev->driver = NULL;
2485 kobj_init((kobj_t) dev, &null_class);
2511 * @param dev the device to initialise
2520 device_probe(device_t dev)
2526 if (dev->state >= DS_ALIVE)
2529 if (!(dev->flags & DF_ENABLED)) {
2530 if (bootverbose && device_get_name(dev) != NULL) {
2531 device_print_prettyname(dev);
2536 if ((error = device_probe_child(dev->parent, dev)) != 0) {
2538 !(dev->flags & DF_DONENOMATCH)) {
2539 device_handle_nomatch(dev);
2552 device_probe_and_attach(device_t dev)
2558 error = device_probe(dev);
2564 return (device_attach(dev));
2579 * @param dev the device to initialise
2587 device_attach(device_t dev)
2593 if (resource_disabled(dev->driver->name, dev->unit)) {
2598 device_disable(dev);
2599 (void)device_set_driver(dev, NULL);
2600 dev->state = DS_NOTPRESENT;
2602 device_printf(dev, "disabled via hints entry\n");
2610 device_sysctl_init(dev);
2611 if (!device_is_quiet(dev))
2612 device_print_child(dev->parent, dev);
2614 dev->state = DS_ATTACHING;
2615 if ((error = DEVICE_ATTACH(dev)) != 0) {
2617 dev->driver->name, dev->unit, error);
2618 BUS_CHILD_DETACHED(dev->parent, dev);
2628 device_disable(dev);
2635 if (!(dev->flags & DF_FIXEDCLASS))
2636 devclass_delete_device(dev->devclass, dev);
2637 (void)device_set_driver(dev, NULL);
2638 device_sysctl_fini(dev);
2639 KASSERT(dev->busy == 0, ("attach failed but busy"));
2640 dev->state = DS_NOTPRESENT;
2646 dev->flags |= DF_ATTACHED_ONCE;
2653 device_sysctl_update(dev);
2654 dev->state = DS_ATTACHED;
2655 dev->flags &= ~DF_DONENOMATCH;
2656 EVENTHANDLER_DIRECT_INVOKE(device_attach, dev);
2665 * BUS_CHILD_DETACHED() for the parent of @p dev, queues a
2669 * @param dev the device to un-initialise
2677 device_detach(device_t dev)
2683 PDEBUG(("%s", DEVICENAME(dev)));
2684 if (dev->busy > 0)
2686 if (dev->state == DS_ATTACHING) {
2687 device_printf(dev, "device in attaching state! Deferring detach.\n");
2690 if (dev->state != DS_ATTACHED)
2693 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, EVHDEV_DETACH_BEGIN);
2694 if ((error = DEVICE_DETACH(dev)) != 0) {
2695 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev,
2699 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev,
2702 if (!device_is_quiet(dev))
2703 device_printf(dev, "detached\n");
2704 if (dev->parent)
2705 BUS_CHILD_DETACHED(dev->parent, dev);
2707 if (!(dev->flags & DF_FIXEDCLASS))
2708 devclass_delete_device(dev->devclass, dev);
2710 device_verbose(dev);
2711 dev->state = DS_NOTPRESENT;
2712 (void)device_set_driver(dev, NULL);
2713 device_sysctl_fini(dev);
2724 * @param dev the device to quiesce
2732 device_quiesce(device_t dev)
2734 PDEBUG(("%s", DEVICENAME(dev)));
2735 if (dev->busy > 0)
2737 if (dev->state != DS_ATTACHED)
2740 return (DEVICE_QUIESCE(dev));
2752 device_shutdown(device_t dev)
2754 if (dev->state < DS_ATTACHED)
2756 return (DEVICE_SHUTDOWN(dev));
2766 device_set_unit(device_t dev, int unit)
2771 if (unit == dev->unit)
2773 dc = device_get_devclass(dev);
2776 err = devclass_delete_device(dc, dev);
2779 dev->unit = unit;
2780 err = devclass_add_device(dc, dev);
3396 bus_generic_add_child(device_t dev, u_int order, const char *name, int unit)
3398 return (device_add_child_ordered(dev, order, name, unit));
3410 bus_generic_probe(device_t dev)
3412 bus_identify_children(dev);
3421 * The driver for @param dev must implement the BUS_ADD_CHILD method.
3423 * @param dev the parent device
3426 bus_identify_children(device_t dev)
3428 devclass_t dc = dev->devclass;
3443 DEVICE_IDENTIFY(dl->driver, dev);
3455 bus_generic_attach(device_t dev)
3457 bus_attach_children(dev);
3469 * @param dev the parent device
3472 bus_attach_children(device_t dev)
3476 TAILQ_FOREACH(child, &dev->children, link) {
3489 bus_delayed_attach_children(device_t dev)
3492 config_intrhook_oneshot((ich_func_t)bus_attach_children, dev);
3502 * @param dev the parent device
3508 bus_generic_detach(device_t dev)
3512 error = bus_detach_children(dev);
3516 return (device_delete_children(dev));
3528 * @param dev the parent device
3534 bus_detach_children(device_t dev)
3543 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
3559 bus_generic_shutdown(device_t dev)
3567 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
3580 bus_generic_suspend_child(device_t dev, device_t child)
3602 bus_generic_resume_child(device_t dev, device_t child)
3620 bus_generic_suspend(device_t dev)
3632 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
3633 error = BUS_SUSPEND_CHILD(dev, child);
3637 TAILQ_FOREACH_FROM(child, &dev->children, link)
3638 BUS_RESUME_CHILD(dev, child);
3653 bus_generic_resume(device_t dev)
3657 TAILQ_FOREACH(child, &dev->children, link) {
3658 BUS_RESUME_CHILD(dev, child);
3671 * @param dev The bus
3675 bus_helper_reset_post(device_t dev, int flags)
3681 TAILQ_FOREACH(child, &dev->children,link) {
3682 BUS_RESET_POST(dev, child);
3685 BUS_RESUME_CHILD(dev, child);
3693 bus_helper_reset_prepare_rollback(device_t dev, device_t child, int flags)
3698 TAILQ_FOREACH_FROM(child, &dev->children,link) {
3699 BUS_RESET_POST(dev, child);
3703 BUS_RESUME_CHILD(dev, child);
3715 * @param dev The bus
3719 bus_helper_reset_prepare(device_t dev, int flags)
3724 if (dev->state != DS_ATTACHED)
3727 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
3732 error = BUS_SUSPEND_CHILD(dev, child);
3735 error = BUS_RESET_PREPARE(dev, child);
3740 BUS_RESUME_CHILD(dev, child);
3744 bus_helper_reset_prepare_rollback(dev, child, flags);
3761 bus_print_child_header(device_t dev, device_t child)
3779 * name and unit of the @p dev.
3784 bus_print_child_footer(device_t dev, device_t child)
3786 return (printf(" on %s\n", device_get_nameunit(dev)));
3797 bus_print_child_domain(device_t dev, device_t child)
3802 if (BUS_GET_DOMAIN(dev, child, &domain) != 0)
3817 bus_generic_print_child(device_t dev, device_t child)
3821 retval += bus_print_child_header(dev, child);
3822 retval += bus_print_child_domain(dev, child);
3823 retval += bus_print_child_footer(dev, child);
3834 bus_generic_read_ivar(device_t dev, device_t child, int index,
3846 bus_generic_write_ivar(device_t dev, device_t child, int index,
3855 * This simply calls the BUS_GET_PROPERTY of the parent of dev,
3859 bus_generic_get_property(device_t dev, device_t child, const char *propname,
3862 if (device_get_parent(dev) != NULL)
3863 return (BUS_GET_PROPERTY(device_get_parent(dev), child,
3875 bus_generic_get_resource_list(device_t dev, device_t child)
3888 bus_generic_driver_added(device_t dev, driver_t *driver)
3892 DEVICE_IDENTIFY(driver, dev);
3893 TAILQ_FOREACH(child, &dev->children, link) {
3910 bus_generic_new_pass(device_t dev)
3916 dc = dev->devclass;
3919 DEVICE_IDENTIFY(dl->driver, dev);
3921 TAILQ_FOREACH(child, &dev->children, link) {
3933 * BUS_SETUP_INTR() method of the parent of @p dev.
3936 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq,
3941 if (dev->parent)
3942 return (BUS_SETUP_INTR(dev->parent, child, irq, flags,
3951 * BUS_TEARDOWN_INTR() method of the parent of @p dev.
3954 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq,
3958 if (dev->parent)
3959 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie));
3967 * BUS_SUSPEND_INTR() method of the parent of @p dev.
3970 bus_generic_suspend_intr(device_t dev, device_t child, struct resource *irq)
3973 if (dev->parent)
3974 return (BUS_SUSPEND_INTR(dev->parent, child, irq));
3982 * BUS_RESUME_INTR() method of the parent of @p dev.
3985 bus_generic_resume_intr(device_t dev, device_t child, struct resource *irq)
3988 if (dev->parent)
3989 return (BUS_RESUME_INTR(dev->parent, child, irq));
3997 * BUS_ADJUST_RESOURCE() method of the parent of @p dev.
4000 bus_generic_adjust_resource(device_t dev, device_t child, struct resource *r,
4004 if (dev->parent)
4005 return (BUS_ADJUST_RESOURCE(dev->parent, child, r, start, end));
4013 * BUS_TRANSLATE_RESOURCE() method of the parent of @p dev. If there is no
4017 bus_generic_translate_resource(device_t dev, int type, rman_res_t start,
4020 if (dev->parent)
4021 return (BUS_TRANSLATE_RESOURCE(dev->parent, type, start,
4031 * BUS_ALLOC_RESOURCE() method of the parent of @p dev.
4034 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid,
4038 if (dev->parent)
4039 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid,
4048 * BUS_RELEASE_RESOURCE() method of the parent of @p dev.
4051 bus_generic_release_resource(device_t dev, device_t child, struct resource *r)
4054 if (dev->parent)
4055 return (BUS_RELEASE_RESOURCE(dev->parent, child, r));
4063 * BUS_ACTIVATE_RESOURCE() method of the parent of @p dev.
4066 bus_generic_activate_resource(device_t dev, device_t child, struct resource *r)
4069 if (dev->parent)
4070 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, r));
4078 * BUS_DEACTIVATE_RESOURCE() method of the parent of @p dev.
4081 bus_generic_deactivate_resource(device_t dev, device_t child,
4085 if (dev->parent)
4086 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, r));
4094 * BUS_MAP_RESOURCE() method of the parent of @p dev.
4097 bus_generic_map_resource(device_t dev, device_t child, struct resource *r,
4101 if (dev->parent)
4102 return (BUS_MAP_RESOURCE(dev->parent, child, r, args, map));
4110 * BUS_UNMAP_RESOURCE() method of the parent of @p dev.
4113 bus_generic_unmap_resource(device_t dev, device_t child, struct resource *r,
4117 if (dev->parent)
4118 return (BUS_UNMAP_RESOURCE(dev->parent, child, r, map));
4126 * BUS_BIND_INTR() method of the parent of @p dev.
4129 bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq,
4133 if (dev->parent)
4134 return (BUS_BIND_INTR(dev->parent, child, irq, cpu));
4142 * BUS_CONFIG_INTR() method of the parent of @p dev.
4145 bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig,
4149 if (dev->parent)
4150 return (BUS_CONFIG_INTR(dev->parent, irq, trig, pol));
4158 * BUS_DESCRIBE_INTR() method of the parent of @p dev.
4161 bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq,
4165 if (dev->parent)
4166 return (BUS_DESCRIBE_INTR(dev->parent, child, irq, cookie,
4175 * BUS_GET_CPUS() method of the parent of @p dev.
4178 bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op,
4182 if (dev->parent != NULL)
4183 return (BUS_GET_CPUS(dev->parent, child, op, setsize, cpuset));
4191 * BUS_GET_DMA_TAG() method of the parent of @p dev.
4194 bus_generic_get_dma_tag(device_t dev, device_t child)
4197 if (dev->parent != NULL)
4198 return (BUS_GET_DMA_TAG(dev->parent, child));
4206 * BUS_GET_BUS_TAG() method of the parent of @p dev.
4209 bus_generic_get_bus_tag(device_t dev, device_t child)
4212 if (dev->parent != NULL)
4213 return (BUS_GET_BUS_TAG(dev->parent, child));
4226 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid,
4232 rl = BUS_GET_RESOURCE_LIST(dev, child);
4257 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid,
4262 rl = BUS_GET_RESOURCE_LIST(dev, child);
4280 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid)
4284 rl = BUS_GET_RESOURCE_LIST(dev, child);
4301 bus_generic_rl_release_resource(device_t dev, device_t child,
4306 if (device_get_parent(child) != dev)
4307 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child, r));
4309 rl = BUS_GET_RESOURCE_LIST(dev, child);
4313 return (resource_list_release(rl, dev, child, r));
4324 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type,
4329 if (device_get_parent(child) != dev)
4330 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
4333 rl = BUS_GET_RESOURCE_LIST(dev, child);
4337 return (resource_list_alloc(rl, dev, child, type, rid,
4349 bus_generic_rman_alloc_resource(device_t dev, device_t child, int type,
4355 rm = BUS_GET_RMAN(dev, type, flags);
4384 bus_generic_rman_adjust_resource(device_t dev, device_t child,
4389 rm = BUS_GET_RMAN(dev, rman_get_type(r), rman_get_flags(r));
4404 bus_generic_rman_release_resource(device_t dev, device_t child,
4413 rm = BUS_GET_RMAN(dev, rman_get_type(r), rman_get_flags(r));
4433 bus_generic_rman_activate_resource(device_t dev, device_t child,
4444 rm = BUS_GET_RMAN(dev, type, rman_get_flags(r));
4457 error = BUS_MAP_RESOURCE(dev, child, r, NULL, &map);
4482 bus_generic_rman_deactivate_resource(device_t dev, device_t child,
4493 rm = BUS_GET_RMAN(dev, type, rman_get_flags(r));
4507 BUS_UNMAP_RESOURCE(dev, child, r, &map);
4523 * BUS_CHILD_PRESENT() method of the parent of @p dev.
4526 bus_generic_child_present(device_t dev, device_t child)
4528 return (BUS_CHILD_PRESENT(device_get_parent(dev), dev));
4535 * BUS_GET_DOMAIN() method of the parent of @p dev. If @p dev
4539 bus_generic_get_domain(device_t dev, device_t child, int *domain)
4541 if (dev->parent)
4542 return (BUS_GET_DOMAIN(dev->parent, dev, domain));
4599 bus_null_rescan(device_t dev)
4613 bus_alloc_resources(device_t dev, struct resource_spec *rs,
4621 res[i] = bus_alloc_resource_any(dev,
4624 bus_release_resources(dev, rs, res);
4632 bus_release_resources(device_t dev, const struct resource_spec *rs,
4640 dev, rs[i].type, rs[i].rid, res[i]);
4649 * parent of @p dev.
4652 bus_alloc_resource(device_t dev, int type, int *rid, rman_res_t start,
4657 if (dev->parent == NULL)
4659 res = BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end,
4668 * parent of @p dev.
4671 bus_adjust_resource(device_t dev, struct resource *r, rman_res_t start,
4674 if (dev->parent == NULL)
4676 return (BUS_ADJUST_RESOURCE(dev->parent, dev, r, start, end));
4680 bus_adjust_resource_old(device_t dev, int type __unused, struct resource *r,
4683 return (bus_adjust_resource(dev, r, start, end));
4690 * parent of @p dev.
4693 bus_translate_resource(device_t dev, int type, rman_res_t start,
4696 if (dev->parent == NULL)
4698 return (BUS_TRANSLATE_RESOURCE(dev->parent, type, start, newstart));
4705 * parent of @p dev.
4708 bus_activate_resource(device_t dev, struct resource *r)
4710 if (dev->parent == NULL)
4712 return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, r));
4716 bus_activate_resource_old(device_t dev, int type, int rid, struct resource *r)
4718 return (bus_activate_resource(dev, r));
4725 * parent of @p dev.
4728 bus_deactivate_resource(device_t dev, struct resource *r)
4730 if (dev->parent == NULL)
4732 return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, r));
4736 bus_deactivate_resource_old(device_t dev, int type, int rid, struct resource *r)
4738 return (bus_deactivate_resource(dev, r));
4745 * parent of @p dev.
4748 bus_map_resource(device_t dev, struct resource *r,
4751 if (dev->parent == NULL)
4753 return (BUS_MAP_RESOURCE(dev->parent, dev, r, args, map));
4757 bus_map_resource_old(device_t dev, int type, struct resource *r,
4760 return (bus_map_resource(dev, r, args, map));
4767 * parent of @p dev.
4770 bus_unmap_resource(device_t dev, struct resource *r, struct resource_map *map)
4772 if (dev->parent == NULL)
4774 return (BUS_UNMAP_RESOURCE(dev->parent, dev, r, map));
4778 bus_unmap_resource_old(device_t dev, int type, struct resource *r,
4781 return (bus_unmap_resource(dev, r, map));
4788 * parent of @p dev.
4791 bus_release_resource(device_t dev, struct resource *r)
4795 if (dev->parent == NULL)
4797 rv = BUS_RELEASE_RESOURCE(dev->parent, dev, r);
4802 bus_release_resource_old(device_t dev, int type, int rid, struct resource *r)
4804 return (bus_release_resource(dev, r));
4811 * parent of @p dev.
4814 bus_setup_intr(device_t dev, struct resource *r, int flags,
4819 if (dev->parent == NULL)
4821 error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler,
4826 device_printf(dev, "[GIANT-LOCKED]\n");
4834 * parent of @p dev.
4837 bus_teardown_intr(device_t dev, struct resource *r, void *cookie)
4839 if (dev->parent == NULL)
4841 return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie));
4848 * parent of @p dev.
4851 bus_suspend_intr(device_t dev, struct resource *r)
4853 if (dev->parent == NULL)
4855 return (BUS_SUSPEND_INTR(dev->parent, dev, r));
4862 * parent of @p dev.
4865 bus_resume_intr(device_t dev, struct resource *r)
4867 if (dev->parent == NULL)
4869 return (BUS_RESUME_INTR(dev->parent, dev, r));
4876 * parent of @p dev.
4879 bus_bind_intr(device_t dev, struct resource *r, int cpu)
4881 if (dev->parent == NULL)
4883 return (BUS_BIND_INTR(dev->parent, dev, r, cpu));
4891 * the parent of @p dev.
4894 bus_describe_intr(device_t dev, struct resource *irq, void *cookie,
4900 if (dev->parent == NULL)
4905 return (BUS_DESCRIBE_INTR(dev->parent, dev, irq, cookie, descr));
4912 * parent of @p dev.
4915 bus_set_resource(device_t dev, int type, int rid,
4918 return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid,
4926 * parent of @p dev.
4929 bus_get_resource(device_t dev, int type, int rid,
4932 return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
4940 * parent of @p dev and returns the start value.
4943 bus_get_resource_start(device_t dev, int type, int rid)
4949 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
4960 * parent of @p dev and returns the count value.
4963 bus_get_resource_count(device_t dev, int type, int rid)
4969 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
4980 * parent of @p dev.
4983 bus_delete_resource(device_t dev, int type, int rid)
4985 BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid);
4992 * parent of @p dev.
5004 * dev.
5024 bus_generic_child_pnpinfo(device_t dev, device_t child, struct sbuf *sb)
5033 * @p dev.
5053 bus_generic_child_location(device_t dev, device_t child, struct sbuf *sb)
5062 * parent of @p dev.
5065 bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, cpuset_t *cpuset)
5069 parent = device_get_parent(dev);
5072 return (BUS_GET_CPUS(parent, dev, op, setsize, cpuset));
5079 * parent of @p dev.
5082 bus_get_dma_tag(device_t dev)
5086 parent = device_get_parent(dev);
5089 return (BUS_GET_DMA_TAG(parent, dev));
5096 * parent of @p dev.
5099 bus_get_bus_tag(device_t dev)
5103 parent = device_get_parent(dev);
5106 return (BUS_GET_BUS_TAG(parent, dev));
5113 * parent of @p dev.
5116 bus_get_domain(device_t dev, int *domain)
5118 return (BUS_GET_DOMAIN(device_get_parent(dev), dev, domain));
5123 root_resume(device_t dev)
5127 error = bus_generic_resume(dev);
5135 root_print_child(device_t dev, device_t child)
5139 retval += bus_print_child_header(dev, child);
5146 root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
5163 root_child_present(device_t dev, device_t child)
5169 root_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize,
5327 * @param dev bus device to enumerate
5360 print_device_short(device_t dev, int indent)
5362 if (!dev)
5366 dev->unit, dev->desc,
5367 (dev->parent? "":"no "),
5368 (TAILQ_EMPTY(&dev->children)? "no ":""),
5369 (dev->flags&DF_ENABLED? "enabled,":"disabled,"),
5370 (dev->flags&DF_FIXEDCLASS? "fixed,":""),
5371 (dev->flags&DF_WILDCARD? "wildcard,":""),
5372 (dev->flags&DF_DESCMALLOCED? "descmalloced,":""),
5373 (dev->flags&DF_SUSPENDED? "suspended,":""),
5374 (dev->ivars? "":"no "),
5375 (dev->softc? "":"no "),
5376 dev->busy));
5380 print_device(device_t dev, int indent)
5382 if (!dev)
5385 print_device_short(dev, indent);
5388 print_device_short(dev->parent, indent+1);
5390 print_driver_short(dev->driver, indent+1);
5392 print_devclass_short(dev->devclass, indent+1);
5396 print_device_tree_short(device_t dev, int indent)
5401 if (!dev)
5404 print_device_short(dev, indent);
5406 TAILQ_FOREACH(child, &dev->children, link) {
5412 print_device_tree(device_t dev, int indent)
5417 if (!dev)
5420 print_device(dev, indent);
5422 TAILQ_FOREACH(child, &dev->children, link) {
5542 device_t dev;
5557 TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
5561 if (dev == NULL)
5568 udev->dv_handle = (uintptr_t)dev;
5569 udev->dv_parent = (uintptr_t)dev->parent;
5570 udev->dv_devflags = dev->devflags;
5571 udev->dv_flags = dev->flags;
5572 udev->dv_state = dev->state;
5574 if (dev->nameunit != NULL)
5575 sbuf_cat(&sb, dev->nameunit);
5577 if (dev->desc != NULL)
5578 sbuf_cat(&sb, dev->desc);
5580 if (dev->driver != NULL)
5581 sbuf_cat(&sb, dev->driver->name);
5583 bus_child_pnpinfo(dev, &sb);
5585 bus_child_location(dev, &sb);
5616 bus_free_resource(device_t dev, int type, struct resource *r)
5620 return (bus_release_resource(dev, type, rman_get_rid(r), r));
5626 device_t dev;
5628 TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
5629 if (dev->nameunit != NULL && strcmp(dev->nameunit, name) == 0)
5630 return (dev);
5636 * /dev/devctl2 implementation. The existing /dev/devctl device has
5638 * Another option would be to call this /dev/bus?
5643 device_t dev;
5655 dev = device_lookup_by_name(req->dr_name);
5656 if (dev != NULL) {
5657 *devp = dev;
5662 dev = NULL;
5663 EVENTHANDLER_DIRECT_INVOKE(dev_lookup, req->dr_name, &dev);
5664 if (dev == NULL)
5666 *devp = dev;
5683 device_gen_nomatch(device_t dev)
5687 if (dev->flags & DF_NEEDNOMATCH &&
5688 dev->state == DS_NOTPRESENT) {
5689 device_handle_nomatch(dev);
5691 dev->flags &= ~DF_NEEDNOMATCH;
5692 TAILQ_FOREACH(child, &dev->children, link) {
5728 device_get_path(device_t dev, const char *locator, struct sbuf *sb)
5734 parent = device_get_parent(dev);
5738 error = BUS_GET_DEVICE_PATH(parent, dev, locator, sb);
5754 device_t dev;
5774 error = find_device(req, &dev);
5781 error = find_device(req, &dev);
5795 if (device_is_attached(dev))
5797 else if (!device_is_enabled(dev))
5800 error = device_probe_and_attach(dev);
5803 if (!device_is_attached(dev)) {
5808 error = device_quiesce(dev);
5812 error = device_detach(dev);
5815 if (device_is_enabled(dev)) {
5825 device_enable(dev);
5826 if (dev->devclass != NULL) {
5831 if (resource_disabled(dev->devclass->name, dev->unit))
5832 resource_unset_value(dev->devclass->name,
5833 dev->unit, "disabled");
5836 if (!(dev->flags & DF_FIXEDCLASS))
5837 devclass_delete_device(dev->devclass, dev);
5839 error = device_probe_and_attach(dev);
5842 if (!device_is_enabled(dev)) {
5848 error = device_quiesce(dev);
5857 old = dev->flags;
5858 dev->flags |= DF_FIXEDCLASS;
5859 error = device_detach(dev);
5861 dev->flags &= ~DF_FIXEDCLASS;
5863 device_disable(dev);
5866 if (device_is_suspended(dev)) {
5870 if (device_get_parent(dev) == NULL) {
5874 error = BUS_SUSPEND_CHILD(device_get_parent(dev), dev);
5877 if (!device_is_suspended(dev)) {
5881 if (device_get_parent(dev) == NULL) {
5885 error = BUS_RESUME_CHILD(device_get_parent(dev), dev);
5898 if (dev->devclass != NULL &&
5899 strcmp(driver, dev->devclass->name) == 0)
5907 if (dev->parent == NULL) {
5911 if (!driver_exists(dev->parent, driver)) {
5922 if (device_is_attached(dev)) {
5924 error = device_detach(dev);
5932 if (dev->flags & DF_FIXEDCLASS)
5933 devclass_delete_device(dev->devclass, dev);
5934 dev->flags |= DF_WILDCARD;
5935 dev->unit = DEVICE_UNIT_ANY;
5938 error = devclass_add_device(dc, dev);
5941 dev->flags |= DF_FIXEDCLASS;
5942 error = device_probe_and_attach(dev);
5946 if (!(dev->flags & DF_FIXEDCLASS)) {
5950 if (device_is_attached(dev)) {
5952 error = device_detach(dev);
5959 dev->flags &= ~DF_FIXEDCLASS;
5960 dev->flags |= DF_WILDCARD;
5961 devclass_delete_device(dev->devclass, dev);
5962 error = device_probe_and_attach(dev);
5965 if (!device_is_attached(dev)) {
5969 error = BUS_RESCAN(dev);
5974 parent = device_get_parent(dev);
5980 if (bus_child_present(dev) != 0) {
5986 error = device_delete_child(parent, dev);
6008 if (device_get_parent(dev) == NULL) {
6012 error = BUS_RESET_CHILD(device_get_parent(dev), dev,
6026 error = device_get_path(dev, locator, sb);
6130 dev_wired_cache_match(device_location_cache_t *dcp, device_t dev,
6156 error = device_get_path(dev, locator, sb);
6171 device_prop_find(device_t dev, const char *name)
6177 LIST_FOREACH(e, &dev->props, link) {
6185 device_set_prop(device_t dev, const char *name, void *val,
6192 e = device_prop_find(dev, name);
6197 e = device_prop_find(dev, name);
6207 LIST_INSERT_HEAD(&dev->props, e1, link);
6213 e->dtr(dev, name, e->val, e->dtr_ctx);
6217 LIST_INSERT_HEAD(&dev->props, e, link);
6222 device_get_prop(device_t dev, const char *name, void **valp)
6228 e = device_prop_find(dev, name);
6236 device_clear_prop(device_t dev, const char *name)
6242 e = device_prop_find(dev, name);
6247 e->dtr(dev, e->name, e->val, e->dtr_ctx);
6253 device_destroy_props(device_t dev)
6259 while ((e = LIST_FIRST(&dev->props)) != NULL) {
6260 LIST_REMOVE_HEAD(&dev->props, link);
6262 e->dtr(dev, e->name, e->val, e->dtr_ctx);
6270 device_t dev;
6272 TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
6273 device_clear_prop(dev, name);
6313 _gone_in_dev(device_t dev, int major, const char *msg)
6317 device_printf(dev,
6320 device_printf(dev,
6328 device_t dev;
6333 dev = (device_t)addr;
6335 db_printf("name: %s\n", device_get_nameunit(dev));
6336 db_printf(" driver: %s\n", DRIVERNAME(dev->driver));
6337 db_printf(" class: %s\n", DEVCLANAME(dev->devclass));
6338 db_printf(" addr: %p\n", dev);
6339 db_printf(" parent: %p\n", dev->parent);
6340 db_printf(" softc: %p\n", dev->softc);
6341 db_printf(" ivars: %p\n", dev->ivars);
6346 device_t dev;
6348 TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
6349 db_show_device((db_expr_t)dev, true, count, modif);