Lines Matching +full:dt +full:- +full:binding +full:- +full:check
1 // SPDX-License-Identifier: GPL-2.0
3 * drivers/base/core.c - core driver model code (device registration, etc)
5 * Copyright (c) 2002-3 Patrick Mochel
6 * Copyright (c) 2002-3 Open Source Development Labs
7 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
16 #include <linux/dma-map-ops.h> /* for dma_default_coherent */
51 * __fwnode_link_add - Create a link between two fwnode_handles.
73 list_for_each_entry(link, &sup->consumers, s_hook) in __fwnode_link_add()
74 if (link->consumer == con) { in __fwnode_link_add()
75 link->flags |= flags; in __fwnode_link_add()
81 return -ENOMEM; in __fwnode_link_add()
83 link->supplier = sup; in __fwnode_link_add()
84 INIT_LIST_HEAD(&link->s_hook); in __fwnode_link_add()
85 link->consumer = con; in __fwnode_link_add()
86 INIT_LIST_HEAD(&link->c_hook); in __fwnode_link_add()
87 link->flags = flags; in __fwnode_link_add()
89 list_add(&link->s_hook, &sup->consumers); in __fwnode_link_add()
90 list_add(&link->c_hook, &con->suppliers); in __fwnode_link_add()
106 * __fwnode_link_del - Delete a link between two fwnode_handles.
114 link->consumer, link->supplier); in __fwnode_link_del()
115 list_del(&link->s_hook); in __fwnode_link_del()
116 list_del(&link->c_hook); in __fwnode_link_del()
121 * __fwnode_link_cycle - Mark a fwnode link as being part of a cycle.
129 link->consumer, link->supplier); in __fwnode_link_cycle()
130 link->flags |= FWLINK_FLAG_CYCLE; in __fwnode_link_cycle()
134 * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle.
145 list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) in fwnode_links_purge_suppliers()
150 * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle.
161 list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) in fwnode_links_purge_consumers()
166 * fwnode_links_purge - Delete all links connected to a fwnode_handle.
182 if (fwnode->dev) in fw_devlink_purge_absent_suppliers()
185 fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; in fw_devlink_purge_absent_suppliers()
194 * __fwnode_links_move_consumers - Move consumer from @from to @to fwnode_handle
205 list_for_each_entry_safe(link, tmp, &from->consumers, s_hook) { in __fwnode_links_move_consumers()
206 __fwnode_link_add(link->consumer, to, link->flags); in __fwnode_links_move_consumers()
212 * __fw_devlink_pickup_dangling_consumers - Pick up dangling consumers
228 if (fwnode->dev && fwnode->dev->bus) in __fw_devlink_pickup_dangling_consumers()
231 fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; in __fw_devlink_pickup_dangling_consumers()
273 list_del_rcu(&link->s_node); in device_link_remove_from_lists()
274 list_del_rcu(&link->c_node); in device_link_remove_from_lists()
279 while (target->parent) { in device_is_ancestor()
280 target = target->parent; in device_is_ancestor()
296 * device_is_dependent - Check if one device depends on another one
297 * @dev: Device to check dependencies for.
298 * @target: Device to check against.
300 * Check if @target depends on @dev or any device dependent on it (its child or
309 * The "ancestors" check is needed to catch the case when the target in device_is_dependent()
320 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_is_dependent()
321 if (device_link_flag_is_sync_state_only(link->flags)) in device_is_dependent()
324 if (link->consumer == target) in device_is_dependent()
327 ret = device_is_dependent(link->consumer, target); in device_is_dependent()
338 switch (supplier->links.status) { in device_link_init_status()
340 switch (consumer->links.status) { in device_link_init_status()
349 link->status = DL_STATE_CONSUMER_PROBE; in device_link_init_status()
352 link->status = DL_STATE_DORMANT; in device_link_init_status()
357 switch (consumer->links.status) { in device_link_init_status()
359 link->status = DL_STATE_CONSUMER_PROBE; in device_link_init_status()
362 link->status = DL_STATE_ACTIVE; in device_link_init_status()
365 link->status = DL_STATE_AVAILABLE; in device_link_init_status()
370 link->status = DL_STATE_SUPPLIER_UNBIND; in device_link_init_status()
373 link->status = DL_STATE_DORMANT; in device_link_init_status()
393 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_reorder_to_tail()
394 if (device_link_flag_is_sync_state_only(link->flags)) in device_reorder_to_tail()
396 device_reorder_to_tail(link->consumer, NULL); in device_reorder_to_tail()
403 * device_pm_move_to_tail - Move set of devices to the end of device lists
429 switch (to_devlink(dev)->status) { in status_show()
513 * PM-runtime usage counter to remove the reference taken by in device_link_release_fn()
516 if (link->supplier_preactivated) in device_link_release_fn()
517 pm_runtime_put_noidle(link->supplier); in device_link_release_fn()
519 pm_request_idle(link->supplier); in device_link_release_fn()
521 put_device(link->consumer); in device_link_release_fn()
522 put_device(link->supplier); in device_link_release_fn()
530 INIT_WORK(&link->rm_work, device_link_release_fn); in devlink_dev_release()
537 queue_work(device_link_wq, &link->rm_work); in devlink_dev_release()
541 * device_link_wait_removal - Wait for ongoing devlink removal jobs to terminate
565 struct device *sup = link->supplier; in devlink_add_symlinks()
566 struct device *con = link->consumer; in devlink_add_symlinks()
568 ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); in devlink_add_symlinks()
572 ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); in devlink_add_symlinks()
578 ret = -ENOMEM; in devlink_add_symlinks()
582 ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf_con); in devlink_add_symlinks()
588 ret = -ENOMEM; in devlink_add_symlinks()
592 ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf_sup); in devlink_add_symlinks()
599 sysfs_remove_link(&sup->kobj, buf_con); in devlink_add_symlinks()
601 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_add_symlinks()
603 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_add_symlinks()
612 struct device *sup = link->supplier; in devlink_remove_symlinks()
613 struct device *con = link->consumer; in devlink_remove_symlinks()
615 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_remove_symlinks()
616 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_remove_symlinks()
622 sysfs_remove_link(&con->kobj, buf_sup); in devlink_remove_symlinks()
628 sysfs_remove_link(&sup->kobj, buf_con); in devlink_remove_symlinks()
669 * device_link_add - Create a link between two devices.
681 * be forced into the active meta state and reference-counted upon the creation
691 * can only be used to check whether or not the link is present. In that case,
705 * driver after successfully binding a driver to the supplier device.
718 * A side effect of the link creation is re-ordering of dpm_list and the
759 * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and in device_link_add()
761 * SYNC_STATE_ONLY link, we don't check for reverse dependencies in device_link_add()
776 consumer->links.status != DL_DEV_NO_DRIVER && in device_link_add()
777 consumer->links.status != DL_DEV_PROBING) { in device_link_add()
790 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_add()
791 if (link->consumer != consumer) in device_link_add()
796 link->flags &= ~DL_FLAG_INFERRED; in device_link_add()
801 link->flags |= DL_FLAG_PM_RUNTIME; in device_link_add()
804 refcount_inc(&link->rpm_active); in device_link_add()
808 kref_get(&link->kref); in device_link_add()
811 link->flags |= DL_FLAG_STATELESS; in device_link_add()
814 link->flags |= DL_FLAG_STATELESS; in device_link_add()
826 link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; in device_link_add()
827 link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; in device_link_add()
830 link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | in device_link_add()
834 kref_get(&link->kref); in device_link_add()
835 link->flags |= DL_FLAG_MANAGED; in device_link_add()
840 link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; in device_link_add()
851 refcount_set(&link->rpm_active, 1); in device_link_add()
854 link->supplier = supplier; in device_link_add()
855 INIT_LIST_HEAD(&link->s_node); in device_link_add()
857 link->consumer = consumer; in device_link_add()
858 INIT_LIST_HEAD(&link->c_node); in device_link_add()
859 link->flags = flags; in device_link_add()
860 kref_init(&link->kref); in device_link_add()
862 link->link_dev.class = &devlink_class; in device_link_add()
863 device_set_pm_not_required(&link->link_dev); in device_link_add()
864 dev_set_name(&link->link_dev, "%s:%s--%s:%s", in device_link_add()
867 if (device_register(&link->link_dev)) { in device_link_add()
868 put_device(&link->link_dev); in device_link_add()
875 refcount_inc(&link->rpm_active); in device_link_add()
882 link->status = DL_STATE_NONE; in device_link_add()
890 if (link->status == DL_STATE_CONSUMER_PROBE && in device_link_add()
894 list_add_tail_rcu(&link->s_node, &supplier->links.consumers); in device_link_add()
895 list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); in device_link_add()
931 dev_dbg(link->consumer, "Dropping the link to %s\n", in __device_link_del()
932 dev_name(link->supplier)); in __device_link_del()
937 device_unregister(&link->link_dev); in __device_link_del()
943 kref_put(&link->kref, __device_link_del); in device_link_put_kref()
944 else if (!device_is_registered(link->consumer)) in device_link_put_kref()
945 __device_link_del(&link->kref); in device_link_put_kref()
951 * device_link_del - Delete a stateless link between two devices.
968 * device_link_remove - Delete a stateless link between two devices.
984 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_remove()
985 if (link->consumer == consumer) { in device_link_remove()
999 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_missing_supplier()
1000 if (link->status != DL_STATE_CONSUMER_PROBE) in device_links_missing_supplier()
1003 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in device_links_missing_supplier()
1004 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_missing_supplier()
1007 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_missing_supplier()
1014 return (fw_devlink_best_effort && dev->can_match) || in dev_is_best_effort()
1015 (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT)); in dev_is_best_effort()
1026 list_for_each_entry(link, &fwnode->suppliers, c_hook) in fwnode_links_check_suppliers()
1027 if (!(link->flags & in fwnode_links_check_suppliers()
1029 return link->supplier; in fwnode_links_check_suppliers()
1035 * device_links_check_suppliers - Check presence of supplier drivers.
1038 * Check links from this device to any suppliers. Walk the list of the device's
1040 * return -EPROBE_DEFER.
1042 * We need to guarantee that the supplier will not go away after the check has
1061 sup_fw = fwnode_links_check_suppliers(dev->fwnode); in device_links_check_suppliers()
1064 fwnode_ret = -EAGAIN; in device_links_check_suppliers()
1066 return dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1073 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_check_suppliers()
1077 if (link->status != DL_STATE_AVAILABLE && in device_links_check_suppliers()
1082 !link->supplier->can_match) { in device_links_check_suppliers()
1083 ret = -EAGAIN; in device_links_check_suppliers()
1088 ret = dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1089 "supplier %s not ready\n", dev_name(link->supplier)); in device_links_check_suppliers()
1092 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_check_suppliers()
1094 dev->links.status = DL_DEV_PROBING; in device_links_check_suppliers()
1102 * __device_links_queue_sync_state - Queue a device for sync_state() callback
1126 if (dev->state_synced) in __device_links_queue_sync_state()
1129 list_for_each_entry(link, &dev->links.consumers, s_node) { in __device_links_queue_sync_state()
1132 if (link->status != DL_STATE_ACTIVE) in __device_links_queue_sync_state()
1141 dev->state_synced = true; in __device_links_queue_sync_state()
1143 if (WARN_ON(!list_empty(&dev->links.defer_sync))) in __device_links_queue_sync_state()
1147 list_add_tail(&dev->links.defer_sync, list); in __device_links_queue_sync_state()
1151 * device_links_flush_sync_list - Call sync_state() on a list of devices
1166 list_del_init(&dev->links.defer_sync); in device_links_flush_sync_list()
1197 defer_sync_state_count--; in device_links_supplier_sync_state_resume()
1206 list_del_init(&dev->links.defer_sync); in device_links_supplier_sync_state_resume()
1224 if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) in __device_links_supplier_defer_sync()
1225 list_add_tail(&sup->links.defer_sync, &deferred_sync); in __device_links_supplier_defer_sync()
1230 link->flags &= ~DL_FLAG_MANAGED; in device_link_drop_managed()
1231 WRITE_ONCE(link->status, DL_STATE_NONE); in device_link_drop_managed()
1232 kref_put(&link->kref, __device_link_del); in device_link_drop_managed()
1243 val = !!fwnode_links_check_suppliers(dev->fwnode); in waiting_for_supplier_show()
1250 * device_links_force_bind - Prepares device to be force bound
1269 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_force_bind()
1273 if (link->status != DL_STATE_AVAILABLE) { in device_links_force_bind()
1277 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_force_bind()
1279 dev->links.status = DL_DEV_PROBING; in device_links_force_bind()
1285 * device_links_driver_bound - Update device links after probing its driver.
1314 if (dev->fwnode && dev->fwnode->dev == dev) { in device_links_driver_bound()
1317 fwnode_links_purge_suppliers(dev->fwnode); in device_links_driver_bound()
1321 fwnode_for_each_available_child_node(dev->fwnode, child) in device_links_driver_bound()
1323 dev->fwnode); in device_links_driver_bound()
1330 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_driver_bound()
1340 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_driver_bound()
1341 link->status == DL_STATE_ACTIVE) in device_links_driver_bound()
1344 WARN_ON(link->status != DL_STATE_DORMANT); in device_links_driver_bound()
1345 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_driver_bound()
1348 driver_deferred_probe_add(link->consumer); in device_links_driver_bound()
1356 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_driver_bound()
1362 supplier = link->supplier; in device_links_driver_bound()
1372 link->status != DL_STATE_CONSUMER_PROBE && in device_links_driver_bound()
1373 !link->supplier->can_match) { in device_links_driver_bound()
1383 WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); in device_links_driver_bound()
1384 WRITE_ONCE(link->status, DL_STATE_ACTIVE); in device_links_driver_bound()
1399 dev->links.status = DL_DEV_DRIVER_BOUND; in device_links_driver_bound()
1407 * __device_links_no_driver - Update links of a device without a driver.
1410 * Delete all non-persistent links from this device to any suppliers.
1422 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in __device_links_no_driver()
1431 if (link->status != DL_STATE_CONSUMER_PROBE && in __device_links_no_driver()
1432 link->status != DL_STATE_ACTIVE) in __device_links_no_driver()
1435 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in __device_links_no_driver()
1436 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in __device_links_no_driver()
1439 WRITE_ONCE(link->status, DL_STATE_DORMANT); in __device_links_no_driver()
1443 dev->links.status = DL_DEV_NO_DRIVER; in __device_links_no_driver()
1447 * device_links_no_driver - Update links after failing driver probe.
1462 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_no_driver()
1473 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_no_driver()
1474 link->status == DL_STATE_ACTIVE) in device_links_no_driver()
1475 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_no_driver()
1484 * device_links_driver_cleanup - Update links after driver removal.
1499 list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { in device_links_driver_cleanup()
1504 WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); in device_links_driver_cleanup()
1511 if (link->status == DL_STATE_SUPPLIER_UNBIND && in device_links_driver_cleanup()
1515 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_driver_cleanup()
1518 list_del_init(&dev->links.defer_sync); in device_links_driver_cleanup()
1525 * device_links_busy - Check if there are any busy links to consumers.
1526 * @dev: Device to check.
1528 * Check each consumer of the device and return 'true' if its link's status
1545 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_busy()
1549 if (link->status == DL_STATE_CONSUMER_PROBE in device_links_busy()
1550 || link->status == DL_STATE_ACTIVE) { in device_links_busy()
1554 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_busy()
1557 dev->links.status = DL_DEV_UNBINDING; in device_links_busy()
1564 * device_links_unbind_consumers - Force unbind consumers of the given device.
1572 * and check if the link was in the "active" state. If so, force the consumer
1573 * driver to unbind and start over (the consumer will not re-probe as we have
1585 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_unbind_consumers()
1592 status = link->status; in device_links_unbind_consumers()
1599 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_unbind_consumers()
1601 struct device *consumer = link->consumer; in device_links_unbind_consumers()
1608 consumer->parent); in device_links_unbind_consumers()
1618 * device_links_purge - Delete existing links to other devices.
1625 if (dev->class == &devlink_class) in device_links_purge()
1634 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in device_links_purge()
1635 WARN_ON(link->status == DL_STATE_ACTIVE); in device_links_purge()
1636 __device_link_del(&link->kref); in device_links_purge()
1639 list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { in device_links_purge()
1640 WARN_ON(link->status != DL_STATE_DORMANT && in device_links_purge()
1641 link->status != DL_STATE_NONE); in device_links_purge()
1642 __device_link_del(&link->kref); in device_links_purge()
1659 return -EINVAL; in fw_devlink_setup()
1693 return -EINVAL; in fw_devlink_sync_state_setup()
1702 return -EINVAL; in fw_devlink_sync_state_setup()
1726 if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) in fw_devlink_parse_fwnode()
1730 fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; in fw_devlink_parse_fwnode()
1748 if (device_link_flag_is_sync_state_only(link->flags)) in fw_devlink_relax_link()
1752 link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; in fw_devlink_relax_link()
1753 dev_dbg(link->consumer, "Relaxing link with %s\n", in fw_devlink_relax_link()
1754 dev_name(link->supplier)); in fw_devlink_relax_link()
1761 if (!link->supplier->can_match) in fw_devlink_no_driver()
1779 struct device *sup = link->supplier; in fw_devlink_dev_sync_state()
1782 link->status == DL_STATE_ACTIVE || sup->state_synced || in fw_devlink_dev_sync_state()
1788 dev_name(link->consumer)); in fw_devlink_dev_sync_state()
1792 if (!list_empty(&sup->links.defer_sync)) in fw_devlink_dev_sync_state()
1796 sup->state_synced = true; in fw_devlink_dev_sync_state()
1798 list_add_tail(&sup->links.defer_sync, data); in fw_devlink_dev_sync_state()
1815 * wait_for_init_devices_probe - Try to probe any device needed for init
1878 list_for_each_entry(link, &dev->links.consumers, s_node) in fw_devlink_unblock_consumers()
1888 if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED)) in fwnode_init_without_drv()
1892 ret = !dev || dev->links.status == DL_DEV_NO_DRIVER; in fwnode_init_without_drv()
1913 * fwnode_is_ancestor_of - Test if @ancestor is ancestor of @child
1942 * fwnode_get_next_parent_dev - Find device of closest ancestor fwnode
1970 * __fw_devlink_relax_cycles - Relax and mark dependency cycles.
1976 * Check if @sup_handle or any of its ancestors or suppliers direct/indirectly
2004 if (sup_handle->flags & FWNODE_FLAG_VISITED) in __fw_devlink_relax_cycles()
2007 sup_handle->flags |= FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
2011 pr_debug("----- cycle: start -----\n"); in __fw_devlink_relax_cycles()
2019 * If sup_dev is bound to a driver and @con hasn't started binding to a in __fw_devlink_relax_cycles()
2020 * driver, sup_dev can't be a consumer of @con. So, no need to check in __fw_devlink_relax_cycles()
2023 if (sup_dev && sup_dev->links.status == DL_DEV_DRIVER_BOUND && in __fw_devlink_relax_cycles()
2024 con_dev && con_dev->links.status == DL_DEV_NO_DRIVER) { in __fw_devlink_relax_cycles()
2029 list_for_each_entry(link, &sup_handle->suppliers, c_hook) { in __fw_devlink_relax_cycles()
2030 if (link->flags & FWLINK_FLAG_IGNORE) in __fw_devlink_relax_cycles()
2033 if (__fw_devlink_relax_cycles(con_handle, link->supplier)) { in __fw_devlink_relax_cycles()
2044 par_dev = get_device(sup_dev->parent); in __fw_devlink_relax_cycles()
2048 if (par_dev && __fw_devlink_relax_cycles(con_handle, par_dev->fwnode)) { in __fw_devlink_relax_cycles()
2050 par_dev->fwnode); in __fw_devlink_relax_cycles()
2057 list_for_each_entry(dev_link, &sup_dev->links.suppliers, c_node) { in __fw_devlink_relax_cycles()
2062 if (device_link_flag_is_sync_state_only(dev_link->flags) && in __fw_devlink_relax_cycles()
2067 dev_link->supplier->fwnode)) { in __fw_devlink_relax_cycles()
2069 dev_link->supplier->fwnode); in __fw_devlink_relax_cycles()
2071 dev_link->flags |= DL_FLAG_CYCLE; in __fw_devlink_relax_cycles()
2077 sup_handle->flags &= ~FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
2085 * fw_devlink_create_devlink - Create a device link from a consumer to fwnode
2100 * -EINVAL if the device link cannot be created as expected
2101 * -EAGAIN if the device link cannot be created right now, but it may be
2112 if (link->flags & FWLINK_FLAG_IGNORE) in fw_devlink_create_devlink()
2130 if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD && in fw_devlink_create_devlink()
2131 fwnode_is_ancestor_of(sup_handle, con->fwnode)) in fw_devlink_create_devlink()
2132 return -EINVAL; in fw_devlink_create_devlink()
2140 if (__fw_devlink_relax_cycles(link->consumer, sup_handle)) { in fw_devlink_create_devlink()
2142 pr_debug("----- cycle: end -----\n"); in fw_devlink_create_devlink()
2144 link->consumer, sup_handle); in fw_devlink_create_devlink()
2148 if (con->fwnode == link->consumer) in fw_devlink_create_devlink()
2149 flags = fw_devlink_get_flags(link->flags); in fw_devlink_create_devlink()
2153 if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE) in fw_devlink_create_devlink()
2164 if (sup_dev->links.status == DL_DEV_NO_DRIVER && in fw_devlink_create_devlink()
2165 sup_handle->flags & FWNODE_FLAG_INITIALIZED) { in fw_devlink_create_devlink()
2167 "Not linking %pfwf - dev might never probe\n", in fw_devlink_create_devlink()
2169 ret = -EINVAL; in fw_devlink_create_devlink()
2175 flags, dev_name(sup_dev), link->consumer); in fw_devlink_create_devlink()
2176 ret = -EINVAL; in fw_devlink_create_devlink()
2188 dev_dbg(con, "Not linking %pfwf - might never become dev\n", in fw_devlink_create_devlink()
2190 return -EINVAL; in fw_devlink_create_devlink()
2193 ret = -EAGAIN; in fw_devlink_create_devlink()
2200 * __fw_devlink_link_to_consumers - Create device links to consumers of a device
2217 struct fwnode_handle *fwnode = dev->fwnode; in __fw_devlink_link_to_consumers()
2220 list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { in __fw_devlink_link_to_consumers()
2225 con_dev = get_dev_from_fwnode(link->consumer); in __fw_devlink_link_to_consumers()
2237 con_dev = fwnode_get_next_parent_dev(link->consumer); in __fw_devlink_link_to_consumers()
2241 * consumer-supplier link from the parent to its child in __fw_devlink_link_to_consumers()
2245 fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { in __fw_devlink_link_to_consumers()
2258 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_consumers()
2266 * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device
2274 * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev
2291 bool own_link = (dev->fwnode == fwnode); in __fw_devlink_link_to_suppliers()
2295 list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { in __fw_devlink_link_to_suppliers()
2297 struct fwnode_handle *sup = link->supplier; in __fw_devlink_link_to_suppliers()
2300 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_suppliers()
2318 struct fwnode_handle *fwnode = dev->fwnode; in fw_devlink_link_device()
2366 return !(dev->type == &part_type); in device_is_not_partition()
2390 * dev_driver_string - Return a device's driver name, if at all possible
2402 /* dev->driver can change to NULL underneath us because of unbinding, in dev_driver_string()
2403 * so be careful about accessing it. dev->bus and dev->class should in dev_driver_string()
2406 drv = READ_ONCE(dev->driver); in dev_driver_string()
2407 return drv ? drv->name : dev_bus_name(dev); in dev_driver_string()
2418 ssize_t ret = -EIO; in dev_attr_show()
2420 if (dev_attr->show) in dev_attr_show()
2421 ret = dev_attr->show(dev, dev_attr, buf); in dev_attr_show()
2424 dev_attr->show); in dev_attr_show()
2434 ssize_t ret = -EIO; in dev_attr_store()
2436 if (dev_attr->store) in dev_attr_store()
2437 ret = dev_attr->store(dev, dev_attr, buf, count); in dev_attr_store()
2459 *(unsigned long *)(ea->var) = new; in device_store_ulong()
2470 return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); in device_show_ulong()
2487 return -EINVAL; in device_store_int()
2488 *(int *)(ea->var) = new; in device_store_int()
2500 return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); in device_show_int()
2509 if (kstrtobool(buf, ea->var) < 0) in device_store_bool()
2510 return -EINVAL; in device_store_bool()
2521 return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); in device_show_bool()
2530 return sysfs_emit(buf, "%s\n", (char *)ea->var); in device_show_string()
2535 * device_release - free device structure.
2545 struct device_private *p = dev->p; in device_release()
2558 kfree(dev->dma_range_map); in device_release()
2560 if (dev->release) in device_release()
2561 dev->release(dev); in device_release()
2562 else if (dev->type && dev->type->release) in device_release()
2563 dev->type->release(dev); in device_release()
2564 else if (dev->class && dev->class->dev_release) in device_release()
2565 dev->class->dev_release(dev); in device_release()
2567 …e a release() function, it is broken and must be fixed. See Documentation/core-api/kobject.rst.\n", in device_release()
2577 if (dev->class && dev->class->namespace) in device_namespace()
2578 ns = dev->class->namespace(dev); in device_namespace()
2587 if (dev->class && dev->class->get_ownership) in device_get_ownership()
2588 dev->class->get_ownership(dev, uid, gid); in device_get_ownership()
2605 if (dev->bus) in dev_uevent_filter()
2607 if (dev->class) in dev_uevent_filter()
2617 if (dev->bus) in dev_uevent_name()
2618 return dev->bus->name; in dev_uevent_name()
2619 if (dev->class) in dev_uevent_name()
2620 return dev->class->name; in dev_uevent_name()
2626 * function may race with binding and unbinding the device from a driver,
2627 * we need to be careful. Binding is generally safe, at worst we miss the
2629 * information that is delivered through uevents is best-effort, it may
2640 struct subsys_private *sp = bus_to_subsys(dev->bus); in dev_driver_uevent()
2643 scoped_guard(spinlock, &sp->klist_drivers.k_lock) { in dev_driver_uevent()
2644 struct device_driver *drv = READ_ONCE(dev->driver); in dev_driver_uevent()
2646 add_uevent_var(env, "DRIVER=%s", drv->name); in dev_driver_uevent()
2659 if (MAJOR(dev->devt)) { in dev_uevent()
2666 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); in dev_uevent()
2667 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); in dev_uevent()
2681 if (dev->type && dev->type->name) in dev_uevent()
2682 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); in dev_uevent()
2687 /* Add common DT information about the device */ in dev_uevent()
2691 if (dev->bus && dev->bus->uevent) { in dev_uevent()
2692 retval = dev->bus->uevent(dev, env); in dev_uevent()
2699 if (dev->class && dev->class->dev_uevent) { in dev_uevent()
2700 retval = dev->class->dev_uevent(dev, env); in dev_uevent()
2708 if (dev->type && dev->type->uevent) { in dev_uevent()
2709 retval = dev->type->uevent(dev, env); in dev_uevent()
2736 top_kobj = &dev->kobj; in uevent_show()
2737 while (!top_kobj->kset && top_kobj->parent) in uevent_show()
2738 top_kobj = top_kobj->parent; in uevent_show()
2739 if (!top_kobj->kset) in uevent_show()
2742 kset = top_kobj->kset; in uevent_show()
2743 if (!kset->uevent_ops || !kset->uevent_ops->uevent) in uevent_show()
2747 if (kset->uevent_ops && kset->uevent_ops->filter) in uevent_show()
2748 if (!kset->uevent_ops->filter(&dev->kobj)) in uevent_show()
2753 return -ENOMEM; in uevent_show()
2756 retval = kset->uevent_ops->uevent(&dev->kobj, env); in uevent_show()
2761 for (i = 0; i < env->envp_idx; i++) in uevent_show()
2762 len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); in uevent_show()
2773 rc = kobject_synth_uevent(&dev->kobj, buf, count); in uevent_store()
2790 val = !dev->offline; in online_show()
2820 switch (dev->removable) { in removable_show()
2836 return sysfs_create_groups(&dev->kobj, groups); in device_add_groups()
2843 sysfs_remove_groups(&dev->kobj, groups); in device_remove_groups()
2855 const struct attribute_group *group = devres->group; in devm_attr_group_remove()
2858 sysfs_remove_group(&dev->kobj, group); in devm_attr_group_remove()
2862 * devm_device_add_group - given a device, create a managed attribute group
2879 return -ENOMEM; in devm_device_add_group()
2881 error = sysfs_create_group(&dev->kobj, grp); in devm_device_add_group()
2887 devres->group = grp; in devm_device_add_group()
2895 const struct class *class = dev->class; in device_add_attrs()
2896 const struct device_type *type = dev->type; in device_add_attrs()
2900 error = device_add_groups(dev, class->dev_groups); in device_add_attrs()
2906 error = device_add_groups(dev, type->groups); in device_add_attrs()
2911 error = device_add_groups(dev, dev->groups); in device_add_attrs()
2915 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_add_attrs()
2921 if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { in device_add_attrs()
2949 device_remove_groups(dev, dev->groups); in device_add_attrs()
2952 device_remove_groups(dev, type->groups); in device_add_attrs()
2955 device_remove_groups(dev, class->dev_groups); in device_add_attrs()
2962 const struct class *class = dev->class; in device_remove_attrs()
2963 const struct device_type *type = dev->type; in device_remove_attrs()
2965 if (dev->physical_location) { in device_remove_attrs()
2967 kfree(dev->physical_location); in device_remove_attrs()
2973 device_remove_groups(dev, dev->groups); in device_remove_attrs()
2976 device_remove_groups(dev, type->groups); in device_remove_attrs()
2979 device_remove_groups(dev, class->dev_groups); in device_remove_attrs()
2985 return print_dev_t(buf, dev->devt); in dev_show()
2993 * devices_kset_move_before - Move device in the devices_kset's list.
3003 spin_lock(&devices_kset->list_lock); in devices_kset_move_before()
3004 list_move_tail(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_before()
3005 spin_unlock(&devices_kset->list_lock); in devices_kset_move_before()
3009 * devices_kset_move_after - Move device in the devices_kset's list.
3019 spin_lock(&devices_kset->list_lock); in devices_kset_move_after()
3020 list_move(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_after()
3021 spin_unlock(&devices_kset->list_lock); in devices_kset_move_after()
3025 * devices_kset_move_last - move the device to the end of devices_kset's list.
3033 spin_lock(&devices_kset->list_lock); in devices_kset_move_last()
3034 list_move_tail(&dev->kobj.entry, &devices_kset->list); in devices_kset_move_last()
3035 spin_unlock(&devices_kset->list_lock); in devices_kset_move_last()
3039 * device_create_file - create sysfs attribute file for device.
3049 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), in device_create_file()
3051 attr->attr.name); in device_create_file()
3052 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), in device_create_file()
3054 attr->attr.name); in device_create_file()
3055 error = sysfs_create_file(&dev->kobj, &attr->attr); in device_create_file()
3063 * device_remove_file - remove sysfs attribute file.
3071 sysfs_remove_file(&dev->kobj, &attr->attr); in device_remove_file()
3076 * device_remove_file_self - remove sysfs attribute file from its own method.
3086 return sysfs_remove_file_self(&dev->kobj, &attr->attr); in device_remove_file_self()
3093 * device_create_bin_file - create sysfs binary attribute file for device.
3100 int error = -EINVAL; in device_create_bin_file()
3102 error = sysfs_create_bin_file(&dev->kobj, attr); in device_create_bin_file()
3108 * device_remove_bin_file - remove sysfs binary attribute file
3116 sysfs_remove_bin_file(&dev->kobj, attr); in device_remove_bin_file()
3123 struct device *dev = p->device; in klist_children_get()
3131 struct device *dev = p->device; in klist_children_put()
3137 * device_initialize - init device structure.
3158 dev->kobj.kset = devices_kset; in device_initialize()
3159 kobject_init(&dev->kobj, &device_ktype); in device_initialize()
3160 INIT_LIST_HEAD(&dev->dma_pools); in device_initialize()
3161 mutex_init(&dev->mutex); in device_initialize()
3162 lockdep_set_novalidate_class(&dev->mutex); in device_initialize()
3163 spin_lock_init(&dev->devres_lock); in device_initialize()
3164 INIT_LIST_HEAD(&dev->devres_head); in device_initialize()
3167 INIT_LIST_HEAD(&dev->links.consumers); in device_initialize()
3168 INIT_LIST_HEAD(&dev->links.suppliers); in device_initialize()
3169 INIT_LIST_HEAD(&dev->links.defer_sync); in device_initialize()
3170 dev->links.status = DL_DEV_NO_DRIVER; in device_initialize()
3174 dev->dma_coherent = dma_default_coherent; in device_initialize()
3186 &devices_kset->kobj); in virtual_device_parent()
3208 return dir->class->ns_type; in class_dir_child_ns_type()
3225 return ERR_PTR(-ENOMEM); in class_dir_create_and_add()
3227 dir->class = sp->class; in class_dir_create_and_add()
3228 kobject_init(&dir->kobj, &class_dir_ktype); in class_dir_create_and_add()
3230 dir->kobj.kset = &sp->glue_dirs; in class_dir_create_and_add()
3232 retval = kobject_add(&dir->kobj, parent_kobj, "%s", sp->class->name); in class_dir_create_and_add()
3234 kobject_put(&dir->kobj); in class_dir_create_and_add()
3237 return &dir->kobj; in class_dir_create_and_add()
3245 struct subsys_private *sp = class_to_subsys(dev->class); in get_device_parent()
3254 * Class-devices with a non class-device as parent, live in get_device_parent()
3259 else if (parent->class && !dev->class->ns_type) { in get_device_parent()
3261 return &parent->kobj; in get_device_parent()
3263 parent_kobj = &parent->kobj; in get_device_parent()
3268 /* find our class-directory at the parent and reference it */ in get_device_parent()
3269 spin_lock(&sp->glue_dirs.list_lock); in get_device_parent()
3270 list_for_each_entry(k, &sp->glue_dirs.list, entry) in get_device_parent()
3271 if (k->parent == parent_kobj) { in get_device_parent()
3275 spin_unlock(&sp->glue_dirs.list_lock); in get_device_parent()
3282 /* or create a new class-directory at the parent device */ in get_device_parent()
3291 if (!parent && dev->bus) { in get_device_parent()
3292 struct device *dev_root = bus_get_dev_root(dev->bus); in get_device_parent()
3295 kobj = &dev_root->kobj; in get_device_parent()
3302 return &parent->kobj; in get_device_parent()
3312 if (!kobj || !dev->class) in live_in_glue_dir()
3315 sp = class_to_subsys(dev->class); in live_in_glue_dir()
3319 if (kobj->kset == &sp->glue_dirs) in live_in_glue_dir()
3330 return dev->kobj.parent; in get_glue_dir()
3334 * kobject_has_children - Returns whether a kobject has children.
3345 WARN_ON_ONCE(kref_read(&kobj->kref) == 0); in kobject_has_children()
3347 return kobj->sd && kobj->sd->dir.subdirs; in kobject_has_children()
3390 * sysfs_remove_dir() // glue_dir->sd=NULL in cleanup_glue_dir()
3391 * sysfs_put() // free glue_dir->sd in cleanup_glue_dir()
3403 * and sysfs_put(). This result in glue_dir->sd is freed. in cleanup_glue_dir()
3412 ref = kref_read(&glue_dir->kref); in cleanup_glue_dir()
3413 if (!kobject_has_children(glue_dir) && !--ref) in cleanup_glue_dir()
3426 error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); in device_add_class_symlinks()
3432 sp = class_to_subsys(dev->class); in device_add_class_symlinks()
3436 error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); in device_add_class_symlinks()
3440 if (dev->parent && device_is_not_partition(dev)) { in device_add_class_symlinks()
3441 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, in device_add_class_symlinks()
3448 error = sysfs_create_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_add_class_symlinks()
3454 sysfs_remove_link(&dev->kobj, "device"); in device_add_class_symlinks()
3456 sysfs_remove_link(&dev->kobj, "subsystem"); in device_add_class_symlinks()
3458 sysfs_remove_link(&dev->kobj, "of_node"); in device_add_class_symlinks()
3466 struct subsys_private *sp = class_to_subsys(dev->class); in device_remove_class_symlinks()
3469 sysfs_remove_link(&dev->kobj, "of_node"); in device_remove_class_symlinks()
3474 if (dev->parent && device_is_not_partition(dev)) in device_remove_class_symlinks()
3475 sysfs_remove_link(&dev->kobj, "device"); in device_remove_class_symlinks()
3476 sysfs_remove_link(&dev->kobj, "subsystem"); in device_remove_class_symlinks()
3477 sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_remove_class_symlinks()
3482 * dev_set_name - set a device name
3492 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); in dev_set_name()
3514 format_dev_t(devt_str, dev->devt); in device_create_sys_dev_entry()
3515 error = sysfs_create_link(kobj, &dev->kobj, devt_str); in device_create_sys_dev_entry()
3527 format_dev_t(devt_str, dev->devt); in device_remove_sys_dev_entry()
3534 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); in device_private_init()
3535 if (!dev->p) in device_private_init()
3536 return -ENOMEM; in device_private_init()
3537 dev->p->device = dev; in device_private_init()
3538 klist_init(&dev->p->klist_children, klist_children_get, in device_private_init()
3540 INIT_LIST_HEAD(&dev->p->deferred_probe); in device_private_init()
3545 * device_add - add device to device hierarchy.
3577 int error = -EINVAL; in device_add()
3584 if (!dev->p) { in device_add()
3595 if (dev->init_name) { in device_add()
3596 error = dev_set_name(dev, "%s", dev->init_name); in device_add()
3597 dev->init_name = NULL; in device_add()
3603 else if (dev->bus && dev->bus->dev_name) in device_add()
3604 error = dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); in device_add()
3606 error = -EINVAL; in device_add()
3612 parent = get_device(dev->parent); in device_add()
3619 dev->kobj.parent = kobj; in device_add()
3627 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); in device_add()
3654 if (MAJOR(dev->devt)) { in device_add()
3670 kobject_uevent(&dev->kobj, KOBJ_ADD); in device_add()
3673 * Check if any of the other devices (consumers) have been waiting for in device_add()
3684 if (dev->fwnode && !dev->fwnode->dev) { in device_add()
3685 dev->fwnode->dev = dev; in device_add()
3696 if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) in device_add()
3700 klist_add_tail(&dev->p->knode_parent, in device_add()
3701 &parent->p->klist_children); in device_add()
3703 sp = class_to_subsys(dev->class); in device_add()
3705 mutex_lock(&sp->mutex); in device_add()
3707 klist_add_tail(&dev->p->knode_class, &sp->klist_devices); in device_add()
3710 list_for_each_entry(class_intf, &sp->interfaces, node) in device_add()
3711 if (class_intf->add_dev) in device_add()
3712 class_intf->add_dev(dev); in device_add()
3713 mutex_unlock(&sp->mutex); in device_add()
3720 if (MAJOR(dev->devt)) in device_add()
3736 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_add()
3738 kobject_del(&dev->kobj); in device_add()
3744 kfree(dev->p); in device_add()
3745 dev->p = NULL; in device_add()
3751 * device_register - register a device with the system.
3754 * This happens in two clean steps - initialize the device
3776 * get_device - increment reference count for device.
3785 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; in get_device()
3790 * put_device - decrement reference count.
3797 kobject_put(&dev->kobj); in put_device()
3812 if (dev->p->dead) in kill_device()
3814 dev->p->dead = true; in kill_device()
3820 * device_del - delete device from system.
3835 struct device *parent = dev->parent; in device_del()
3844 if (dev->fwnode && dev->fwnode->dev == dev) in device_del()
3845 dev->fwnode->dev = NULL; in device_del()
3855 klist_del(&dev->p->knode_parent); in device_del()
3856 if (MAJOR(dev->devt)) { in device_del()
3862 sp = class_to_subsys(dev->class); in device_del()
3866 mutex_lock(&sp->mutex); in device_del()
3868 list_for_each_entry(class_intf, &sp->interfaces, node) in device_del()
3869 if (class_intf->remove_dev) in device_del()
3870 class_intf->remove_dev(dev); in device_del()
3872 klist_del(&dev->p->knode_class); in device_del()
3873 mutex_unlock(&sp->mutex); in device_del()
3896 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_del()
3898 kobject_del(&dev->kobj); in device_del()
3906 * device_unregister - unregister device from system.
3932 dev = p->device; in prev_device()
3945 dev = p->device; in next_device()
3951 * device_get_devnode - path of device node file
3959 * Non-default names may need to allocate a memory to compose
3972 if (dev->type && dev->type->devnode) in device_get_devnode()
3973 *tmp = dev->type->devnode(dev, mode, uid, gid); in device_get_devnode()
3978 if (dev->class && dev->class->devnode) in device_get_devnode()
3979 *tmp = dev->class->devnode(dev, mode); in device_get_devnode()
3995 * device_for_each_child - device child iterator.
4003 * We check the return of @fn each time. If it returns anything
4013 if (!parent || !parent->p) in device_for_each_child()
4016 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child()
4025 * device_for_each_child_reverse - device child iterator in reversed order.
4033 * We check the return of @fn each time. If it returns anything
4043 if (!parent || !parent->p) in device_for_each_child_reverse()
4046 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child_reverse()
4055 * device_for_each_child_reverse_from - device child iterator in reversed order.
4077 if (!parent || !parent->p) in device_for_each_child_reverse_from()
4080 klist_iter_init_node(&parent->p->klist_children, &i, in device_for_each_child_reverse_from()
4081 (from ? &from->p->knode_parent : NULL)); in device_for_each_child_reverse_from()
4090 * device_find_child - device iterator for locating a particular device.
4093 * @match: Callback function to check device
4099 * The callback should return 0 if the device doesn't match and non-zero
4100 * if it does. If the callback returns non-zero and a reference to the
4112 if (!parent || !parent->p) in device_find_child()
4115 klist_iter_init(&parent->p->klist_children, &i); in device_find_child()
4131 return -ENOMEM; in devices_init()
4155 return -ENOMEM; in devices_init()
4166 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; in device_check_offline()
4170 * device_offline - Prepare the device for hot-removal.
4174 * the device for a subsequent hot-removal. If that succeeds, the device must
4184 if (dev->offline_disabled) in device_offline()
4185 return -EPERM; in device_offline()
4193 if (dev->offline) { in device_offline()
4196 ret = dev->bus->offline(dev); in device_offline()
4198 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); in device_offline()
4199 dev->offline = true; in device_offline()
4209 * device_online - Put the device back online after successful device_offline().
4224 if (dev->offline) { in device_online()
4225 ret = dev->bus->online(dev); in device_online()
4227 kobject_uevent(&dev->kobj, KOBJ_ONLINE); in device_online()
4228 dev->offline = false; in device_online()
4255 * __root_device_register - allocate and register a root device
4279 int err = -ENOMEM; in __root_device_register()
4285 err = dev_set_name(&root->dev, "%s", name); in __root_device_register()
4291 root->dev.release = root_device_release; in __root_device_register()
4293 err = device_register(&root->dev); in __root_device_register()
4295 put_device(&root->dev); in __root_device_register()
4301 struct module_kobject *mk = &owner->mkobj; in __root_device_register()
4303 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); in __root_device_register()
4305 device_unregister(&root->dev); in __root_device_register()
4308 root->owner = owner; in __root_device_register()
4312 return &root->dev; in __root_device_register()
4317 * root_device_unregister - unregister and free a root device
4327 if (root->owner) in root_device_unregister()
4328 sysfs_remove_link(&root->dev.kobj, "module"); in root_device_unregister()
4348 int retval = -ENODEV; in device_create_groups_vargs()
4355 retval = -ENOMEM; in device_create_groups_vargs()
4360 dev->devt = devt; in device_create_groups_vargs()
4361 dev->class = class; in device_create_groups_vargs()
4362 dev->parent = parent; in device_create_groups_vargs()
4363 dev->groups = groups; in device_create_groups_vargs()
4364 dev->release = device_create_release; in device_create_groups_vargs()
4367 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); in device_create_groups_vargs()
4383 * device_create - creates a device and registers it with sysfs
4418 * device_create_with_groups - creates a device and registers it with sysfs
4423 * @groups: NULL-terminated list of attribute groups to be created
4459 * device_destroy - removes a device that was created with device_create()
4479 * device_rename - renames a device
4502 * renamed it -- then you get events for the same DEVPATH, before you even see
4505 * other things than (driver-core wise very simple) network devices.
4509 * symlinks -- but never rename kernel devices later, it's a complete mess. We
4516 struct kobject *kobj = &dev->kobj; in device_rename()
4523 return -EINVAL; in device_rename()
4529 error = -ENOMEM; in device_rename()
4533 if (dev->class) { in device_rename()
4534 sp = class_to_subsys(dev->class); in device_rename()
4537 error = -EINVAL; in device_rename()
4541 error = sysfs_rename_link_ns(&sp->subsys.kobj, kobj, old_device_name, in device_rename()
4552 sysfs_rename_link_ns(&sp->subsys.kobj, kobj, new_name, in device_rename()
4571 sysfs_remove_link(&dev->kobj, "device"); in device_move_class_links()
4573 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, in device_move_class_links()
4579 * device_move - moves a device to a new parent
4593 return -EINVAL; in device_move()
4606 error = kobject_move(&dev->kobj, new_parent_kobj); in device_move()
4612 old_parent = dev->parent; in device_move()
4613 dev->parent = new_parent; in device_move()
4615 klist_remove(&dev->p->knode_parent); in device_move()
4617 klist_add_tail(&dev->p->knode_parent, in device_move()
4618 &new_parent->p->klist_children); in device_move()
4622 if (dev->class) { in device_move()
4627 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { in device_move()
4629 klist_remove(&dev->p->knode_parent); in device_move()
4630 dev->parent = old_parent; in device_move()
4632 klist_add_tail(&dev->p->knode_parent, in device_move()
4633 &old_parent->p->klist_children); in device_move()
4670 struct kobject *kobj = &dev->kobj; in device_attrs_change_owner()
4671 const struct class *class = dev->class; in device_attrs_change_owner()
4672 const struct device_type *type = dev->type; in device_attrs_change_owner()
4680 error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, in device_attrs_change_owner()
4691 error = sysfs_groups_change_owner(kobj, type->groups, kuid, in device_attrs_change_owner()
4698 error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); in device_attrs_change_owner()
4702 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_attrs_change_owner()
4714 * device_change_owner - change the owner of an existing device.
4728 struct kobject *kobj = &dev->kobj; in device_change_owner()
4733 return -EINVAL; in device_change_owner()
4772 sp = class_to_subsys(dev->class); in device_change_owner()
4774 error = -EINVAL; in device_change_owner()
4777 error = sysfs_link_change_owner(&sp->subsys.kobj, &dev->kobj, dev_name(dev), kuid, kgid); in device_change_owner()
4787 * device_shutdown - call ->shutdown() on each device to shutdown.
4798 spin_lock(&devices_kset->list_lock); in device_shutdown()
4804 while (!list_empty(&devices_kset->list)) { in device_shutdown()
4805 dev = list_entry(devices_kset->list.prev, struct device, in device_shutdown()
4813 parent = get_device(dev->parent); in device_shutdown()
4817 * event that dev->*->shutdown() doesn't remove it. in device_shutdown()
4819 list_del_init(&dev->kobj.entry); in device_shutdown()
4820 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4831 if (dev->class && dev->class->shutdown_pre) { in device_shutdown()
4834 dev->class->shutdown_pre(dev); in device_shutdown()
4836 if (dev->bus && dev->bus->shutdown) { in device_shutdown()
4839 dev->bus->shutdown(dev); in device_shutdown()
4840 } else if (dev->driver && dev->driver->shutdown) { in device_shutdown()
4843 dev->driver->shutdown(dev); in device_shutdown()
4853 spin_lock(&devices_kset->list_lock); in device_shutdown()
4855 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4870 if (dev->class) in set_dev_info()
4871 subsys = dev->class->name; in set_dev_info()
4872 else if (dev->bus) in set_dev_info()
4873 subsys = dev->bus->name; in set_dev_info()
4877 strscpy(dev_info->subsystem, subsys); in set_dev_info()
4886 if (MAJOR(dev->devt)) { in set_dev_info()
4894 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4895 "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); in set_dev_info()
4899 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4900 "n%u", net->ifindex); in set_dev_info()
4902 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4937 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", in __dev_printk()
4995 * size-1 array containing a structure. As a result, function parameter in __dev_probe_failed()
5009 case -EPROBE_DEFER: in __dev_probe_failed()
5014 case -ENOMEM: in __dev_probe_failed()
5015 /* Don't print anything on -ENOMEM, there's already enough output */ in __dev_probe_failed()
5031 * dev_err_probe - probe error check and log helper
5034 * @fmt: printf-style format string
5039 * -EPROBE_DEFER and propagate error upwards.
5040 * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
5044 * if (err != -EPROBE_DEFER)
5055 * is known to never be -EPROBE_DEFER.
5058 * instead of "-35"), and having the error code returned allows more
5069 /* Use dev_err() for logging when err doesn't equal -EPROBE_DEFER */ in dev_err_probe()
5079 * dev_warn_probe - probe error check and log helper
5082 * @fmt: printf-style format string
5087 * -EPROBE_DEFER and propagate error upwards.
5088 * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
5092 * if (err != -EPROBE_DEFER)
5103 * is known to never be -EPROBE_DEFER.
5106 * instead of "-35"), and having the error code returned allows more
5117 /* Use dev_warn() for logging when err doesn't equal -EPROBE_DEFER */ in dev_warn_probe()
5128 return fwnode && !IS_ERR(fwnode->secondary); in fwnode_is_primary()
5132 * set_primary_fwnode - Change the primary firmware node of a given device.
5140 * - primary --> secondary --> -ENODEV
5141 * - primary --> NULL
5142 * - secondary --> -ENODEV
5143 * - NULL
5147 struct device *parent = dev->parent; in set_primary_fwnode()
5148 struct fwnode_handle *fn = dev->fwnode; in set_primary_fwnode()
5152 fn = fn->secondary; in set_primary_fwnode()
5155 WARN_ON(fwnode->secondary); in set_primary_fwnode()
5156 fwnode->secondary = fn; in set_primary_fwnode()
5158 dev->fwnode = fwnode; in set_primary_fwnode()
5161 dev->fwnode = fn->secondary; in set_primary_fwnode()
5163 /* Skip nullifying fn->secondary if the primary is shared */ in set_primary_fwnode()
5164 if (parent && fn == parent->fwnode) in set_primary_fwnode()
5167 /* Set fn->secondary = NULL, so fn remains the primary fwnode */ in set_primary_fwnode()
5168 fn->secondary = NULL; in set_primary_fwnode()
5170 dev->fwnode = NULL; in set_primary_fwnode()
5177 * set_secondary_fwnode - Change the secondary firmware node of a given device.
5188 fwnode->secondary = ERR_PTR(-ENODEV); in set_secondary_fwnode()
5190 if (fwnode_is_primary(dev->fwnode)) in set_secondary_fwnode()
5191 dev->fwnode->secondary = fwnode; in set_secondary_fwnode()
5193 dev->fwnode = fwnode; in set_secondary_fwnode()
5198 * device_remove_of_node - Remove an of_node from a device
5207 if (!dev->of_node) in device_remove_of_node()
5210 if (dev->fwnode == of_fwnode_handle(dev->of_node)) in device_remove_of_node()
5211 dev->fwnode = NULL; in device_remove_of_node()
5213 of_node_put(dev->of_node); in device_remove_of_node()
5214 dev->of_node = NULL; in device_remove_of_node()
5222 * device_add_of_node - Add an of_node to an existing device
5233 return -EINVAL; in device_add_of_node()
5237 return -EINVAL; in device_add_of_node()
5239 if (dev->of_node) { in device_add_of_node()
5241 dev->of_node, of_node); in device_add_of_node()
5242 ret = -EBUSY; in device_add_of_node()
5246 dev->of_node = of_node_get(of_node); in device_add_of_node()
5248 if (!dev->fwnode) in device_add_of_node()
5249 dev->fwnode = of_fwnode_handle(of_node); in device_add_of_node()
5259 * device_set_of_node_from_dev - reuse device-tree node of another device
5260 * @dev: device whose device-tree node is being set
5261 * @dev2: device whose device-tree node is being reused
5263 * Takes another reference to the new device-tree node after first dropping
5268 of_node_put(dev->of_node); in device_set_of_node_from_dev()
5269 dev->of_node = of_node_get(dev2->of_node); in device_set_of_node_from_dev()
5270 dev->of_node_reused = true; in device_set_of_node_from_dev()
5276 dev->fwnode = fwnode; in device_set_node()
5277 dev->of_node = to_of_node(fwnode); in device_set_node()
5282 * get_dev_from_fwnode - Obtain a reference count of the struct device the
5298 * hence can out-live the struct device it is associated with.
5302 return get_device((fwnode)->dev); in get_dev_from_fwnode()
5314 return dev->type == type; in device_match_type()
5320 return np && dev->of_node == np; in device_match_of_node()
5332 return dev->devt == *(dev_t *)pdevt; in device_match_devt()