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>
48 /* Device links support. */
119 * device_is_dependent - Check if one device depends on another one
138 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_is_dependent()
139 if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) in device_is_dependent()
142 if (link->consumer == target) in device_is_dependent()
145 ret = device_is_dependent(link->consumer, target); in device_is_dependent()
156 switch (supplier->links.status) { in device_link_init_status()
158 switch (consumer->links.status) { in device_link_init_status()
167 link->status = DL_STATE_CONSUMER_PROBE; in device_link_init_status()
170 link->status = DL_STATE_DORMANT; in device_link_init_status()
175 switch (consumer->links.status) { in device_link_init_status()
177 link->status = DL_STATE_CONSUMER_PROBE; in device_link_init_status()
180 link->status = DL_STATE_ACTIVE; in device_link_init_status()
183 link->status = DL_STATE_AVAILABLE; in device_link_init_status()
188 link->status = DL_STATE_SUPPLIER_UNBIND; in device_link_init_status()
191 link->status = DL_STATE_DORMANT; in device_link_init_status()
211 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_reorder_to_tail()
212 if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) in device_reorder_to_tail()
214 device_reorder_to_tail(link->consumer, NULL); in device_reorder_to_tail()
221 * device_pm_move_to_tail - Move set of devices to the end of device lists
247 switch (to_devlink(dev)->status) { in status_show()
281 if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) in auto_remove_on_show()
283 else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) in auto_remove_on_show()
297 return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); in runtime_pm_show()
307 !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in sync_state_only_show()
322 while (refcount_dec_not_one(&link->rpm_active)) in device_link_free()
323 pm_runtime_put(link->supplier); in device_link_free()
325 put_device(link->consumer); in device_link_free()
326 put_device(link->supplier); in device_link_free()
340 call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); in devlink_dev_release()
362 struct device *sup = link->supplier; in devlink_add_symlinks()
363 struct device *con = link->consumer; in devlink_add_symlinks()
370 return -ENOMEM; in devlink_add_symlinks()
372 ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); in devlink_add_symlinks()
376 ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); in devlink_add_symlinks()
381 ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); in devlink_add_symlinks()
386 ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); in devlink_add_symlinks()
394 sysfs_remove_link(&sup->kobj, buf); in devlink_add_symlinks()
396 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_add_symlinks()
398 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_add_symlinks()
409 struct device *sup = link->supplier; in devlink_remove_symlinks()
410 struct device *con = link->consumer; in devlink_remove_symlinks()
413 sysfs_remove_link(&link->link_dev.kobj, "consumer"); in devlink_remove_symlinks()
414 sysfs_remove_link(&link->link_dev.kobj, "supplier"); in devlink_remove_symlinks()
425 sysfs_remove_link(&con->kobj, buf); in devlink_remove_symlinks()
427 sysfs_remove_link(&sup->kobj, buf); in devlink_remove_symlinks()
462 * device_link_add - Create a link between two devices.
471 * be forced into the active metastate and reference-counted upon the creation
508 * A side effect of the link creation is re-ordering of dpm_list and the
546 * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and in device_link_add()
566 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_add()
567 if (link->consumer != consumer) in device_link_add()
571 if (!(link->flags & DL_FLAG_PM_RUNTIME)) { in device_link_add()
573 link->flags |= DL_FLAG_PM_RUNTIME; in device_link_add()
576 refcount_inc(&link->rpm_active); in device_link_add()
580 kref_get(&link->kref); in device_link_add()
581 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
582 !(link->flags & DL_FLAG_STATELESS)) { in device_link_add()
583 link->flags |= DL_FLAG_STATELESS; in device_link_add()
586 link->flags |= DL_FLAG_STATELESS; in device_link_add()
597 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in device_link_add()
598 link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; in device_link_add()
599 link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; in device_link_add()
602 link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | in device_link_add()
605 if (!(link->flags & DL_FLAG_MANAGED)) { in device_link_add()
606 kref_get(&link->kref); in device_link_add()
607 link->flags |= DL_FLAG_MANAGED; in device_link_add()
610 if (link->flags & DL_FLAG_SYNC_STATE_ONLY && in device_link_add()
612 link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; in device_link_add()
623 refcount_set(&link->rpm_active, 1); in device_link_add()
626 link->supplier = supplier; in device_link_add()
627 INIT_LIST_HEAD(&link->s_node); in device_link_add()
629 link->consumer = consumer; in device_link_add()
630 INIT_LIST_HEAD(&link->c_node); in device_link_add()
631 link->flags = flags; in device_link_add()
632 kref_init(&link->kref); in device_link_add()
634 link->link_dev.class = &devlink_class; in device_link_add()
635 device_set_pm_not_required(&link->link_dev); in device_link_add()
636 dev_set_name(&link->link_dev, "%s--%s", in device_link_add()
638 if (device_register(&link->link_dev)) { in device_link_add()
648 refcount_inc(&link->rpm_active); in device_link_add()
655 link->status = DL_STATE_NONE; in device_link_add()
663 if (link->status == DL_STATE_CONSUMER_PROBE && in device_link_add()
667 list_add_tail_rcu(&link->s_node, &supplier->links.consumers); in device_link_add()
668 list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); in device_link_add()
701 * device_link_wait_for_supplier - Add device to wait_for_suppliers list
708 * The caller is responsible for adding the links to the supplier devices once
710 * wait_for_suppliers list once links to all the suppliers have been created.
719 list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers); in device_link_wait_for_supplier()
720 consumer->links.need_for_probe = need_for_probe; in device_link_wait_for_supplier()
735 * device_link_add_missing_supplier_links - Add links from consumer devices to
741 * supplier links. If that succeeds, the consumer device is removed from
746 * added all the supplier links for the consumer device. It should return an
758 links.needs_suppliers) { in device_link_add_missing_supplier_links()
759 int ret = fwnode_call_int_op(dev->fwnode, add_links, dev); in device_link_add_missing_supplier_links()
761 list_del_init(&dev->links.needs_suppliers); in device_link_add_missing_supplier_links()
762 else if (ret != -ENODEV || fw_devlink_is_permissive()) in device_link_add_missing_supplier_links()
763 dev->links.need_for_probe = false; in device_link_add_missing_supplier_links()
773 dev_dbg(link->consumer, "Dropping the link to %s\n", in __device_link_del()
774 dev_name(link->supplier)); in __device_link_del()
778 list_del_rcu(&link->s_node); in __device_link_del()
779 list_del_rcu(&link->c_node); in __device_link_del()
780 device_unregister(&link->link_dev); in __device_link_del()
787 dev_info(link->consumer, "Dropping the link to %s\n", in __device_link_del()
788 dev_name(link->supplier)); in __device_link_del()
792 list_del(&link->s_node); in __device_link_del()
793 list_del(&link->c_node); in __device_link_del()
794 device_unregister(&link->link_dev); in __device_link_del()
800 if (link->flags & DL_FLAG_STATELESS) in device_link_put_kref()
801 kref_put(&link->kref, __device_link_del); in device_link_put_kref()
807 * device_link_del - Delete a stateless link between two devices.
812 * Care is required for hotplugged devices: Their links are purged on removal
824 * device_link_remove - Delete a stateless link between two devices.
840 list_for_each_entry(link, &supplier->links.consumers, s_node) { in device_link_remove()
841 if (link->consumer == consumer) { in device_link_remove()
855 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_missing_supplier()
856 if (link->status != DL_STATE_CONSUMER_PROBE) in device_links_missing_supplier()
859 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in device_links_missing_supplier()
860 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_missing_supplier()
862 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in device_links_missing_supplier()
863 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_missing_supplier()
869 * device_links_check_suppliers - Check presence of supplier drivers.
872 * Check links from this device to any suppliers. Walk the list of the device's
873 * links to suppliers and see if all of them are available. If not, simply
874 * return -EPROBE_DEFER.
878 * that function checks the device's links to consumers. This means we need to
882 * Links without the DL_FLAG_MANAGED flag set are ignored.
894 if (!list_empty(&dev->links.needs_suppliers) && in device_links_check_suppliers()
895 dev->links.need_for_probe) { in device_links_check_suppliers()
897 return -EPROBE_DEFER; in device_links_check_suppliers()
903 list_for_each_entry(link, &dev->links.suppliers, c_node) { in device_links_check_suppliers()
904 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_check_suppliers()
907 if (link->status != DL_STATE_AVAILABLE && in device_links_check_suppliers()
908 !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { in device_links_check_suppliers()
910 ret = -EPROBE_DEFER; in device_links_check_suppliers()
913 WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); in device_links_check_suppliers()
915 dev->links.status = DL_DEV_PROBING; in device_links_check_suppliers()
922 * __device_links_queue_sync_state - Queue a device for sync_state() callback
926 * Queues a device for a sync_state() callback when the device links write lock
927 * isn't held. This allows the sync_state() execution flow to use device links
946 if (dev->state_synced) in __device_links_queue_sync_state()
949 list_for_each_entry(link, &dev->links.consumers, s_node) { in __device_links_queue_sync_state()
950 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_queue_sync_state()
952 if (link->status != DL_STATE_ACTIVE) in __device_links_queue_sync_state()
961 dev->state_synced = true; in __device_links_queue_sync_state()
963 if (WARN_ON(!list_empty(&dev->links.defer_hook))) in __device_links_queue_sync_state()
967 list_add_tail(&dev->links.defer_hook, list); in __device_links_queue_sync_state()
971 * device_links_flush_sync_list - Call sync_state() on a list of devices
985 list_for_each_entry_safe(dev, tmp, list, links.defer_hook) { in device_links_flush_sync_list()
986 list_del_init(&dev->links.defer_hook); in device_links_flush_sync_list()
991 if (dev->bus->sync_state) in device_links_flush_sync_list()
992 dev->bus->sync_state(dev); in device_links_flush_sync_list()
993 else if (dev->driver && dev->driver->sync_state) in device_links_flush_sync_list()
994 dev->driver->sync_state(dev); in device_links_flush_sync_list()
1020 defer_sync_state_count--; in device_links_supplier_sync_state_resume()
1024 list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_hook) { in device_links_supplier_sync_state_resume()
1029 list_del_init(&dev->links.defer_hook); in device_links_supplier_sync_state_resume()
1047 if (list_empty(&sup->links.defer_hook) && dev_has_sync_state(sup)) in __device_links_supplier_defer_sync()
1048 list_add_tail(&sup->links.defer_hook, &deferred_sync); in __device_links_supplier_defer_sync()
1053 link->flags &= ~DL_FLAG_MANAGED; in device_link_drop_managed()
1054 WRITE_ONCE(link->status, DL_STATE_NONE); in device_link_drop_managed()
1055 kref_put(&link->kref, __device_link_del); in device_link_drop_managed()
1066 val = !list_empty(&dev->links.needs_suppliers) in waiting_for_supplier_show()
1067 && dev->links.need_for_probe; in waiting_for_supplier_show()
1075 * device_links_driver_bound - Update device links after probing its driver.
1076 * @dev: Device to update the links for.
1078 * The probe has been successful, so update links from this device to any
1081 * Also change the status of @dev's links to suppliers to "active".
1083 * Links without the DL_FLAG_MANAGED flag set are ignored.
1092 * the device links it needs to or make new device links as it needs in device_links_driver_bound()
1096 list_del_init(&dev->links.needs_suppliers); in device_links_driver_bound()
1102 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_driver_bound()
1103 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1107 * Links created during consumer probe may be in the "consumer in device_links_driver_bound()
1112 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_driver_bound()
1113 link->status == DL_STATE_ACTIVE) in device_links_driver_bound()
1116 WARN_ON(link->status != DL_STATE_DORMANT); in device_links_driver_bound()
1117 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in device_links_driver_bound()
1119 if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) in device_links_driver_bound()
1120 driver_deferred_probe_add(link->consumer); in device_links_driver_bound()
1128 list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { in device_links_driver_bound()
1131 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_bound()
1134 supplier = link->supplier; in device_links_driver_bound()
1135 if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { in device_links_driver_bound()
1143 WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); in device_links_driver_bound()
1144 WRITE_ONCE(link->status, DL_STATE_ACTIVE); in device_links_driver_bound()
1159 dev->links.status = DL_DEV_DRIVER_BOUND; in device_links_driver_bound()
1167 * __device_links_no_driver - Update links of a device without a driver.
1170 * Delete all non-persistent links from this device to any suppliers.
1172 * Persistent links stay around, but their status is changed to "available",
1176 * Links without the DL_FLAG_MANAGED flag set are ignored.
1182 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in __device_links_no_driver()
1183 if (!(link->flags & DL_FLAG_MANAGED)) in __device_links_no_driver()
1186 if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { in __device_links_no_driver()
1191 if (link->status != DL_STATE_CONSUMER_PROBE && in __device_links_no_driver()
1192 link->status != DL_STATE_ACTIVE) in __device_links_no_driver()
1195 if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { in __device_links_no_driver()
1196 WRITE_ONCE(link->status, DL_STATE_AVAILABLE); in __device_links_no_driver()
1198 WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); in __device_links_no_driver()
1199 WRITE_ONCE(link->status, DL_STATE_DORMANT); in __device_links_no_driver()
1203 dev->links.status = DL_DEV_NO_DRIVER; in __device_links_no_driver()
1207 * device_links_no_driver - Update links after failing driver probe.
1210 * Clean up leftover links to consumers for @dev and invoke
1211 * %__device_links_no_driver() to update links to suppliers for it as
1214 * Links without the DL_FLAG_MANAGED flag set are ignored.
1222 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_no_driver()
1223 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_no_driver()
1233 if (link->status == DL_STATE_CONSUMER_PROBE || in device_links_no_driver()
1234 link->status == DL_STATE_ACTIVE) in device_links_no_driver()
1235 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_no_driver()
1244 * device_links_driver_cleanup - Update links after driver removal.
1247 * Update links to consumers for @dev by changing their status to "dormant" and
1248 * invoke %__device_links_no_driver() to update links to suppliers for it as
1251 * Links without the DL_FLAG_MANAGED flag set are ignored.
1259 list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { in device_links_driver_cleanup()
1260 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_driver_cleanup()
1263 WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); in device_links_driver_cleanup()
1264 WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); in device_links_driver_cleanup()
1267 * autoremove the links between this @dev and its consumer in device_links_driver_cleanup()
1271 if (link->status == DL_STATE_SUPPLIER_UNBIND && in device_links_driver_cleanup()
1272 link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) in device_links_driver_cleanup()
1275 WRITE_ONCE(link->status, DL_STATE_DORMANT); in device_links_driver_cleanup()
1278 list_del_init(&dev->links.defer_hook); in device_links_driver_cleanup()
1285 * device_links_busy - Check if there are any busy links to consumers.
1296 * Links without the DL_FLAG_MANAGED flag set are ignored.
1305 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_busy()
1306 if (!(link->flags & DL_FLAG_MANAGED)) in device_links_busy()
1309 if (link->status == DL_STATE_CONSUMER_PROBE in device_links_busy()
1310 || link->status == DL_STATE_ACTIVE) { in device_links_busy()
1314 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_busy()
1317 dev->links.status = DL_DEV_UNBINDING; in device_links_busy()
1324 * device_links_unbind_consumers - Force unbind consumers of the given device.
1327 * Walk the list of links to consumers for @dev and if any of them is in the
1333 * driver to unbind and start over (the consumer will not re-probe as we have
1336 * Links without the DL_FLAG_MANAGED flag set are ignored.
1345 list_for_each_entry(link, &dev->links.consumers, s_node) { in device_links_unbind_consumers()
1348 if (!(link->flags & DL_FLAG_MANAGED) || in device_links_unbind_consumers()
1349 link->flags & DL_FLAG_SYNC_STATE_ONLY) in device_links_unbind_consumers()
1352 status = link->status; in device_links_unbind_consumers()
1359 WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); in device_links_unbind_consumers()
1361 struct device *consumer = link->consumer; in device_links_unbind_consumers()
1368 consumer->parent); in device_links_unbind_consumers()
1378 * device_links_purge - Delete existing links to other devices.
1385 if (dev->class == &devlink_class) in device_links_purge()
1389 list_del(&dev->links.needs_suppliers); in device_links_purge()
1393 * Delete all of the remaining links from this device to any other in device_links_purge()
1398 list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { in device_links_purge()
1399 WARN_ON(link->status == DL_STATE_ACTIVE); in device_links_purge()
1400 __device_link_del(&link->kref); in device_links_purge()
1403 list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { in device_links_purge()
1404 WARN_ON(link->status != DL_STATE_DORMANT && in device_links_purge()
1405 link->status != DL_STATE_NONE); in device_links_purge()
1406 __device_link_del(&link->kref); in device_links_purge()
1416 return -EINVAL; in fw_devlink_setup()
1458 if (!fwnode_has_op(dev->fwnode, add_links)) in fw_devlink_link_device()
1468 fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev); in fw_devlink_link_device()
1469 if (fw_ret == -ENODEV && fw_devlink_is_permissive()) in fw_devlink_link_device()
1470 fw_ret = -EAGAIN; in fw_devlink_link_device()
1472 fw_ret = -ENODEV; in fw_devlink_link_device()
1478 list_add_tail(&dev->links.defer_hook, &deferred_fw_devlink); in fw_devlink_link_device()
1481 if (fw_ret == -ENODEV) in fw_devlink_link_device()
1491 * fw_devlink_pause - Pause parsing of fwnode to create device links
1493 * Calling this function defers any fwnode parsing to create device links until
1498 * - Any device that is added won't have its fwnode parsed to create device
1499 * links.
1500 * - The probe of the device will also be deferred during this period.
1501 * - Any devices that were already added, but waiting for suppliers won't be
1505 * - All the fwnodes that was not parsed will be parsed.
1506 * - All the devices that were deferred probing will be reattempted if they
1514 * - All the consumers are added before their suppliers
1515 * - All the suppliers of the N devices are part of the N devices
1519 * - With the use of fw_devlink_pause() and fw_devlink_resume(), each device
1526 * - Without the use of fw_devlink_pause() and fw_devlink_resume(), we would
1540 /** fw_devlink_resume - Resume parsing of fwnode to create device links
1556 defer_fw_devlink_count--; in fw_devlink_resume()
1570 list_for_each_entry_safe(dev, tmp, &probe_list, links.defer_hook) { in fw_devlink_resume()
1571 list_del_init(&dev->links.defer_hook); in fw_devlink_resume()
1575 /* Device links support end. */
1608 return !(dev->type == &part_type); in device_is_not_partition()
1638 * dev_driver_string - Return a device's driver name, if at all possible
1650 /* dev->driver can change to NULL underneath us because of unbinding, in dev_driver_string()
1651 * so be careful about accessing it. dev->bus and dev->class should in dev_driver_string()
1654 drv = READ_ONCE(dev->driver); in dev_driver_string()
1655 return drv ? drv->name : in dev_driver_string()
1656 (dev->bus ? dev->bus->name : in dev_driver_string()
1657 (dev->class ? dev->class->name : "")); in dev_driver_string()
1668 ssize_t ret = -EIO; in dev_attr_show()
1670 if (dev_attr->show) in dev_attr_show()
1671 ret = dev_attr->show(dev, dev_attr, buf); in dev_attr_show()
1674 dev_attr->show); in dev_attr_show()
1684 ssize_t ret = -EIO; in dev_attr_store()
1686 if (dev_attr->store) in dev_attr_store()
1687 ret = dev_attr->store(dev, dev_attr, buf, count); in dev_attr_store()
1709 *(unsigned long *)(ea->var) = new; in device_store_ulong()
1720 return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); in device_show_ulong()
1737 return -EINVAL; in device_store_int()
1738 *(int *)(ea->var) = new; in device_store_int()
1750 return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); in device_show_int()
1759 if (strtobool(buf, ea->var) < 0) in device_store_bool()
1760 return -EINVAL; in device_store_bool()
1771 return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); in device_show_bool()
1776 * device_release - free device structure.
1786 struct device_private *p = dev->p; in device_release()
1799 kfree(dev->dma_range_map); in device_release()
1801 if (dev->release) in device_release()
1802 dev->release(dev); in device_release()
1803 else if (dev->type && dev->type->release) in device_release()
1804 dev->type->release(dev); in device_release()
1805 else if (dev->class && dev->class->dev_release) in device_release()
1806 dev->class->dev_release(dev); in device_release()
1808 …does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kob… in device_release()
1818 if (dev->class && dev->class->ns_type) in device_namespace()
1819 ns = dev->class->namespace(dev); in device_namespace()
1828 if (dev->class && dev->class->get_ownership) in device_get_ownership()
1829 dev->class->get_ownership(dev, uid, gid); in device_get_ownership()
1846 if (dev->bus) in dev_uevent_filter()
1848 if (dev->class) in dev_uevent_filter()
1858 if (dev->bus) in dev_uevent_name()
1859 return dev->bus->name; in dev_uevent_name()
1860 if (dev->class) in dev_uevent_name()
1861 return dev->class->name; in dev_uevent_name()
1872 if (MAJOR(dev->devt)) { in dev_uevent()
1879 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); in dev_uevent()
1880 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); in dev_uevent()
1894 if (dev->type && dev->type->name) in dev_uevent()
1895 add_uevent_var(env, "DEVTYPE=%s", dev->type->name); in dev_uevent()
1897 if (dev->driver) in dev_uevent()
1898 add_uevent_var(env, "DRIVER=%s", dev->driver->name); in dev_uevent()
1904 if (dev->bus && dev->bus->uevent) { in dev_uevent()
1905 retval = dev->bus->uevent(dev, env); in dev_uevent()
1912 if (dev->class && dev->class->dev_uevent) { in dev_uevent()
1913 retval = dev->class->dev_uevent(dev, env); in dev_uevent()
1921 if (dev->type && dev->type->uevent) { in dev_uevent()
1922 retval = dev->type->uevent(dev, env); in dev_uevent()
1949 top_kobj = &dev->kobj; in uevent_show()
1950 while (!top_kobj->kset && top_kobj->parent) in uevent_show()
1951 top_kobj = top_kobj->parent; in uevent_show()
1952 if (!top_kobj->kset) in uevent_show()
1955 kset = top_kobj->kset; in uevent_show()
1956 if (!kset->uevent_ops || !kset->uevent_ops->uevent) in uevent_show()
1960 if (kset->uevent_ops && kset->uevent_ops->filter) in uevent_show()
1961 if (!kset->uevent_ops->filter(kset, &dev->kobj)) in uevent_show()
1966 return -ENOMEM; in uevent_show()
1969 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); in uevent_show()
1974 for (i = 0; i < env->envp_idx; i++) in uevent_show()
1975 len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); in uevent_show()
1986 rc = kobject_synth_uevent(&dev->kobj, buf, count); in uevent_store()
2003 val = !dev->offline; in online_show()
2030 return sysfs_create_groups(&dev->kobj, groups); in device_add_groups()
2037 sysfs_remove_groups(&dev->kobj, groups); in device_remove_groups()
2048 return ((union device_attr_group_devres *)res)->group == data; in devm_attr_group_match()
2054 const struct attribute_group *group = devres->group; in devm_attr_group_remove()
2057 sysfs_remove_group(&dev->kobj, group); in devm_attr_group_remove()
2063 const struct attribute_group **groups = devres->groups; in devm_attr_groups_remove()
2066 sysfs_remove_groups(&dev->kobj, groups); in devm_attr_groups_remove()
2070 * devm_device_add_group - given a device, create a managed attribute group
2087 return -ENOMEM; in devm_device_add_group()
2089 error = sysfs_create_group(&dev->kobj, grp); in devm_device_add_group()
2095 devres->group = grp; in devm_device_add_group()
2119 * devm_device_add_groups - create a bunch of managed attribute groups
2140 return -ENOMEM; in devm_device_add_groups()
2142 error = sysfs_create_groups(&dev->kobj, groups); in devm_device_add_groups()
2148 devres->groups = groups; in devm_device_add_groups()
2155 * devm_device_remove_groups - remove a list of managed groups
2173 struct class *class = dev->class; in device_add_attrs()
2174 const struct device_type *type = dev->type; in device_add_attrs()
2178 error = device_add_groups(dev, class->dev_groups); in device_add_attrs()
2184 error = device_add_groups(dev, type->groups); in device_add_attrs()
2189 error = device_add_groups(dev, dev->groups); in device_add_attrs()
2193 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_add_attrs()
2210 device_remove_groups(dev, dev->groups); in device_add_attrs()
2213 device_remove_groups(dev, type->groups); in device_add_attrs()
2216 device_remove_groups(dev, class->dev_groups); in device_add_attrs()
2223 struct class *class = dev->class; in device_remove_attrs()
2224 const struct device_type *type = dev->type; in device_remove_attrs()
2228 device_remove_groups(dev, dev->groups); in device_remove_attrs()
2231 device_remove_groups(dev, type->groups); in device_remove_attrs()
2234 device_remove_groups(dev, class->dev_groups); in device_remove_attrs()
2240 return print_dev_t(buf, dev->devt); in dev_show()
2248 * devices_kset_move_before - Move device in the devices_kset's list.
2258 spin_lock(&devices_kset->list_lock); in devices_kset_move_before()
2259 list_move_tail(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_before()
2260 spin_unlock(&devices_kset->list_lock); in devices_kset_move_before()
2264 * devices_kset_move_after - Move device in the devices_kset's list.
2274 spin_lock(&devices_kset->list_lock); in devices_kset_move_after()
2275 list_move(&deva->kobj.entry, &devb->kobj.entry); in devices_kset_move_after()
2276 spin_unlock(&devices_kset->list_lock); in devices_kset_move_after()
2280 * devices_kset_move_last - move the device to the end of devices_kset's list.
2288 spin_lock(&devices_kset->list_lock); in devices_kset_move_last()
2289 list_move_tail(&dev->kobj.entry, &devices_kset->list); in devices_kset_move_last()
2290 spin_unlock(&devices_kset->list_lock); in devices_kset_move_last()
2294 * device_create_file - create sysfs attribute file for device.
2304 WARN(((attr->attr.mode & S_IWUGO) && !attr->store), in device_create_file()
2306 attr->attr.name); in device_create_file()
2307 WARN(((attr->attr.mode & S_IRUGO) && !attr->show), in device_create_file()
2309 attr->attr.name); in device_create_file()
2310 error = sysfs_create_file(&dev->kobj, &attr->attr); in device_create_file()
2318 * device_remove_file - remove sysfs attribute file.
2326 sysfs_remove_file(&dev->kobj, &attr->attr); in device_remove_file()
2331 * device_remove_file_self - remove sysfs attribute file from its own method.
2341 return sysfs_remove_file_self(&dev->kobj, &attr->attr); in device_remove_file_self()
2348 * device_create_bin_file - create sysfs binary attribute file for device.
2355 int error = -EINVAL; in device_create_bin_file()
2357 error = sysfs_create_bin_file(&dev->kobj, attr); in device_create_bin_file()
2363 * device_remove_bin_file - remove sysfs binary attribute file
2371 sysfs_remove_bin_file(&dev->kobj, attr); in device_remove_bin_file()
2378 struct device *dev = p->device; in klist_children_get()
2386 struct device *dev = p->device; in klist_children_put()
2392 * device_initialize - init device structure.
2413 dev->kobj.kset = devices_kset; in device_initialize()
2414 kobject_init(&dev->kobj, &device_ktype); in device_initialize()
2415 INIT_LIST_HEAD(&dev->dma_pools); in device_initialize()
2416 mutex_init(&dev->mutex); in device_initialize()
2418 mutex_init(&dev->lockdep_mutex); in device_initialize()
2420 lockdep_set_novalidate_class(&dev->mutex); in device_initialize()
2421 spin_lock_init(&dev->devres_lock); in device_initialize()
2422 INIT_LIST_HEAD(&dev->devres_head); in device_initialize()
2424 set_dev_node(dev, -1); in device_initialize()
2426 INIT_LIST_HEAD(&dev->msi_list); in device_initialize()
2428 INIT_LIST_HEAD(&dev->links.consumers); in device_initialize()
2429 INIT_LIST_HEAD(&dev->links.suppliers); in device_initialize()
2430 INIT_LIST_HEAD(&dev->links.needs_suppliers); in device_initialize()
2431 INIT_LIST_HEAD(&dev->links.defer_hook); in device_initialize()
2432 dev->links.status = DL_DEV_NO_DRIVER; in device_initialize()
2442 &devices_kset->kobj); in virtual_device_parent()
2464 return dir->class->ns_type; in class_dir_child_ns_type()
2481 return ERR_PTR(-ENOMEM); in class_dir_create_and_add()
2483 dir->class = class; in class_dir_create_and_add()
2484 kobject_init(&dir->kobj, &class_dir_ktype); in class_dir_create_and_add()
2486 dir->kobj.kset = &class->p->glue_dirs; in class_dir_create_and_add()
2488 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); in class_dir_create_and_add()
2490 kobject_put(&dir->kobj); in class_dir_create_and_add()
2493 return &dir->kobj; in class_dir_create_and_add()
2501 if (dev->class) { in get_device_parent()
2508 if (sysfs_deprecated && dev->class == &block_class) { in get_device_parent()
2509 if (parent && parent->class == &block_class) in get_device_parent()
2510 return &parent->kobj; in get_device_parent()
2511 return &block_class.p->subsys.kobj; in get_device_parent()
2517 * Class-devices with a non class-device as parent, live in get_device_parent()
2522 else if (parent->class && !dev->class->ns_type) in get_device_parent()
2523 return &parent->kobj; in get_device_parent()
2525 parent_kobj = &parent->kobj; in get_device_parent()
2529 /* find our class-directory at the parent and reference it */ in get_device_parent()
2530 spin_lock(&dev->class->p->glue_dirs.list_lock); in get_device_parent()
2531 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) in get_device_parent()
2532 if (k->parent == parent_kobj) { in get_device_parent()
2536 spin_unlock(&dev->class->p->glue_dirs.list_lock); in get_device_parent()
2542 /* or create a new class-directory at the parent device */ in get_device_parent()
2543 k = class_dir_create_and_add(dev->class, parent_kobj); in get_device_parent()
2550 if (!parent && dev->bus && dev->bus->dev_root) in get_device_parent()
2551 return &dev->bus->dev_root->kobj; in get_device_parent()
2554 return &parent->kobj; in get_device_parent()
2561 if (!kobj || !dev->class || in live_in_glue_dir()
2562 kobj->kset != &dev->class->p->glue_dirs) in live_in_glue_dir()
2569 return dev->kobj.parent; in get_glue_dir()
2612 * sysfs_remove_dir() // glue_dir->sd=NULL in cleanup_glue_dir()
2613 * sysfs_put() // free glue_dir->sd in cleanup_glue_dir()
2625 * and sysfs_put(). This result in glue_dir->sd is freed. in cleanup_glue_dir()
2634 ref = kref_read(&glue_dir->kref); in cleanup_glue_dir()
2635 if (!kobject_has_children(glue_dir) && !--ref) in cleanup_glue_dir()
2647 error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); in device_add_class_symlinks()
2653 if (!dev->class) in device_add_class_symlinks()
2656 error = sysfs_create_link(&dev->kobj, in device_add_class_symlinks()
2657 &dev->class->p->subsys.kobj, in device_add_class_symlinks()
2662 if (dev->parent && device_is_not_partition(dev)) { in device_add_class_symlinks()
2663 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, in device_add_class_symlinks()
2671 if (sysfs_deprecated && dev->class == &block_class) in device_add_class_symlinks()
2676 error = sysfs_create_link(&dev->class->p->subsys.kobj, in device_add_class_symlinks()
2677 &dev->kobj, dev_name(dev)); in device_add_class_symlinks()
2684 sysfs_remove_link(&dev->kobj, "device"); in device_add_class_symlinks()
2687 sysfs_remove_link(&dev->kobj, "subsystem"); in device_add_class_symlinks()
2689 sysfs_remove_link(&dev->kobj, "of_node"); in device_add_class_symlinks()
2696 sysfs_remove_link(&dev->kobj, "of_node"); in device_remove_class_symlinks()
2698 if (!dev->class) in device_remove_class_symlinks()
2701 if (dev->parent && device_is_not_partition(dev)) in device_remove_class_symlinks()
2702 sysfs_remove_link(&dev->kobj, "device"); in device_remove_class_symlinks()
2703 sysfs_remove_link(&dev->kobj, "subsystem"); in device_remove_class_symlinks()
2705 if (sysfs_deprecated && dev->class == &block_class) in device_remove_class_symlinks()
2708 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); in device_remove_class_symlinks()
2712 * dev_set_name - set a device name
2722 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); in dev_set_name()
2729 * device_to_dev_kobj - select a /sys/dev/ directory for the device
2732 * By default we select char/ for new entries. Setting class->dev_obj
2733 * to NULL prevents an entry from being created. class->dev_kobj must
2743 if (dev->class) in device_to_dev_kobj()
2744 kobj = dev->class->dev_kobj; in device_to_dev_kobj()
2758 format_dev_t(devt_str, dev->devt); in device_create_sys_dev_entry()
2759 error = sysfs_create_link(kobj, &dev->kobj, devt_str); in device_create_sys_dev_entry()
2771 format_dev_t(devt_str, dev->devt); in device_remove_sys_dev_entry()
2778 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); in device_private_init()
2779 if (!dev->p) in device_private_init()
2780 return -ENOMEM; in device_private_init()
2781 dev->p->device = dev; in device_private_init()
2782 klist_init(&dev->p->klist_children, klist_children_get, in device_private_init()
2784 INIT_LIST_HEAD(&dev->p->deferred_probe); in device_private_init()
2789 * device_add - add device to device hierarchy.
2820 int error = -EINVAL; in device_add()
2827 if (!dev->p) { in device_add()
2838 if (dev->init_name) { in device_add()
2839 dev_set_name(dev, "%s", dev->init_name); in device_add()
2840 dev->init_name = NULL; in device_add()
2844 if (!dev_name(dev) && dev->bus && dev->bus->dev_name) in device_add()
2845 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); in device_add()
2848 error = -EINVAL; in device_add()
2854 parent = get_device(dev->parent); in device_add()
2861 dev->kobj.parent = kobj; in device_add()
2869 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); in device_add()
2898 if (MAJOR(dev->devt)) { in device_add()
2913 if (dev->bus) in device_add()
2914 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, in device_add()
2917 kobject_uevent(&dev->kobj, KOBJ_ADD); in device_add()
2931 if (dev->fwnode && !dev->fwnode->dev) { in device_add()
2932 dev->fwnode->dev = dev; in device_add()
2938 klist_add_tail(&dev->p->knode_parent, in device_add()
2939 &parent->p->klist_children); in device_add()
2941 if (dev->class) { in device_add()
2942 mutex_lock(&dev->class->p->mutex); in device_add()
2944 klist_add_tail(&dev->p->knode_class, in device_add()
2945 &dev->class->p->klist_devices); in device_add()
2949 &dev->class->p->interfaces, node) in device_add()
2950 if (class_intf->add_dev) in device_add()
2951 class_intf->add_dev(dev, class_intf); in device_add()
2952 mutex_unlock(&dev->class->p->mutex); in device_add()
2958 if (MAJOR(dev->devt)) in device_add()
2974 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_add()
2976 kobject_del(&dev->kobj); in device_add()
2982 kfree(dev->p); in device_add()
2983 dev->p = NULL; in device_add()
2989 * device_register - register a device with the system.
2992 * This happens in two clean steps - initialize the device
3014 * get_device - increment reference count for device.
3023 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; in get_device()
3028 * put_device - decrement reference count.
3035 kobject_put(&dev->kobj); in put_device()
3048 lockdep_assert_held(&dev->mutex); in kill_device()
3050 if (dev->p->dead) in kill_device()
3052 dev->p->dead = true; in kill_device()
3058 * device_del - delete device from system.
3072 struct device *parent = dev->parent; in device_del()
3081 if (dev->fwnode && dev->fwnode->dev == dev) in device_del()
3082 dev->fwnode->dev = NULL; in device_del()
3088 if (dev->bus) in device_del()
3089 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, in device_del()
3094 klist_del(&dev->p->knode_parent); in device_del()
3095 if (MAJOR(dev->devt)) { in device_del()
3100 if (dev->class) { in device_del()
3103 mutex_lock(&dev->class->p->mutex); in device_del()
3106 &dev->class->p->interfaces, node) in device_del()
3107 if (class_intf->remove_dev) in device_del()
3108 class_intf->remove_dev(dev, class_intf); in device_del()
3110 klist_del(&dev->p->knode_class); in device_del()
3111 mutex_unlock(&dev->class->p->mutex); in device_del()
3122 if (dev->bus) in device_del()
3123 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, in device_del()
3125 kobject_uevent(&dev->kobj, KOBJ_REMOVE); in device_del()
3127 kobject_del(&dev->kobj); in device_del()
3135 * device_unregister - unregister device from system.
3161 dev = p->device; in prev_device()
3174 dev = p->device; in next_device()
3180 * device_get_devnode - path of device node file
3188 * Non-default names may need to allocate a memory to compose
3201 if (dev->type && dev->type->devnode) in device_get_devnode()
3202 *tmp = dev->type->devnode(dev, mode, uid, gid); in device_get_devnode()
3207 if (dev->class && dev->class->devnode) in device_get_devnode()
3208 *tmp = dev->class->devnode(dev, mode); in device_get_devnode()
3225 * device_for_each_child - device child iterator.
3243 if (!parent->p) in device_for_each_child()
3246 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child()
3255 * device_for_each_child_reverse - device child iterator in reversed order.
3273 if (!parent->p) in device_for_each_child_reverse()
3276 klist_iter_init(&parent->p->klist_children, &i); in device_for_each_child_reverse()
3285 * device_find_child - device iterator for locating a particular device.
3294 * The callback should return 0 if the device doesn't match and non-zero
3295 * if it does. If the callback returns non-zero and a reference to the
3310 klist_iter_init(&parent->p->klist_children, &i); in device_find_child()
3320 * device_find_child_by_name - device iterator for locating a child device.
3338 klist_iter_init(&parent->p->klist_children, &i); in device_find_child_by_name()
3351 return -ENOMEM; in devices_init()
3370 return -ENOMEM; in devices_init()
3381 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; in device_check_offline()
3385 * device_offline - Prepare the device for hot-removal.
3389 * the device for a subsequent hot-removal. If that succeeds, the device must
3399 if (dev->offline_disabled) in device_offline()
3400 return -EPERM; in device_offline()
3408 if (dev->offline) { in device_offline()
3411 ret = dev->bus->offline(dev); in device_offline()
3413 kobject_uevent(&dev->kobj, KOBJ_OFFLINE); in device_offline()
3414 dev->offline = true; in device_offline()
3424 * device_online - Put the device back online after successful device_offline().
3439 if (dev->offline) { in device_online()
3440 ret = dev->bus->online(dev); in device_online()
3442 kobject_uevent(&dev->kobj, KOBJ_ONLINE); in device_online()
3443 dev->offline = false; in device_online()
3470 * __root_device_register - allocate and register a root device
3494 int err = -ENOMEM; in __root_device_register()
3500 err = dev_set_name(&root->dev, "%s", name); in __root_device_register()
3506 root->dev.release = root_device_release; in __root_device_register()
3508 err = device_register(&root->dev); in __root_device_register()
3510 put_device(&root->dev); in __root_device_register()
3516 struct module_kobject *mk = &owner->mkobj; in __root_device_register()
3518 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); in __root_device_register()
3520 device_unregister(&root->dev); in __root_device_register()
3523 root->owner = owner; in __root_device_register()
3527 return &root->dev; in __root_device_register()
3532 * root_device_unregister - unregister and free a root device
3542 if (root->owner) in root_device_unregister()
3543 sysfs_remove_link(&root->dev.kobj, "module"); in root_device_unregister()
3563 int retval = -ENODEV; in device_create_groups_vargs()
3570 retval = -ENOMEM; in device_create_groups_vargs()
3575 dev->devt = devt; in device_create_groups_vargs()
3576 dev->class = class; in device_create_groups_vargs()
3577 dev->parent = parent; in device_create_groups_vargs()
3578 dev->groups = groups; in device_create_groups_vargs()
3579 dev->release = device_create_release; in device_create_groups_vargs()
3582 retval = kobject_set_name_vargs(&dev->kobj, fmt, args); in device_create_groups_vargs()
3598 * device_create - creates a device and registers it with sysfs
3636 * device_create_with_groups - creates a device and registers it with sysfs
3641 * @groups: NULL-terminated list of attribute groups to be created
3680 * device_destroy - removes a device that was created with device_create()
3700 * device_rename - renames a device
3720 * renamed it -- then you get events for the same DEVPATH, before you even see
3723 * other things than (driver-core wise very simple) network devices.
3728 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
3729 * be allowed to some other name than eth[0-9]*, for the aforementioned
3734 * symlinks -- but never rename kernel devices later, it's a complete mess. We
3740 struct kobject *kobj = &dev->kobj; in device_rename()
3746 return -EINVAL; in device_rename()
3752 error = -ENOMEM; in device_rename()
3756 if (dev->class) { in device_rename()
3757 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, in device_rename()
3784 sysfs_remove_link(&dev->kobj, "device"); in device_move_class_links()
3786 error = sysfs_create_link(&dev->kobj, &new_parent->kobj, in device_move_class_links()
3792 * device_move - moves a device to a new parent
3806 return -EINVAL; in device_move()
3819 error = kobject_move(&dev->kobj, new_parent_kobj); in device_move()
3825 old_parent = dev->parent; in device_move()
3826 dev->parent = new_parent; in device_move()
3828 klist_remove(&dev->p->knode_parent); in device_move()
3830 klist_add_tail(&dev->p->knode_parent, in device_move()
3831 &new_parent->p->klist_children); in device_move()
3835 if (dev->class) { in device_move()
3840 if (!kobject_move(&dev->kobj, &old_parent->kobj)) { in device_move()
3842 klist_remove(&dev->p->knode_parent); in device_move()
3843 dev->parent = old_parent; in device_move()
3845 klist_add_tail(&dev->p->knode_parent, in device_move()
3846 &old_parent->p->klist_children); in device_move()
3883 struct kobject *kobj = &dev->kobj; in device_attrs_change_owner()
3884 struct class *class = dev->class; in device_attrs_change_owner()
3885 const struct device_type *type = dev->type; in device_attrs_change_owner()
3893 error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, in device_attrs_change_owner()
3904 error = sysfs_groups_change_owner(kobj, type->groups, kuid, in device_attrs_change_owner()
3911 error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); in device_attrs_change_owner()
3915 if (device_supports_offline(dev) && !dev->offline_disabled) { in device_attrs_change_owner()
3927 * device_change_owner - change the owner of an existing device.
3941 struct kobject *kobj = &dev->kobj; in device_change_owner()
3945 return -EINVAL; in device_change_owner()
3979 if (sysfs_deprecated && dev->class == &block_class) in device_change_owner()
3989 error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, in device_change_owner()
4001 * device_shutdown - call ->shutdown() on each device to shutdown.
4012 spin_lock(&devices_kset->list_lock); in device_shutdown()
4018 while (!list_empty(&devices_kset->list)) { in device_shutdown()
4019 dev = list_entry(devices_kset->list.prev, struct device, in device_shutdown()
4027 parent = get_device(dev->parent); in device_shutdown()
4031 * event that dev->*->shutdown() doesn't remove it. in device_shutdown()
4033 list_del_init(&dev->kobj.entry); in device_shutdown()
4034 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4045 if (dev->class && dev->class->shutdown_pre) { in device_shutdown()
4048 dev->class->shutdown_pre(dev); in device_shutdown()
4050 if (dev->bus && dev->bus->shutdown) { in device_shutdown()
4053 dev->bus->shutdown(dev); in device_shutdown()
4054 } else if (dev->driver && dev->driver->shutdown) { in device_shutdown()
4057 dev->driver->shutdown(dev); in device_shutdown()
4067 spin_lock(&devices_kset->list_lock); in device_shutdown()
4069 spin_unlock(&devices_kset->list_lock); in device_shutdown()
4084 if (dev->class) in set_dev_info()
4085 subsys = dev->class->name; in set_dev_info()
4086 else if (dev->bus) in set_dev_info()
4087 subsys = dev->bus->name; in set_dev_info()
4091 strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); in set_dev_info()
4100 if (MAJOR(dev->devt)) { in set_dev_info()
4108 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4109 "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); in set_dev_info()
4113 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4114 "n%u", net->ifindex); in set_dev_info()
4116 snprintf(dev_info->device, sizeof(dev_info->device), in set_dev_info()
4151 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", in __dev_printk()
4202 * dev_err_probe - probe error check and log helper
4205 * @fmt: printf-style format string
4210 * -EPROBE_DEFER and propagate error upwards.
4211 * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
4215 * if (err != -EPROBE_DEFER)
4237 if (err != -EPROBE_DEFER) { in dev_err_probe()
4252 return fwnode && !IS_ERR(fwnode->secondary); in fwnode_is_primary()
4256 * set_primary_fwnode - Change the primary firmware node of a given device.
4265 struct device *parent = dev->parent; in set_primary_fwnode()
4266 struct fwnode_handle *fn = dev->fwnode; in set_primary_fwnode()
4270 fn = fn->secondary; in set_primary_fwnode()
4273 WARN_ON(fwnode->secondary); in set_primary_fwnode()
4274 fwnode->secondary = fn; in set_primary_fwnode()
4276 dev->fwnode = fwnode; in set_primary_fwnode()
4279 dev->fwnode = fn->secondary; in set_primary_fwnode()
4280 if (!(parent && fn == parent->fwnode)) in set_primary_fwnode()
4281 fn->secondary = ERR_PTR(-ENODEV); in set_primary_fwnode()
4283 dev->fwnode = NULL; in set_primary_fwnode()
4290 * set_secondary_fwnode - Change the secondary firmware node of a given device.
4301 fwnode->secondary = ERR_PTR(-ENODEV); in set_secondary_fwnode()
4303 if (fwnode_is_primary(dev->fwnode)) in set_secondary_fwnode()
4304 dev->fwnode->secondary = fwnode; in set_secondary_fwnode()
4306 dev->fwnode = fwnode; in set_secondary_fwnode()
4311 * device_set_of_node_from_dev - reuse device-tree node of another device
4312 * @dev: device whose device-tree node is being set
4313 * @dev2: device whose device-tree node is being reused
4315 * Takes another reference to the new device-tree node after first dropping
4320 of_node_put(dev->of_node); in device_set_of_node_from_dev()
4321 dev->of_node = of_node_get(dev2->of_node); in device_set_of_node_from_dev()
4322 dev->of_node_reused = true; in device_set_of_node_from_dev()
4334 return dev->of_node == np; in device_match_of_node()
4346 return dev->devt == *(dev_t *)pdevt; in device_match_devt()