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.
62 * Attempts to create duplicate links between the same pair of fwnode handles
70 list_for_each_entry(link, &sup->consumers, s_hook) in __fwnode_link_add()
71 if (link->consumer == con) { in __fwnode_link_add()
72 link->flags |= flags; in __fwnode_link_add()
78 return -ENOMEM; in __fwnode_link_add()
80 link->supplier = sup; in __fwnode_link_add()
81 INIT_LIST_HEAD(&link->s_hook); in __fwnode_link_add()
82 link->consumer = con; in __fwnode_link_add()
83 INIT_LIST_HEAD(&link->c_hook); in __fwnode_link_add()
84 link->flags = flags; in __fwnode_link_add()
86 list_add(&link->s_hook, &sup->consumers); in __fwnode_link_add()
87 list_add(&link->c_hook, &con->suppliers); in __fwnode_link_add()
105 * __fwnode_link_del - Delete a link between two fwnode_handles.
113 link->consumer, link->supplier); in __fwnode_link_del()
114 list_del(&link->s_hook); in __fwnode_link_del()
115 list_del(&link->c_hook); in __fwnode_link_del()
120 * __fwnode_link_cycle - Mark a fwnode link as being part of a cycle.
128 link->consumer, link->supplier); in __fwnode_link_cycle()
129 link->flags |= FWLINK_FLAG_CYCLE; in __fwnode_link_cycle()
133 * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle.
134 * @fwnode: fwnode whose supplier links need to be deleted
136 * Deletes all supplier links connecting directly to @fwnode.
143 list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) in fwnode_links_purge_suppliers()
149 * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle.
150 * @fwnode: fwnode whose consumer links need to be deleted
152 * Deletes all consumer links connecting directly to @fwnode.
159 list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) in fwnode_links_purge_consumers()
165 * fwnode_links_purge - Delete all links connected to a fwnode_handle.
166 * @fwnode: fwnode whose links needs to be deleted
168 * Deletes all links connecting directly to a fwnode.
180 /* Don't purge consumer links of an added child */ in fw_devlink_purge_absent_suppliers()
181 if (fwnode->dev) in fw_devlink_purge_absent_suppliers()
184 fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; in fw_devlink_purge_absent_suppliers()
193 * __fwnode_links_move_consumers - Move consumer from @from to @to fwnode_handle
197 * Move all consumer links from @from fwnode to @to fwnode.
204 list_for_each_entry_safe(link, tmp, &from->consumers, s_hook) { in __fwnode_links_move_consumers()
205 __fwnode_link_add(link->consumer, to, link->flags); in __fwnode_links_move_consumers()
211 * __fw_devlink_pickup_dangling_consumers - Pick up dangling consumers
217 * MANAGED device links to this device, so leave @fwnode and its descendant's
218 * fwnode links alone.
227 if (fwnode->dev && fwnode->dev->bus) in __fw_devlink_pickup_dangling_consumers()
230 fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; in __fw_devlink_pickup_dangling_consumers()
272 list_del_rcu(&link->s_node); in device_link_remove_from_lists()
273 list_del_rcu(&link->c_node); in device_link_remove_from_lists()
278 while (target->parent) { in device_is_ancestor()
279 target = target->parent; in device_is_ancestor()
293 * device_is_dependent - Check if one device depends on another one
317 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_is_dependent()
318 if (device_link_flag_is_sync_state_only(link->flags)) in device_is_dependent()
321 if (link->consumer == target) in device_is_dependent()
324 ret = device_is_dependent(link->consumer, target); in device_is_dependent()
335 switch (supplier->links.status) { in device_link_init_status()
337 switch (consumer->links.status) { in device_link_init_status()
346 link->status = DL_STATE_CONSUMER_PROBE; in device_link_init_status()
349 link->status = DL_STATE_DORMANT; in device_link_init_status()
354 switch (consumer->links.status) { in device_link_init_status()
356 link->status = DL_STATE_CONSUMER_PROBE; in device_link_init_status()
359 link->status = DL_STATE_ACTIVE; in device_link_init_status()
362 link->status = DL_STATE_AVAILABLE; in device_link_init_status()
367 link->status = DL_STATE_SUPPLIER_UNBIND; in device_link_init_status()
370 link->status = DL_STATE_DORMANT; in device_link_init_status()
390 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_reorder_to_tail()
391 if (device_link_flag_is_sync_state_only(link->flags)) in device_reorder_to_tail()
393 device_reorder_to_tail(link->consumer, NULL); in device_reorder_to_tail()
400 * device_pm_move_to_tail - Move set of devices to the end of device lists
426 switch (to_devlink(dev)->status) { in status_show()
460 if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) in auto_remove_on_show()
462 else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) in auto_remove_on_show()
476 return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); in runtime_pm_show()
486 !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in sync_state_only_show()
511 * PM-runtime usage counter to remove the reference taken by in device_link_release_fn()
514 if (link->supplier_preactivated) in device_link_release_fn()
515 pm_runtime_put_noidle(link->supplier); in device_link_release_fn()
517 pm_request_idle(link->supplier); in device_link_release_fn()
519 put_device(link->consumer); in device_link_release_fn()
520 put_device(link->supplier); in device_link_release_fn()
528 INIT_WORK(&link->rm_work, device_link_release_fn); in devlink_dev_release()
535 queue_work(system_long_wq, &link->rm_work); in devlink_dev_release()
549 struct device *sup = link->supplier; in devlink_add_symlinks()
550 struct device *con = link->consumer; in devlink_add_symlinks()
559 return -ENOMEM; in devlink_add_symlinks()
561 ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); in devlink_add_symlinks()
565 ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); in devlink_add_symlinks()
570 ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); in devlink_add_symlinks()
575 ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); in devlink_add_symlinks()
583 sysfs_remove_link(&sup->kobj, buf); in devlink_add_symlinks()
585 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_add_symlinks()
587 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_add_symlinks()
597 struct device *sup = link->supplier; in devlink_remove_symlinks()
598 struct device *con = link->consumer; in devlink_remove_symlinks()
601 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_remove_symlinks()
602 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_remove_symlinks()
616 sysfs_remove_link(&con->kobj, buf); in devlink_remove_symlinks()
619 sysfs_remove_link(&sup->kobj, buf); in devlink_remove_symlinks()
656 * device_link_add - Create a link between two devices.
665 * be forced into the active meta state and reference-counted upon the creation
702 * A side effect of the link creation is re-ordering of dpm_list and the
743 * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and in device_link_add()
756 * SYNC_STATE_ONLY links are useless once a consumer device has probed. in device_link_add()
760 consumer->links.status != DL_DEV_NO_DRIVER && in device_link_add()
761 consumer->links.status != DL_DEV_PROBING) { in device_link_add()
774 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_add()
775 if (link->consumer != consumer) in device_link_add()
778 if (link->flags & DL_FLAG_INFERRED && in device_link_add()
780 link->flags &= ~DL_FLAG_INFERRED; in device_link_add()
783 if (!(link->flags & DL_FLAG_PM_RUNTIME)) { in device_link_add()
785 link->flags |= DL_FLAG_PM_RUNTIME; in device_link_add()
788 refcount_inc(&link->rpm_active); in device_link_add()
792 kref_get(&link->kref); in device_link_add()
793 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
794 !(link->flags & DL_FLAG_STATELESS)) { in device_link_add()
795 link->flags |= DL_FLAG_STATELESS; in device_link_add()
798 link->flags |= DL_FLAG_STATELESS; in device_link_add()
809 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in device_link_add()
810 link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; in device_link_add()
811 link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; in device_link_add()
814 link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | in device_link_add()
817 if (!(link->flags & DL_FLAG_MANAGED)) { in device_link_add()
818 kref_get(&link->kref); in device_link_add()
819 link->flags |= DL_FLAG_MANAGED; in device_link_add()
822 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
824 link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; in device_link_add()
835 refcount_set(&link->rpm_active, 1); in device_link_add()
838 link->supplier = supplier; in device_link_add()
839 INIT_LIST_HEAD(&link->s_node); in device_link_add()
841 link->consumer = consumer; in device_link_add()
842 INIT_LIST_HEAD(&link->c_node); in device_link_add()
843 link->flags = flags; in device_link_add()
844 kref_init(&link->kref); in device_link_add()
846 link->link_dev.class = &devlink_class; in device_link_add()
847 device_set_pm_not_required(&link->link_dev); in device_link_add()
848 dev_set_name(&link->link_dev, "%s:%s--%s:%s", in device_link_add()
851 if (device_register(&link->link_dev)) { in device_link_add()
852 put_device(&link->link_dev); in device_link_add()
859 refcount_inc(&link->rpm_active); in device_link_add()
866 link->status = DL_STATE_NONE; in device_link_add()
874 if (link->status == DL_STATE_CONSUMER_PROBE && in device_link_add()
878 list_add_tail_rcu(&link->s_node, &supplier->links.consumers); in device_link_add()
879 list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); in device_link_add()
915 dev_dbg(link->consumer, "Dropping the link to %s\n", in __device_link_del()
916 dev_name(link->supplier)); in __device_link_del()
921 device_unregister(&link->link_dev); in __device_link_del()
926 if (link->flags & DL_FLAG_STATELESS) in device_link_put_kref()
927 kref_put(&link->kref, __device_link_del); in device_link_put_kref()
928 else if (!device_is_registered(link->consumer)) in device_link_put_kref()
929 __device_link_del(&link->kref); in device_link_put_kref()
935 * device_link_del - Delete a stateless link between two devices.
940 * Care is required for hotplugged devices: Their links are purged on removal
952 * device_link_remove - Delete a stateless link between two devices.
968 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_remove()
969 if (link->consumer == consumer) { in device_link_remove()
983 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_missing_supplier()
984 if (link->status != DL_STATE_CONSUMER_PROBE) in device_links_missing_supplier()
987 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in device_links_missing_supplier()
988 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_missing_supplier()
990 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in device_links_missing_supplier()
991 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_missing_supplier()
998 return (fw_devlink_best_effort && dev->can_match) || in dev_is_best_effort()
999 (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT)); in dev_is_best_effort()
1010 list_for_each_entry(link, &fwnode->suppliers, c_hook) in fwnode_links_check_suppliers()
1011 if (!(link->flags & FWLINK_FLAG_CYCLE)) in fwnode_links_check_suppliers()
1012 return link->supplier; in fwnode_links_check_suppliers()
1018 * device_links_check_suppliers - Check presence of supplier drivers.
1021 * Check links from this device to any suppliers. Walk the list of the device's
1022 * links to suppliers and see if all of them are available. If not, simply
1023 * return -EPROBE_DEFER.
1027 * that function checks the device's links to consumers. This means we need to
1031 * Links without the DL_FLAG_MANAGED flag set are ignored.
1044 sup_fw = fwnode_links_check_suppliers(dev->fwnode); in device_links_check_suppliers()
1047 fwnode_ret = -EPROBE_DEFER; in device_links_check_suppliers()
1048 dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1051 fwnode_ret = -EAGAIN; in device_links_check_suppliers()
1055 if (fwnode_ret == -EPROBE_DEFER) in device_links_check_suppliers()
1060 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_check_suppliers()
1061 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_check_suppliers()
1064 if (link->status != DL_STATE_AVAILABLE && in device_links_check_suppliers()
1065 !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { in device_links_check_suppliers()
1068 link->flags & DL_FLAG_INFERRED && in device_links_check_suppliers()
1069 !link->supplier->can_match) { in device_links_check_suppliers()
1070 ret = -EAGAIN; in device_links_check_suppliers()
1075 dev_err_probe(dev, -EPROBE_DEFER, in device_links_check_suppliers()
1077 dev_name(link->supplier)); in device_links_check_suppliers()
1078 ret = -EPROBE_DEFER; in device_links_check_suppliers()
1081 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_check_suppliers()
1083 dev->links.status = DL_DEV_PROBING; in device_links_check_suppliers()
1091 * __device_links_queue_sync_state - Queue a device for sync_state() callback
1095 * Queues a device for a sync_state() callback when the device links write lock
1096 * isn't held. This allows the sync_state() execution flow to use device links
1115 if (dev->state_synced) in __device_links_queue_sync_state()
1118 list_for_each_entry(link, &dev->links.consumers, s_node) { in __device_links_queue_sync_state()
1119 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_queue_sync_state()
1121 if (link->status != DL_STATE_ACTIVE) in __device_links_queue_sync_state()
1130 dev->state_synced = true; in __device_links_queue_sync_state()
1132 if (WARN_ON(!list_empty(&dev->links.defer_sync))) in __device_links_queue_sync_state()
1136 list_add_tail(&dev->links.defer_sync, list); in __device_links_queue_sync_state()
1140 * device_links_flush_sync_list - Call sync_state() on a list of devices
1154 list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { in device_links_flush_sync_list()
1155 list_del_init(&dev->links.defer_sync); in device_links_flush_sync_list()
1186 defer_sync_state_count--; in device_links_supplier_sync_state_resume()
1190 list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { in device_links_supplier_sync_state_resume()
1195 list_del_init(&dev->links.defer_sync); in device_links_supplier_sync_state_resume()
1213 if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) in __device_links_supplier_defer_sync()
1214 list_add_tail(&sup->links.defer_sync, &deferred_sync); in __device_links_supplier_defer_sync()
1219 link->flags &= ~DL_FLAG_MANAGED; in device_link_drop_managed()
1220 WRITE_ONCE(link->status, DL_STATE_NONE); in device_link_drop_managed()
1221 kref_put(&link->kref, __device_link_del); in device_link_drop_managed()
1232 val = !!fwnode_links_check_suppliers(dev->fwnode); in waiting_for_supplier_show()
1240 * device_links_force_bind - Prepares device to be force bound
1249 * supplier device links and checks if the supplier is bound. If it is, then
1251 * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored.
1259 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_force_bind()
1260 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_force_bind()
1263 if (link->status != DL_STATE_AVAILABLE) { in device_links_force_bind()
1267 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_force_bind()
1269 dev->links.status = DL_DEV_PROBING; in device_links_force_bind()
1275 * device_links_driver_bound - Update device links after probing its driver.
1276 * @dev: Device to update the links for.
1278 * The probe has been successful, so update links from this device to any
1281 * Also change the status of @dev's links to suppliers to "active".
1283 * Links without the DL_FLAG_MANAGED flag set are ignored.
1292 * the device links it needs to or make new device links as it needs in device_links_driver_bound()
1293 * them. So, fw_devlink no longer needs to create device links to any in device_links_driver_bound()
1304 if (dev->fwnode && dev->fwnode->dev == dev) { in device_links_driver_bound()
1306 fwnode_links_purge_suppliers(dev->fwnode); in device_links_driver_bound()
1308 fwnode_for_each_available_child_node(dev->fwnode, child) in device_links_driver_bound()
1310 dev->fwnode); in device_links_driver_bound()
1318 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_driver_bound()
1319 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1323 * Links created during consumer probe may be in the "consumer in device_links_driver_bound()
1328 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_driver_bound()
1329 link->status == DL_STATE_ACTIVE) in device_links_driver_bound()
1332 WARN_ON(link->status != DL_STATE_DORMANT); in device_links_driver_bound()
1333 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_driver_bound()
1335 if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) in device_links_driver_bound()
1336 driver_deferred_probe_add(link->consumer); in device_links_driver_bound()
1344 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_driver_bound()
1347 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1350 supplier = link->supplier; in device_links_driver_bound()
1351 if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { in device_links_driver_bound()
1359 link->flags & DL_FLAG_INFERRED && in device_links_driver_bound()
1360 link->status != DL_STATE_CONSUMER_PROBE && in device_links_driver_bound()
1361 !link->supplier->can_match) { in device_links_driver_bound()
1364 * links to suppliers that don't have a driver. If the in device_links_driver_bound()
1371 WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); in device_links_driver_bound()
1372 WRITE_ONCE(link->status, DL_STATE_ACTIVE); in device_links_driver_bound()
1387 dev->links.status = DL_DEV_DRIVER_BOUND; in device_links_driver_bound()
1395 * __device_links_no_driver - Update links of a device without a driver.
1398 * Delete all non-persistent links from this device to any suppliers.
1400 * Persistent links stay around, but their status is changed to "available",
1404 * Links without the DL_FLAG_MANAGED flag set are ignored.
1410 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in __device_links_no_driver()
1411 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_no_driver()
1414 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in __device_links_no_driver()
1419 if (link->status != DL_STATE_CONSUMER_PROBE && in __device_links_no_driver()
1420 link->status != DL_STATE_ACTIVE) in __device_links_no_driver()
1423 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in __device_links_no_driver()
1424 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in __device_links_no_driver()
1426 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in __device_links_no_driver()
1427 WRITE_ONCE(link->status, DL_STATE_DORMANT); in __device_links_no_driver()
1431 dev->links.status = DL_DEV_NO_DRIVER; in __device_links_no_driver()
1435 * device_links_no_driver - Update links after failing driver probe.
1438 * Clean up leftover links to consumers for @dev and invoke
1439 * %__device_links_no_driver() to update links to suppliers for it as
1442 * Links without the DL_FLAG_MANAGED flag set are ignored.
1450 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_no_driver()
1451 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_no_driver()
1461 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_no_driver()
1462 link->status == DL_STATE_ACTIVE) in device_links_no_driver()
1463 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_no_driver()
1472 * device_links_driver_cleanup - Update links after driver removal.
1475 * Update links to consumers for @dev by changing their status to "dormant" and
1476 * invoke %__device_links_no_driver() to update links to suppliers for it as
1479 * Links without the DL_FLAG_MANAGED flag set are ignored.
1487 list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { in device_links_driver_cleanup()
1488 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_cleanup()
1491 WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); in device_links_driver_cleanup()
1492 WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); in device_links_driver_cleanup()
1495 * autoremove the links between this @dev and its consumer in device_links_driver_cleanup()
1499 if (link->status == DL_STATE_SUPPLIER_UNBIND && in device_links_driver_cleanup()
1500 link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) in device_links_driver_cleanup()
1503 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_driver_cleanup()
1506 list_del_init(&dev->links.defer_sync); in device_links_driver_cleanup()
1513 * device_links_busy - Check if there are any busy links to consumers.
1524 * Links without the DL_FLAG_MANAGED flag set are ignored.
1533 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_busy()
1534 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_busy()
1537 if (link->status == DL_STATE_CONSUMER_PROBE in device_links_busy()
1538 || link->status == DL_STATE_ACTIVE) { in device_links_busy()
1542 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_busy()
1545 dev->links.status = DL_DEV_UNBINDING; in device_links_busy()
1552 * device_links_unbind_consumers - Force unbind consumers of the given device.
1555 * Walk the list of links to consumers for @dev and if any of them is in the
1561 * driver to unbind and start over (the consumer will not re-probe as we have
1564 * Links without the DL_FLAG_MANAGED flag set are ignored.
1573 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_unbind_consumers()
1576 if (!(link->flags & DL_FLAG_MANAGED) || in device_links_unbind_consumers()
1577 link->flags & DL_FLAG_SYNC_STATE_ONLY) in device_links_unbind_consumers()
1580 status = link->status; in device_links_unbind_consumers()
1587 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_unbind_consumers()
1589 struct device *consumer = link->consumer; in device_links_unbind_consumers()
1596 consumer->parent); in device_links_unbind_consumers()
1606 * device_links_purge - Delete existing links to other devices.
1613 if (dev->class == &devlink_class) in device_links_purge()
1617 * Delete all of the remaining links from this device to any other in device_links_purge()
1622 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in device_links_purge()
1623 WARN_ON(link->status == DL_STATE_ACTIVE); in device_links_purge()
1624 __device_link_del(&link->kref); in device_links_purge()
1627 list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { in device_links_purge()
1628 WARN_ON(link->status != DL_STATE_DORMANT && in device_links_purge()
1629 link->status != DL_STATE_NONE); in device_links_purge()
1630 __device_link_del(&link->kref); in device_links_purge()
1647 return -EINVAL; in fw_devlink_setup()
1681 return -EINVAL; in fw_devlink_sync_state_setup()
1690 return -EINVAL; in fw_devlink_sync_state_setup()
1714 if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) in fw_devlink_parse_fwnode()
1718 fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; in fw_devlink_parse_fwnode()
1733 if (!(link->flags & DL_FLAG_INFERRED)) in fw_devlink_relax_link()
1736 if (device_link_flag_is_sync_state_only(link->flags)) in fw_devlink_relax_link()
1740 link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; in fw_devlink_relax_link()
1741 dev_dbg(link->consumer, "Relaxing link with %s\n", in fw_devlink_relax_link()
1742 dev_name(link->supplier)); in fw_devlink_relax_link()
1749 if (!link->supplier->can_match) in fw_devlink_no_driver()
1767 struct device *sup = link->supplier; in fw_devlink_dev_sync_state()
1769 if (!(link->flags & DL_FLAG_MANAGED) || in fw_devlink_dev_sync_state()
1770 link->status == DL_STATE_ACTIVE || sup->state_synced || in fw_devlink_dev_sync_state()
1776 dev_name(link->consumer)); in fw_devlink_dev_sync_state()
1780 if (!list_empty(&sup->links.defer_sync)) in fw_devlink_dev_sync_state()
1784 sup->state_synced = true; in fw_devlink_dev_sync_state()
1786 list_add_tail(&sup->links.defer_sync, data); in fw_devlink_dev_sync_state()
1803 * wait_for_init_devices_probe - Try to probe any device needed for init
1866 list_for_each_entry(link, &dev->links.consumers, s_node) in fw_devlink_unblock_consumers()
1877 if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED)) in fwnode_init_without_drv()
1881 ret = !dev || dev->links.status == DL_DEV_NO_DRIVER; in fwnode_init_without_drv()
1902 * __fw_devlink_relax_cycles - Relax and mark dependency cycles.
1910 * and @con. When such dependency cycles are found, convert all device links
1911 * created solely by fw_devlink into SYNC_STATE_ONLY device links. Also, mark
1912 * all fwnode links in the cycle with FWLINK_FLAG_CYCLE so that when they are
1914 * SYNC_STATE_ONLY device links. This is the equivalent of doing
1936 if (sup_handle->flags & FWNODE_FLAG_VISITED) in __fw_devlink_relax_cycles()
1939 sup_handle->flags |= FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
1954 if (sup_dev && sup_dev->links.status == DL_DEV_DRIVER_BOUND && in __fw_devlink_relax_cycles()
1955 con->links.status == DL_DEV_NO_DRIVER) { in __fw_devlink_relax_cycles()
1960 list_for_each_entry(link, &sup_handle->suppliers, c_hook) { in __fw_devlink_relax_cycles()
1961 if (__fw_devlink_relax_cycles(con, link->supplier)) { in __fw_devlink_relax_cycles()
1972 par_dev = get_device(sup_dev->parent); in __fw_devlink_relax_cycles()
1976 if (par_dev && __fw_devlink_relax_cycles(con, par_dev->fwnode)) in __fw_devlink_relax_cycles()
1982 list_for_each_entry(dev_link, &sup_dev->links.suppliers, c_node) { in __fw_devlink_relax_cycles()
1987 if (device_link_flag_is_sync_state_only(dev_link->flags) && in __fw_devlink_relax_cycles()
1988 !(dev_link->flags & DL_FLAG_CYCLE)) in __fw_devlink_relax_cycles()
1992 dev_link->supplier->fwnode)) { in __fw_devlink_relax_cycles()
1994 dev_link->flags |= DL_FLAG_CYCLE; in __fw_devlink_relax_cycles()
2000 sup_handle->flags &= ~FWNODE_FLAG_VISITED; in __fw_devlink_relax_cycles()
2007 * fw_devlink_create_devlink - Create a device link from a consumer to fwnode
2016 * fwnode links can sometimes cause the supplier device to never be created.
2022 * -EINVAL if the device link cannot be created as expected
2023 * -EAGAIN if the device link cannot be created right now, but it may be
2034 if (con->fwnode == link->consumer) in fw_devlink_create_devlink()
2035 flags = fw_devlink_get_flags(link->flags); in fw_devlink_create_devlink()
2051 * When such a flag is set, we can't create device links where P is the in fw_devlink_create_devlink()
2054 if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD && in fw_devlink_create_devlink()
2055 fwnode_is_ancestor_of(sup_handle, con->fwnode)) in fw_devlink_create_devlink()
2056 return -EINVAL; in fw_devlink_create_devlink()
2059 * SYNC_STATE_ONLY device links don't block probing and supports cycles. in fw_devlink_create_devlink()
2066 flags = fw_devlink_get_flags(link->flags); in fw_devlink_create_devlink()
2067 dev_info(con, "Fixed dependency cycle(s) with %pfwf\n", in fw_devlink_create_devlink()
2073 if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE) in fw_devlink_create_devlink()
2084 if (sup_dev->links.status == DL_DEV_NO_DRIVER && in fw_devlink_create_devlink()
2085 sup_handle->flags & FWNODE_FLAG_INITIALIZED) { in fw_devlink_create_devlink()
2087 "Not linking %pfwf - dev might never probe\n", in fw_devlink_create_devlink()
2089 ret = -EINVAL; in fw_devlink_create_devlink()
2096 ret = -EINVAL; in fw_devlink_create_devlink()
2108 dev_dbg(con, "Not linking %pfwf - might never become dev\n", in fw_devlink_create_devlink()
2110 return -EINVAL; in fw_devlink_create_devlink()
2113 ret = -EAGAIN; in fw_devlink_create_devlink()
2120 * __fw_devlink_link_to_consumers - Create device links to consumers of a device
2124 * links between the consumer device and @dev (supplier).
2132 * Once device links are created from the real consumer to @dev (supplier), the
2133 * fwnode links are deleted.
2137 struct fwnode_handle *fwnode = dev->fwnode; in __fw_devlink_link_to_consumers()
2140 list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { in __fw_devlink_link_to_consumers()
2145 con_dev = get_dev_from_fwnode(link->consumer); in __fw_devlink_link_to_consumers()
2157 con_dev = fwnode_get_next_parent_dev(link->consumer); in __fw_devlink_link_to_consumers()
2161 * consumer-supplier link from the parent to its child in __fw_devlink_link_to_consumers()
2165 fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { in __fw_devlink_link_to_consumers()
2178 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_consumers()
2186 * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device
2188 * @fwnode: Root of the fwnode tree that is used to create device links
2191 * @fwnode and creates device links between @dev (consumer) and all the
2194 * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev
2195 * and the real suppliers of @dev. Once these device links are created, the
2196 * fwnode links are deleted.
2201 * driver core. So, this function creates SYNC_STATE_ONLY device links between
2204 * their device links. The fwnode links that correspond to the child devices
2205 * aren't delete because they are needed later to create the device links
2211 bool own_link = (dev->fwnode == fwnode); in __fw_devlink_link_to_suppliers()
2215 list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { in __fw_devlink_link_to_suppliers()
2217 struct fwnode_handle *sup = link->supplier; in __fw_devlink_link_to_suppliers()
2220 if (!own_link || ret == -EAGAIN) in __fw_devlink_link_to_suppliers()
2227 * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of in __fw_devlink_link_to_suppliers()
2238 struct fwnode_handle *fwnode = dev->fwnode; in fw_devlink_link_device()
2251 /* Device links support end. */
2288 return !(dev->type == &part_type); in device_is_not_partition()
2318 * dev_driver_string - Return a device's driver name, if at all possible
2330 /* dev->driver can change to NULL underneath us because of unbinding, in dev_driver_string()
2331 * so be careful about accessing it. dev->bus and dev->class should in dev_driver_string()
2334 drv = READ_ONCE(dev->driver); in dev_driver_string()
2335 return drv ? drv->name : dev_bus_name(dev); in dev_driver_string()
2346 ssize_t ret = -EIO; in dev_attr_show()
2348 if (dev_attr->show) in dev_attr_show()
2349 ret = dev_attr->show(dev, dev_attr, buf); in dev_attr_show()
2352 dev_attr->show); in dev_attr_show()
2362 ssize_t ret = -EIO; in dev_attr_store()
2364 if (dev_attr->store) in dev_attr_store()
2365 ret = dev_attr->store(dev, dev_attr, buf, count); in dev_attr_store()
2387 *(unsigned long *)(ea->var) = new; in device_store_ulong()
2398 return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); in device_show_ulong()
2415 return -EINVAL; in device_store_int()
2416 *(int *)(ea->var) = new; in device_store_int()
2428 return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); in device_show_int()
2437 if (kstrtobool(buf, ea->var) < 0) in device_store_bool()
2438 return -EINVAL; in device_store_bool()
2449 return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); in device_show_bool()
2454 * device_release - free device structure.
2464 struct device_private *p = dev->p; in device_release()
2477 kfree(dev->dma_range_map); in device_release()
2479 if (dev->release) in device_release()
2480 dev->release(dev); in device_release()
2481 else if (dev->type && dev->type->release) in device_release()
2482 dev->type->release(dev); in device_release()
2483 else if (dev->class && dev->class->dev_release) in device_release()
2484 dev->class->dev_release(dev); in device_release()
2486 …does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kob… in device_release()
2496 if (dev->class && dev->class->ns_type) in device_namespace()
2497 ns = dev->class->namespace(dev); in device_namespace()
2506 if (dev->class && dev->class->get_ownership) in device_get_ownership()
2507 dev->class->get_ownership(dev, uid, gid); in device_get_ownership()
2524 if (dev->bus) in dev_uevent_filter()
2526 if (dev->class) in dev_uevent_filter()
2536 if (dev->bus) in dev_uevent_name()
2537 return dev->bus->name; in dev_uevent_name()
2538 if (dev->class) in dev_uevent_name()
2539 return dev->class->name; in dev_uevent_name()
2549 if (MAJOR(dev->devt)) { in dev_uevent()
2556 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); in dev_uevent()
2557 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); in dev_uevent()
2571 if (dev->type && dev->type->name) in dev_uevent()
2572 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); in dev_uevent()
2574 if (dev->driver) in dev_uevent()
2575 add_uevent_var(env, "DRIVER=%s", dev->driver->name); in dev_uevent()
2581 if (dev->bus && dev->bus->uevent) { in dev_uevent()
2582 retval = dev->bus->uevent(dev, env); in dev_uevent()
2589 if (dev->class && dev->class->dev_uevent) { in dev_uevent()
2590 retval = dev->class->dev_uevent(dev, env); in dev_uevent()
2598 if (dev->type && dev->type->uevent) { in dev_uevent()
2599 retval = dev->type->uevent(dev, env); in dev_uevent()
2626 top_kobj = &dev->kobj; in uevent_show()
2627 while (!top_kobj->kset && top_kobj->parent) in uevent_show()
2628 top_kobj = top_kobj->parent; in uevent_show()
2629 if (!top_kobj->kset) in uevent_show()
2632 kset = top_kobj->kset; in uevent_show()
2633 if (!kset->uevent_ops || !kset->uevent_ops->uevent) in uevent_show()
2637 if (kset->uevent_ops && kset->uevent_ops->filter) in uevent_show()
2638 if (!kset->uevent_ops->filter(&dev->kobj)) in uevent_show()
2643 return -ENOMEM; in uevent_show()
2646 retval = kset->uevent_ops->uevent(&dev->kobj, env); in uevent_show()
2651 for (i = 0; i < env->envp_idx; i++) in uevent_show()
2652 len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); in uevent_show()
2663 rc = kobject_synth_uevent(&dev->kobj, buf, count); in uevent_store()
2680 val = !dev->offline; in online_show()
2710 switch (dev->removable) { in removable_show()
2715 loc = "fixed"; in removable_show()
2726 return sysfs_create_groups(&dev->kobj, groups); in device_add_groups()
2733 sysfs_remove_groups(&dev->kobj, groups); in device_remove_groups()
2745 const struct attribute_group *group = devres->group; in devm_attr_group_remove()
2748 sysfs_remove_group(&dev->kobj, group); in devm_attr_group_remove()
2754 const struct attribute_group **groups = devres->groups; in devm_attr_groups_remove()
2757 sysfs_remove_groups(&dev->kobj, groups); in devm_attr_groups_remove()
2761 * devm_device_add_group - given a device, create a managed attribute group
2778 return -ENOMEM; in devm_device_add_group()
2780 error = sysfs_create_group(&dev->kobj, grp); in devm_device_add_group()
2786 devres->group = grp; in devm_device_add_group()
2793 * devm_device_add_groups - create a bunch of managed attribute groups
2814 return -ENOMEM; in devm_device_add_groups()
2816 error = sysfs_create_groups(&dev->kobj, groups); in devm_device_add_groups()
2822 devres->groups = groups; in devm_device_add_groups()
2830 const struct class *class = dev->class; in device_add_attrs()
2831 const struct device_type *type = dev->type; in device_add_attrs()
2835 error = device_add_groups(dev, class->dev_groups); in device_add_attrs()
2841 error = device_add_groups(dev, type->groups); in device_add_attrs()
2846 error = device_add_groups(dev, dev->groups); in device_add_attrs()
2850 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_add_attrs()
2856 if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { in device_add_attrs()
2884 device_remove_groups(dev, dev->groups); in device_add_attrs()
2887 device_remove_groups(dev, type->groups); in device_add_attrs()
2890 device_remove_groups(dev, class->dev_groups); in device_add_attrs()
2897 const struct class *class = dev->class; in device_remove_attrs()
2898 const struct device_type *type = dev->type; in device_remove_attrs()
2900 if (dev->physical_location) { in device_remove_attrs()
2902 kfree(dev->physical_location); in device_remove_attrs()
2908 device_remove_groups(dev, dev->groups); in device_remove_attrs()
2911 device_remove_groups(dev, type->groups); in device_remove_attrs()
2914 device_remove_groups(dev, class->dev_groups); in device_remove_attrs()
2920 return print_dev_t(buf, dev->devt); in dev_show()
2928 * devices_kset_move_before - Move device in the devices_kset's list.
2938 spin_lock(&devices_kset->list_lock); in devices_kset_move_before()
2939 list_move_tail(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_before()
2940 spin_unlock(&devices_kset->list_lock); in devices_kset_move_before()
2944 * devices_kset_move_after - Move device in the devices_kset's list.
2954 spin_lock(&devices_kset->list_lock); in devices_kset_move_after()
2955 list_move(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_after()
2956 spin_unlock(&devices_kset->list_lock); in devices_kset_move_after()
2960 * devices_kset_move_last - move the device to the end of devices_kset's list.
2968 spin_lock(&devices_kset->list_lock); in devices_kset_move_last()
2969 list_move_tail(&dev->kobj.entry, &devices_kset->list); in devices_kset_move_last()
2970 spin_unlock(&devices_kset->list_lock); in devices_kset_move_last()
2974 * device_create_file - create sysfs attribute file for device.
2984 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), in device_create_file()
2986 attr->attr.name); in device_create_file()
2987 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), in device_create_file()
2989 attr->attr.name); in device_create_file()
2990 error = sysfs_create_file(&dev->kobj, &attr->attr); in device_create_file()
2998 * device_remove_file - remove sysfs attribute file.
3006 sysfs_remove_file(&dev->kobj, &attr->attr); in device_remove_file()
3011 * device_remove_file_self - remove sysfs attribute file from its own method.
3021 return sysfs_remove_file_self(&dev->kobj, &attr->attr); in device_remove_file_self()
3028 * device_create_bin_file - create sysfs binary attribute file for device.
3035 int error = -EINVAL; in device_create_bin_file()
3037 error = sysfs_create_bin_file(&dev->kobj, attr); in device_create_bin_file()
3043 * device_remove_bin_file - remove sysfs binary attribute file
3051 sysfs_remove_bin_file(&dev->kobj, attr); in device_remove_bin_file()
3058 struct device *dev = p->device; in klist_children_get()
3066 struct device *dev = p->device; in klist_children_put()
3072 * device_initialize - init device structure.
3093 dev->kobj.kset = devices_kset; in device_initialize()
3094 kobject_init(&dev->kobj, &device_ktype); in device_initialize()
3095 INIT_LIST_HEAD(&dev->dma_pools); in device_initialize()
3096 mutex_init(&dev->mutex); in device_initialize()
3097 lockdep_set_novalidate_class(&dev->mutex); in device_initialize()
3098 spin_lock_init(&dev->devres_lock); in device_initialize()
3099 INIT_LIST_HEAD(&dev->devres_head); in device_initialize()
3102 INIT_LIST_HEAD(&dev->links.consumers); in device_initialize()
3103 INIT_LIST_HEAD(&dev->links.suppliers); in device_initialize()
3104 INIT_LIST_HEAD(&dev->links.defer_sync); in device_initialize()
3105 dev->links.status = DL_DEV_NO_DRIVER; in device_initialize()
3109 dev->dma_coherent = dma_default_coherent; in device_initialize()
3121 &devices_kset->kobj); in virtual_device_parent()
3143 return dir->class->ns_type; in class_dir_child_ns_type()
3160 return ERR_PTR(-ENOMEM); in class_dir_create_and_add()
3162 dir->class = sp->class; in class_dir_create_and_add()
3163 kobject_init(&dir->kobj, &class_dir_ktype); in class_dir_create_and_add()
3165 dir->kobj.kset = &sp->glue_dirs; in class_dir_create_and_add()
3167 retval = kobject_add(&dir->kobj, parent_kobj, "%s", sp->class->name); in class_dir_create_and_add()
3169 kobject_put(&dir->kobj); in class_dir_create_and_add()
3172 return &dir->kobj; in class_dir_create_and_add()
3180 struct subsys_private *sp = class_to_subsys(dev->class); in get_device_parent()
3189 * Class-devices with a non class-device as parent, live in get_device_parent()
3194 else if (parent->class && !dev->class->ns_type) { in get_device_parent()
3196 return &parent->kobj; in get_device_parent()
3198 parent_kobj = &parent->kobj; in get_device_parent()
3203 /* find our class-directory at the parent and reference it */ in get_device_parent()
3204 spin_lock(&sp->glue_dirs.list_lock); in get_device_parent()
3205 list_for_each_entry(k, &sp->glue_dirs.list, entry) in get_device_parent()
3206 if (k->parent == parent_kobj) { in get_device_parent()
3210 spin_unlock(&sp->glue_dirs.list_lock); in get_device_parent()
3217 /* or create a new class-directory at the parent device */ in get_device_parent()
3226 if (!parent && dev->bus) { in get_device_parent()
3227 struct device *dev_root = bus_get_dev_root(dev->bus); in get_device_parent()
3230 kobj = &dev_root->kobj; in get_device_parent()
3237 return &parent->kobj; in get_device_parent()
3247 if (!kobj || !dev->class) in live_in_glue_dir()
3250 sp = class_to_subsys(dev->class); in live_in_glue_dir()
3254 if (kobj->kset == &sp->glue_dirs) in live_in_glue_dir()
3265 return dev->kobj.parent; in get_glue_dir()
3269 * kobject_has_children - Returns whether a kobject has children.
3280 WARN_ON_ONCE(kref_read(&kobj->kref) == 0); in kobject_has_children()
3282 return kobj->sd && kobj->sd->dir.subdirs; in kobject_has_children()
3325 * sysfs_remove_dir() // glue_dir->sd=NULL in cleanup_glue_dir()
3326 * sysfs_put() // free glue_dir->sd in cleanup_glue_dir()
3338 * and sysfs_put(). This result in glue_dir->sd is freed. in cleanup_glue_dir()
3347 ref = kref_read(&glue_dir->kref); in cleanup_glue_dir()
3348 if (!kobject_has_children(glue_dir) && !--ref) in cleanup_glue_dir()
3361 error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); in device_add_class_symlinks()
3367 sp = class_to_subsys(dev->class); in device_add_class_symlinks()
3371 error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); in device_add_class_symlinks()
3375 if (dev->parent && device_is_not_partition(dev)) { in device_add_class_symlinks()
3376 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, in device_add_class_symlinks()
3383 error = sysfs_create_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_add_class_symlinks()
3389 sysfs_remove_link(&dev->kobj, "device"); in device_add_class_symlinks()
3391 sysfs_remove_link(&dev->kobj, "subsystem"); in device_add_class_symlinks()
3393 sysfs_remove_link(&dev->kobj, "of_node"); in device_add_class_symlinks()
3401 struct subsys_private *sp = class_to_subsys(dev->class); in device_remove_class_symlinks()
3404 sysfs_remove_link(&dev->kobj, "of_node"); in device_remove_class_symlinks()
3409 if (dev->parent && device_is_not_partition(dev)) in device_remove_class_symlinks()
3410 sysfs_remove_link(&dev->kobj, "device"); in device_remove_class_symlinks()
3411 sysfs_remove_link(&dev->kobj, "subsystem"); in device_remove_class_symlinks()
3412 sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); in device_remove_class_symlinks()
3417 * dev_set_name - set a device name
3427 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); in dev_set_name()
3449 format_dev_t(devt_str, dev->devt); in device_create_sys_dev_entry()
3450 error = sysfs_create_link(kobj, &dev->kobj, devt_str); in device_create_sys_dev_entry()
3462 format_dev_t(devt_str, dev->devt); in device_remove_sys_dev_entry()
3469 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); in device_private_init()
3470 if (!dev->p) in device_private_init()
3471 return -ENOMEM; in device_private_init()
3472 dev->p->device = dev; in device_private_init()
3473 klist_init(&dev->p->klist_children, klist_children_get, in device_private_init()
3475 INIT_LIST_HEAD(&dev->p->deferred_probe); in device_private_init()
3480 * device_add - add device to device hierarchy.
3512 int error = -EINVAL; in device_add()
3519 if (!dev->p) { in device_add()
3530 if (dev->init_name) { in device_add()
3531 error = dev_set_name(dev, "%s", dev->init_name); in device_add()
3532 dev->init_name = NULL; in device_add()
3538 else if (dev->bus && dev->bus->dev_name) in device_add()
3539 error = dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); in device_add()
3541 error = -EINVAL; in device_add()
3547 parent = get_device(dev->parent); in device_add()
3554 dev->kobj.parent = kobj; in device_add()
3562 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); in device_add()
3589 if (MAJOR(dev->devt)) { in device_add()
3605 kobject_uevent(&dev->kobj, KOBJ_ADD); in device_add()
3619 if (dev->fwnode && !dev->fwnode->dev) { in device_add()
3620 dev->fwnode->dev = dev; in device_add()
3631 if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) in device_add()
3635 klist_add_tail(&dev->p->knode_parent, in device_add()
3636 &parent->p->klist_children); in device_add()
3638 sp = class_to_subsys(dev->class); in device_add()
3640 mutex_lock(&sp->mutex); in device_add()
3642 klist_add_tail(&dev->p->knode_class, &sp->klist_devices); in device_add()
3645 list_for_each_entry(class_intf, &sp->interfaces, node) in device_add()
3646 if (class_intf->add_dev) in device_add()
3647 class_intf->add_dev(dev); in device_add()
3648 mutex_unlock(&sp->mutex); in device_add()
3655 if (MAJOR(dev->devt)) in device_add()
3661 dev->driver = NULL; in device_add()
3671 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_add()
3673 kobject_del(&dev->kobj); in device_add()
3679 kfree(dev->p); in device_add()
3680 dev->p = NULL; in device_add()
3686 * device_register - register a device with the system.
3689 * This happens in two clean steps - initialize the device
3711 * get_device - increment reference count for device.
3720 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; in get_device()
3725 * put_device - decrement reference count.
3732 kobject_put(&dev->kobj); in put_device()
3747 if (dev->p->dead) in kill_device()
3749 dev->p->dead = true; in kill_device()
3755 * device_del - delete device from system.
3770 struct device *parent = dev->parent; in device_del()
3779 if (dev->fwnode && dev->fwnode->dev == dev) in device_del()
3780 dev->fwnode->dev = NULL; in device_del()
3790 klist_del(&dev->p->knode_parent); in device_del()
3791 if (MAJOR(dev->devt)) { in device_del()
3797 sp = class_to_subsys(dev->class); in device_del()
3801 mutex_lock(&sp->mutex); in device_del()
3803 list_for_each_entry(class_intf, &sp->interfaces, node) in device_del()
3804 if (class_intf->remove_dev) in device_del()
3805 class_intf->remove_dev(dev); in device_del()
3807 klist_del(&dev->p->knode_class); in device_del()
3808 mutex_unlock(&sp->mutex); in device_del()
3831 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_del()
3833 kobject_del(&dev->kobj); in device_del()
3841 * device_unregister - unregister device from system.
3867 dev = p->device; in prev_device()
3880 dev = p->device; in next_device()
3886 * device_get_devnode - path of device node file
3894 * Non-default names may need to allocate a memory to compose
3907 if (dev->type && dev->type->devnode) in device_get_devnode()
3908 *tmp = dev->type->devnode(dev, mode, uid, gid); in device_get_devnode()
3913 if (dev->class && dev->class->devnode) in device_get_devnode()
3914 *tmp = dev->class->devnode(dev, mode); in device_get_devnode()
3930 * device_for_each_child - device child iterator.
3948 if (!parent->p) in device_for_each_child()
3951 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child()
3960 * device_for_each_child_reverse - device child iterator in reversed order.
3978 if (!parent->p) in device_for_each_child_reverse()
3981 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child_reverse()
3990 * device_find_child - device iterator for locating a particular device.
3999 * The callback should return 0 if the device doesn't match and non-zero
4000 * if it does. If the callback returns non-zero and a reference to the
4015 klist_iter_init(&parent->p->klist_children, &i); in device_find_child()
4025 * device_find_child_by_name - device iterator for locating a child device.
4043 klist_iter_init(&parent->p->klist_children, &i); in device_find_child_by_name()
4058 * device_find_any_child - device iterator for locating a child device, if any.
4076 return -ENOMEM; in devices_init()
4095 return -ENOMEM; in devices_init()
4106 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; in device_check_offline()
4110 * device_offline - Prepare the device for hot-removal.
4114 * the device for a subsequent hot-removal. If that succeeds, the device must
4124 if (dev->offline_disabled) in device_offline()
4125 return -EPERM; in device_offline()
4133 if (dev->offline) { in device_offline()
4136 ret = dev->bus->offline(dev); in device_offline()
4138 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); in device_offline()
4139 dev->offline = true; in device_offline()
4149 * device_online - Put the device back online after successful device_offline().
4164 if (dev->offline) { in device_online()
4165 ret = dev->bus->online(dev); in device_online()
4167 kobject_uevent(&dev->kobj, KOBJ_ONLINE); in device_online()
4168 dev->offline = false; in device_online()
4195 * __root_device_register - allocate and register a root device
4219 int err = -ENOMEM; in __root_device_register()
4225 err = dev_set_name(&root->dev, "%s", name); in __root_device_register()
4231 root->dev.release = root_device_release; in __root_device_register()
4233 err = device_register(&root->dev); in __root_device_register()
4235 put_device(&root->dev); in __root_device_register()
4241 struct module_kobject *mk = &owner->mkobj; in __root_device_register()
4243 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); in __root_device_register()
4245 device_unregister(&root->dev); in __root_device_register()
4248 root->owner = owner; in __root_device_register()
4252 return &root->dev; in __root_device_register()
4257 * root_device_unregister - unregister and free a root device
4267 if (root->owner) in root_device_unregister()
4268 sysfs_remove_link(&root->dev.kobj, "module"); in root_device_unregister()
4288 int retval = -ENODEV; in device_create_groups_vargs()
4295 retval = -ENOMEM; in device_create_groups_vargs()
4300 dev->devt = devt; in device_create_groups_vargs()
4301 dev->class = class; in device_create_groups_vargs()
4302 dev->parent = parent; in device_create_groups_vargs()
4303 dev->groups = groups; in device_create_groups_vargs()
4304 dev->release = device_create_release; in device_create_groups_vargs()
4307 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); in device_create_groups_vargs()
4323 * device_create - creates a device and registers it with sysfs
4358 * device_create_with_groups - creates a device and registers it with sysfs
4363 * @groups: NULL-terminated list of attribute groups to be created
4399 * device_destroy - removes a device that was created with device_create()
4419 * device_rename - renames a device
4442 * renamed it -- then you get events for the same DEVPATH, before you even see
4445 * other things than (driver-core wise very simple) network devices.
4449 * symlinks -- but never rename kernel devices later, it's a complete mess. We
4455 struct kobject *kobj = &dev->kobj; in device_rename()
4461 return -EINVAL; in device_rename()
4467 error = -ENOMEM; in device_rename()
4471 if (dev->class) { in device_rename()
4472 struct subsys_private *sp = class_to_subsys(dev->class); in device_rename()
4475 error = -EINVAL; in device_rename()
4479 error = sysfs_rename_link_ns(&sp->subsys.kobj, kobj, old_device_name, in device_rename()
4506 sysfs_remove_link(&dev->kobj, "device"); in device_move_class_links()
4508 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, in device_move_class_links()
4514 * device_move - moves a device to a new parent
4528 return -EINVAL; in device_move()
4541 error = kobject_move(&dev->kobj, new_parent_kobj); in device_move()
4547 old_parent = dev->parent; in device_move()
4548 dev->parent = new_parent; in device_move()
4550 klist_remove(&dev->p->knode_parent); in device_move()
4552 klist_add_tail(&dev->p->knode_parent, in device_move()
4553 &new_parent->p->klist_children); in device_move()
4557 if (dev->class) { in device_move()
4562 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { in device_move()
4564 klist_remove(&dev->p->knode_parent); in device_move()
4565 dev->parent = old_parent; in device_move()
4567 klist_add_tail(&dev->p->knode_parent, in device_move()
4568 &old_parent->p->klist_children); in device_move()
4605 struct kobject *kobj = &dev->kobj; in device_attrs_change_owner()
4606 const struct class *class = dev->class; in device_attrs_change_owner()
4607 const struct device_type *type = dev->type; in device_attrs_change_owner()
4615 error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, in device_attrs_change_owner()
4626 error = sysfs_groups_change_owner(kobj, type->groups, kuid, in device_attrs_change_owner()
4633 error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); in device_attrs_change_owner()
4637 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_attrs_change_owner()
4649 * device_change_owner - change the owner of an existing device.
4663 struct kobject *kobj = &dev->kobj; in device_change_owner()
4668 return -EINVAL; in device_change_owner()
4707 sp = class_to_subsys(dev->class); in device_change_owner()
4709 error = -EINVAL; in device_change_owner()
4712 error = sysfs_link_change_owner(&sp->subsys.kobj, &dev->kobj, dev_name(dev), kuid, kgid); in device_change_owner()
4722 * device_shutdown - call ->shutdown() on each device to shutdown.
4733 spin_lock(&devices_kset->list_lock); in device_shutdown()
4739 while (!list_empty(&devices_kset->list)) { in device_shutdown()
4740 dev = list_entry(devices_kset->list.prev, struct device, in device_shutdown()
4748 parent = get_device(dev->parent); in device_shutdown()
4752 * event that dev->*->shutdown() doesn't remove it. in device_shutdown()
4754 list_del_init(&dev->kobj.entry); in device_shutdown()
4755 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4766 if (dev->class && dev->class->shutdown_pre) { in device_shutdown()
4769 dev->class->shutdown_pre(dev); in device_shutdown()
4771 if (dev->bus && dev->bus->shutdown) { in device_shutdown()
4774 dev->bus->shutdown(dev); in device_shutdown()
4775 } else if (dev->driver && dev->driver->shutdown) { in device_shutdown()
4778 dev->driver->shutdown(dev); in device_shutdown()
4788 spin_lock(&devices_kset->list_lock); in device_shutdown()
4790 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4805 if (dev->class) in set_dev_info()
4806 subsys = dev->class->name; in set_dev_info()
4807 else if (dev->bus) in set_dev_info()
4808 subsys = dev->bus->name; in set_dev_info()
4812 strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); in set_dev_info()
4821 if (MAJOR(dev->devt)) { in set_dev_info()
4829 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4830 "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); in set_dev_info()
4834 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4835 "n%u", net->ifindex); in set_dev_info()
4837 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4872 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", in __dev_printk()
4923 * dev_err_probe - probe error check and log helper
4926 * @fmt: printf-style format string
4931 * -EPROBE_DEFER and propagate error upwards.
4932 * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
4936 * if (err != -EPROBE_DEFER)
4947 * prints during probe even if the @err is known to never be -EPROBE_DEFER.
4963 if (err != -EPROBE_DEFER) { in dev_err_probe()
4978 return fwnode && !IS_ERR(fwnode->secondary); in fwnode_is_primary()
4982 * set_primary_fwnode - Change the primary firmware node of a given device.
4990 * - primary --> secondary --> -ENODEV
4991 * - primary --> NULL
4992 * - secondary --> -ENODEV
4993 * - NULL
4997 struct device *parent = dev->parent; in set_primary_fwnode()
4998 struct fwnode_handle *fn = dev->fwnode; in set_primary_fwnode()
5002 fn = fn->secondary; in set_primary_fwnode()
5005 WARN_ON(fwnode->secondary); in set_primary_fwnode()
5006 fwnode->secondary = fn; in set_primary_fwnode()
5008 dev->fwnode = fwnode; in set_primary_fwnode()
5011 dev->fwnode = fn->secondary; in set_primary_fwnode()
5013 /* Skip nullifying fn->secondary if the primary is shared */ in set_primary_fwnode()
5014 if (parent && fn == parent->fwnode) in set_primary_fwnode()
5017 /* Set fn->secondary = NULL, so fn remains the primary fwnode */ in set_primary_fwnode()
5018 fn->secondary = NULL; in set_primary_fwnode()
5020 dev->fwnode = NULL; in set_primary_fwnode()
5027 * set_secondary_fwnode - Change the secondary firmware node of a given device.
5038 fwnode->secondary = ERR_PTR(-ENODEV); in set_secondary_fwnode()
5040 if (fwnode_is_primary(dev->fwnode)) in set_secondary_fwnode()
5041 dev->fwnode->secondary = fwnode; in set_secondary_fwnode()
5043 dev->fwnode = fwnode; in set_secondary_fwnode()
5048 * device_set_of_node_from_dev - reuse device-tree node of another device
5049 * @dev: device whose device-tree node is being set
5050 * @dev2: device whose device-tree node is being reused
5052 * Takes another reference to the new device-tree node after first dropping
5057 of_node_put(dev->of_node); in device_set_of_node_from_dev()
5058 dev->of_node = of_node_get(dev2->of_node); in device_set_of_node_from_dev()
5059 dev->of_node_reused = true; in device_set_of_node_from_dev()
5065 dev->fwnode = fwnode; in device_set_node()
5066 dev->of_node = to_of_node(fwnode); in device_set_node()
5078 return dev->of_node == np; in device_match_of_node()
5090 return dev->devt == *(dev_t *)pdevt; in device_match_devt()