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>
16 #include <linux/dma-map-ops.h> /* for dma_default_coherent */
40 /* Device links support. */
51 * __fwnode_link_add - Create a link between two fwnode_handles.
65 * Attempts to create duplicate links between the same pair of 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.
135 * @fwnode: fwnode whose supplier links need to be deleted
137 * Deletes all supplier links connecting directly to @fwnode.
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.
151 * @fwnode: fwnode whose consumer links need to be deleted
153 * Deletes all consumer links connecting directly to @fwnode.
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.
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(device_link_wq, &link->rm_work); in devlink_dev_release()
542 * device_link_wait_removal - Wait for ongoing devlink removal jobs to terminate
566 struct device *sup = link->supplier; in devlink_add_symlinks()
567 struct device *con = link->consumer; in devlink_add_symlinks()
569 ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); in devlink_add_symlinks()
573 ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); in devlink_add_symlinks()
579 ret = -ENOMEM; in devlink_add_symlinks()
583 ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf_con); in devlink_add_symlinks()
589 ret = -ENOMEM; in devlink_add_symlinks()
593 ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf_sup); in devlink_add_symlinks()
600 sysfs_remove_link(&sup->kobj, buf_con); in devlink_add_symlinks()
602 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_add_symlinks()
604 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_add_symlinks()
613 struct device *sup = link->supplier; in devlink_remove_symlinks()
614 struct device *con = link->consumer; in devlink_remove_symlinks()
616 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_remove_symlinks()
617 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_remove_symlinks()
623 sysfs_remove_link(&con->kobj, buf_sup); in devlink_remove_symlinks()
629 sysfs_remove_link(&sup->kobj, buf_con); in devlink_remove_symlinks()
670 * device_link_add - Create a link between two devices.
682 * be forced into the active meta state and reference-counted upon the creation
719 * A side effect of the link creation is re-ordering of dpm_list and the
760 * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and in device_link_add()
773 * SYNC_STATE_ONLY links are useless once a consumer device has probed. in device_link_add()
777 consumer->links.status != DL_DEV_NO_DRIVER && in device_link_add()
778 consumer->links.status != DL_DEV_PROBING) { in device_link_add()
791 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_add()
792 if (link->consumer != consumer) in device_link_add()
795 if (link->flags & DL_FLAG_INFERRED && in device_link_add()
797 link->flags &= ~DL_FLAG_INFERRED; in device_link_add()
800 if (!(link->flags & DL_FLAG_PM_RUNTIME)) { in device_link_add()
802 link->flags |= DL_FLAG_PM_RUNTIME; in device_link_add()
805 refcount_inc(&link->rpm_active); in device_link_add()
809 kref_get(&link->kref); in device_link_add()
810 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
811 !(link->flags & DL_FLAG_STATELESS)) { in device_link_add()
812 link->flags |= DL_FLAG_STATELESS; in device_link_add()
815 link->flags |= DL_FLAG_STATELESS; in device_link_add()
826 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in device_link_add()
827 link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; in device_link_add()
828 link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; in device_link_add()
831 link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | in device_link_add()
834 if (!(link->flags & DL_FLAG_MANAGED)) { in device_link_add()
835 kref_get(&link->kref); in device_link_add()
836 link->flags |= DL_FLAG_MANAGED; in device_link_add()
839 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
841 link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; in device_link_add()
852 refcount_set(&link->rpm_active, 1); in device_link_add()
855 link->supplier = supplier; in device_link_add()
856 INIT_LIST_HEAD(&link->s_node); in device_link_add()
858 link->consumer = consumer; in device_link_add()
859 INIT_LIST_HEAD(&link->c_node); in device_link_add()
860 link->flags = flags; in device_link_add()
861 kref_init(&link->kref); in device_link_add()
863 link->link_dev.class = &devlink_class; in device_link_add()
864 device_set_pm_not_required(&link->link_dev); in device_link_add()
865 dev_set_name(&link->link_dev, "%s:%s--%s:%s", in device_link_add()
868 if (device_register(&link->link_dev)) { in device_link_add()
869 put_device(&link->link_dev); in device_link_add()
876 refcount_inc(&link->rpm_active); in device_link_add()
883 link->status = DL_STATE_NONE; in device_link_add()
891 if (link->status == DL_STATE_CONSUMER_PROBE && in device_link_add()
895 list_add_tail_rcu(&link->s_node, &supplier->links.consumers); in device_link_add()
896 list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); in device_link_add()
932 dev_dbg(link->consumer, "Dropping the link to %s\n", in __device_link_del()
933 dev_name(link->supplier)); in __device_link_del()
938 device_unregister(&link->link_dev); in __device_link_del()
943 if (link->flags & DL_FLAG_STATELESS) in device_link_put_kref()
944 kref_put(&link->kref, __device_link_del); in device_link_put_kref()
945 else if (!device_is_registered(link->consumer)) in device_link_put_kref()
946 __device_link_del(&link->kref); in device_link_put_kref()
952 * device_link_del - Delete a stateless link between two devices.
957 * Care is required for hotplugged devices: Their links are purged on removal
969 * device_link_remove - Delete a stateless link between two devices.
985 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_remove()
986 if (link->consumer == consumer) { in device_link_remove()
1000 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_missing_supplier()
1001 if (link->status != DL_STATE_CONSUMER_PROBE) in device_links_missing_supplier()
1004 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in device_links_missing_supplier()
1005 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_missing_supplier()
1007 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in device_links_missing_supplier()
1008 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_missing_supplier()
1015 return (fw_devlink_best_effort && dev->can_match) || in dev_is_best_effort()
1016 (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT)); in dev_is_best_effort()
1027 list_for_each_entry(link, &fwnode->suppliers, c_hook) in fwnode_links_check_suppliers()
1028 if (!(link->flags & in fwnode_links_check_suppliers()
1030 return link->supplier; in fwnode_links_check_suppliers()
1036 * device_links_check_suppliers - Check presence of supplier drivers.
1039 * Check links from this device to any suppliers. Walk the list of the device's
1040 * links to suppliers and see if all of them are available. If not, simply
1041 * return -EPROBE_DEFER.
1045 * that function checks the device's links to consumers. This means we need to
1049 * Links without the DL_FLAG_MANAGED flag set are ignored.
1062 sup_fw = fwnode_links_check_suppliers(dev->fwnode); in device_links_check_suppliers()
1065 fwnode_ret = -EAGAIN; in device_links_check_suppliers()
1067 return dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1074 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_check_suppliers()
1075 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_check_suppliers()
1078 if (link->status != DL_STATE_AVAILABLE && in device_links_check_suppliers()
1079 !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { in device_links_check_suppliers()
1082 link->flags & DL_FLAG_INFERRED && in device_links_check_suppliers()
1083 !link->supplier->can_match) { in device_links_check_suppliers()
1084 ret = -EAGAIN; in device_links_check_suppliers()
1089 ret = dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1090 "supplier %s not ready\n", dev_name(link->supplier)); in device_links_check_suppliers()
1093 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_check_suppliers()
1095 dev->links.status = DL_DEV_PROBING; in device_links_check_suppliers()
1103 * __device_links_queue_sync_state - Queue a device for sync_state() callback
1107 * Queues a device for a sync_state() callback when the device links write lock
1108 * isn't held. This allows the sync_state() execution flow to use device links
1127 if (dev->state_synced) in __device_links_queue_sync_state()
1130 list_for_each_entry(link, &dev->links.consumers, s_node) { in __device_links_queue_sync_state()
1131 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_queue_sync_state()
1133 if (link->status != DL_STATE_ACTIVE) in __device_links_queue_sync_state()
1142 dev->state_synced = true; in __device_links_queue_sync_state()
1144 if (WARN_ON(!list_empty(&dev->links.defer_sync))) in __device_links_queue_sync_state()
1148 list_add_tail(&dev->links.defer_sync, list); in __device_links_queue_sync_state()
1152 * device_links_flush_sync_list - Call sync_state() on a list of devices
1166 list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { in device_links_flush_sync_list()
1167 list_del_init(&dev->links.defer_sync); in device_links_flush_sync_list()
1198 defer_sync_state_count--; in device_links_supplier_sync_state_resume()
1202 list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { in device_links_supplier_sync_state_resume()
1207 list_del_init(&dev->links.defer_sync); in device_links_supplier_sync_state_resume()
1225 if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) in __device_links_supplier_defer_sync()
1226 list_add_tail(&sup->links.defer_sync, &deferred_sync); in __device_links_supplier_defer_sync()
1231 link->flags &= ~DL_FLAG_MANAGED; in device_link_drop_managed()
1232 WRITE_ONCE(link->status, DL_STATE_NONE); in device_link_drop_managed()
1233 kref_put(&link->kref, __device_link_del); in device_link_drop_managed()
1244 val = !!fwnode_links_check_suppliers(dev->fwnode); in waiting_for_supplier_show()
1251 * device_links_force_bind - Prepares device to be force bound
1260 * supplier device links and checks if the supplier is bound. If it is, then
1262 * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored.
1270 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_force_bind()
1271 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_force_bind()
1274 if (link->status != DL_STATE_AVAILABLE) { in device_links_force_bind()
1278 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_force_bind()
1280 dev->links.status = DL_DEV_PROBING; in device_links_force_bind()
1286 * device_links_driver_bound - Update device links after probing its driver.
1287 * @dev: Device to update the links for.
1289 * The probe has been successful, so update links from this device to any
1292 * Also change the status of @dev's links to suppliers to "active".
1294 * Links without the DL_FLAG_MANAGED flag set are ignored.
1303 * the device links it needs to or make new device links as it needs in device_links_driver_bound()
1304 * them. So, fw_devlink no longer needs to create device links to any in device_links_driver_bound()
1315 if (dev->fwnode && dev->fwnode->dev == dev) { in device_links_driver_bound()
1318 fwnode_links_purge_suppliers(dev->fwnode); in device_links_driver_bound()
1322 fwnode_for_each_available_child_node(dev->fwnode, child) in device_links_driver_bound()
1324 dev->fwnode); in device_links_driver_bound()
1331 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_driver_bound()
1332 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1336 * Links created during consumer probe may be in the "consumer in device_links_driver_bound()
1341 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_driver_bound()
1342 link->status == DL_STATE_ACTIVE) in device_links_driver_bound()
1345 WARN_ON(link->status != DL_STATE_DORMANT); in device_links_driver_bound()
1346 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_driver_bound()
1348 if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) in device_links_driver_bound()
1349 driver_deferred_probe_add(link->consumer); in device_links_driver_bound()
1357 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_driver_bound()
1360 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1363 supplier = link->supplier; in device_links_driver_bound()
1364 if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { in device_links_driver_bound()
1372 link->flags & DL_FLAG_INFERRED && in device_links_driver_bound()
1373 link->status != DL_STATE_CONSUMER_PROBE && in device_links_driver_bound()
1374 !link->supplier->can_match) { in device_links_driver_bound()
1377 * links to suppliers that don't have a driver. If the in device_links_driver_bound()
1384 WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); in device_links_driver_bound()
1385 WRITE_ONCE(link->status, DL_STATE_ACTIVE); in device_links_driver_bound()
1400 dev->links.status = DL_DEV_DRIVER_BOUND; in device_links_driver_bound()
1408 * __device_links_no_driver - Update links of a device without a driver.
1411 * Delete all non-persistent links from this device to any suppliers.
1413 * Persistent links stay around, but their status is changed to "available",
1417 * Links without the DL_FLAG_MANAGED flag set are ignored.
1423 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in __device_links_no_driver()
1424 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_no_driver()
1427 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in __device_links_no_driver()
1432 if (link->status != DL_STATE_CONSUMER_PROBE && in __device_links_no_driver()
1433 link->status != DL_STATE_ACTIVE) in __device_links_no_driver()
1436 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in __device_links_no_driver()
1437 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in __device_links_no_driver()
1439 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in __device_links_no_driver()
1440 WRITE_ONCE(link->status, DL_STATE_DORMANT); in __device_links_no_driver()
1444 dev->links.status = DL_DEV_NO_DRIVER; in __device_links_no_driver()
1448 * device_links_no_driver - Update links after failing driver probe.
1451 * Clean up leftover links to consumers for @dev and invoke
1452 * %__device_links_no_driver() to update links to suppliers for it as
1455 * Links without the DL_FLAG_MANAGED flag set are ignored.
1463 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_no_driver()
1464 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_no_driver()
1474 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_no_driver()
1475 link->status == DL_STATE_ACTIVE) in device_links_no_driver()
1476 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_no_driver()
1485 * device_links_driver_cleanup - Update links after driver removal.
1488 * Update links to consumers for @dev by changing their status to "dormant" and
1489 * invoke %__device_links_no_driver() to update links to suppliers for it as
1492 * Links without the DL_FLAG_MANAGED flag set are ignored.
1500 list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { in device_links_driver_cleanup()
1501 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_cleanup()
1504 WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); in device_links_driver_cleanup()
1505 WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); in device_links_driver_cleanup()
1508 * autoremove the links between this @dev and its consumer in device_links_driver_cleanup()
1512 if (link->status == DL_STATE_SUPPLIER_UNBIND && in device_links_driver_cleanup()
1513 link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) in device_links_driver_cleanup()
1516 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_driver_cleanup()
1519 list_del_init(&dev->links.defer_sync); in device_links_driver_cleanup()
1526 * device_links_busy - Check if there are any busy links to consumers.
1537 * Links without the DL_FLAG_MANAGED flag set are ignored.
1546 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_busy()
1547 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_busy()
1550 if (link->status == DL_STATE_CONSUMER_PROBE in device_links_busy()
1551 || link->status == DL_STATE_ACTIVE) { in device_links_busy()
1555 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_busy()
1558 dev->links.status = DL_DEV_UNBINDING; in device_links_busy()
1565 * device_links_unbind_consumers - Force unbind consumers of the given device.
1568 * Walk the list of links to consumers for @dev and if any of them is in the
1574 * driver to unbind and start over (the consumer will not re-probe as we have
1577 * Links without the DL_FLAG_MANAGED flag set are ignored.
1586 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_unbind_consumers()
1589 if (!(link->flags & DL_FLAG_MANAGED) || in device_links_unbind_consumers()
1590 link->flags & DL_FLAG_SYNC_STATE_ONLY) in device_links_unbind_consumers()
1593 status = link->status; in device_links_unbind_consumers()
1600 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_unbind_consumers()
1602 struct device *consumer = link->consumer; in device_links_unbind_consumers()
1609 consumer->parent); in device_links_unbind_consumers()
1619 * device_links_purge - Delete existing links to other devices.
1626 if (dev->class == &devlink_class) in device_links_purge()
1630 * Delete all of the remaining links from this device to any other in device_links_purge()
1635 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in device_links_purge()
1636 WARN_ON(link->status == DL_STATE_ACTIVE); in device_links_purge()
1637 __device_link_del(&link->kref); in device_links_purge()
1640 list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { in device_links_purge()
1641 WARN_ON(link->status != DL_STATE_DORMANT && in device_links_purge()
1642 link->status != DL_STATE_NONE); in device_links_purge()
1643 __device_link_del(&link->kref); in device_links_purge()
1660 return -EINVAL; in fw_devlink_setup()
1694 return -EINVAL; in fw_devlink_sync_state_setup()
1703 return -EINVAL; in fw_devlink_sync_state_setup()
1727 if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) in fw_devlink_parse_fwnode()
1731 fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; in fw_devlink_parse_fwnode()
1746 if (!(link->flags & DL_FLAG_INFERRED)) in fw_devlink_relax_link()
1749 if (device_link_flag_is_sync_state_only(link->flags)) in fw_devlink_relax_link()
1753 link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; in fw_devlink_relax_link()
1754 dev_dbg(link->consumer, "Relaxing link with %s\n", in fw_devlink_relax_link()
1755 dev_name(link->supplier)); in fw_devlink_relax_link()
1762 if (!link->supplier->can_match) in fw_devlink_no_driver()
1780 struct device *sup = link->supplier; in fw_devlink_dev_sync_state()
1782 if (!(link->flags & DL_FLAG_MANAGED) || in fw_devlink_dev_sync_state()
1783 link->status == DL_STATE_ACTIVE || sup->state_synced || in fw_devlink_dev_sync_state()
1789 dev_name(link->consumer)); in fw_devlink_dev_sync_state()
1793 if (!list_empty(&sup->links.defer_sync)) in fw_devlink_dev_sync_state()
1797 sup->state_synced = true; in fw_devlink_dev_sync_state()
1799 list_add_tail(&sup->links.defer_sync, data); in fw_devlink_dev_sync_state()
1816 * wait_for_init_devices_probe - Try to probe any device needed for init
1879 list_for_each_entry(link, &dev->links.consumers, s_node) in fw_devlink_unblock_consumers()
1884 #define get_dev_from_fwnode(fwnode) get_device((fwnode)->dev)
1891 if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED)) in fwnode_init_without_drv()
1895 ret = !dev || dev->links.status == DL_DEV_NO_DRIVER; in fwnode_init_without_drv()
1916 * fwnode_is_ancestor_of - Test if @ancestor is ancestor of @child
1945 * fwnode_get_next_parent_dev - Find device of closest ancestor fwnode
1973 * __fw_devlink_relax_cycles - Relax and mark dependency cycles.
1981 * and @con. When such dependency cycles are found, convert all device links
1982 * created solely by fw_devlink into SYNC_STATE_ONLY device links. Also, mark
1983 * all fwnode links in the cycle with FWLINK_FLAG_CYCLE so that when they are
1985 * SYNC_STATE_ONLY device links. This is the equivalent of doing
2007 if (sup_handle->flags & FWNODE_FLAG_VISITED) in __fw_devlink_relax_cycles()
2010 sup_handle->flags |= FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
2014 pr_debug("----- cycle: start -----\n"); in __fw_devlink_relax_cycles()
2026 if (sup_dev && sup_dev->links.status == DL_DEV_DRIVER_BOUND && in __fw_devlink_relax_cycles()
2027 con_dev && con_dev->links.status == DL_DEV_NO_DRIVER) { in __fw_devlink_relax_cycles()
2032 list_for_each_entry(link, &sup_handle->suppliers, c_hook) { in __fw_devlink_relax_cycles()
2033 if (link->flags & FWLINK_FLAG_IGNORE) in __fw_devlink_relax_cycles()
2036 if (__fw_devlink_relax_cycles(con_handle, link->supplier)) { in __fw_devlink_relax_cycles()
2047 par_dev = get_device(sup_dev->parent); in __fw_devlink_relax_cycles()
2051 if (par_dev && __fw_devlink_relax_cycles(con_handle, par_dev->fwnode)) { in __fw_devlink_relax_cycles()
2053 par_dev->fwnode); in __fw_devlink_relax_cycles()
2060 list_for_each_entry(dev_link, &sup_dev->links.suppliers, c_node) { in __fw_devlink_relax_cycles()
2065 if (device_link_flag_is_sync_state_only(dev_link->flags) && in __fw_devlink_relax_cycles()
2066 !(dev_link->flags & DL_FLAG_CYCLE)) in __fw_devlink_relax_cycles()
2070 dev_link->supplier->fwnode)) { in __fw_devlink_relax_cycles()
2072 dev_link->supplier->fwnode); in __fw_devlink_relax_cycles()
2074 dev_link->flags |= DL_FLAG_CYCLE; in __fw_devlink_relax_cycles()
2080 sup_handle->flags &= ~FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
2088 * fw_devlink_create_devlink - Create a device link from a consumer to fwnode
2097 * fwnode links can sometimes cause the supplier device to never be created.
2103 * -EINVAL if the device link cannot be created as expected
2104 * -EAGAIN if the device link cannot be created right now, but it may be
2115 if (link->flags & FWLINK_FLAG_IGNORE) in fw_devlink_create_devlink()
2130 * When such a flag is set, we can't create device links where P is the in fw_devlink_create_devlink()
2133 if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD && in fw_devlink_create_devlink()
2134 fwnode_is_ancestor_of(sup_handle, con->fwnode)) in fw_devlink_create_devlink()
2135 return -EINVAL; in fw_devlink_create_devlink()
2143 if (__fw_devlink_relax_cycles(link->consumer, sup_handle)) { in fw_devlink_create_devlink()
2145 pr_debug("----- cycle: end -----\n"); in fw_devlink_create_devlink()
2146 pr_info("%pfwf: Fixed dependency cycle(s) with %pfwf\n", in fw_devlink_create_devlink()
2147 link->consumer, sup_handle); in fw_devlink_create_devlink()
2151 if (con->fwnode == link->consumer) in fw_devlink_create_devlink()
2152 flags = fw_devlink_get_flags(link->flags); in fw_devlink_create_devlink()
2156 if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE) in fw_devlink_create_devlink()
2167 if (sup_dev->links.status == DL_DEV_NO_DRIVER && in fw_devlink_create_devlink()
2168 sup_handle->flags & FWNODE_FLAG_INITIALIZED) { in fw_devlink_create_devlink()
2170 "Not linking %pfwf - dev might never probe\n", in fw_devlink_create_devlink()
2172 ret = -EINVAL; in fw_devlink_create_devlink()
2178 flags, dev_name(sup_dev), link->consumer); in fw_devlink_create_devlink()
2179 ret = -EINVAL; in fw_devlink_create_devlink()
2191 dev_dbg(con, "Not linking %pfwf - might never become dev\n", in fw_devlink_create_devlink()
2193 return -EINVAL; in fw_devlink_create_devlink()
2196 ret = -EAGAIN; in fw_devlink_create_devlink()
2203 * __fw_devlink_link_to_consumers - Create device links to consumers of a device
2207 * links between the consumer device and @dev (supplier).
2215 * Once device links are created from the real consumer to @dev (supplier), the
2216 * fwnode links are deleted.
2220 struct fwnode_handle *fwnode = dev->fwnode; in __fw_devlink_link_to_consumers()
2223 list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { in __fw_devlink_link_to_consumers()
2228 con_dev = get_dev_from_fwnode(link->consumer); in __fw_devlink_link_to_consumers()
2240 con_dev = fwnode_get_next_parent_dev(link->consumer); in __fw_devlink_link_to_consumers()
2244 * consumer-supplier link from the parent to its child in __fw_devlink_link_to_consumers()
2248 fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { in __fw_devlink_link_to_consumers()
2261 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_consumers()
2269 * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device
2271 * @fwnode: Root of the fwnode tree that is used to create device links
2274 * @fwnode and creates device links between @dev (consumer) and all the
2277 * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev
2278 * and the real suppliers of @dev. Once these device links are created, the
2279 * fwnode links are deleted.
2284 * driver core. So, this function creates SYNC_STATE_ONLY device links between
2287 * their device links. The fwnode links that correspond to the child devices
2288 * aren't delete because they are needed later to create the device links
2294 bool own_link = (dev->fwnode == fwnode); in __fw_devlink_link_to_suppliers()
2298 list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { in __fw_devlink_link_to_suppliers()
2300 struct fwnode_handle *sup = link->supplier; in __fw_devlink_link_to_suppliers()
2303 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_suppliers()
2310 * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of in __fw_devlink_link_to_suppliers()
2321 struct fwnode_handle *fwnode = dev->fwnode; in fw_devlink_link_device()
2334 /* Device links support end. */
2369 return !(dev->type == &part_type); in device_is_not_partition()
2393 * dev_driver_string - Return a device's driver name, if at all possible
2405 /* dev->driver can change to NULL underneath us because of unbinding, in dev_driver_string()
2406 * so be careful about accessing it. dev->bus and dev->class should in dev_driver_string()
2409 drv = READ_ONCE(dev->driver); in dev_driver_string()
2410 return drv ? drv->name : dev_bus_name(dev); in dev_driver_string()
2421 ssize_t ret = -EIO; in dev_attr_show()
2423 if (dev_attr->show) in dev_attr_show()
2424 ret = dev_attr->show(dev, dev_attr, buf); in dev_attr_show()
2427 dev_attr->show); in dev_attr_show()
2437 ssize_t ret = -EIO; in dev_attr_store()
2439 if (dev_attr->store) in dev_attr_store()
2440 ret = dev_attr->store(dev, dev_attr, buf, count); in dev_attr_store()
2462 *(unsigned long *)(ea->var) = new; in device_store_ulong()
2473 return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); in device_show_ulong()
2490 return -EINVAL; in device_store_int()
2491 *(int *)(ea->var) = new; in device_store_int()
2503 return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); in device_show_int()
2512 if (kstrtobool(buf, ea->var) < 0) in device_store_bool()
2513 return -EINVAL; in device_store_bool()
2524 return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); in device_show_bool()
2533 return sysfs_emit(buf, "%s\n", (char *)ea->var); in device_show_string()
2538 * device_release - free device structure.
2548 struct device_private *p = dev->p; in device_release()
2561 kfree(dev->dma_range_map); in device_release()
2563 if (dev->release) in device_release()
2564 dev->release(dev); in device_release()
2565 else if (dev->type && dev->type->release) in device_release()
2566 dev->type->release(dev); in device_release()
2567 else if (dev->class && dev->class->dev_release) in device_release()
2568 dev->class->dev_release(dev); in device_release()
2570 …does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kob… in device_release()
2580 if (dev->class && dev->class->namespace) in device_namespace()
2581 ns = dev->class->namespace(dev); in device_namespace()
2590 if (dev->class && dev->class->get_ownership) in device_get_ownership()
2591 dev->class->get_ownership(dev, uid, gid); in device_get_ownership()
2608 if (dev->bus) in dev_uevent_filter()
2610 if (dev->class) in dev_uevent_filter()
2620 if (dev->bus) in dev_uevent_name()
2621 return dev->bus->name; in dev_uevent_name()
2622 if (dev->class) in dev_uevent_name()
2623 return dev->class->name; in dev_uevent_name()
2633 if (MAJOR(dev->devt)) { in dev_uevent()
2640 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); in dev_uevent()
2641 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); in dev_uevent()
2655 if (dev->type && dev->type->name) in dev_uevent()
2656 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); in dev_uevent()
2658 if (dev->driver) in dev_uevent()
2659 add_uevent_var(env, "DRIVER=%s", dev->driver->name); in dev_uevent()
2665 if (dev->bus && dev->bus->uevent) { in dev_uevent()
2666 retval = dev->bus->uevent(dev, env); in dev_uevent()
2673 if (dev->class && dev->class->dev_uevent) { in dev_uevent()
2674 retval = dev->class->dev_uevent(dev, env); in dev_uevent()
2682 if (dev->type && dev->type->uevent) { in dev_uevent()
2683 retval = dev->type->uevent(dev, env); in dev_uevent()
2710 top_kobj = &dev->kobj; in uevent_show()
2711 while (!top_kobj->kset && top_kobj->parent) in uevent_show()
2712 top_kobj = top_kobj->parent; in uevent_show()
2713 if (!top_kobj->kset) in uevent_show()
2716 kset = top_kobj->kset; in uevent_show()
2717 if (!kset->uevent_ops || !kset->uevent_ops->uevent) in uevent_show()
2721 if (kset->uevent_ops && kset->uevent_ops->filter) in uevent_show()
2722 if (!kset->uevent_ops->filter(&dev->kobj)) in uevent_show()
2727 return -ENOMEM; in uevent_show()
2732 retval = kset->uevent_ops->uevent(&dev->kobj, env); in uevent_show()
2738 for (i = 0; i < env->envp_idx; i++) in uevent_show()
2739 len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); in uevent_show()
2750 rc = kobject_synth_uevent(&dev->kobj, buf, count); in uevent_store()
2767 val = !dev->offline; in online_show()
2797 switch (dev->removable) { in removable_show()
2802 loc = "fixed"; in removable_show()
2813 return sysfs_create_groups(&dev->kobj, groups); in device_add_groups()
2820 sysfs_remove_groups(&dev->kobj, groups); in device_remove_groups()
2832 const struct attribute_group *group = devres->group; in devm_attr_group_remove()
2835 sysfs_remove_group(&dev->kobj, group); in devm_attr_group_remove()
2839 * devm_device_add_group - given a device, create a managed attribute group
2856 return -ENOMEM; in devm_device_add_group()
2858 error = sysfs_create_group(&dev->kobj, grp); in devm_device_add_group()
2864 devres->group = grp; in devm_device_add_group()
2872 const struct class *class = dev->class; in device_add_attrs()
2873 const struct device_type *type = dev->type; in device_add_attrs()
2877 error = device_add_groups(dev, class->dev_groups); in device_add_attrs()
2883 error = device_add_groups(dev, type->groups); in device_add_attrs()
2888 error = device_add_groups(dev, dev->groups); in device_add_attrs()
2892 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_add_attrs()
2898 if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { in device_add_attrs()
2926 device_remove_groups(dev, dev->groups); in device_add_attrs()
2929 device_remove_groups(dev, type->groups); in device_add_attrs()
2932 device_remove_groups(dev, class->dev_groups); in device_add_attrs()
2939 const struct class *class = dev->class; in device_remove_attrs()
2940 const struct device_type *type = dev->type; in device_remove_attrs()
2942 if (dev->physical_location) { in device_remove_attrs()
2944 kfree(dev->physical_location); in device_remove_attrs()
2950 device_remove_groups(dev, dev->groups); in device_remove_attrs()
2953 device_remove_groups(dev, type->groups); in device_remove_attrs()
2956 device_remove_groups(dev, class->dev_groups); in device_remove_attrs()
2962 return print_dev_t(buf, dev->devt); in dev_show()
2970 * devices_kset_move_before - Move device in the devices_kset's list.
2980 spin_lock(&devices_kset->list_lock); in devices_kset_move_before()
2981 list_move_tail(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_before()
2982 spin_unlock(&devices_kset->list_lock); in devices_kset_move_before()
2986 * devices_kset_move_after - Move device in the devices_kset's list.
2996 spin_lock(&devices_kset->list_lock); in devices_kset_move_after()
2997 list_move(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_after()
2998 spin_unlock(&devices_kset->list_lock); in devices_kset_move_after()
3002 * devices_kset_move_last - move the device to the end of devices_kset's list.
3010 spin_lock(&devices_kset->list_lock); in devices_kset_move_last()
3011 list_move_tail(&dev->kobj.entry, &devices_kset->list); in devices_kset_move_last()
3012 spin_unlock(&devices_kset->list_lock); in devices_kset_move_last()
3016 * device_create_file - create sysfs attribute file for device.
3026 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), in device_create_file()
3028 attr->attr.name); in device_create_file()
3029 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), in device_create_file()
3031 attr->attr.name); in device_create_file()
3032 error = sysfs_create_file(&dev->kobj, &attr->attr); in device_create_file()
3040 * device_remove_file - remove sysfs attribute file.
3048 sysfs_remove_file(&dev->kobj, &attr->attr); in device_remove_file()
3053 * device_remove_file_self - remove sysfs attribute file from its own method.
3063 return sysfs_remove_file_self(&dev->kobj, &attr->attr); in device_remove_file_self()
3070 * device_create_bin_file - create sysfs binary attribute file for device.
3077 int error = -EINVAL; in device_create_bin_file()
3079 error = sysfs_create_bin_file(&dev->kobj, attr); in device_create_bin_file()
3085 * device_remove_bin_file - remove sysfs binary attribute file
3093 sysfs_remove_bin_file(&dev->kobj, attr); in device_remove_bin_file()
3100 struct device *dev = p->device; in klist_children_get()
3108 struct device *dev = p->device; in klist_children_put()
3114 * device_initialize - init device structure.
3135 dev->kobj.kset = devices_kset; in device_initialize()
3136 kobject_init(&dev->kobj, &device_ktype); in device_initialize()
3137 INIT_LIST_HEAD(&dev->dma_pools); in device_initialize()
3138 mutex_init(&dev->mutex); in device_initialize()
3139 lockdep_set_novalidate_class(&dev->mutex); in device_initialize()
3140 spin_lock_init(&dev->devres_lock); in device_initialize()
3141 INIT_LIST_HEAD(&dev->devres_head); in device_initialize()
3144 INIT_LIST_HEAD(&dev->links.consumers); in device_initialize()
3145 INIT_LIST_HEAD(&dev->links.suppliers); in device_initialize()
3146 INIT_LIST_HEAD(&dev->links.defer_sync); in device_initialize()
3147 dev->links.status = DL_DEV_NO_DRIVER; in device_initialize()
3151 dev->dma_coherent = dma_default_coherent; in device_initialize()
3163 &devices_kset->kobj); in virtual_device_parent()
3185 return dir->class->ns_type; in class_dir_child_ns_type()
3202 return ERR_PTR(-ENOMEM); in class_dir_create_and_add()
3204 dir->class = sp->class; in class_dir_create_and_add()
3205 kobject_init(&dir->kobj, &class_dir_ktype); in class_dir_create_and_add()
3207 dir->kobj.kset = &sp->glue_dirs; in class_dir_create_and_add()
3209 retval = kobject_add(&dir->kobj, parent_kobj, "%s", sp->class->name); in class_dir_create_and_add()
3211 kobject_put(&dir->kobj); in class_dir_create_and_add()
3214 return &dir->kobj; in class_dir_create_and_add()
3222 struct subsys_private *sp = class_to_subsys(dev->class); in get_device_parent()
3231 * Class-devices with a non class-device as parent, live in get_device_parent()
3236 else if (parent->class && !dev->class->ns_type) { in get_device_parent()
3238 return &parent->kobj; in get_device_parent()
3240 parent_kobj = &parent->kobj; in get_device_parent()
3245 /* find our class-directory at the parent and reference it */ in get_device_parent()
3246 spin_lock(&sp->glue_dirs.list_lock); in get_device_parent()
3247 list_for_each_entry(k, &sp->glue_dirs.list, entry) in get_device_parent()
3248 if (k->parent == parent_kobj) { in get_device_parent()
3252 spin_unlock(&sp->glue_dirs.list_lock); in get_device_parent()
3259 /* or create a new class-directory at the parent device */ in get_device_parent()
3268 if (!parent && dev->bus) { in get_device_parent()
3269 struct device *dev_root = bus_get_dev_root(dev->bus); in get_device_parent()
3272 kobj = &dev_root->kobj; in get_device_parent()
3279 return &parent->kobj; in get_device_parent()
3289 if (!kobj || !dev->class) in live_in_glue_dir()
3292 sp = class_to_subsys(dev->class); in live_in_glue_dir()
3296 if (kobj->kset == &sp->glue_dirs) in live_in_glue_dir()
3307 return dev->kobj.parent; in get_glue_dir()
3311 * kobject_has_children - Returns whether a kobject has children.
3322 WARN_ON_ONCE(kref_read(&kobj->kref) == 0); in kobject_has_children()
3324 return kobj->sd && kobj->sd->dir.subdirs; in kobject_has_children()
3367 * sysfs_remove_dir() // glue_dir->sd=NULL in cleanup_glue_dir()
3368 * sysfs_put() // free glue_dir->sd in cleanup_glue_dir()
3380 * and sysfs_put(). This result in glue_dir->sd is freed. in cleanup_glue_dir()
3389 ref = kref_read(&glue_dir->kref); in cleanup_glue_dir()
3390 if (!kobject_has_children(glue_dir) && !--ref) in cleanup_glue_dir()
3403 error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); in device_add_class_symlinks()
3409 sp = class_to_subsys(dev->class); in device_add_class_symlinks()
3413 error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); in device_add_class_symlinks()
3417 if (dev->parent && device_is_not_partition(dev)) { in device_add_class_symlinks()
3418 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, in device_add_class_symlinks()
3425 error = sysfs_create_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_add_class_symlinks()
3431 sysfs_remove_link(&dev->kobj, "device"); in device_add_class_symlinks()
3433 sysfs_remove_link(&dev->kobj, "subsystem"); in device_add_class_symlinks()
3435 sysfs_remove_link(&dev->kobj, "of_node"); in device_add_class_symlinks()
3443 struct subsys_private *sp = class_to_subsys(dev->class); in device_remove_class_symlinks()
3446 sysfs_remove_link(&dev->kobj, "of_node"); in device_remove_class_symlinks()
3451 if (dev->parent && device_is_not_partition(dev)) in device_remove_class_symlinks()
3452 sysfs_remove_link(&dev->kobj, "device"); in device_remove_class_symlinks()
3453 sysfs_remove_link(&dev->kobj, "subsystem"); in device_remove_class_symlinks()
3454 sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_remove_class_symlinks()
3459 * dev_set_name - set a device name
3469 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); in dev_set_name()
3491 format_dev_t(devt_str, dev->devt); in device_create_sys_dev_entry()
3492 error = sysfs_create_link(kobj, &dev->kobj, devt_str); in device_create_sys_dev_entry()
3504 format_dev_t(devt_str, dev->devt); in device_remove_sys_dev_entry()
3511 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); in device_private_init()
3512 if (!dev->p) in device_private_init()
3513 return -ENOMEM; in device_private_init()
3514 dev->p->device = dev; in device_private_init()
3515 klist_init(&dev->p->klist_children, klist_children_get, in device_private_init()
3517 INIT_LIST_HEAD(&dev->p->deferred_probe); in device_private_init()
3522 * device_add - add device to device hierarchy.
3554 int error = -EINVAL; in device_add()
3561 if (!dev->p) { in device_add()
3572 if (dev->init_name) { in device_add()
3573 error = dev_set_name(dev, "%s", dev->init_name); in device_add()
3574 dev->init_name = NULL; in device_add()
3580 else if (dev->bus && dev->bus->dev_name) in device_add()
3581 error = dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); in device_add()
3583 error = -EINVAL; in device_add()
3589 parent = get_device(dev->parent); in device_add()
3596 dev->kobj.parent = kobj; in device_add()
3604 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); in device_add()
3631 if (MAJOR(dev->devt)) { in device_add()
3647 kobject_uevent(&dev->kobj, KOBJ_ADD); in device_add()
3661 if (dev->fwnode && !dev->fwnode->dev) { in device_add()
3662 dev->fwnode->dev = dev; in device_add()
3673 if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) in device_add()
3677 klist_add_tail(&dev->p->knode_parent, in device_add()
3678 &parent->p->klist_children); in device_add()
3680 sp = class_to_subsys(dev->class); in device_add()
3682 mutex_lock(&sp->mutex); in device_add()
3684 klist_add_tail(&dev->p->knode_class, &sp->klist_devices); in device_add()
3687 list_for_each_entry(class_intf, &sp->interfaces, node) in device_add()
3688 if (class_intf->add_dev) in device_add()
3689 class_intf->add_dev(dev); in device_add()
3690 mutex_unlock(&sp->mutex); in device_add()
3697 if (MAJOR(dev->devt)) in device_add()
3703 dev->driver = NULL; in device_add()
3713 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_add()
3715 kobject_del(&dev->kobj); in device_add()
3721 kfree(dev->p); in device_add()
3722 dev->p = NULL; in device_add()
3728 * device_register - register a device with the system.
3731 * This happens in two clean steps - initialize the device
3753 * get_device - increment reference count for device.
3762 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; in get_device()
3767 * put_device - decrement reference count.
3774 kobject_put(&dev->kobj); in put_device()
3789 if (dev->p->dead) in kill_device()
3791 dev->p->dead = true; in kill_device()
3797 * device_del - delete device from system.
3812 struct device *parent = dev->parent; in device_del()
3821 if (dev->fwnode && dev->fwnode->dev == dev) in device_del()
3822 dev->fwnode->dev = NULL; in device_del()
3832 klist_del(&dev->p->knode_parent); in device_del()
3833 if (MAJOR(dev->devt)) { in device_del()
3839 sp = class_to_subsys(dev->class); in device_del()
3843 mutex_lock(&sp->mutex); in device_del()
3845 list_for_each_entry(class_intf, &sp->interfaces, node) in device_del()
3846 if (class_intf->remove_dev) in device_del()
3847 class_intf->remove_dev(dev); in device_del()
3849 klist_del(&dev->p->knode_class); in device_del()
3850 mutex_unlock(&sp->mutex); in device_del()
3873 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_del()
3875 kobject_del(&dev->kobj); in device_del()
3883 * device_unregister - unregister device from system.
3909 dev = p->device; in prev_device()
3922 dev = p->device; in next_device()
3928 * device_get_devnode - path of device node file
3936 * Non-default names may need to allocate a memory to compose
3949 if (dev->type && dev->type->devnode) in device_get_devnode()
3950 *tmp = dev->type->devnode(dev, mode, uid, gid); in device_get_devnode()
3955 if (dev->class && dev->class->devnode) in device_get_devnode()
3956 *tmp = dev->class->devnode(dev, mode); in device_get_devnode()
3972 * device_for_each_child - device child iterator.
3990 if (!parent || !parent->p) in device_for_each_child()
3993 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child()
4002 * device_for_each_child_reverse - device child iterator in reversed order.
4020 if (!parent || !parent->p) in device_for_each_child_reverse()
4023 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child_reverse()
4032 * device_for_each_child_reverse_from - device child iterator in reversed order.
4054 if (!parent || !parent->p) in device_for_each_child_reverse_from()
4057 klist_iter_init_node(&parent->p->klist_children, &i, in device_for_each_child_reverse_from()
4058 (from ? &from->p->knode_parent : NULL)); in device_for_each_child_reverse_from()
4067 * device_find_child - device iterator for locating a particular device.
4076 * The callback should return 0 if the device doesn't match and non-zero
4077 * if it does. If the callback returns non-zero and a reference to the
4089 if (!parent || !parent->p) in device_find_child()
4092 klist_iter_init(&parent->p->klist_children, &i); in device_find_child()
4108 return -ENOMEM; in devices_init()
4132 return -ENOMEM; in devices_init()
4143 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; in device_check_offline()
4147 * device_offline - Prepare the device for hot-removal.
4151 * the device for a subsequent hot-removal. If that succeeds, the device must
4161 if (dev->offline_disabled) in device_offline()
4162 return -EPERM; in device_offline()
4170 if (dev->offline) { in device_offline()
4173 ret = dev->bus->offline(dev); in device_offline()
4175 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); in device_offline()
4176 dev->offline = true; in device_offline()
4186 * device_online - Put the device back online after successful device_offline().
4201 if (dev->offline) { in device_online()
4202 ret = dev->bus->online(dev); in device_online()
4204 kobject_uevent(&dev->kobj, KOBJ_ONLINE); in device_online()
4205 dev->offline = false; in device_online()
4232 * __root_device_register - allocate and register a root device
4256 int err = -ENOMEM; in __root_device_register()
4262 err = dev_set_name(&root->dev, "%s", name); in __root_device_register()
4268 root->dev.release = root_device_release; in __root_device_register()
4270 err = device_register(&root->dev); in __root_device_register()
4272 put_device(&root->dev); in __root_device_register()
4278 struct module_kobject *mk = &owner->mkobj; in __root_device_register()
4280 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); in __root_device_register()
4282 device_unregister(&root->dev); in __root_device_register()
4285 root->owner = owner; in __root_device_register()
4289 return &root->dev; in __root_device_register()
4294 * root_device_unregister - unregister and free a root device
4304 if (root->owner) in root_device_unregister()
4305 sysfs_remove_link(&root->dev.kobj, "module"); in root_device_unregister()
4325 int retval = -ENODEV; in device_create_groups_vargs()
4332 retval = -ENOMEM; in device_create_groups_vargs()
4337 dev->devt = devt; in device_create_groups_vargs()
4338 dev->class = class; in device_create_groups_vargs()
4339 dev->parent = parent; in device_create_groups_vargs()
4340 dev->groups = groups; in device_create_groups_vargs()
4341 dev->release = device_create_release; in device_create_groups_vargs()
4344 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); in device_create_groups_vargs()
4360 * device_create - creates a device and registers it with sysfs
4395 * device_create_with_groups - creates a device and registers it with sysfs
4400 * @groups: NULL-terminated list of attribute groups to be created
4436 * device_destroy - removes a device that was created with device_create()
4456 * device_rename - renames a device
4479 * renamed it -- then you get events for the same DEVPATH, before you even see
4482 * other things than (driver-core wise very simple) network devices.
4486 * symlinks -- but never rename kernel devices later, it's a complete mess. We
4493 struct kobject *kobj = &dev->kobj; in device_rename()
4500 return -EINVAL; in device_rename()
4506 error = -ENOMEM; in device_rename()
4510 if (dev->class) { in device_rename()
4511 sp = class_to_subsys(dev->class); in device_rename()
4514 error = -EINVAL; in device_rename()
4518 error = sysfs_rename_link_ns(&sp->subsys.kobj, kobj, old_device_name, in device_rename()
4529 sysfs_rename_link_ns(&sp->subsys.kobj, kobj, new_name, in device_rename()
4548 sysfs_remove_link(&dev->kobj, "device"); in device_move_class_links()
4550 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, in device_move_class_links()
4556 * device_move - moves a device to a new parent
4570 return -EINVAL; in device_move()
4583 error = kobject_move(&dev->kobj, new_parent_kobj); in device_move()
4589 old_parent = dev->parent; in device_move()
4590 dev->parent = new_parent; in device_move()
4592 klist_remove(&dev->p->knode_parent); in device_move()
4594 klist_add_tail(&dev->p->knode_parent, in device_move()
4595 &new_parent->p->klist_children); in device_move()
4599 if (dev->class) { in device_move()
4604 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { in device_move()
4606 klist_remove(&dev->p->knode_parent); in device_move()
4607 dev->parent = old_parent; in device_move()
4609 klist_add_tail(&dev->p->knode_parent, in device_move()
4610 &old_parent->p->klist_children); in device_move()
4647 struct kobject *kobj = &dev->kobj; in device_attrs_change_owner()
4648 const struct class *class = dev->class; in device_attrs_change_owner()
4649 const struct device_type *type = dev->type; in device_attrs_change_owner()
4657 error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, in device_attrs_change_owner()
4668 error = sysfs_groups_change_owner(kobj, type->groups, kuid, in device_attrs_change_owner()
4675 error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); in device_attrs_change_owner()
4679 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_attrs_change_owner()
4691 * device_change_owner - change the owner of an existing device.
4705 struct kobject *kobj = &dev->kobj; in device_change_owner()
4710 return -EINVAL; in device_change_owner()
4749 sp = class_to_subsys(dev->class); in device_change_owner()
4751 error = -EINVAL; in device_change_owner()
4754 error = sysfs_link_change_owner(&sp->subsys.kobj, &dev->kobj, dev_name(dev), kuid, kgid); in device_change_owner()
4764 * device_shutdown - call ->shutdown() on each device to shutdown.
4775 spin_lock(&devices_kset->list_lock); in device_shutdown()
4781 while (!list_empty(&devices_kset->list)) { in device_shutdown()
4782 dev = list_entry(devices_kset->list.prev, struct device, in device_shutdown()
4790 parent = get_device(dev->parent); in device_shutdown()
4794 * event that dev->*->shutdown() doesn't remove it. in device_shutdown()
4796 list_del_init(&dev->kobj.entry); in device_shutdown()
4797 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4808 if (dev->class && dev->class->shutdown_pre) { in device_shutdown()
4811 dev->class->shutdown_pre(dev); in device_shutdown()
4813 if (dev->bus && dev->bus->shutdown) { in device_shutdown()
4816 dev->bus->shutdown(dev); in device_shutdown()
4817 } else if (dev->driver && dev->driver->shutdown) { in device_shutdown()
4820 dev->driver->shutdown(dev); in device_shutdown()
4830 spin_lock(&devices_kset->list_lock); in device_shutdown()
4832 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4847 if (dev->class) in set_dev_info()
4848 subsys = dev->class->name; in set_dev_info()
4849 else if (dev->bus) in set_dev_info()
4850 subsys = dev->bus->name; in set_dev_info()
4854 strscpy(dev_info->subsystem, subsys); in set_dev_info()
4863 if (MAJOR(dev->devt)) { in set_dev_info()
4871 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4872 "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); in set_dev_info()
4876 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4877 "n%u", net->ifindex); in set_dev_info()
4879 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4914 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", in __dev_printk()
4972 * size-1 array containing a structure. As a result, function parameter in __dev_probe_failed()
4986 case -EPROBE_DEFER: in __dev_probe_failed()
4991 case -ENOMEM: in __dev_probe_failed()
4992 /* Don't print anything on -ENOMEM, there's already enough output */ in __dev_probe_failed()
5008 * dev_err_probe - probe error check and log helper
5011 * @fmt: printf-style format string
5016 * -EPROBE_DEFER and propagate error upwards.
5017 * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
5021 * if (err != -EPROBE_DEFER)
5032 * is known to never be -EPROBE_DEFER.
5035 * instead of "-35"), and having the error code returned allows more
5046 /* Use dev_err() for logging when err doesn't equal -EPROBE_DEFER */ in dev_err_probe()
5056 * dev_warn_probe - probe error check and log helper
5059 * @fmt: printf-style format string
5064 * -EPROBE_DEFER and propagate error upwards.
5065 * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
5069 * if (err != -EPROBE_DEFER)
5080 * is known to never be -EPROBE_DEFER.
5083 * instead of "-35"), and having the error code returned allows more
5094 /* Use dev_warn() for logging when err doesn't equal -EPROBE_DEFER */ in dev_warn_probe()
5105 return fwnode && !IS_ERR(fwnode->secondary); in fwnode_is_primary()
5109 * set_primary_fwnode - Change the primary firmware node of a given device.
5117 * - primary --> secondary --> -ENODEV
5118 * - primary --> NULL
5119 * - secondary --> -ENODEV
5120 * - NULL
5124 struct device *parent = dev->parent; in set_primary_fwnode()
5125 struct fwnode_handle *fn = dev->fwnode; in set_primary_fwnode()
5129 fn = fn->secondary; in set_primary_fwnode()
5132 WARN_ON(fwnode->secondary); in set_primary_fwnode()
5133 fwnode->secondary = fn; in set_primary_fwnode()
5135 dev->fwnode = fwnode; in set_primary_fwnode()
5138 dev->fwnode = fn->secondary; in set_primary_fwnode()
5140 /* Skip nullifying fn->secondary if the primary is shared */ in set_primary_fwnode()
5141 if (parent && fn == parent->fwnode) in set_primary_fwnode()
5144 /* Set fn->secondary = NULL, so fn remains the primary fwnode */ in set_primary_fwnode()
5145 fn->secondary = NULL; in set_primary_fwnode()
5147 dev->fwnode = NULL; in set_primary_fwnode()
5154 * set_secondary_fwnode - Change the secondary firmware node of a given device.
5165 fwnode->secondary = ERR_PTR(-ENODEV); in set_secondary_fwnode()
5167 if (fwnode_is_primary(dev->fwnode)) in set_secondary_fwnode()
5168 dev->fwnode->secondary = fwnode; in set_secondary_fwnode()
5170 dev->fwnode = fwnode; in set_secondary_fwnode()
5175 * device_set_of_node_from_dev - reuse device-tree node of another device
5176 * @dev: device whose device-tree node is being set
5177 * @dev2: device whose device-tree node is being reused
5179 * Takes another reference to the new device-tree node after first dropping
5184 of_node_put(dev->of_node); in device_set_of_node_from_dev()
5185 dev->of_node = of_node_get(dev2->of_node); in device_set_of_node_from_dev()
5186 dev->of_node_reused = true; in device_set_of_node_from_dev()
5192 dev->fwnode = fwnode; in device_set_node()
5193 dev->of_node = to_of_node(fwnode); in device_set_node()
5205 return dev->type == type; in device_match_type()
5211 return np && dev->of_node == np; in device_match_of_node()
5223 return dev->devt == *(dev_t *)pdevt; in device_match_devt()