Lines Matching +full:fixed +full:- +full:links
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>
33 #include <linux/dma-map-ops.h> /* for dma_default_coherent */
39 /* Device links support. */
49 * __fwnode_link_add - Create a link between two fwnode_handles.
63 * Attempts to create duplicate links between the same pair of fwnode handles
71 list_for_each_entry(link, &sup->consumers, s_hook) in __fwnode_link_add()
72 if (link->consumer == con) { in __fwnode_link_add()
73 link->flags |= flags; in __fwnode_link_add()
79 return -ENOMEM; in __fwnode_link_add()
81 link->supplier = sup; in __fwnode_link_add()
82 INIT_LIST_HEAD(&link->s_hook); in __fwnode_link_add()
83 link->consumer = con; in __fwnode_link_add()
84 INIT_LIST_HEAD(&link->c_hook); in __fwnode_link_add()
85 link->flags = flags; in __fwnode_link_add()
87 list_add(&link->s_hook, &sup->consumers); in __fwnode_link_add()
88 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.
135 * @fwnode: fwnode whose supplier links need to be deleted
137 * Deletes all supplier links connecting directly to @fwnode.
144 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.
151 * @fwnode: fwnode whose consumer links need to be deleted
153 * Deletes all consumer links connecting directly to @fwnode.
160 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.
167 * @fwnode: fwnode whose links needs to be deleted
169 * Deletes all links connecting directly to a fwnode.
181 /* Don't purge consumer links of an added child */ in fw_devlink_purge_absent_suppliers()
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
198 * Move all consumer links from @from fwnode to @to fwnode.
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
218 * MANAGED device links to this device, so leave @fwnode and its descendant's
219 * fwnode links alone.
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
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()
463 if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) in auto_remove_on_show()
465 else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) in auto_remove_on_show()
479 return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); in runtime_pm_show()
489 !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in sync_state_only_show()
514 * PM-runtime usage counter to remove the reference taken by in device_link_release_fn()
517 if (link->supplier_preactivated) in device_link_release_fn()
518 pm_runtime_put_noidle(link->supplier); in device_link_release_fn()
520 pm_request_idle(link->supplier); in device_link_release_fn()
522 put_device(link->consumer); in device_link_release_fn()
523 put_device(link->supplier); in device_link_release_fn()
531 INIT_WORK(&link->rm_work, device_link_release_fn); in devlink_dev_release()
538 queue_work(system_long_wq, &link->rm_work); in devlink_dev_release()
552 struct device *sup = link->supplier; in devlink_add_symlinks()
553 struct device *con = link->consumer; in devlink_add_symlinks()
562 return -ENOMEM; in devlink_add_symlinks()
564 ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); in devlink_add_symlinks()
568 ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); in devlink_add_symlinks()
573 ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); in devlink_add_symlinks()
578 ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); in devlink_add_symlinks()
586 sysfs_remove_link(&sup->kobj, buf); in devlink_add_symlinks()
588 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_add_symlinks()
590 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_add_symlinks()
600 struct device *sup = link->supplier; in devlink_remove_symlinks()
601 struct device *con = link->consumer; in devlink_remove_symlinks()
604 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_remove_symlinks()
605 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_remove_symlinks()
619 sysfs_remove_link(&con->kobj, buf); in devlink_remove_symlinks()
622 sysfs_remove_link(&sup->kobj, buf); in devlink_remove_symlinks()
659 * device_link_add - Create a link between two devices.
668 * be forced into the active meta state and reference-counted upon the creation
705 * A side effect of the link creation is re-ordering of dpm_list and the
746 * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and in device_link_add()
759 * SYNC_STATE_ONLY links are useless once a consumer device has probed. in device_link_add()
763 consumer->links.status != DL_DEV_NO_DRIVER && in device_link_add()
764 consumer->links.status != DL_DEV_PROBING) { in device_link_add()
777 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_add()
778 if (link->consumer != consumer) in device_link_add()
781 if (link->flags & DL_FLAG_INFERRED && in device_link_add()
783 link->flags &= ~DL_FLAG_INFERRED; in device_link_add()
786 if (!(link->flags & DL_FLAG_PM_RUNTIME)) { in device_link_add()
788 link->flags |= DL_FLAG_PM_RUNTIME; in device_link_add()
791 refcount_inc(&link->rpm_active); in device_link_add()
795 kref_get(&link->kref); in device_link_add()
796 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
797 !(link->flags & DL_FLAG_STATELESS)) { in device_link_add()
798 link->flags |= DL_FLAG_STATELESS; in device_link_add()
801 link->flags |= DL_FLAG_STATELESS; in device_link_add()
812 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in device_link_add()
813 link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; in device_link_add()
814 link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; in device_link_add()
817 link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | in device_link_add()
820 if (!(link->flags & DL_FLAG_MANAGED)) { in device_link_add()
821 kref_get(&link->kref); in device_link_add()
822 link->flags |= DL_FLAG_MANAGED; in device_link_add()
825 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
827 link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; in device_link_add()
838 refcount_set(&link->rpm_active, 1); in device_link_add()
841 link->supplier = supplier; in device_link_add()
842 INIT_LIST_HEAD(&link->s_node); in device_link_add()
844 link->consumer = consumer; in device_link_add()
845 INIT_LIST_HEAD(&link->c_node); in device_link_add()
846 link->flags = flags; in device_link_add()
847 kref_init(&link->kref); in device_link_add()
849 link->link_dev.class = &devlink_class; in device_link_add()
850 device_set_pm_not_required(&link->link_dev); in device_link_add()
851 dev_set_name(&link->link_dev, "%s:%s--%s:%s", in device_link_add()
854 if (device_register(&link->link_dev)) { in device_link_add()
855 put_device(&link->link_dev); in device_link_add()
862 refcount_inc(&link->rpm_active); in device_link_add()
869 link->status = DL_STATE_NONE; in device_link_add()
877 if (link->status == DL_STATE_CONSUMER_PROBE && in device_link_add()
881 list_add_tail_rcu(&link->s_node, &supplier->links.consumers); in device_link_add()
882 list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); in device_link_add()
918 dev_dbg(link->consumer, "Dropping the link to %s\n", in __device_link_del()
919 dev_name(link->supplier)); in __device_link_del()
924 device_unregister(&link->link_dev); in __device_link_del()
929 if (link->flags & DL_FLAG_STATELESS) in device_link_put_kref()
930 kref_put(&link->kref, __device_link_del); in device_link_put_kref()
931 else if (!device_is_registered(link->consumer)) in device_link_put_kref()
932 __device_link_del(&link->kref); in device_link_put_kref()
938 * device_link_del - Delete a stateless link between two devices.
943 * Care is required for hotplugged devices: Their links are purged on removal
955 * device_link_remove - Delete a stateless link between two devices.
971 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_remove()
972 if (link->consumer == consumer) { in device_link_remove()
986 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_missing_supplier()
987 if (link->status != DL_STATE_CONSUMER_PROBE) in device_links_missing_supplier()
990 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in device_links_missing_supplier()
991 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_missing_supplier()
993 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in device_links_missing_supplier()
994 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_missing_supplier()
1001 return (fw_devlink_best_effort && dev->can_match) || in dev_is_best_effort()
1002 (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT)); in dev_is_best_effort()
1013 list_for_each_entry(link, &fwnode->suppliers, c_hook) in fwnode_links_check_suppliers()
1014 if (!(link->flags & FWLINK_FLAG_CYCLE)) in fwnode_links_check_suppliers()
1015 return link->supplier; in fwnode_links_check_suppliers()
1021 * device_links_check_suppliers - Check presence of supplier drivers.
1024 * Check links from this device to any suppliers. Walk the list of the device's
1025 * links to suppliers and see if all of them are available. If not, simply
1026 * return -EPROBE_DEFER.
1030 * that function checks the device's links to consumers. This means we need to
1034 * Links without the DL_FLAG_MANAGED flag set are ignored.
1047 sup_fw = fwnode_links_check_suppliers(dev->fwnode); in device_links_check_suppliers()
1050 fwnode_ret = -EPROBE_DEFER; in device_links_check_suppliers()
1051 dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1054 fwnode_ret = -EAGAIN; in device_links_check_suppliers()
1058 if (fwnode_ret == -EPROBE_DEFER) in device_links_check_suppliers()
1063 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_check_suppliers()
1064 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_check_suppliers()
1067 if (link->status != DL_STATE_AVAILABLE && in device_links_check_suppliers()
1068 !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { in device_links_check_suppliers()
1071 link->flags & DL_FLAG_INFERRED && in device_links_check_suppliers()
1072 !link->supplier->can_match) { in device_links_check_suppliers()
1073 ret = -EAGAIN; in device_links_check_suppliers()
1078 dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1080 dev_name(link->supplier)); in device_links_check_suppliers()
1081 ret = -EPROBE_DEFER; in device_links_check_suppliers()
1084 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_check_suppliers()
1086 dev->links.status = DL_DEV_PROBING; in device_links_check_suppliers()
1094 * __device_links_queue_sync_state - Queue a device for sync_state() callback
1098 * Queues a device for a sync_state() callback when the device links write lock
1099 * isn't held. This allows the sync_state() execution flow to use device links
1118 if (dev->state_synced) in __device_links_queue_sync_state()
1121 list_for_each_entry(link, &dev->links.consumers, s_node) { in __device_links_queue_sync_state()
1122 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_queue_sync_state()
1124 if (link->status != DL_STATE_ACTIVE) in __device_links_queue_sync_state()
1133 dev->state_synced = true; in __device_links_queue_sync_state()
1135 if (WARN_ON(!list_empty(&dev->links.defer_sync))) in __device_links_queue_sync_state()
1139 list_add_tail(&dev->links.defer_sync, list); in __device_links_queue_sync_state()
1143 * device_links_flush_sync_list - Call sync_state() on a list of devices
1157 list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { in device_links_flush_sync_list()
1158 list_del_init(&dev->links.defer_sync); in device_links_flush_sync_list()
1189 defer_sync_state_count--; in device_links_supplier_sync_state_resume()
1193 list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { in device_links_supplier_sync_state_resume()
1198 list_del_init(&dev->links.defer_sync); in device_links_supplier_sync_state_resume()
1216 if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) in __device_links_supplier_defer_sync()
1217 list_add_tail(&sup->links.defer_sync, &deferred_sync); in __device_links_supplier_defer_sync()
1222 link->flags &= ~DL_FLAG_MANAGED; in device_link_drop_managed()
1223 WRITE_ONCE(link->status, DL_STATE_NONE); in device_link_drop_managed()
1224 kref_put(&link->kref, __device_link_del); in device_link_drop_managed()
1235 val = !!fwnode_links_check_suppliers(dev->fwnode); in waiting_for_supplier_show()
1243 * device_links_force_bind - Prepares device to be force bound
1252 * supplier device links and checks if the supplier is bound. If it is, then
1254 * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored.
1262 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_force_bind()
1263 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_force_bind()
1266 if (link->status != DL_STATE_AVAILABLE) { in device_links_force_bind()
1270 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_force_bind()
1272 dev->links.status = DL_DEV_PROBING; in device_links_force_bind()
1278 * device_links_driver_bound - Update device links after probing its driver.
1279 * @dev: Device to update the links for.
1281 * The probe has been successful, so update links from this device to any
1284 * Also change the status of @dev's links to suppliers to "active".
1286 * Links without the DL_FLAG_MANAGED flag set are ignored.
1295 * the device links it needs to or make new device links as it needs in device_links_driver_bound()
1296 * them. So, fw_devlink no longer needs to create device links to any in device_links_driver_bound()
1307 if (dev->fwnode && dev->fwnode->dev == dev) { in device_links_driver_bound()
1309 fwnode_links_purge_suppliers(dev->fwnode); in device_links_driver_bound()
1311 fwnode_for_each_available_child_node(dev->fwnode, child) in device_links_driver_bound()
1313 dev->fwnode); in device_links_driver_bound()
1321 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_driver_bound()
1322 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1326 * Links created during consumer probe may be in the "consumer in device_links_driver_bound()
1331 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_driver_bound()
1332 link->status == DL_STATE_ACTIVE) in device_links_driver_bound()
1335 WARN_ON(link->status != DL_STATE_DORMANT); in device_links_driver_bound()
1336 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_driver_bound()
1338 if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) in device_links_driver_bound()
1339 driver_deferred_probe_add(link->consumer); in device_links_driver_bound()
1347 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_driver_bound()
1350 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1353 supplier = link->supplier; in device_links_driver_bound()
1354 if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { in device_links_driver_bound()
1362 link->flags & DL_FLAG_INFERRED && in device_links_driver_bound()
1363 link->status != DL_STATE_CONSUMER_PROBE && in device_links_driver_bound()
1364 !link->supplier->can_match) { in device_links_driver_bound()
1367 * links to suppliers that don't have a driver. If the in device_links_driver_bound()
1374 WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); in device_links_driver_bound()
1375 WRITE_ONCE(link->status, DL_STATE_ACTIVE); in device_links_driver_bound()
1390 dev->links.status = DL_DEV_DRIVER_BOUND; in device_links_driver_bound()
1398 * __device_links_no_driver - Update links of a device without a driver.
1401 * Delete all non-persistent links from this device to any suppliers.
1403 * Persistent links stay around, but their status is changed to "available",
1407 * Links without the DL_FLAG_MANAGED flag set are ignored.
1413 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in __device_links_no_driver()
1414 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_no_driver()
1417 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in __device_links_no_driver()
1422 if (link->status != DL_STATE_CONSUMER_PROBE && in __device_links_no_driver()
1423 link->status != DL_STATE_ACTIVE) in __device_links_no_driver()
1426 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in __device_links_no_driver()
1427 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in __device_links_no_driver()
1429 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in __device_links_no_driver()
1430 WRITE_ONCE(link->status, DL_STATE_DORMANT); in __device_links_no_driver()
1434 dev->links.status = DL_DEV_NO_DRIVER; in __device_links_no_driver()
1438 * device_links_no_driver - Update links after failing driver probe.
1441 * Clean up leftover links to consumers for @dev and invoke
1442 * %__device_links_no_driver() to update links to suppliers for it as
1445 * Links without the DL_FLAG_MANAGED flag set are ignored.
1453 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_no_driver()
1454 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_no_driver()
1464 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_no_driver()
1465 link->status == DL_STATE_ACTIVE) in device_links_no_driver()
1466 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_no_driver()
1475 * device_links_driver_cleanup - Update links after driver removal.
1478 * Update links to consumers for @dev by changing their status to "dormant" and
1479 * invoke %__device_links_no_driver() to update links to suppliers for it as
1482 * Links without the DL_FLAG_MANAGED flag set are ignored.
1490 list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { in device_links_driver_cleanup()
1491 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_cleanup()
1494 WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); in device_links_driver_cleanup()
1495 WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); in device_links_driver_cleanup()
1498 * autoremove the links between this @dev and its consumer in device_links_driver_cleanup()
1502 if (link->status == DL_STATE_SUPPLIER_UNBIND && in device_links_driver_cleanup()
1503 link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) in device_links_driver_cleanup()
1506 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_driver_cleanup()
1509 list_del_init(&dev->links.defer_sync); in device_links_driver_cleanup()
1516 * device_links_busy - Check if there are any busy links to consumers.
1527 * Links without the DL_FLAG_MANAGED flag set are ignored.
1536 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_busy()
1537 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_busy()
1540 if (link->status == DL_STATE_CONSUMER_PROBE in device_links_busy()
1541 || link->status == DL_STATE_ACTIVE) { in device_links_busy()
1545 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_busy()
1548 dev->links.status = DL_DEV_UNBINDING; in device_links_busy()
1555 * device_links_unbind_consumers - Force unbind consumers of the given device.
1558 * Walk the list of links to consumers for @dev and if any of them is in the
1564 * driver to unbind and start over (the consumer will not re-probe as we have
1567 * Links without the DL_FLAG_MANAGED flag set are ignored.
1576 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_unbind_consumers()
1579 if (!(link->flags & DL_FLAG_MANAGED) || in device_links_unbind_consumers()
1580 link->flags & DL_FLAG_SYNC_STATE_ONLY) in device_links_unbind_consumers()
1583 status = link->status; in device_links_unbind_consumers()
1590 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_unbind_consumers()
1592 struct device *consumer = link->consumer; in device_links_unbind_consumers()
1599 consumer->parent); in device_links_unbind_consumers()
1609 * device_links_purge - Delete existing links to other devices.
1616 if (dev->class == &devlink_class) in device_links_purge()
1620 * Delete all of the remaining links from this device to any other in device_links_purge()
1625 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in device_links_purge()
1626 WARN_ON(link->status == DL_STATE_ACTIVE); in device_links_purge()
1627 __device_link_del(&link->kref); in device_links_purge()
1630 list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { in device_links_purge()
1631 WARN_ON(link->status != DL_STATE_DORMANT && in device_links_purge()
1632 link->status != DL_STATE_NONE); in device_links_purge()
1633 __device_link_del(&link->kref); in device_links_purge()
1650 return -EINVAL; in fw_devlink_setup()
1684 return -EINVAL; in fw_devlink_sync_state_setup()
1693 return -EINVAL; in fw_devlink_sync_state_setup()
1717 if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) in fw_devlink_parse_fwnode()
1721 fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; in fw_devlink_parse_fwnode()
1736 if (!(link->flags & DL_FLAG_INFERRED)) in fw_devlink_relax_link()
1739 if (device_link_flag_is_sync_state_only(link->flags)) in fw_devlink_relax_link()
1743 link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; in fw_devlink_relax_link()
1744 dev_dbg(link->consumer, "Relaxing link with %s\n", in fw_devlink_relax_link()
1745 dev_name(link->supplier)); in fw_devlink_relax_link()
1752 if (!link->supplier->can_match) in fw_devlink_no_driver()
1770 struct device *sup = link->supplier; in fw_devlink_dev_sync_state()
1772 if (!(link->flags & DL_FLAG_MANAGED) || in fw_devlink_dev_sync_state()
1773 link->status == DL_STATE_ACTIVE || sup->state_synced || in fw_devlink_dev_sync_state()
1779 dev_name(link->consumer)); in fw_devlink_dev_sync_state()
1783 if (!list_empty(&sup->links.defer_sync)) in fw_devlink_dev_sync_state()
1787 sup->state_synced = true; in fw_devlink_dev_sync_state()
1789 list_add_tail(&sup->links.defer_sync, data); in fw_devlink_dev_sync_state()
1806 * wait_for_init_devices_probe - Try to probe any device needed for init
1869 list_for_each_entry(link, &dev->links.consumers, s_node) in fw_devlink_unblock_consumers()
1880 if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED)) in fwnode_init_without_drv()
1884 ret = !dev || dev->links.status == DL_DEV_NO_DRIVER; in fwnode_init_without_drv()
1905 * __fw_devlink_relax_cycles - Relax and mark dependency cycles.
1913 * and @con. When such dependency cycles are found, convert all device links
1914 * created solely by fw_devlink into SYNC_STATE_ONLY device links. Also, mark
1915 * all fwnode links in the cycle with FWLINK_FLAG_CYCLE so that when they are
1917 * SYNC_STATE_ONLY device links. This is the equivalent of doing
1939 if (sup_handle->flags & FWNODE_FLAG_VISITED) in __fw_devlink_relax_cycles()
1942 sup_handle->flags |= FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
1948 pr_debug("----- cycle: start -----\n"); in __fw_devlink_relax_cycles()
1958 if (sup_dev && sup_dev->links.status == DL_DEV_DRIVER_BOUND && in __fw_devlink_relax_cycles()
1959 con->links.status == DL_DEV_NO_DRIVER) { in __fw_devlink_relax_cycles()
1964 list_for_each_entry(link, &sup_handle->suppliers, c_hook) { in __fw_devlink_relax_cycles()
1965 if (__fw_devlink_relax_cycles(con, link->supplier)) { in __fw_devlink_relax_cycles()
1976 par_dev = get_device(sup_dev->parent); in __fw_devlink_relax_cycles()
1980 if (par_dev && __fw_devlink_relax_cycles(con, par_dev->fwnode)) { in __fw_devlink_relax_cycles()
1982 par_dev->fwnode); in __fw_devlink_relax_cycles()
1989 list_for_each_entry(dev_link, &sup_dev->links.suppliers, c_node) { in __fw_devlink_relax_cycles()
1994 if (device_link_flag_is_sync_state_only(dev_link->flags) && in __fw_devlink_relax_cycles()
1995 !(dev_link->flags & DL_FLAG_CYCLE)) in __fw_devlink_relax_cycles()
1999 dev_link->supplier->fwnode)) { in __fw_devlink_relax_cycles()
2001 dev_link->supplier->fwnode); in __fw_devlink_relax_cycles()
2003 dev_link->flags |= DL_FLAG_CYCLE; in __fw_devlink_relax_cycles()
2009 sup_handle->flags &= ~FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
2016 * fw_devlink_create_devlink - Create a device link from a consumer to fwnode
2025 * fwnode links can sometimes cause the supplier device to never be created.
2031 * -EINVAL if the device link cannot be created as expected
2032 * -EAGAIN if the device link cannot be created right now, but it may be
2043 if (con->fwnode == link->consumer) in fw_devlink_create_devlink()
2044 flags = fw_devlink_get_flags(link->flags); in fw_devlink_create_devlink()
2060 * When such a flag is set, we can't create device links where P is the in fw_devlink_create_devlink()
2063 if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD && in fw_devlink_create_devlink()
2064 fwnode_is_ancestor_of(sup_handle, con->fwnode)) in fw_devlink_create_devlink()
2065 return -EINVAL; in fw_devlink_create_devlink()
2068 * SYNC_STATE_ONLY device links don't block probing and supports cycles. in fw_devlink_create_devlink()
2080 flags = fw_devlink_get_flags(link->flags); in fw_devlink_create_devlink()
2081 pr_debug("----- cycle: end -----\n"); in fw_devlink_create_devlink()
2082 dev_info(con, "Fixed dependency cycle(s) with %pfwf\n", in fw_devlink_create_devlink()
2088 if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE) in fw_devlink_create_devlink()
2099 if (sup_dev->links.status == DL_DEV_NO_DRIVER && in fw_devlink_create_devlink()
2100 sup_handle->flags & FWNODE_FLAG_INITIALIZED) { in fw_devlink_create_devlink()
2102 "Not linking %pfwf - dev might never probe\n", in fw_devlink_create_devlink()
2104 ret = -EINVAL; in fw_devlink_create_devlink()
2111 ret = -EINVAL; in fw_devlink_create_devlink()
2123 dev_dbg(con, "Not linking %pfwf - might never become dev\n", in fw_devlink_create_devlink()
2125 return -EINVAL; in fw_devlink_create_devlink()
2128 ret = -EAGAIN; in fw_devlink_create_devlink()
2135 * __fw_devlink_link_to_consumers - Create device links to consumers of a device
2139 * links between the consumer device and @dev (supplier).
2147 * Once device links are created from the real consumer to @dev (supplier), the
2148 * fwnode links are deleted.
2152 struct fwnode_handle *fwnode = dev->fwnode; in __fw_devlink_link_to_consumers()
2155 list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { in __fw_devlink_link_to_consumers()
2160 con_dev = get_dev_from_fwnode(link->consumer); in __fw_devlink_link_to_consumers()
2172 con_dev = fwnode_get_next_parent_dev(link->consumer); in __fw_devlink_link_to_consumers()
2176 * consumer-supplier link from the parent to its child in __fw_devlink_link_to_consumers()
2180 fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { in __fw_devlink_link_to_consumers()
2193 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_consumers()
2201 * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device
2203 * @fwnode: Root of the fwnode tree that is used to create device links
2206 * @fwnode and creates device links between @dev (consumer) and all the
2209 * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev
2210 * and the real suppliers of @dev. Once these device links are created, the
2211 * fwnode links are deleted.
2216 * driver core. So, this function creates SYNC_STATE_ONLY device links between
2219 * their device links. The fwnode links that correspond to the child devices
2220 * aren't delete because they are needed later to create the device links
2226 bool own_link = (dev->fwnode == fwnode); in __fw_devlink_link_to_suppliers()
2230 list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { in __fw_devlink_link_to_suppliers()
2232 struct fwnode_handle *sup = link->supplier; in __fw_devlink_link_to_suppliers()
2235 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_suppliers()
2242 * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of in __fw_devlink_link_to_suppliers()
2253 struct fwnode_handle *fwnode = dev->fwnode; in fw_devlink_link_device()
2266 /* Device links support end. */
2303 return !(dev->type == &part_type); in device_is_not_partition()
2333 * dev_driver_string - Return a device's driver name, if at all possible
2345 /* dev->driver can change to NULL underneath us because of unbinding, in dev_driver_string()
2346 * so be careful about accessing it. dev->bus and dev->class should in dev_driver_string()
2349 drv = READ_ONCE(dev->driver); in dev_driver_string()
2350 return drv ? drv->name : dev_bus_name(dev); in dev_driver_string()
2361 ssize_t ret = -EIO; in dev_attr_show()
2363 if (dev_attr->show) in dev_attr_show()
2364 ret = dev_attr->show(dev, dev_attr, buf); in dev_attr_show()
2367 dev_attr->show); in dev_attr_show()
2377 ssize_t ret = -EIO; in dev_attr_store()
2379 if (dev_attr->store) in dev_attr_store()
2380 ret = dev_attr->store(dev, dev_attr, buf, count); in dev_attr_store()
2402 *(unsigned long *)(ea->var) = new; in device_store_ulong()
2413 return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); in device_show_ulong()
2430 return -EINVAL; in device_store_int()
2431 *(int *)(ea->var) = new; in device_store_int()
2443 return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); in device_show_int()
2452 if (kstrtobool(buf, ea->var) < 0) in device_store_bool()
2453 return -EINVAL; in device_store_bool()
2464 return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); in device_show_bool()
2469 * device_release - free device structure.
2479 struct device_private *p = dev->p; in device_release()
2492 kfree(dev->dma_range_map); in device_release()
2494 if (dev->release) in device_release()
2495 dev->release(dev); in device_release()
2496 else if (dev->type && dev->type->release) in device_release()
2497 dev->type->release(dev); in device_release()
2498 else if (dev->class && dev->class->dev_release) in device_release()
2499 dev->class->dev_release(dev); in device_release()
2501 …does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kob… in device_release()
2511 if (dev->class && dev->class->ns_type) in device_namespace()
2512 ns = dev->class->namespace(dev); in device_namespace()
2521 if (dev->class && dev->class->get_ownership) in device_get_ownership()
2522 dev->class->get_ownership(dev, uid, gid); in device_get_ownership()
2539 if (dev->bus) in dev_uevent_filter()
2541 if (dev->class) in dev_uevent_filter()
2551 if (dev->bus) in dev_uevent_name()
2552 return dev->bus->name; in dev_uevent_name()
2553 if (dev->class) in dev_uevent_name()
2554 return dev->class->name; in dev_uevent_name()
2564 if (MAJOR(dev->devt)) { in dev_uevent()
2571 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); in dev_uevent()
2572 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); in dev_uevent()
2586 if (dev->type && dev->type->name) in dev_uevent()
2587 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); in dev_uevent()
2589 if (dev->driver) in dev_uevent()
2590 add_uevent_var(env, "DRIVER=%s", dev->driver->name); in dev_uevent()
2596 if (dev->bus && dev->bus->uevent) { in dev_uevent()
2597 retval = dev->bus->uevent(dev, env); in dev_uevent()
2604 if (dev->class && dev->class->dev_uevent) { in dev_uevent()
2605 retval = dev->class->dev_uevent(dev, env); in dev_uevent()
2613 if (dev->type && dev->type->uevent) { in dev_uevent()
2614 retval = dev->type->uevent(dev, env); in dev_uevent()
2641 top_kobj = &dev->kobj; in uevent_show()
2642 while (!top_kobj->kset && top_kobj->parent) in uevent_show()
2643 top_kobj = top_kobj->parent; in uevent_show()
2644 if (!top_kobj->kset) in uevent_show()
2647 kset = top_kobj->kset; in uevent_show()
2648 if (!kset->uevent_ops || !kset->uevent_ops->uevent) in uevent_show()
2652 if (kset->uevent_ops && kset->uevent_ops->filter) in uevent_show()
2653 if (!kset->uevent_ops->filter(&dev->kobj)) in uevent_show()
2658 return -ENOMEM; in uevent_show()
2661 retval = kset->uevent_ops->uevent(&dev->kobj, env); in uevent_show()
2666 for (i = 0; i < env->envp_idx; i++) in uevent_show()
2667 len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); in uevent_show()
2678 rc = kobject_synth_uevent(&dev->kobj, buf, count); in uevent_store()
2695 val = !dev->offline; in online_show()
2725 switch (dev->removable) { in removable_show()
2730 loc = "fixed"; in removable_show()
2741 return sysfs_create_groups(&dev->kobj, groups); in device_add_groups()
2748 sysfs_remove_groups(&dev->kobj, groups); in device_remove_groups()
2760 const struct attribute_group *group = devres->group; in devm_attr_group_remove()
2763 sysfs_remove_group(&dev->kobj, group); in devm_attr_group_remove()
2769 const struct attribute_group **groups = devres->groups; in devm_attr_groups_remove()
2772 sysfs_remove_groups(&dev->kobj, groups); in devm_attr_groups_remove()
2776 * devm_device_add_group - given a device, create a managed attribute group
2793 return -ENOMEM; in devm_device_add_group()
2795 error = sysfs_create_group(&dev->kobj, grp); in devm_device_add_group()
2801 devres->group = grp; in devm_device_add_group()
2808 * devm_device_add_groups - create a bunch of managed attribute groups
2829 return -ENOMEM; in devm_device_add_groups()
2831 error = sysfs_create_groups(&dev->kobj, groups); in devm_device_add_groups()
2837 devres->groups = groups; in devm_device_add_groups()
2845 const struct class *class = dev->class; in device_add_attrs()
2846 const struct device_type *type = dev->type; in device_add_attrs()
2850 error = device_add_groups(dev, class->dev_groups); in device_add_attrs()
2856 error = device_add_groups(dev, type->groups); in device_add_attrs()
2861 error = device_add_groups(dev, dev->groups); in device_add_attrs()
2865 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_add_attrs()
2871 if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { in device_add_attrs()
2899 device_remove_groups(dev, dev->groups); in device_add_attrs()
2902 device_remove_groups(dev, type->groups); in device_add_attrs()
2905 device_remove_groups(dev, class->dev_groups); in device_add_attrs()
2912 const struct class *class = dev->class; in device_remove_attrs()
2913 const struct device_type *type = dev->type; in device_remove_attrs()
2915 if (dev->physical_location) { in device_remove_attrs()
2917 kfree(dev->physical_location); in device_remove_attrs()
2923 device_remove_groups(dev, dev->groups); in device_remove_attrs()
2926 device_remove_groups(dev, type->groups); in device_remove_attrs()
2929 device_remove_groups(dev, class->dev_groups); in device_remove_attrs()
2935 return print_dev_t(buf, dev->devt); in dev_show()
2943 * devices_kset_move_before - Move device in the devices_kset's list.
2953 spin_lock(&devices_kset->list_lock); in devices_kset_move_before()
2954 list_move_tail(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_before()
2955 spin_unlock(&devices_kset->list_lock); in devices_kset_move_before()
2959 * devices_kset_move_after - Move device in the devices_kset's list.
2969 spin_lock(&devices_kset->list_lock); in devices_kset_move_after()
2970 list_move(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_after()
2971 spin_unlock(&devices_kset->list_lock); in devices_kset_move_after()
2975 * devices_kset_move_last - move the device to the end of devices_kset's list.
2983 spin_lock(&devices_kset->list_lock); in devices_kset_move_last()
2984 list_move_tail(&dev->kobj.entry, &devices_kset->list); in devices_kset_move_last()
2985 spin_unlock(&devices_kset->list_lock); in devices_kset_move_last()
2989 * device_create_file - create sysfs attribute file for device.
2999 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), in device_create_file()
3001 attr->attr.name); in device_create_file()
3002 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), in device_create_file()
3004 attr->attr.name); in device_create_file()
3005 error = sysfs_create_file(&dev->kobj, &attr->attr); in device_create_file()
3013 * device_remove_file - remove sysfs attribute file.
3021 sysfs_remove_file(&dev->kobj, &attr->attr); in device_remove_file()
3026 * device_remove_file_self - remove sysfs attribute file from its own method.
3036 return sysfs_remove_file_self(&dev->kobj, &attr->attr); in device_remove_file_self()
3043 * device_create_bin_file - create sysfs binary attribute file for device.
3050 int error = -EINVAL; in device_create_bin_file()
3052 error = sysfs_create_bin_file(&dev->kobj, attr); in device_create_bin_file()
3058 * device_remove_bin_file - remove sysfs binary attribute file
3066 sysfs_remove_bin_file(&dev->kobj, attr); in device_remove_bin_file()
3073 struct device *dev = p->device; in klist_children_get()
3081 struct device *dev = p->device; in klist_children_put()
3087 * device_initialize - init device structure.
3108 dev->kobj.kset = devices_kset; in device_initialize()
3109 kobject_init(&dev->kobj, &device_ktype); in device_initialize()
3110 INIT_LIST_HEAD(&dev->dma_pools); in device_initialize()
3111 mutex_init(&dev->mutex); in device_initialize()
3112 lockdep_set_novalidate_class(&dev->mutex); in device_initialize()
3113 spin_lock_init(&dev->devres_lock); in device_initialize()
3114 INIT_LIST_HEAD(&dev->devres_head); in device_initialize()
3117 INIT_LIST_HEAD(&dev->links.consumers); in device_initialize()
3118 INIT_LIST_HEAD(&dev->links.suppliers); in device_initialize()
3119 INIT_LIST_HEAD(&dev->links.defer_sync); in device_initialize()
3120 dev->links.status = DL_DEV_NO_DRIVER; in device_initialize()
3124 dev->dma_coherent = dma_default_coherent; in device_initialize()
3136 &devices_kset->kobj); in virtual_device_parent()
3158 return dir->class->ns_type; in class_dir_child_ns_type()
3175 return ERR_PTR(-ENOMEM); in class_dir_create_and_add()
3177 dir->class = sp->class; in class_dir_create_and_add()
3178 kobject_init(&dir->kobj, &class_dir_ktype); in class_dir_create_and_add()
3180 dir->kobj.kset = &sp->glue_dirs; in class_dir_create_and_add()
3182 retval = kobject_add(&dir->kobj, parent_kobj, "%s", sp->class->name); in class_dir_create_and_add()
3184 kobject_put(&dir->kobj); in class_dir_create_and_add()
3187 return &dir->kobj; in class_dir_create_and_add()
3195 struct subsys_private *sp = class_to_subsys(dev->class); in get_device_parent()
3204 * Class-devices with a non class-device as parent, live in get_device_parent()
3209 else if (parent->class && !dev->class->ns_type) { in get_device_parent()
3211 return &parent->kobj; in get_device_parent()
3213 parent_kobj = &parent->kobj; in get_device_parent()
3218 /* find our class-directory at the parent and reference it */ in get_device_parent()
3219 spin_lock(&sp->glue_dirs.list_lock); in get_device_parent()
3220 list_for_each_entry(k, &sp->glue_dirs.list, entry) in get_device_parent()
3221 if (k->parent == parent_kobj) { in get_device_parent()
3225 spin_unlock(&sp->glue_dirs.list_lock); in get_device_parent()
3232 /* or create a new class-directory at the parent device */ in get_device_parent()
3241 if (!parent && dev->bus) { in get_device_parent()
3242 struct device *dev_root = bus_get_dev_root(dev->bus); in get_device_parent()
3245 kobj = &dev_root->kobj; in get_device_parent()
3252 return &parent->kobj; in get_device_parent()
3262 if (!kobj || !dev->class) in live_in_glue_dir()
3265 sp = class_to_subsys(dev->class); in live_in_glue_dir()
3269 if (kobj->kset == &sp->glue_dirs) in live_in_glue_dir()
3280 return dev->kobj.parent; in get_glue_dir()
3284 * kobject_has_children - Returns whether a kobject has children.
3295 WARN_ON_ONCE(kref_read(&kobj->kref) == 0); in kobject_has_children()
3297 return kobj->sd && kobj->sd->dir.subdirs; in kobject_has_children()
3340 * sysfs_remove_dir() // glue_dir->sd=NULL in cleanup_glue_dir()
3341 * sysfs_put() // free glue_dir->sd in cleanup_glue_dir()
3353 * and sysfs_put(). This result in glue_dir->sd is freed. in cleanup_glue_dir()
3362 ref = kref_read(&glue_dir->kref); in cleanup_glue_dir()
3363 if (!kobject_has_children(glue_dir) && !--ref) in cleanup_glue_dir()
3376 error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); in device_add_class_symlinks()
3382 sp = class_to_subsys(dev->class); in device_add_class_symlinks()
3386 error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); in device_add_class_symlinks()
3390 if (dev->parent && device_is_not_partition(dev)) { in device_add_class_symlinks()
3391 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, in device_add_class_symlinks()
3398 error = sysfs_create_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_add_class_symlinks()
3404 sysfs_remove_link(&dev->kobj, "device"); in device_add_class_symlinks()
3406 sysfs_remove_link(&dev->kobj, "subsystem"); in device_add_class_symlinks()
3408 sysfs_remove_link(&dev->kobj, "of_node"); in device_add_class_symlinks()
3416 struct subsys_private *sp = class_to_subsys(dev->class); in device_remove_class_symlinks()
3419 sysfs_remove_link(&dev->kobj, "of_node"); in device_remove_class_symlinks()
3424 if (dev->parent && device_is_not_partition(dev)) in device_remove_class_symlinks()
3425 sysfs_remove_link(&dev->kobj, "device"); in device_remove_class_symlinks()
3426 sysfs_remove_link(&dev->kobj, "subsystem"); in device_remove_class_symlinks()
3427 sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_remove_class_symlinks()
3432 * dev_set_name - set a device name
3442 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); in dev_set_name()
3464 format_dev_t(devt_str, dev->devt); in device_create_sys_dev_entry()
3465 error = sysfs_create_link(kobj, &dev->kobj, devt_str); in device_create_sys_dev_entry()
3477 format_dev_t(devt_str, dev->devt); in device_remove_sys_dev_entry()
3484 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); in device_private_init()
3485 if (!dev->p) in device_private_init()
3486 return -ENOMEM; in device_private_init()
3487 dev->p->device = dev; in device_private_init()
3488 klist_init(&dev->p->klist_children, klist_children_get, in device_private_init()
3490 INIT_LIST_HEAD(&dev->p->deferred_probe); in device_private_init()
3495 * device_add - add device to device hierarchy.
3527 int error = -EINVAL; in device_add()
3534 if (!dev->p) { in device_add()
3545 if (dev->init_name) { in device_add()
3546 error = dev_set_name(dev, "%s", dev->init_name); in device_add()
3547 dev->init_name = NULL; in device_add()
3553 else if (dev->bus && dev->bus->dev_name) in device_add()
3554 error = dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); in device_add()
3556 error = -EINVAL; in device_add()
3562 parent = get_device(dev->parent); in device_add()
3569 dev->kobj.parent = kobj; in device_add()
3577 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); in device_add()
3604 if (MAJOR(dev->devt)) { in device_add()
3620 kobject_uevent(&dev->kobj, KOBJ_ADD); in device_add()
3634 if (dev->fwnode && !dev->fwnode->dev) { in device_add()
3635 dev->fwnode->dev = dev; in device_add()
3646 if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) in device_add()
3650 klist_add_tail(&dev->p->knode_parent, in device_add()
3651 &parent->p->klist_children); in device_add()
3653 sp = class_to_subsys(dev->class); in device_add()
3655 mutex_lock(&sp->mutex); in device_add()
3657 klist_add_tail(&dev->p->knode_class, &sp->klist_devices); in device_add()
3660 list_for_each_entry(class_intf, &sp->interfaces, node) in device_add()
3661 if (class_intf->add_dev) in device_add()
3662 class_intf->add_dev(dev); in device_add()
3663 mutex_unlock(&sp->mutex); in device_add()
3670 if (MAJOR(dev->devt)) in device_add()
3676 dev->driver = NULL; in device_add()
3686 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_add()
3688 kobject_del(&dev->kobj); in device_add()
3694 kfree(dev->p); in device_add()
3695 dev->p = NULL; in device_add()
3701 * device_register - register a device with the system.
3704 * This happens in two clean steps - initialize the device
3726 * get_device - increment reference count for device.
3735 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; in get_device()
3740 * put_device - decrement reference count.
3747 kobject_put(&dev->kobj); in put_device()
3762 if (dev->p->dead) in kill_device()
3764 dev->p->dead = true; in kill_device()
3770 * device_del - delete device from system.
3785 struct device *parent = dev->parent; in device_del()
3794 if (dev->fwnode && dev->fwnode->dev == dev) in device_del()
3795 dev->fwnode->dev = NULL; in device_del()
3805 klist_del(&dev->p->knode_parent); in device_del()
3806 if (MAJOR(dev->devt)) { in device_del()
3812 sp = class_to_subsys(dev->class); in device_del()
3816 mutex_lock(&sp->mutex); in device_del()
3818 list_for_each_entry(class_intf, &sp->interfaces, node) in device_del()
3819 if (class_intf->remove_dev) in device_del()
3820 class_intf->remove_dev(dev); in device_del()
3822 klist_del(&dev->p->knode_class); in device_del()
3823 mutex_unlock(&sp->mutex); in device_del()
3846 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_del()
3848 kobject_del(&dev->kobj); in device_del()
3856 * device_unregister - unregister device from system.
3882 dev = p->device; in prev_device()
3895 dev = p->device; in next_device()
3901 * device_get_devnode - path of device node file
3909 * Non-default names may need to allocate a memory to compose
3922 if (dev->type && dev->type->devnode) in device_get_devnode()
3923 *tmp = dev->type->devnode(dev, mode, uid, gid); in device_get_devnode()
3928 if (dev->class && dev->class->devnode) in device_get_devnode()
3929 *tmp = dev->class->devnode(dev, mode); in device_get_devnode()
3945 * device_for_each_child - device child iterator.
3963 if (!parent->p) in device_for_each_child()
3966 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child()
3975 * device_for_each_child_reverse - device child iterator in reversed order.
3993 if (!parent->p) in device_for_each_child_reverse()
3996 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child_reverse()
4005 * device_find_child - device iterator for locating a particular device.
4014 * The callback should return 0 if the device doesn't match and non-zero
4015 * if it does. If the callback returns non-zero and a reference to the
4030 klist_iter_init(&parent->p->klist_children, &i); in device_find_child()
4040 * device_find_child_by_name - device iterator for locating a child device.
4058 klist_iter_init(&parent->p->klist_children, &i); in device_find_child_by_name()
4073 * device_find_any_child - device iterator for locating a child device, if any.
4091 return -ENOMEM; in devices_init()
4110 return -ENOMEM; in devices_init()
4121 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; in device_check_offline()
4125 * device_offline - Prepare the device for hot-removal.
4129 * the device for a subsequent hot-removal. If that succeeds, the device must
4139 if (dev->offline_disabled) in device_offline()
4140 return -EPERM; in device_offline()
4148 if (dev->offline) { in device_offline()
4151 ret = dev->bus->offline(dev); in device_offline()
4153 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); in device_offline()
4154 dev->offline = true; in device_offline()
4164 * device_online - Put the device back online after successful device_offline().
4179 if (dev->offline) { in device_online()
4180 ret = dev->bus->online(dev); in device_online()
4182 kobject_uevent(&dev->kobj, KOBJ_ONLINE); in device_online()
4183 dev->offline = false; in device_online()
4210 * __root_device_register - allocate and register a root device
4234 int err = -ENOMEM; in __root_device_register()
4240 err = dev_set_name(&root->dev, "%s", name); in __root_device_register()
4246 root->dev.release = root_device_release; in __root_device_register()
4248 err = device_register(&root->dev); in __root_device_register()
4250 put_device(&root->dev); in __root_device_register()
4256 struct module_kobject *mk = &owner->mkobj; in __root_device_register()
4258 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); in __root_device_register()
4260 device_unregister(&root->dev); in __root_device_register()
4263 root->owner = owner; in __root_device_register()
4267 return &root->dev; in __root_device_register()
4272 * root_device_unregister - unregister and free a root device
4282 if (root->owner) in root_device_unregister()
4283 sysfs_remove_link(&root->dev.kobj, "module"); in root_device_unregister()
4303 int retval = -ENODEV; in device_create_groups_vargs()
4310 retval = -ENOMEM; in device_create_groups_vargs()
4315 dev->devt = devt; in device_create_groups_vargs()
4316 dev->class = class; in device_create_groups_vargs()
4317 dev->parent = parent; in device_create_groups_vargs()
4318 dev->groups = groups; in device_create_groups_vargs()
4319 dev->release = device_create_release; in device_create_groups_vargs()
4322 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); in device_create_groups_vargs()
4338 * device_create - creates a device and registers it with sysfs
4373 * device_create_with_groups - creates a device and registers it with sysfs
4378 * @groups: NULL-terminated list of attribute groups to be created
4414 * device_destroy - removes a device that was created with device_create()
4434 * device_rename - renames a device
4457 * renamed it -- then you get events for the same DEVPATH, before you even see
4460 * other things than (driver-core wise very simple) network devices.
4464 * symlinks -- but never rename kernel devices later, it's a complete mess. We
4470 struct kobject *kobj = &dev->kobj; in device_rename()
4476 return -EINVAL; in device_rename()
4482 error = -ENOMEM; in device_rename()
4486 if (dev->class) { in device_rename()
4487 struct subsys_private *sp = class_to_subsys(dev->class); in device_rename()
4490 error = -EINVAL; in device_rename()
4494 error = sysfs_rename_link_ns(&sp->subsys.kobj, kobj, old_device_name, in device_rename()
4521 sysfs_remove_link(&dev->kobj, "device"); in device_move_class_links()
4523 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, in device_move_class_links()
4529 * device_move - moves a device to a new parent
4543 return -EINVAL; in device_move()
4556 error = kobject_move(&dev->kobj, new_parent_kobj); in device_move()
4562 old_parent = dev->parent; in device_move()
4563 dev->parent = new_parent; in device_move()
4565 klist_remove(&dev->p->knode_parent); in device_move()
4567 klist_add_tail(&dev->p->knode_parent, in device_move()
4568 &new_parent->p->klist_children); in device_move()
4572 if (dev->class) { in device_move()
4577 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { in device_move()
4579 klist_remove(&dev->p->knode_parent); in device_move()
4580 dev->parent = old_parent; in device_move()
4582 klist_add_tail(&dev->p->knode_parent, in device_move()
4583 &old_parent->p->klist_children); in device_move()
4620 struct kobject *kobj = &dev->kobj; in device_attrs_change_owner()
4621 const struct class *class = dev->class; in device_attrs_change_owner()
4622 const struct device_type *type = dev->type; in device_attrs_change_owner()
4630 error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, in device_attrs_change_owner()
4641 error = sysfs_groups_change_owner(kobj, type->groups, kuid, in device_attrs_change_owner()
4648 error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); in device_attrs_change_owner()
4652 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_attrs_change_owner()
4664 * device_change_owner - change the owner of an existing device.
4678 struct kobject *kobj = &dev->kobj; in device_change_owner()
4683 return -EINVAL; in device_change_owner()
4722 sp = class_to_subsys(dev->class); in device_change_owner()
4724 error = -EINVAL; in device_change_owner()
4727 error = sysfs_link_change_owner(&sp->subsys.kobj, &dev->kobj, dev_name(dev), kuid, kgid); in device_change_owner()
4737 * device_shutdown - call ->shutdown() on each device to shutdown.
4748 spin_lock(&devices_kset->list_lock); in device_shutdown()
4754 while (!list_empty(&devices_kset->list)) { in device_shutdown()
4755 dev = list_entry(devices_kset->list.prev, struct device, in device_shutdown()
4763 parent = get_device(dev->parent); in device_shutdown()
4767 * event that dev->*->shutdown() doesn't remove it. in device_shutdown()
4769 list_del_init(&dev->kobj.entry); in device_shutdown()
4770 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4781 if (dev->class && dev->class->shutdown_pre) { in device_shutdown()
4784 dev->class->shutdown_pre(dev); in device_shutdown()
4786 if (dev->bus && dev->bus->shutdown) { in device_shutdown()
4789 dev->bus->shutdown(dev); in device_shutdown()
4790 } else if (dev->driver && dev->driver->shutdown) { in device_shutdown()
4793 dev->driver->shutdown(dev); in device_shutdown()
4803 spin_lock(&devices_kset->list_lock); in device_shutdown()
4805 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4820 if (dev->class) in set_dev_info()
4821 subsys = dev->class->name; in set_dev_info()
4822 else if (dev->bus) in set_dev_info()
4823 subsys = dev->bus->name; in set_dev_info()
4827 strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); in set_dev_info()
4836 if (MAJOR(dev->devt)) { in set_dev_info()
4844 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4845 "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); in set_dev_info()
4849 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4850 "n%u", net->ifindex); in set_dev_info()
4852 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4887 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", in __dev_printk()
4938 * dev_err_probe - probe error check and log helper
4941 * @fmt: printf-style format string
4946 * -EPROBE_DEFER and propagate error upwards.
4947 * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
4951 * if (err != -EPROBE_DEFER)
4962 * known to never be -EPROBE_DEFER.
4965 * instead of "-35") and the fact that the error code is returned which allows
4979 if (err != -EPROBE_DEFER) { in dev_err_probe()
4994 return fwnode && !IS_ERR(fwnode->secondary); in fwnode_is_primary()
4998 * set_primary_fwnode - Change the primary firmware node of a given device.
5006 * - primary --> secondary --> -ENODEV
5007 * - primary --> NULL
5008 * - secondary --> -ENODEV
5009 * - NULL
5013 struct device *parent = dev->parent; in set_primary_fwnode()
5014 struct fwnode_handle *fn = dev->fwnode; in set_primary_fwnode()
5018 fn = fn->secondary; in set_primary_fwnode()
5021 WARN_ON(fwnode->secondary); in set_primary_fwnode()
5022 fwnode->secondary = fn; in set_primary_fwnode()
5024 dev->fwnode = fwnode; in set_primary_fwnode()
5027 dev->fwnode = fn->secondary; in set_primary_fwnode()
5029 /* Skip nullifying fn->secondary if the primary is shared */ in set_primary_fwnode()
5030 if (parent && fn == parent->fwnode) in set_primary_fwnode()
5033 /* Set fn->secondary = NULL, so fn remains the primary fwnode */ in set_primary_fwnode()
5034 fn->secondary = NULL; in set_primary_fwnode()
5036 dev->fwnode = NULL; in set_primary_fwnode()
5043 * set_secondary_fwnode - Change the secondary firmware node of a given device.
5054 fwnode->secondary = ERR_PTR(-ENODEV); in set_secondary_fwnode()
5056 if (fwnode_is_primary(dev->fwnode)) in set_secondary_fwnode()
5057 dev->fwnode->secondary = fwnode; in set_secondary_fwnode()
5059 dev->fwnode = fwnode; in set_secondary_fwnode()
5064 * device_set_of_node_from_dev - reuse device-tree node of another device
5065 * @dev: device whose device-tree node is being set
5066 * @dev2: device whose device-tree node is being reused
5068 * Takes another reference to the new device-tree node after first dropping
5073 of_node_put(dev->of_node); in device_set_of_node_from_dev()
5074 dev->of_node = of_node_get(dev2->of_node); in device_set_of_node_from_dev()
5075 dev->of_node_reused = true; in device_set_of_node_from_dev()
5081 dev->fwnode = fwnode; in device_set_node()
5082 dev->of_node = to_of_node(fwnode); in device_set_node()
5094 return dev->of_node == np; in device_match_of_node()
5106 return dev->devt == *(dev_t *)pdevt; in device_match_devt()