1989d42e8SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * drivers/base/core.c - core driver model code (device registration, etc) 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright (c) 2002-3 Patrick Mochel 61da177e4SLinus Torvalds * Copyright (c) 2002-3 Open Source Development Labs 764bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 864bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Novell, Inc. 91da177e4SLinus Torvalds */ 101da177e4SLinus Torvalds 117847a145SHeikki Krogerus #include <linux/acpi.h> 1265650b35SRafael J. Wysocki #include <linux/cpufreq.h> 131da177e4SLinus Torvalds #include <linux/device.h> 141da177e4SLinus Torvalds #include <linux/err.h> 1597badf87SRafael J. Wysocki #include <linux/fwnode.h> 161da177e4SLinus Torvalds #include <linux/init.h> 1773060022SChristophe JAILLET #include <linux/kstrtox.h> 181da177e4SLinus Torvalds #include <linux/module.h> 191da177e4SLinus Torvalds #include <linux/slab.h> 201da177e4SLinus Torvalds #include <linux/string.h> 2123681e47SGreg Kroah-Hartman #include <linux/kdev_t.h> 22116af378SBenjamin Herrenschmidt #include <linux/notifier.h> 2307d57a32SGrant Likely #include <linux/of.h> 2407d57a32SGrant Likely #include <linux/of_device.h> 25322cbb50SChristoph Hellwig #include <linux/blkdev.h> 26f75b1c60SDave Young #include <linux/mutex.h> 27af8db150SPeter Chen #include <linux/pm_runtime.h> 28c4e00daaSKay Sievers #include <linux/netdevice.h> 29174cd4b1SIngo Molnar #include <linux/sched/signal.h> 30b8530017SOliver Neukum #include <linux/sched/mm.h> 3169031f50SClaire Chang #include <linux/swiotlb.h> 3263967685SGreg Kroah-Hartman #include <linux/sysfs.h> 336d4e9a8eSChristoph Hellwig #include <linux/dma-map-ops.h> /* for dma_default_coherent */ 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include "base.h" 366423d295SWon Chung #include "physical_location.h" 371da177e4SLinus Torvalds #include "power/power.h" 381da177e4SLinus Torvalds 39e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 40e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 41e52eec13SAndi Kleen long sysfs_deprecated = 1; 42e52eec13SAndi Kleen #else 43e52eec13SAndi Kleen long sysfs_deprecated = 0; 44e52eec13SAndi Kleen #endif 453454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 46e52eec13SAndi Kleen { 4734da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 48e52eec13SAndi Kleen } 49e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 50e52eec13SAndi Kleen #endif 51e52eec13SAndi Kleen 529ed98953SRafael J. Wysocki /* Device links support. */ 53fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 54fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 557b337cb3SSaravana Kannan static DEFINE_MUTEX(fwnode_link_lock); 5625ac86c6SSaravana Kannan static bool fw_devlink_is_permissive(void); 573a2dbc51SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev); 58d46f3e3eSSaravana Kannan static bool fw_devlink_drv_reg_done; 592f8c3ae8SSaravana Kannan static bool fw_devlink_best_effort; 607b337cb3SSaravana Kannan 617b337cb3SSaravana Kannan /** 623a2dbc51SSaravana Kannan * __fwnode_link_add - Create a link between two fwnode_handles. 637b337cb3SSaravana Kannan * @con: Consumer end of the link. 647b337cb3SSaravana Kannan * @sup: Supplier end of the link. 657b337cb3SSaravana Kannan * 667b337cb3SSaravana Kannan * Create a fwnode link between fwnode handles @con and @sup. The fwnode link 677b337cb3SSaravana Kannan * represents the detail that the firmware lists @sup fwnode as supplying a 687b337cb3SSaravana Kannan * resource to @con. 697b337cb3SSaravana Kannan * 707b337cb3SSaravana Kannan * The driver core will use the fwnode link to create a device link between the 717b337cb3SSaravana Kannan * two device objects corresponding to @con and @sup when they are created. The 727b337cb3SSaravana Kannan * driver core will automatically delete the fwnode link between @con and @sup 737b337cb3SSaravana Kannan * after doing that. 747b337cb3SSaravana Kannan * 757b337cb3SSaravana Kannan * Attempts to create duplicate links between the same pair of fwnode handles 767b337cb3SSaravana Kannan * are ignored and there is no reference counting. 777b337cb3SSaravana Kannan */ 783a2dbc51SSaravana Kannan static int __fwnode_link_add(struct fwnode_handle *con, 793a2dbc51SSaravana Kannan struct fwnode_handle *sup) 807b337cb3SSaravana Kannan { 817b337cb3SSaravana Kannan struct fwnode_link *link; 827b337cb3SSaravana Kannan 837b337cb3SSaravana Kannan list_for_each_entry(link, &sup->consumers, s_hook) 847b337cb3SSaravana Kannan if (link->consumer == con) 853a2dbc51SSaravana Kannan return 0; 867b337cb3SSaravana Kannan 877b337cb3SSaravana Kannan link = kzalloc(sizeof(*link), GFP_KERNEL); 883a2dbc51SSaravana Kannan if (!link) 893a2dbc51SSaravana Kannan return -ENOMEM; 907b337cb3SSaravana Kannan 917b337cb3SSaravana Kannan link->supplier = sup; 927b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->s_hook); 937b337cb3SSaravana Kannan link->consumer = con; 947b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->c_hook); 957b337cb3SSaravana Kannan 967b337cb3SSaravana Kannan list_add(&link->s_hook, &sup->consumers); 977b337cb3SSaravana Kannan list_add(&link->c_hook, &con->suppliers); 98ebd6823aSSaravana Kannan pr_debug("%pfwP Linked as a fwnode consumer to %pfwP\n", 99ebd6823aSSaravana Kannan con, sup); 1007b337cb3SSaravana Kannan 1013a2dbc51SSaravana Kannan return 0; 1023a2dbc51SSaravana Kannan } 1033a2dbc51SSaravana Kannan 1043a2dbc51SSaravana Kannan int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup) 1053a2dbc51SSaravana Kannan { 1063a2dbc51SSaravana Kannan int ret; 1073a2dbc51SSaravana Kannan 1083a2dbc51SSaravana Kannan mutex_lock(&fwnode_link_lock); 1093a2dbc51SSaravana Kannan ret = __fwnode_link_add(con, sup); 1103a2dbc51SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1117b337cb3SSaravana Kannan return ret; 1127b337cb3SSaravana Kannan } 1137b337cb3SSaravana Kannan 1147b337cb3SSaravana Kannan /** 11576f13081SSaravana Kannan * __fwnode_link_del - Delete a link between two fwnode_handles. 11676f13081SSaravana Kannan * @link: the fwnode_link to be deleted 11776f13081SSaravana Kannan * 11876f13081SSaravana Kannan * The fwnode_link_lock needs to be held when this function is called. 11976f13081SSaravana Kannan */ 12076f13081SSaravana Kannan static void __fwnode_link_del(struct fwnode_link *link) 12176f13081SSaravana Kannan { 122ebd6823aSSaravana Kannan pr_debug("%pfwP Dropping the fwnode link to %pfwP\n", 123ebd6823aSSaravana Kannan link->consumer, link->supplier); 12476f13081SSaravana Kannan list_del(&link->s_hook); 12576f13081SSaravana Kannan list_del(&link->c_hook); 12676f13081SSaravana Kannan kfree(link); 12776f13081SSaravana Kannan } 12876f13081SSaravana Kannan 12976f13081SSaravana Kannan /** 1307b337cb3SSaravana Kannan * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle. 1317b337cb3SSaravana Kannan * @fwnode: fwnode whose supplier links need to be deleted 1327b337cb3SSaravana Kannan * 1337b337cb3SSaravana Kannan * Deletes all supplier links connecting directly to @fwnode. 1347b337cb3SSaravana Kannan */ 1357b337cb3SSaravana Kannan static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode) 1367b337cb3SSaravana Kannan { 1377b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1387b337cb3SSaravana Kannan 1397b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 14076f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) 14176f13081SSaravana Kannan __fwnode_link_del(link); 1427b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1437b337cb3SSaravana Kannan } 1447b337cb3SSaravana Kannan 1457b337cb3SSaravana Kannan /** 1467b337cb3SSaravana Kannan * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle. 1477b337cb3SSaravana Kannan * @fwnode: fwnode whose consumer links need to be deleted 1487b337cb3SSaravana Kannan * 1497b337cb3SSaravana Kannan * Deletes all consumer links connecting directly to @fwnode. 1507b337cb3SSaravana Kannan */ 1517b337cb3SSaravana Kannan static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode) 1527b337cb3SSaravana Kannan { 1537b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1547b337cb3SSaravana Kannan 1557b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 15676f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) 15776f13081SSaravana Kannan __fwnode_link_del(link); 1587b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1597b337cb3SSaravana Kannan } 1607b337cb3SSaravana Kannan 1617b337cb3SSaravana Kannan /** 1627b337cb3SSaravana Kannan * fwnode_links_purge - Delete all links connected to a fwnode_handle. 1637b337cb3SSaravana Kannan * @fwnode: fwnode whose links needs to be deleted 1647b337cb3SSaravana Kannan * 1657b337cb3SSaravana Kannan * Deletes all links connecting directly to a fwnode. 1667b337cb3SSaravana Kannan */ 1677b337cb3SSaravana Kannan void fwnode_links_purge(struct fwnode_handle *fwnode) 1687b337cb3SSaravana Kannan { 1697b337cb3SSaravana Kannan fwnode_links_purge_suppliers(fwnode); 1707b337cb3SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1717b337cb3SSaravana Kannan } 1729ed98953SRafael J. Wysocki 17328ec344bSSaravana Kannan void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode) 1749528e0d9SSaravana Kannan { 1759528e0d9SSaravana Kannan struct fwnode_handle *child; 1769528e0d9SSaravana Kannan 1779528e0d9SSaravana Kannan /* Don't purge consumer links of an added child */ 1789528e0d9SSaravana Kannan if (fwnode->dev) 1799528e0d9SSaravana Kannan return; 1809528e0d9SSaravana Kannan 1819528e0d9SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; 1829528e0d9SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1839528e0d9SSaravana Kannan 1849528e0d9SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child) 1859528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 1869528e0d9SSaravana Kannan } 18728ec344bSSaravana Kannan EXPORT_SYMBOL_GPL(fw_devlink_purge_absent_suppliers); 1889528e0d9SSaravana Kannan 1893a2dbc51SSaravana Kannan /** 1903a2dbc51SSaravana Kannan * __fwnode_links_move_consumers - Move consumer from @from to @to fwnode_handle 1913a2dbc51SSaravana Kannan * @from: move consumers away from this fwnode 1923a2dbc51SSaravana Kannan * @to: move consumers to this fwnode 1933a2dbc51SSaravana Kannan * 1943a2dbc51SSaravana Kannan * Move all consumer links from @from fwnode to @to fwnode. 1953a2dbc51SSaravana Kannan */ 1963a2dbc51SSaravana Kannan static void __fwnode_links_move_consumers(struct fwnode_handle *from, 1973a2dbc51SSaravana Kannan struct fwnode_handle *to) 1983a2dbc51SSaravana Kannan { 1993a2dbc51SSaravana Kannan struct fwnode_link *link, *tmp; 2003a2dbc51SSaravana Kannan 2013a2dbc51SSaravana Kannan list_for_each_entry_safe(link, tmp, &from->consumers, s_hook) { 2023a2dbc51SSaravana Kannan __fwnode_link_add(link->consumer, to); 2033a2dbc51SSaravana Kannan __fwnode_link_del(link); 2043a2dbc51SSaravana Kannan } 2053a2dbc51SSaravana Kannan } 2063a2dbc51SSaravana Kannan 2073a2dbc51SSaravana Kannan /** 2083a2dbc51SSaravana Kannan * __fw_devlink_pickup_dangling_consumers - Pick up dangling consumers 2093a2dbc51SSaravana Kannan * @fwnode: fwnode from which to pick up dangling consumers 2103a2dbc51SSaravana Kannan * @new_sup: fwnode of new supplier 2113a2dbc51SSaravana Kannan * 2123a2dbc51SSaravana Kannan * If the @fwnode has a corresponding struct device and the device supports 2133a2dbc51SSaravana Kannan * probing (that is, added to a bus), then we want to let fw_devlink create 2143a2dbc51SSaravana Kannan * MANAGED device links to this device, so leave @fwnode and its descendant's 2153a2dbc51SSaravana Kannan * fwnode links alone. 2163a2dbc51SSaravana Kannan * 2173a2dbc51SSaravana Kannan * Otherwise, move its consumers to the new supplier @new_sup. 2183a2dbc51SSaravana Kannan */ 2193a2dbc51SSaravana Kannan static void __fw_devlink_pickup_dangling_consumers(struct fwnode_handle *fwnode, 2203a2dbc51SSaravana Kannan struct fwnode_handle *new_sup) 2213a2dbc51SSaravana Kannan { 2223a2dbc51SSaravana Kannan struct fwnode_handle *child; 2233a2dbc51SSaravana Kannan 2243a2dbc51SSaravana Kannan if (fwnode->dev && fwnode->dev->bus) 2253a2dbc51SSaravana Kannan return; 2263a2dbc51SSaravana Kannan 2273a2dbc51SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; 2283a2dbc51SSaravana Kannan __fwnode_links_move_consumers(fwnode, new_sup); 2293a2dbc51SSaravana Kannan 2303a2dbc51SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child) 2313a2dbc51SSaravana Kannan __fw_devlink_pickup_dangling_consumers(child, new_sup); 2323a2dbc51SSaravana Kannan } 2333a2dbc51SSaravana Kannan 2349ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 2359ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 2369ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 2379ed98953SRafael J. Wysocki 2389ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 2399ed98953SRafael J. Wysocki { 2409ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 2419ed98953SRafael J. Wysocki } 2429ed98953SRafael J. Wysocki 2439ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 2449ed98953SRafael J. Wysocki { 2459ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 2469ed98953SRafael J. Wysocki } 2479ed98953SRafael J. Wysocki 24868464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 2499ed98953SRafael J. Wysocki { 2509ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 2519ed98953SRafael J. Wysocki } 2529ed98953SRafael J. Wysocki 253ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 2549ed98953SRafael J. Wysocki { 2559ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 2569ed98953SRafael J. Wysocki } 257c2fa1e1bSJoel Fernandes (Google) 258c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 259c2fa1e1bSJoel Fernandes (Google) { 260c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 261c2fa1e1bSJoel Fernandes (Google) } 26280dd33cfSRafael J. Wysocki 26380dd33cfSRafael J. Wysocki static void device_link_synchronize_removal(void) 26480dd33cfSRafael J. Wysocki { 26580dd33cfSRafael J. Wysocki synchronize_srcu(&device_links_srcu); 26680dd33cfSRafael J. Wysocki } 2670c871315SRafael J. Wysocki 2680c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link) 2690c871315SRafael J. Wysocki { 2700c871315SRafael J. Wysocki list_del_rcu(&link->s_node); 2710c871315SRafael J. Wysocki list_del_rcu(&link->c_node); 2720c871315SRafael J. Wysocki } 2739ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 2749ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 2759ed98953SRafael J. Wysocki 2769ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 2779ed98953SRafael J. Wysocki { 2789ed98953SRafael J. Wysocki down_write(&device_links_lock); 2799ed98953SRafael J. Wysocki } 2809ed98953SRafael J. Wysocki 2819ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 2829ed98953SRafael J. Wysocki { 2839ed98953SRafael J. Wysocki up_write(&device_links_lock); 2849ed98953SRafael J. Wysocki } 2859ed98953SRafael J. Wysocki 2869ed98953SRafael J. Wysocki int device_links_read_lock(void) 2879ed98953SRafael J. Wysocki { 2889ed98953SRafael J. Wysocki down_read(&device_links_lock); 2899ed98953SRafael J. Wysocki return 0; 2909ed98953SRafael J. Wysocki } 2919ed98953SRafael J. Wysocki 2929ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 2939ed98953SRafael J. Wysocki { 2949ed98953SRafael J. Wysocki up_read(&device_links_lock); 2959ed98953SRafael J. Wysocki } 296c2fa1e1bSJoel Fernandes (Google) 297c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 298c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 299c2fa1e1bSJoel Fernandes (Google) { 300c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 301c2fa1e1bSJoel Fernandes (Google) } 302c2fa1e1bSJoel Fernandes (Google) #endif 30380dd33cfSRafael J. Wysocki 30480dd33cfSRafael J. Wysocki static inline void device_link_synchronize_removal(void) 30580dd33cfSRafael J. Wysocki { 30680dd33cfSRafael J. Wysocki } 3070c871315SRafael J. Wysocki 3080c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link) 3090c871315SRafael J. Wysocki { 3100c871315SRafael J. Wysocki list_del(&link->s_node); 3110c871315SRafael J. Wysocki list_del(&link->c_node); 3120c871315SRafael J. Wysocki } 3139ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 3149ed98953SRafael J. Wysocki 3153d1cf435SRafael J. Wysocki static bool device_is_ancestor(struct device *dev, struct device *target) 3163d1cf435SRafael J. Wysocki { 3173d1cf435SRafael J. Wysocki while (target->parent) { 3183d1cf435SRafael J. Wysocki target = target->parent; 3193d1cf435SRafael J. Wysocki if (dev == target) 3203d1cf435SRafael J. Wysocki return true; 3213d1cf435SRafael J. Wysocki } 3223d1cf435SRafael J. Wysocki return false; 3233d1cf435SRafael J. Wysocki } 3243d1cf435SRafael J. Wysocki 3259ed98953SRafael J. Wysocki /** 3269ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 3279ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 3289ed98953SRafael J. Wysocki * @target: Device to check against. 3299ed98953SRafael J. Wysocki * 3309ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 3319ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 3329ed98953SRafael J. Wysocki */ 3337d34ca38SSaravana Kannan int device_is_dependent(struct device *dev, void *target) 3349ed98953SRafael J. Wysocki { 3359ed98953SRafael J. Wysocki struct device_link *link; 3369ed98953SRafael J. Wysocki int ret; 3379ed98953SRafael J. Wysocki 3383d1cf435SRafael J. Wysocki /* 3393d1cf435SRafael J. Wysocki * The "ancestors" check is needed to catch the case when the target 3403d1cf435SRafael J. Wysocki * device has not been completely initialized yet and it is still 3413d1cf435SRafael J. Wysocki * missing from the list of children of its parent device. 3423d1cf435SRafael J. Wysocki */ 3433d1cf435SRafael J. Wysocki if (dev == target || device_is_ancestor(dev, target)) 3449ed98953SRafael J. Wysocki return 1; 3459ed98953SRafael J. Wysocki 3469ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 3479ed98953SRafael J. Wysocki if (ret) 3489ed98953SRafael J. Wysocki return ret; 3499ed98953SRafael J. Wysocki 3509ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 3514b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 3524b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 35305ef983eSSaravana Kannan continue; 35405ef983eSSaravana Kannan 355e16f4f3eSBenjamin Gaignard if (link->consumer == target) 3569ed98953SRafael J. Wysocki return 1; 3579ed98953SRafael J. Wysocki 3589ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 3599ed98953SRafael J. Wysocki if (ret) 3609ed98953SRafael J. Wysocki break; 3619ed98953SRafael J. Wysocki } 3629ed98953SRafael J. Wysocki return ret; 3639ed98953SRafael J. Wysocki } 3649ed98953SRafael J. Wysocki 365515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 366515db266SRafael J. Wysocki struct device *consumer, 367515db266SRafael J. Wysocki struct device *supplier) 368515db266SRafael J. Wysocki { 369515db266SRafael J. Wysocki switch (supplier->links.status) { 370515db266SRafael J. Wysocki case DL_DEV_PROBING: 371515db266SRafael J. Wysocki switch (consumer->links.status) { 372515db266SRafael J. Wysocki case DL_DEV_PROBING: 373515db266SRafael J. Wysocki /* 374515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 375515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 376515db266SRafael J. Wysocki * knows that the supplier is already functional (for 377515db266SRafael J. Wysocki * example, it has just acquired some resources from the 378515db266SRafael J. Wysocki * supplier). 379515db266SRafael J. Wysocki */ 380515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 381515db266SRafael J. Wysocki break; 382515db266SRafael J. Wysocki default: 383515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 384515db266SRafael J. Wysocki break; 385515db266SRafael J. Wysocki } 386515db266SRafael J. Wysocki break; 387515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 388515db266SRafael J. Wysocki switch (consumer->links.status) { 389515db266SRafael J. Wysocki case DL_DEV_PROBING: 390515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 391515db266SRafael J. Wysocki break; 392515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 393515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 394515db266SRafael J. Wysocki break; 395515db266SRafael J. Wysocki default: 396515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 397515db266SRafael J. Wysocki break; 398515db266SRafael J. Wysocki } 399515db266SRafael J. Wysocki break; 400515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 401515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 402515db266SRafael J. Wysocki break; 403515db266SRafael J. Wysocki default: 404515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 405515db266SRafael J. Wysocki break; 406515db266SRafael J. Wysocki } 407515db266SRafael J. Wysocki } 408515db266SRafael J. Wysocki 4099ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 4109ed98953SRafael J. Wysocki { 4119ed98953SRafael J. Wysocki struct device_link *link; 4129ed98953SRafael J. Wysocki 4139ed98953SRafael J. Wysocki /* 4149ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 4159ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 4169ed98953SRafael J. Wysocki */ 4179ed98953SRafael J. Wysocki if (device_is_registered(dev)) 4189ed98953SRafael J. Wysocki devices_kset_move_last(dev); 4199ed98953SRafael J. Wysocki 4209ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 4219ed98953SRafael J. Wysocki device_pm_move_last(dev); 4229ed98953SRafael J. Wysocki 4239ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 42405ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 4254b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 4264b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 42705ef983eSSaravana Kannan continue; 4289ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 42905ef983eSSaravana Kannan } 4309ed98953SRafael J. Wysocki 4319ed98953SRafael J. Wysocki return 0; 4329ed98953SRafael J. Wysocki } 4339ed98953SRafael J. Wysocki 4349ed98953SRafael J. Wysocki /** 435494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 436494fd7b7SFeng Kan * @dev: Device to move 437494fd7b7SFeng Kan * 438494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 439494fd7b7SFeng Kan * 440494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 441494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 442494fd7b7SFeng Kan */ 443494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 444494fd7b7SFeng Kan { 445494fd7b7SFeng Kan int idx; 446494fd7b7SFeng Kan 447494fd7b7SFeng Kan idx = device_links_read_lock(); 448494fd7b7SFeng Kan device_pm_lock(); 449494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 450494fd7b7SFeng Kan device_pm_unlock(); 451494fd7b7SFeng Kan device_links_read_unlock(idx); 452494fd7b7SFeng Kan } 453494fd7b7SFeng Kan 454287905e6SSaravana Kannan #define to_devlink(dev) container_of((dev), struct device_link, link_dev) 455287905e6SSaravana Kannan 456287905e6SSaravana Kannan static ssize_t status_show(struct device *dev, 457287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 458287905e6SSaravana Kannan { 459948b3edbSJoe Perches const char *output; 460287905e6SSaravana Kannan 461287905e6SSaravana Kannan switch (to_devlink(dev)->status) { 462287905e6SSaravana Kannan case DL_STATE_NONE: 463948b3edbSJoe Perches output = "not tracked"; 464948b3edbSJoe Perches break; 465287905e6SSaravana Kannan case DL_STATE_DORMANT: 466948b3edbSJoe Perches output = "dormant"; 467948b3edbSJoe Perches break; 468287905e6SSaravana Kannan case DL_STATE_AVAILABLE: 469948b3edbSJoe Perches output = "available"; 470948b3edbSJoe Perches break; 471287905e6SSaravana Kannan case DL_STATE_CONSUMER_PROBE: 472948b3edbSJoe Perches output = "consumer probing"; 473948b3edbSJoe Perches break; 474287905e6SSaravana Kannan case DL_STATE_ACTIVE: 475948b3edbSJoe Perches output = "active"; 476948b3edbSJoe Perches break; 477287905e6SSaravana Kannan case DL_STATE_SUPPLIER_UNBIND: 478948b3edbSJoe Perches output = "supplier unbinding"; 479948b3edbSJoe Perches break; 480287905e6SSaravana Kannan default: 481948b3edbSJoe Perches output = "unknown"; 482948b3edbSJoe Perches break; 483287905e6SSaravana Kannan } 484948b3edbSJoe Perches 485948b3edbSJoe Perches return sysfs_emit(buf, "%s\n", output); 486287905e6SSaravana Kannan } 487287905e6SSaravana Kannan static DEVICE_ATTR_RO(status); 488287905e6SSaravana Kannan 489287905e6SSaravana Kannan static ssize_t auto_remove_on_show(struct device *dev, 490287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 491287905e6SSaravana Kannan { 492287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 493973c3911SJoe Perches const char *output; 494287905e6SSaravana Kannan 495287905e6SSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 496973c3911SJoe Perches output = "supplier unbind"; 497287905e6SSaravana Kannan else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 498973c3911SJoe Perches output = "consumer unbind"; 499287905e6SSaravana Kannan else 500973c3911SJoe Perches output = "never"; 501287905e6SSaravana Kannan 502973c3911SJoe Perches return sysfs_emit(buf, "%s\n", output); 503287905e6SSaravana Kannan } 504287905e6SSaravana Kannan static DEVICE_ATTR_RO(auto_remove_on); 505287905e6SSaravana Kannan 506287905e6SSaravana Kannan static ssize_t runtime_pm_show(struct device *dev, 507287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 508287905e6SSaravana Kannan { 509287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 510287905e6SSaravana Kannan 511aa838896SJoe Perches return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); 512287905e6SSaravana Kannan } 513287905e6SSaravana Kannan static DEVICE_ATTR_RO(runtime_pm); 514287905e6SSaravana Kannan 515287905e6SSaravana Kannan static ssize_t sync_state_only_show(struct device *dev, 516287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 517287905e6SSaravana Kannan { 518287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 519287905e6SSaravana Kannan 520aa838896SJoe Perches return sysfs_emit(buf, "%d\n", 521aa838896SJoe Perches !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 522287905e6SSaravana Kannan } 523287905e6SSaravana Kannan static DEVICE_ATTR_RO(sync_state_only); 524287905e6SSaravana Kannan 525287905e6SSaravana Kannan static struct attribute *devlink_attrs[] = { 526287905e6SSaravana Kannan &dev_attr_status.attr, 527287905e6SSaravana Kannan &dev_attr_auto_remove_on.attr, 528287905e6SSaravana Kannan &dev_attr_runtime_pm.attr, 529287905e6SSaravana Kannan &dev_attr_sync_state_only.attr, 530287905e6SSaravana Kannan NULL, 531287905e6SSaravana Kannan }; 532287905e6SSaravana Kannan ATTRIBUTE_GROUPS(devlink); 533287905e6SSaravana Kannan 53480dd33cfSRafael J. Wysocki static void device_link_release_fn(struct work_struct *work) 535843e600bSSaravana Kannan { 53680dd33cfSRafael J. Wysocki struct device_link *link = container_of(work, struct device_link, rm_work); 53780dd33cfSRafael J. Wysocki 53880dd33cfSRafael J. Wysocki /* Ensure that all references to the link object have been dropped. */ 53980dd33cfSRafael J. Wysocki device_link_synchronize_removal(); 54080dd33cfSRafael J. Wysocki 54107358194SRafael J. Wysocki pm_runtime_release_supplier(link); 54288737106SRafael J. Wysocki /* 54388737106SRafael J. Wysocki * If supplier_preactivated is set, the link has been dropped between 54488737106SRafael J. Wysocki * the pm_runtime_get_suppliers() and pm_runtime_put_suppliers() calls 54588737106SRafael J. Wysocki * in __driver_probe_device(). In that case, drop the supplier's 54688737106SRafael J. Wysocki * PM-runtime usage counter to remove the reference taken by 54788737106SRafael J. Wysocki * pm_runtime_get_suppliers(). 54888737106SRafael J. Wysocki */ 54988737106SRafael J. Wysocki if (link->supplier_preactivated) 55088737106SRafael J. Wysocki pm_runtime_put_noidle(link->supplier); 55188737106SRafael J. Wysocki 55207358194SRafael J. Wysocki pm_request_idle(link->supplier); 553843e600bSSaravana Kannan 554843e600bSSaravana Kannan put_device(link->consumer); 555843e600bSSaravana Kannan put_device(link->supplier); 556843e600bSSaravana Kannan kfree(link); 557843e600bSSaravana Kannan } 558843e600bSSaravana Kannan 559287905e6SSaravana Kannan static void devlink_dev_release(struct device *dev) 560287905e6SSaravana Kannan { 561843e600bSSaravana Kannan struct device_link *link = to_devlink(dev); 562843e600bSSaravana Kannan 56380dd33cfSRafael J. Wysocki INIT_WORK(&link->rm_work, device_link_release_fn); 56480dd33cfSRafael J. Wysocki /* 56580dd33cfSRafael J. Wysocki * It may take a while to complete this work because of the SRCU 56680dd33cfSRafael J. Wysocki * synchronization in device_link_release_fn() and if the consumer or 56780dd33cfSRafael J. Wysocki * supplier devices get deleted when it runs, so put it into the "long" 56880dd33cfSRafael J. Wysocki * workqueue. 56980dd33cfSRafael J. Wysocki */ 57080dd33cfSRafael J. Wysocki queue_work(system_long_wq, &link->rm_work); 571287905e6SSaravana Kannan } 572287905e6SSaravana Kannan 573287905e6SSaravana Kannan static struct class devlink_class = { 574287905e6SSaravana Kannan .name = "devlink", 575287905e6SSaravana Kannan .owner = THIS_MODULE, 576287905e6SSaravana Kannan .dev_groups = devlink_groups, 577287905e6SSaravana Kannan .dev_release = devlink_dev_release, 578287905e6SSaravana Kannan }; 579287905e6SSaravana Kannan 580287905e6SSaravana Kannan static int devlink_add_symlinks(struct device *dev, 581287905e6SSaravana Kannan struct class_interface *class_intf) 582287905e6SSaravana Kannan { 583287905e6SSaravana Kannan int ret; 584287905e6SSaravana Kannan size_t len; 585287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 586287905e6SSaravana Kannan struct device *sup = link->supplier; 587287905e6SSaravana Kannan struct device *con = link->consumer; 588287905e6SSaravana Kannan char *buf; 589287905e6SSaravana Kannan 590e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 591e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 592e020ff61SSaravana Kannan len += strlen(":"); 593287905e6SSaravana Kannan len += strlen("supplier:") + 1; 594287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 595287905e6SSaravana Kannan if (!buf) 596287905e6SSaravana Kannan return -ENOMEM; 597287905e6SSaravana Kannan 598287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); 599287905e6SSaravana Kannan if (ret) 600287905e6SSaravana Kannan goto out; 601287905e6SSaravana Kannan 602287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); 603287905e6SSaravana Kannan if (ret) 604287905e6SSaravana Kannan goto err_con; 605287905e6SSaravana Kannan 606e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 607287905e6SSaravana Kannan ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); 608287905e6SSaravana Kannan if (ret) 609287905e6SSaravana Kannan goto err_con_dev; 610287905e6SSaravana Kannan 611e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 612287905e6SSaravana Kannan ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); 613287905e6SSaravana Kannan if (ret) 614287905e6SSaravana Kannan goto err_sup_dev; 615287905e6SSaravana Kannan 616287905e6SSaravana Kannan goto out; 617287905e6SSaravana Kannan 618287905e6SSaravana Kannan err_sup_dev: 619e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 620287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 621287905e6SSaravana Kannan err_con_dev: 622287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 623287905e6SSaravana Kannan err_con: 624287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 625287905e6SSaravana Kannan out: 626287905e6SSaravana Kannan kfree(buf); 627287905e6SSaravana Kannan return ret; 628287905e6SSaravana Kannan } 629287905e6SSaravana Kannan 630287905e6SSaravana Kannan static void devlink_remove_symlinks(struct device *dev, 631287905e6SSaravana Kannan struct class_interface *class_intf) 632287905e6SSaravana Kannan { 633287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 634287905e6SSaravana Kannan size_t len; 635287905e6SSaravana Kannan struct device *sup = link->supplier; 636287905e6SSaravana Kannan struct device *con = link->consumer; 637287905e6SSaravana Kannan char *buf; 638287905e6SSaravana Kannan 639287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 640287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 641287905e6SSaravana Kannan 642e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 643e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 644e020ff61SSaravana Kannan len += strlen(":"); 645287905e6SSaravana Kannan len += strlen("supplier:") + 1; 646287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 647287905e6SSaravana Kannan if (!buf) { 648287905e6SSaravana Kannan WARN(1, "Unable to properly free device link symlinks!\n"); 649287905e6SSaravana Kannan return; 650287905e6SSaravana Kannan } 651287905e6SSaravana Kannan 652e64daad6SAdrian Hunter if (device_is_registered(con)) { 653e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 654287905e6SSaravana Kannan sysfs_remove_link(&con->kobj, buf); 655e64daad6SAdrian Hunter } 656e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 657287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 658287905e6SSaravana Kannan kfree(buf); 659287905e6SSaravana Kannan } 660287905e6SSaravana Kannan 661287905e6SSaravana Kannan static struct class_interface devlink_class_intf = { 662287905e6SSaravana Kannan .class = &devlink_class, 663287905e6SSaravana Kannan .add_dev = devlink_add_symlinks, 664287905e6SSaravana Kannan .remove_dev = devlink_remove_symlinks, 665287905e6SSaravana Kannan }; 666287905e6SSaravana Kannan 667287905e6SSaravana Kannan static int __init devlink_class_init(void) 668287905e6SSaravana Kannan { 669287905e6SSaravana Kannan int ret; 670287905e6SSaravana Kannan 671287905e6SSaravana Kannan ret = class_register(&devlink_class); 672287905e6SSaravana Kannan if (ret) 673287905e6SSaravana Kannan return ret; 674287905e6SSaravana Kannan 675287905e6SSaravana Kannan ret = class_interface_register(&devlink_class_intf); 676287905e6SSaravana Kannan if (ret) 677287905e6SSaravana Kannan class_unregister(&devlink_class); 678287905e6SSaravana Kannan 679287905e6SSaravana Kannan return ret; 680287905e6SSaravana Kannan } 681287905e6SSaravana Kannan postcore_initcall(devlink_class_init); 682287905e6SSaravana Kannan 683515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 684515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 68505ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 6864b9bbb29SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY | \ 6874b9bbb29SSaravana Kannan DL_FLAG_INFERRED) 688515db266SRafael J. Wysocki 689fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 690fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 691fb583c8eSRafael J. Wysocki 692494fd7b7SFeng Kan /** 6939ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 6949ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 6959ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 6969ed98953SRafael J. Wysocki * @flags: Link flags. 6979ed98953SRafael J. Wysocki * 69821d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 69921d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 70021d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 70121d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 70221d5c57bSRafael J. Wysocki * be forced into the active meta state and reference-counted upon the creation 70321d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 70421d5c57bSRafael J. Wysocki * ignored. 70521d5c57bSRafael J. Wysocki * 706515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 707515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 708515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 70972175d4eSRafael J. Wysocki * 71072175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 71172175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 71272175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 71372175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 71472175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 71572175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 71672175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 71772175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 71872175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 71972175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 72072175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 721c8d50986SRafael J. Wysocki * 722e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 723e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 724e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 725d475f8eaSThierry Reding * be used to request the driver core to automatically probe for a consumer 726e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 727e7dd4010SRafael J. Wysocki * 728515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 729515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 730515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 731515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 732515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 733515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 734515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 735515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 736515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 737515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 7389ed98953SRafael J. Wysocki * 7399ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 7409ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 7419ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 7429ed98953SRafael J. Wysocki * not been registered when this function is called). 7439ed98953SRafael J. Wysocki * 7449ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 7459ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 74664df1148SLukas Wunner * not be registered, however. 7479ed98953SRafael J. Wysocki */ 7489ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 7499ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 7509ed98953SRafael J. Wysocki { 7519ed98953SRafael J. Wysocki struct device_link *link; 7529ed98953SRafael J. Wysocki 753f729a592SSaravana Kannan if (!consumer || !supplier || consumer == supplier || 754f729a592SSaravana Kannan flags & ~DL_ADD_VALID_FLAGS || 755515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 75605ef983eSSaravana Kannan (flags & DL_FLAG_SYNC_STATE_ONLY && 7574b9bbb29SSaravana Kannan (flags & ~DL_FLAG_INFERRED) != DL_FLAG_SYNC_STATE_ONLY) || 758e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 759e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 760e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 7619ed98953SRafael J. Wysocki return NULL; 7629ed98953SRafael J. Wysocki 7635db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 7645db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 7655db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 7665db25c9eSRafael J. Wysocki return NULL; 7675db25c9eSRafael J. Wysocki } 7685db25c9eSRafael J. Wysocki } 7695db25c9eSRafael J. Wysocki 770515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 771515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 772515db266SRafael J. Wysocki 7739ed98953SRafael J. Wysocki device_links_write_lock(); 7749ed98953SRafael J. Wysocki device_pm_lock(); 7759ed98953SRafael J. Wysocki 7769ed98953SRafael J. Wysocki /* 7779ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 77805ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 77905ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 78005ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 78105ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 7829ed98953SRafael J. Wysocki */ 7839ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 78405ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 78505ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 7869ed98953SRafael J. Wysocki link = NULL; 7879ed98953SRafael J. Wysocki goto out; 7889ed98953SRafael J. Wysocki } 7899ed98953SRafael J. Wysocki 79072175d4eSRafael J. Wysocki /* 791ac66c5bbSSaravana Kannan * SYNC_STATE_ONLY links are useless once a consumer device has probed. 792ac66c5bbSSaravana Kannan * So, only create it if the consumer hasn't probed yet. 793ac66c5bbSSaravana Kannan */ 794ac66c5bbSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY && 795ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_NO_DRIVER && 796ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_PROBING) { 797ac66c5bbSSaravana Kannan link = NULL; 798ac66c5bbSSaravana Kannan goto out; 799ac66c5bbSSaravana Kannan } 800ac66c5bbSSaravana Kannan 801ac66c5bbSSaravana Kannan /* 80272175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 80372175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 80472175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 80572175d4eSRafael J. Wysocki */ 80672175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 80772175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 80872175d4eSRafael J. Wysocki 809f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 810f265df55SRafael J. Wysocki if (link->consumer != consumer) 811f265df55SRafael J. Wysocki continue; 812f265df55SRafael J. Wysocki 8134b9bbb29SSaravana Kannan if (link->flags & DL_FLAG_INFERRED && 8144b9bbb29SSaravana Kannan !(flags & DL_FLAG_INFERRED)) 8154b9bbb29SSaravana Kannan link->flags &= ~DL_FLAG_INFERRED; 8164b9bbb29SSaravana Kannan 817e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 818e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 8194c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 820e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 821e2f3cd83SRafael J. Wysocki } 822e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 82336003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 824e2f3cd83SRafael J. Wysocki } 825e2f3cd83SRafael J. Wysocki 82672175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 827ead18c23SLukas Wunner kref_get(&link->kref); 82821c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 82944e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 83044e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 83105ef983eSSaravana Kannan goto reorder; 83244e96049SSaravana Kannan } else { 83344e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 8349ed98953SRafael J. Wysocki goto out; 835ead18c23SLukas Wunner } 83644e96049SSaravana Kannan } 8379ed98953SRafael J. Wysocki 83872175d4eSRafael J. Wysocki /* 83972175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 84072175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 84172175d4eSRafael J. Wysocki * update the existing link to stay around longer. 84272175d4eSRafael J. Wysocki */ 84372175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 84472175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 84572175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 84672175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 84772175d4eSRafael J. Wysocki } 84872175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 84972175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 85072175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 85172175d4eSRafael J. Wysocki } 852515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 853515db266SRafael J. Wysocki kref_get(&link->kref); 854515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 855515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 856515db266SRafael J. Wysocki } 85705ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 85805ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 85905ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 86005ef983eSSaravana Kannan goto reorder; 86105ef983eSSaravana Kannan } 86205ef983eSSaravana Kannan 86372175d4eSRafael J. Wysocki goto out; 86472175d4eSRafael J. Wysocki } 86572175d4eSRafael J. Wysocki 86621d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 8679ed98953SRafael J. Wysocki if (!link) 8689ed98953SRafael J. Wysocki goto out; 8699ed98953SRafael J. Wysocki 870e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 871e2f3cd83SRafael J. Wysocki 8729ed98953SRafael J. Wysocki get_device(supplier); 8739ed98953SRafael J. Wysocki link->supplier = supplier; 8749ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 8759ed98953SRafael J. Wysocki get_device(consumer); 8769ed98953SRafael J. Wysocki link->consumer = consumer; 8779ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 8789ed98953SRafael J. Wysocki link->flags = flags; 879ead18c23SLukas Wunner kref_init(&link->kref); 8809ed98953SRafael J. Wysocki 881287905e6SSaravana Kannan link->link_dev.class = &devlink_class; 882287905e6SSaravana Kannan device_set_pm_not_required(&link->link_dev); 883e020ff61SSaravana Kannan dev_set_name(&link->link_dev, "%s:%s--%s:%s", 884e020ff61SSaravana Kannan dev_bus_name(supplier), dev_name(supplier), 885e020ff61SSaravana Kannan dev_bus_name(consumer), dev_name(consumer)); 886287905e6SSaravana Kannan if (device_register(&link->link_dev)) { 887df0a1814SYang Yingliang put_device(&link->link_dev); 888287905e6SSaravana Kannan link = NULL; 889287905e6SSaravana Kannan goto out; 890287905e6SSaravana Kannan } 891287905e6SSaravana Kannan 892287905e6SSaravana Kannan if (flags & DL_FLAG_PM_RUNTIME) { 893287905e6SSaravana Kannan if (flags & DL_FLAG_RPM_ACTIVE) 894287905e6SSaravana Kannan refcount_inc(&link->rpm_active); 895287905e6SSaravana Kannan 896287905e6SSaravana Kannan pm_runtime_new_link(consumer); 897287905e6SSaravana Kannan } 898287905e6SSaravana Kannan 89964df1148SLukas Wunner /* Determine the initial link state. */ 900515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 9019ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 902515db266SRafael J. Wysocki else 903515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 9049ed98953SRafael J. Wysocki 9059ed98953SRafael J. Wysocki /* 90615cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 90715cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 90815cfb094SRafael J. Wysocki */ 90915cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 91015cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 91115cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 91215cfb094SRafael J. Wysocki 91321c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 91421c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 91521c27f06SSaravana Kannan 91605ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 91705ef983eSSaravana Kannan dev_dbg(consumer, 91805ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 91905ef983eSSaravana Kannan dev_name(supplier)); 92005ef983eSSaravana Kannan goto out; 92105ef983eSSaravana Kannan } 92221c27f06SSaravana Kannan 92305ef983eSSaravana Kannan reorder: 92415cfb094SRafael J. Wysocki /* 9259ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 9269ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 9279ed98953SRafael J. Wysocki * 9289ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 9299ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 9309ed98953SRafael J. Wysocki */ 9319ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 9329ed98953SRafael J. Wysocki 9338a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 9349ed98953SRafael J. Wysocki 9359ed98953SRafael J. Wysocki out: 9369ed98953SRafael J. Wysocki device_pm_unlock(); 9379ed98953SRafael J. Wysocki device_links_write_unlock(); 9385db25c9eSRafael J. Wysocki 939e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 9405db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 9415db25c9eSRafael J. Wysocki 9429ed98953SRafael J. Wysocki return link; 9439ed98953SRafael J. Wysocki } 9449ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 9459ed98953SRafael J. Wysocki 946ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 9479ed98953SRafael J. Wysocki { 948ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 949ead18c23SLukas Wunner 9508a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 9519ed98953SRafael J. Wysocki dev_name(link->supplier)); 9529ed98953SRafael J. Wysocki 953e0e398e2SRafael J. Wysocki pm_runtime_drop_link(link); 954baa8809fSRafael J. Wysocki 9550c871315SRafael J. Wysocki device_link_remove_from_lists(link); 956843e600bSSaravana Kannan device_unregister(&link->link_dev); 9579ed98953SRafael J. Wysocki } 9589ed98953SRafael J. Wysocki 95972175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 96072175d4eSRafael J. Wysocki { 96172175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 96272175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 963bf25967aSAdrian Hunter else if (!device_is_registered(link->consumer)) 964bf25967aSAdrian Hunter __device_link_del(&link->kref); 96572175d4eSRafael J. Wysocki else 96672175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 96772175d4eSRafael J. Wysocki } 96872175d4eSRafael J. Wysocki 9699ed98953SRafael J. Wysocki /** 97072175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 9719ed98953SRafael J. Wysocki * @link: Device link to delete. 9729ed98953SRafael J. Wysocki * 9739ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 974ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 975ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 976ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 9779ed98953SRafael J. Wysocki */ 9789ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 9799ed98953SRafael J. Wysocki { 9809ed98953SRafael J. Wysocki device_links_write_lock(); 98172175d4eSRafael J. Wysocki device_link_put_kref(link); 9829ed98953SRafael J. Wysocki device_links_write_unlock(); 9839ed98953SRafael J. Wysocki } 9849ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 9859ed98953SRafael J. Wysocki 986d8842211Spascal paillet /** 98772175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 988d8842211Spascal paillet * @consumer: Consumer end of the link. 989d8842211Spascal paillet * @supplier: Supplier end of the link. 990d8842211Spascal paillet * 991d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 992d8842211Spascal paillet * PM. 993d8842211Spascal paillet */ 994d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 995d8842211Spascal paillet { 996d8842211Spascal paillet struct device_link *link; 997d8842211Spascal paillet 998d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 999d8842211Spascal paillet return; 1000d8842211Spascal paillet 1001d8842211Spascal paillet device_links_write_lock(); 1002d8842211Spascal paillet 1003d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 1004d8842211Spascal paillet if (link->consumer == consumer) { 100572175d4eSRafael J. Wysocki device_link_put_kref(link); 1006d8842211Spascal paillet break; 1007d8842211Spascal paillet } 1008d8842211Spascal paillet } 1009d8842211Spascal paillet 1010d8842211Spascal paillet device_links_write_unlock(); 1011d8842211Spascal paillet } 1012d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 1013d8842211Spascal paillet 10149ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 10159ed98953SRafael J. Wysocki { 10169ed98953SRafael J. Wysocki struct device_link *link; 10179ed98953SRafael J. Wysocki 10188c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) { 10198c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE) 10208c3e315dSSaravana Kannan continue; 10218c3e315dSSaravana Kannan 10228c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 10239ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 10248c3e315dSSaravana Kannan } else { 10258c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 10268c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 10278c3e315dSSaravana Kannan } 10288c3e315dSSaravana Kannan } 10299ed98953SRafael J. Wysocki } 10309ed98953SRafael J. Wysocki 10312f8c3ae8SSaravana Kannan static bool dev_is_best_effort(struct device *dev) 10322f8c3ae8SSaravana Kannan { 10338f486cabSSaravana Kannan return (fw_devlink_best_effort && dev->can_match) || 10348f486cabSSaravana Kannan (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT)); 10352f8c3ae8SSaravana Kannan } 10362f8c3ae8SSaravana Kannan 10379ed98953SRafael J. Wysocki /** 10389ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 10399ed98953SRafael J. Wysocki * @dev: Consumer device. 10409ed98953SRafael J. Wysocki * 10419ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 10429ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 10439ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 10449ed98953SRafael J. Wysocki * 10459ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 10469ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 10479ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 10489ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 10499ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 10509ed98953SRafael J. Wysocki * 1051515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10529ed98953SRafael J. Wysocki */ 10539ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 10549ed98953SRafael J. Wysocki { 10559ed98953SRafael J. Wysocki struct device_link *link; 10562f8c3ae8SSaravana Kannan int ret = 0, fwnode_ret = 0; 105768223eeeSSaravana Kannan struct fwnode_handle *sup_fw; 10589ed98953SRafael J. Wysocki 1059e2ae9bccSSaravana Kannan /* 1060e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 1061e2ae9bccSSaravana Kannan * probe. 1062e2ae9bccSSaravana Kannan */ 106325ac86c6SSaravana Kannan mutex_lock(&fwnode_link_lock); 106425ac86c6SSaravana Kannan if (dev->fwnode && !list_empty(&dev->fwnode->suppliers) && 106525ac86c6SSaravana Kannan !fw_devlink_is_permissive()) { 106668223eeeSSaravana Kannan sup_fw = list_first_entry(&dev->fwnode->suppliers, 10671f0dfa05SSaravana Kannan struct fwnode_link, 106868223eeeSSaravana Kannan c_hook)->supplier; 10692f8c3ae8SSaravana Kannan if (!dev_is_best_effort(dev)) { 10702f8c3ae8SSaravana Kannan fwnode_ret = -EPROBE_DEFER; 10712f8c3ae8SSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER, 10722f8c3ae8SSaravana Kannan "wait for supplier %pfwP\n", sup_fw); 10732f8c3ae8SSaravana Kannan } else { 10742f8c3ae8SSaravana Kannan fwnode_ret = -EAGAIN; 10752f8c3ae8SSaravana Kannan } 1076e2ae9bccSSaravana Kannan } 107725ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock); 10782f8c3ae8SSaravana Kannan if (fwnode_ret == -EPROBE_DEFER) 10792f8c3ae8SSaravana Kannan return fwnode_ret; 1080e2ae9bccSSaravana Kannan 10819ed98953SRafael J. Wysocki device_links_write_lock(); 10829ed98953SRafael J. Wysocki 10839ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 10848c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 10859ed98953SRafael J. Wysocki continue; 10869ed98953SRafael J. Wysocki 10878c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE && 10888c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { 10892f8c3ae8SSaravana Kannan 10902f8c3ae8SSaravana Kannan if (dev_is_best_effort(dev) && 10912f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED && 10922f8c3ae8SSaravana Kannan !link->supplier->can_match) { 10932f8c3ae8SSaravana Kannan ret = -EAGAIN; 10942f8c3ae8SSaravana Kannan continue; 10952f8c3ae8SSaravana Kannan } 10962f8c3ae8SSaravana Kannan 10979ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 109868223eeeSSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER, 109968223eeeSSaravana Kannan "supplier %s not ready\n", 11001f0dfa05SSaravana Kannan dev_name(link->supplier)); 11019ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 11029ed98953SRafael J. Wysocki break; 11039ed98953SRafael J. Wysocki } 11049ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 11059ed98953SRafael J. Wysocki } 11069ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 11079ed98953SRafael J. Wysocki 11089ed98953SRafael J. Wysocki device_links_write_unlock(); 11092f8c3ae8SSaravana Kannan 11102f8c3ae8SSaravana Kannan return ret ? ret : fwnode_ret; 11119ed98953SRafael J. Wysocki } 11129ed98953SRafael J. Wysocki 111326e77708SSaravana Kannan /** 111426e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 111526e77708SSaravana Kannan * @dev: Device to call sync_state() on 111626e77708SSaravana Kannan * @list: List head to queue the @dev on 111726e77708SSaravana Kannan * 111826e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 111926e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 112026e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 112126e77708SSaravana Kannan * device_links_write_lock() held. 112226e77708SSaravana Kannan * 112326e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 112426e77708SSaravana Kannan * on this list. 112526e77708SSaravana Kannan * 112626e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 112726e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 112826e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 112926e77708SSaravana Kannan * put_device() is called on this device. 113026e77708SSaravana Kannan */ 113126e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 113226e77708SSaravana Kannan struct list_head *list) 1133fc5a251dSSaravana Kannan { 1134fc5a251dSSaravana Kannan struct device_link *link; 1135fc5a251dSSaravana Kannan 113677036165SSaravana Kannan if (!dev_has_sync_state(dev)) 113777036165SSaravana Kannan return; 1138fc5a251dSSaravana Kannan if (dev->state_synced) 1139fc5a251dSSaravana Kannan return; 1140fc5a251dSSaravana Kannan 1141fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 1142fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1143fc5a251dSSaravana Kannan continue; 1144fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 1145fc5a251dSSaravana Kannan return; 1146fc5a251dSSaravana Kannan } 1147fc5a251dSSaravana Kannan 114826e77708SSaravana Kannan /* 114926e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 115026e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 115126e77708SSaravana Kannan * and probed before the list is flushed. 115226e77708SSaravana Kannan */ 115326e77708SSaravana Kannan dev->state_synced = true; 115426e77708SSaravana Kannan 11553b052a3eSSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 115626e77708SSaravana Kannan return; 115726e77708SSaravana Kannan 115826e77708SSaravana Kannan get_device(dev); 11593b052a3eSSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 116026e77708SSaravana Kannan } 116126e77708SSaravana Kannan 116226e77708SSaravana Kannan /** 116326e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 116426e77708SSaravana Kannan * @list: List of devices to call sync_state() on 116521eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 116626e77708SSaravana Kannan * 116726e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 116821eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 116921eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 117021eb93f4SSaravana Kannan * context where a device lock is already held. 117126e77708SSaravana Kannan */ 117221eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 117321eb93f4SSaravana Kannan struct device *dont_lock_dev) 117426e77708SSaravana Kannan { 117526e77708SSaravana Kannan struct device *dev, *tmp; 117626e77708SSaravana Kannan 11773b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 11783b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 117926e77708SSaravana Kannan 118021eb93f4SSaravana Kannan if (dev != dont_lock_dev) 118126e77708SSaravana Kannan device_lock(dev); 118226e77708SSaravana Kannan 1183fc5a251dSSaravana Kannan if (dev->bus->sync_state) 1184fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 1185fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 1186fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 1187fc5a251dSSaravana Kannan 118821eb93f4SSaravana Kannan if (dev != dont_lock_dev) 118926e77708SSaravana Kannan device_unlock(dev); 119026e77708SSaravana Kannan 119126e77708SSaravana Kannan put_device(dev); 119226e77708SSaravana Kannan } 1193fc5a251dSSaravana Kannan } 1194fc5a251dSSaravana Kannan 1195fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 1196fc5a251dSSaravana Kannan { 1197fc5a251dSSaravana Kannan device_links_write_lock(); 1198fc5a251dSSaravana Kannan defer_sync_state_count++; 1199fc5a251dSSaravana Kannan device_links_write_unlock(); 1200fc5a251dSSaravana Kannan } 1201fc5a251dSSaravana Kannan 1202fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 1203fc5a251dSSaravana Kannan { 1204fc5a251dSSaravana Kannan struct device *dev, *tmp; 120526e77708SSaravana Kannan LIST_HEAD(sync_list); 1206fc5a251dSSaravana Kannan 1207fc5a251dSSaravana Kannan device_links_write_lock(); 1208fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 1209fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 1210fc5a251dSSaravana Kannan goto out; 1211fc5a251dSSaravana Kannan } 1212fc5a251dSSaravana Kannan defer_sync_state_count--; 1213fc5a251dSSaravana Kannan if (defer_sync_state_count) 1214fc5a251dSSaravana Kannan goto out; 1215fc5a251dSSaravana Kannan 12163b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 121726e77708SSaravana Kannan /* 121826e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 12193b052a3eSSaravana Kannan * sync_list because defer_sync is used for both lists. 122026e77708SSaravana Kannan */ 12213b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 122226e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 1223fc5a251dSSaravana Kannan } 1224fc5a251dSSaravana Kannan out: 1225fc5a251dSSaravana Kannan device_links_write_unlock(); 122626e77708SSaravana Kannan 122721eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 1228fc5a251dSSaravana Kannan } 1229fc5a251dSSaravana Kannan 1230fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 1231fc5a251dSSaravana Kannan { 1232fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 1233fc5a251dSSaravana Kannan return 0; 1234fc5a251dSSaravana Kannan } 1235fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 1236fc5a251dSSaravana Kannan 1237fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 1238fc5a251dSSaravana Kannan { 12393b052a3eSSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 12403b052a3eSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 1241fc5a251dSSaravana Kannan } 1242fc5a251dSSaravana Kannan 124321c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link) 124421c27f06SSaravana Kannan { 124521c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED; 124621c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE); 124721c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del); 124821c27f06SSaravana Kannan } 124921c27f06SSaravana Kannan 1250da6d6475SSaravana Kannan static ssize_t waiting_for_supplier_show(struct device *dev, 1251da6d6475SSaravana Kannan struct device_attribute *attr, 1252da6d6475SSaravana Kannan char *buf) 1253da6d6475SSaravana Kannan { 1254da6d6475SSaravana Kannan bool val; 1255da6d6475SSaravana Kannan 1256da6d6475SSaravana Kannan device_lock(dev); 125725ac86c6SSaravana Kannan val = !list_empty(&dev->fwnode->suppliers); 1258da6d6475SSaravana Kannan device_unlock(dev); 1259aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 1260da6d6475SSaravana Kannan } 1261da6d6475SSaravana Kannan static DEVICE_ATTR_RO(waiting_for_supplier); 1262da6d6475SSaravana Kannan 12639ed98953SRafael J. Wysocki /** 1264b6f617dfSSaravana Kannan * device_links_force_bind - Prepares device to be force bound 1265b6f617dfSSaravana Kannan * @dev: Consumer device. 1266b6f617dfSSaravana Kannan * 1267b6f617dfSSaravana Kannan * device_bind_driver() force binds a device to a driver without calling any 1268b6f617dfSSaravana Kannan * driver probe functions. So the consumer really isn't going to wait for any 1269b6f617dfSSaravana Kannan * supplier before it's bound to the driver. We still want the device link 1270b6f617dfSSaravana Kannan * states to be sensible when this happens. 1271b6f617dfSSaravana Kannan * 1272b6f617dfSSaravana Kannan * In preparation for device_bind_driver(), this function goes through each 1273b6f617dfSSaravana Kannan * supplier device links and checks if the supplier is bound. If it is, then 1274b6f617dfSSaravana Kannan * the device link status is set to CONSUMER_PROBE. Otherwise, the device link 1275b6f617dfSSaravana Kannan * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored. 1276b6f617dfSSaravana Kannan */ 1277b6f617dfSSaravana Kannan void device_links_force_bind(struct device *dev) 1278b6f617dfSSaravana Kannan { 1279b6f617dfSSaravana Kannan struct device_link *link, *ln; 1280b6f617dfSSaravana Kannan 1281b6f617dfSSaravana Kannan device_links_write_lock(); 1282b6f617dfSSaravana Kannan 1283b6f617dfSSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 1284b6f617dfSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1285b6f617dfSSaravana Kannan continue; 1286b6f617dfSSaravana Kannan 1287b6f617dfSSaravana Kannan if (link->status != DL_STATE_AVAILABLE) { 1288b6f617dfSSaravana Kannan device_link_drop_managed(link); 1289b6f617dfSSaravana Kannan continue; 1290b6f617dfSSaravana Kannan } 1291b6f617dfSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 1292b6f617dfSSaravana Kannan } 1293b6f617dfSSaravana Kannan dev->links.status = DL_DEV_PROBING; 1294b6f617dfSSaravana Kannan 1295b6f617dfSSaravana Kannan device_links_write_unlock(); 1296b6f617dfSSaravana Kannan } 1297b6f617dfSSaravana Kannan 1298b6f617dfSSaravana Kannan /** 12999ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 13009ed98953SRafael J. Wysocki * @dev: Device to update the links for. 13019ed98953SRafael J. Wysocki * 13029ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 13039ed98953SRafael J. Wysocki * consumers by changing their status to "available". 13049ed98953SRafael J. Wysocki * 13059ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 13069ed98953SRafael J. Wysocki * 1307515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 13089ed98953SRafael J. Wysocki */ 13099ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 13109ed98953SRafael J. Wysocki { 131121c27f06SSaravana Kannan struct device_link *link, *ln; 131226e77708SSaravana Kannan LIST_HEAD(sync_list); 13139ed98953SRafael J. Wysocki 1314bcbbcfd5SSaravana Kannan /* 13159528e0d9SSaravana Kannan * If a device binds successfully, it's expected to have created all 1316bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 13179528e0d9SSaravana Kannan * them. So, fw_devlink no longer needs to create device links to any 13189528e0d9SSaravana Kannan * of the device's suppliers. 13199528e0d9SSaravana Kannan * 13203a2dbc51SSaravana Kannan * Also, if a child firmware node of this bound device is not added as a 13213a2dbc51SSaravana Kannan * device by now, assume it is never going to be added. Make this bound 13223a2dbc51SSaravana Kannan * device the fallback supplier to the dangling consumers of the child 13233a2dbc51SSaravana Kannan * firmware node because this bound device is probably implementing the 13243a2dbc51SSaravana Kannan * child firmware node functionality and we don't want the dangling 13253a2dbc51SSaravana Kannan * consumers to defer probe indefinitely waiting for a device for the 13263a2dbc51SSaravana Kannan * child firmware node. 1327bcbbcfd5SSaravana Kannan */ 13289528e0d9SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) { 13299528e0d9SSaravana Kannan struct fwnode_handle *child; 1330f9aa4606SSaravana Kannan fwnode_links_purge_suppliers(dev->fwnode); 13313a2dbc51SSaravana Kannan mutex_lock(&fwnode_link_lock); 13329528e0d9SSaravana Kannan fwnode_for_each_available_child_node(dev->fwnode, child) 13333a2dbc51SSaravana Kannan __fw_devlink_pickup_dangling_consumers(child, 13343a2dbc51SSaravana Kannan dev->fwnode); 13353a2dbc51SSaravana Kannan __fw_devlink_link_to_consumers(dev); 13363a2dbc51SSaravana Kannan mutex_unlock(&fwnode_link_lock); 13379528e0d9SSaravana Kannan } 1338da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 1339bcbbcfd5SSaravana Kannan 13409ed98953SRafael J. Wysocki device_links_write_lock(); 13419ed98953SRafael J. Wysocki 13429ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1343515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13449ed98953SRafael J. Wysocki continue; 13459ed98953SRafael J. Wysocki 134615cfb094SRafael J. Wysocki /* 134715cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 134815cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 134915cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 135015cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 135115cfb094SRafael J. Wysocki */ 135215cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 135315cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 135415cfb094SRafael J. Wysocki continue; 135515cfb094SRafael J. Wysocki 13569ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 13579ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 1358e7dd4010SRafael J. Wysocki 1359e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 1360e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 13619ed98953SRafael J. Wysocki } 13629ed98953SRafael J. Wysocki 136321eb93f4SSaravana Kannan if (defer_sync_state_count) 136421eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 136521eb93f4SSaravana Kannan else 136621eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 136721eb93f4SSaravana Kannan 136821c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 136921c27f06SSaravana Kannan struct device *supplier; 137021c27f06SSaravana Kannan 1371515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13729ed98953SRafael J. Wysocki continue; 13739ed98953SRafael J. Wysocki 137421c27f06SSaravana Kannan supplier = link->supplier; 137521c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { 137621c27f06SSaravana Kannan /* 137721c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no 137821c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's 137921c27f06SSaravana Kannan * save to drop the managed link completely. 138021c27f06SSaravana Kannan */ 138121c27f06SSaravana Kannan device_link_drop_managed(link); 13822f8c3ae8SSaravana Kannan } else if (dev_is_best_effort(dev) && 13832f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED && 13842f8c3ae8SSaravana Kannan link->status != DL_STATE_CONSUMER_PROBE && 13852f8c3ae8SSaravana Kannan !link->supplier->can_match) { 13862f8c3ae8SSaravana Kannan /* 13872f8c3ae8SSaravana Kannan * When dev_is_best_effort() is true, we ignore device 13882f8c3ae8SSaravana Kannan * links to suppliers that don't have a driver. If the 13892f8c3ae8SSaravana Kannan * consumer device still managed to probe, there's no 13902f8c3ae8SSaravana Kannan * point in maintaining a device link in a weird state 13912f8c3ae8SSaravana Kannan * (consumer probed before supplier). So delete it. 13922f8c3ae8SSaravana Kannan */ 13932f8c3ae8SSaravana Kannan device_link_drop_managed(link); 139421c27f06SSaravana Kannan } else { 13959ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 13969ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 139721c27f06SSaravana Kannan } 1398fc5a251dSSaravana Kannan 139921c27f06SSaravana Kannan /* 140021c27f06SSaravana Kannan * This needs to be done even for the deleted 140121c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last 140221c27f06SSaravana Kannan * device link that was preventing the supplier from getting a 140321c27f06SSaravana Kannan * sync_state() call. 140421c27f06SSaravana Kannan */ 1405fc5a251dSSaravana Kannan if (defer_sync_state_count) 140621c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier); 1407fc5a251dSSaravana Kannan else 140821c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list); 14099ed98953SRafael J. Wysocki } 14109ed98953SRafael J. Wysocki 14119ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 14129ed98953SRafael J. Wysocki 14139ed98953SRafael J. Wysocki device_links_write_unlock(); 141426e77708SSaravana Kannan 141521eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 14169ed98953SRafael J. Wysocki } 14179ed98953SRafael J. Wysocki 14189ed98953SRafael J. Wysocki /** 14199ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 14209ed98953SRafael J. Wysocki * @dev: Device without a drvier. 14219ed98953SRafael J. Wysocki * 14229ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 14239ed98953SRafael J. Wysocki * 14249ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 14259ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 14269ed98953SRafael J. Wysocki * case they need not be updated. 14279ed98953SRafael J. Wysocki * 1428515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14299ed98953SRafael J. Wysocki */ 14309ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 14319ed98953SRafael J. Wysocki { 14329ed98953SRafael J. Wysocki struct device_link *link, *ln; 14339ed98953SRafael J. Wysocki 14349ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 1435515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 14369ed98953SRafael J. Wysocki continue; 14379ed98953SRafael J. Wysocki 14388c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 1439515db266SRafael J. Wysocki device_link_drop_managed(link); 14408c3e315dSSaravana Kannan continue; 14418c3e315dSSaravana Kannan } 14428c3e315dSSaravana Kannan 14438c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE && 14448c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE) 14458c3e315dSSaravana Kannan continue; 14468c3e315dSSaravana Kannan 14478c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 14489ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 14498c3e315dSSaravana Kannan } else { 14508c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 14518c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 14528c3e315dSSaravana Kannan } 14539ed98953SRafael J. Wysocki } 14549ed98953SRafael J. Wysocki 14559ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 14569ed98953SRafael J. Wysocki } 14579ed98953SRafael J. Wysocki 145815cfb094SRafael J. Wysocki /** 145915cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 146015cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 146115cfb094SRafael J. Wysocki * 146215cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 146315cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 146415cfb094SRafael J. Wysocki * appropriate. 146515cfb094SRafael J. Wysocki * 1466515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 146715cfb094SRafael J. Wysocki */ 14689ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 14699ed98953SRafael J. Wysocki { 147015cfb094SRafael J. Wysocki struct device_link *link; 147115cfb094SRafael J. Wysocki 14729ed98953SRafael J. Wysocki device_links_write_lock(); 147315cfb094SRafael J. Wysocki 147415cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1475515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 147615cfb094SRafael J. Wysocki continue; 147715cfb094SRafael J. Wysocki 147815cfb094SRafael J. Wysocki /* 147915cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 148015cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 148115cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 148215cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 148315cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 148415cfb094SRafael J. Wysocki */ 148515cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 148615cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 148715cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 148815cfb094SRafael J. Wysocki } 148915cfb094SRafael J. Wysocki 14909ed98953SRafael J. Wysocki __device_links_no_driver(dev); 149115cfb094SRafael J. Wysocki 14929ed98953SRafael J. Wysocki device_links_write_unlock(); 14939ed98953SRafael J. Wysocki } 14949ed98953SRafael J. Wysocki 14959ed98953SRafael J. Wysocki /** 14969ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 14979ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 14989ed98953SRafael J. Wysocki * 14999ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 15009ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 15019ed98953SRafael J. Wysocki * appropriate. 15029ed98953SRafael J. Wysocki * 1503515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 15049ed98953SRafael J. Wysocki */ 15059ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 15069ed98953SRafael J. Wysocki { 1507c8d50986SRafael J. Wysocki struct device_link *link, *ln; 15089ed98953SRafael J. Wysocki 15099ed98953SRafael J. Wysocki device_links_write_lock(); 15109ed98953SRafael J. Wysocki 1511c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1512515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 15139ed98953SRafael J. Wysocki continue; 15149ed98953SRafael J. Wysocki 1515e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 15169ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 15171689cac5SVivek Gautam 15181689cac5SVivek Gautam /* 15191689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 15201689cac5SVivek Gautam * devices that are not active, i.e. where the link state 15211689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 15221689cac5SVivek Gautam */ 15231689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 15241689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1525515db266SRafael J. Wysocki device_link_drop_managed(link); 15261689cac5SVivek Gautam 15279ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 15289ed98953SRafael J. Wysocki } 15299ed98953SRafael J. Wysocki 15303b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 15319ed98953SRafael J. Wysocki __device_links_no_driver(dev); 15329ed98953SRafael J. Wysocki 15339ed98953SRafael J. Wysocki device_links_write_unlock(); 15349ed98953SRafael J. Wysocki } 15359ed98953SRafael J. Wysocki 15369ed98953SRafael J. Wysocki /** 15379ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 15389ed98953SRafael J. Wysocki * @dev: Device to check. 15399ed98953SRafael J. Wysocki * 15409ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 15419ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 15429ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 15439ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 15449ed98953SRafael J. Wysocki * successfully going forward. 15459ed98953SRafael J. Wysocki * 15469ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 15479ed98953SRafael J. Wysocki * 1548515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 15499ed98953SRafael J. Wysocki */ 15509ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 15519ed98953SRafael J. Wysocki { 15529ed98953SRafael J. Wysocki struct device_link *link; 15539ed98953SRafael J. Wysocki bool ret = false; 15549ed98953SRafael J. Wysocki 15559ed98953SRafael J. Wysocki device_links_write_lock(); 15569ed98953SRafael J. Wysocki 15579ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1558515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 15599ed98953SRafael J. Wysocki continue; 15609ed98953SRafael J. Wysocki 15619ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 15629ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 15639ed98953SRafael J. Wysocki ret = true; 15649ed98953SRafael J. Wysocki break; 15659ed98953SRafael J. Wysocki } 15669ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 15679ed98953SRafael J. Wysocki } 15689ed98953SRafael J. Wysocki 15699ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 15709ed98953SRafael J. Wysocki 15719ed98953SRafael J. Wysocki device_links_write_unlock(); 15729ed98953SRafael J. Wysocki return ret; 15739ed98953SRafael J. Wysocki } 15749ed98953SRafael J. Wysocki 15759ed98953SRafael J. Wysocki /** 15769ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 15779ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 15789ed98953SRafael J. Wysocki * 15799ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 15809ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 15819ed98953SRafael J. Wysocki * and start over. 15829ed98953SRafael J. Wysocki * 15839ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 15849ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 15859ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 15869ed98953SRafael J. Wysocki * changed the state of the link already). 15879ed98953SRafael J. Wysocki * 1588515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 15899ed98953SRafael J. Wysocki */ 15909ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 15919ed98953SRafael J. Wysocki { 15929ed98953SRafael J. Wysocki struct device_link *link; 15939ed98953SRafael J. Wysocki 15949ed98953SRafael J. Wysocki start: 15959ed98953SRafael J. Wysocki device_links_write_lock(); 15969ed98953SRafael J. Wysocki 15979ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 15989ed98953SRafael J. Wysocki enum device_link_state status; 15999ed98953SRafael J. Wysocki 160005ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 160105ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 16029ed98953SRafael J. Wysocki continue; 16039ed98953SRafael J. Wysocki 16049ed98953SRafael J. Wysocki status = link->status; 16059ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 16069ed98953SRafael J. Wysocki device_links_write_unlock(); 16079ed98953SRafael J. Wysocki 16089ed98953SRafael J. Wysocki wait_for_device_probe(); 16099ed98953SRafael J. Wysocki goto start; 16109ed98953SRafael J. Wysocki } 16119ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 16129ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 16139ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 16149ed98953SRafael J. Wysocki 16159ed98953SRafael J. Wysocki get_device(consumer); 16169ed98953SRafael J. Wysocki 16179ed98953SRafael J. Wysocki device_links_write_unlock(); 16189ed98953SRafael J. Wysocki 16199ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 16209ed98953SRafael J. Wysocki consumer->parent); 16219ed98953SRafael J. Wysocki put_device(consumer); 16229ed98953SRafael J. Wysocki goto start; 16239ed98953SRafael J. Wysocki } 16249ed98953SRafael J. Wysocki } 16259ed98953SRafael J. Wysocki 16269ed98953SRafael J. Wysocki device_links_write_unlock(); 16279ed98953SRafael J. Wysocki } 16289ed98953SRafael J. Wysocki 16299ed98953SRafael J. Wysocki /** 16309ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 16319ed98953SRafael J. Wysocki * @dev: Target device. 16329ed98953SRafael J. Wysocki */ 16339ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 16349ed98953SRafael J. Wysocki { 16359ed98953SRafael J. Wysocki struct device_link *link, *ln; 16369ed98953SRafael J. Wysocki 1637287905e6SSaravana Kannan if (dev->class == &devlink_class) 1638287905e6SSaravana Kannan return; 1639287905e6SSaravana Kannan 16409ed98953SRafael J. Wysocki /* 16419ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 16429ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 16439ed98953SRafael J. Wysocki */ 16449ed98953SRafael J. Wysocki device_links_write_lock(); 16459ed98953SRafael J. Wysocki 16469ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 16479ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1648ead18c23SLukas Wunner __device_link_del(&link->kref); 16499ed98953SRafael J. Wysocki } 16509ed98953SRafael J. Wysocki 16519ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 16529ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 16539ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1654ead18c23SLukas Wunner __device_link_del(&link->kref); 16559ed98953SRafael J. Wysocki } 16569ed98953SRafael J. Wysocki 16579ed98953SRafael J. Wysocki device_links_write_unlock(); 16589ed98953SRafael J. Wysocki } 16599ed98953SRafael J. Wysocki 1660b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_PERMISSIVE (DL_FLAG_INFERRED | \ 1661b90fb8f6SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 1662b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_ON (DL_FLAG_INFERRED | \ 1663b90fb8f6SSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER) 1664b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_RPM (FW_DEVLINK_FLAGS_ON | \ 1665b90fb8f6SSaravana Kannan DL_FLAG_PM_RUNTIME) 1666b90fb8f6SSaravana Kannan 1667ea718c69SSaravana Kannan static u32 fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 166842926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 166942926ac3SSaravana Kannan { 167042926ac3SSaravana Kannan if (!arg) 167142926ac3SSaravana Kannan return -EINVAL; 167242926ac3SSaravana Kannan 167342926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 167442926ac3SSaravana Kannan fw_devlink_flags = 0; 167542926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 1676b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 167742926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 1678b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 167942926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 1680b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_RPM; 168142926ac3SSaravana Kannan } 168242926ac3SSaravana Kannan return 0; 168342926ac3SSaravana Kannan } 168442926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 168542926ac3SSaravana Kannan 1686d8ab4685SGreg Kroah-Hartman static bool fw_devlink_strict; 168719d0f5f6SSaravana Kannan static int __init fw_devlink_strict_setup(char *arg) 168819d0f5f6SSaravana Kannan { 168973060022SChristophe JAILLET return kstrtobool(arg, &fw_devlink_strict); 169019d0f5f6SSaravana Kannan } 169119d0f5f6SSaravana Kannan early_param("fw_devlink.strict", fw_devlink_strict_setup); 169219d0f5f6SSaravana Kannan 169342926ac3SSaravana Kannan u32 fw_devlink_get_flags(void) 169442926ac3SSaravana Kannan { 169542926ac3SSaravana Kannan return fw_devlink_flags; 169642926ac3SSaravana Kannan } 169742926ac3SSaravana Kannan 169842926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 169942926ac3SSaravana Kannan { 1700b90fb8f6SSaravana Kannan return fw_devlink_flags == FW_DEVLINK_FLAGS_PERMISSIVE; 170142926ac3SSaravana Kannan } 170242926ac3SSaravana Kannan 170319d0f5f6SSaravana Kannan bool fw_devlink_is_strict(void) 170419d0f5f6SSaravana Kannan { 170519d0f5f6SSaravana Kannan return fw_devlink_strict && !fw_devlink_is_permissive(); 17069ed98953SRafael J. Wysocki } 17079ed98953SRafael J. Wysocki 1708c2c724c8SSaravana Kannan static void fw_devlink_parse_fwnode(struct fwnode_handle *fwnode) 1709c2c724c8SSaravana Kannan { 1710c2c724c8SSaravana Kannan if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) 1711c2c724c8SSaravana Kannan return; 1712c2c724c8SSaravana Kannan 17132d09e6ebSSaravana Kannan fwnode_call_int_op(fwnode, add_links); 1714c2c724c8SSaravana Kannan fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; 1715c2c724c8SSaravana Kannan } 1716c2c724c8SSaravana Kannan 1717c2c724c8SSaravana Kannan static void fw_devlink_parse_fwtree(struct fwnode_handle *fwnode) 1718c2c724c8SSaravana Kannan { 1719c2c724c8SSaravana Kannan struct fwnode_handle *child = NULL; 1720c2c724c8SSaravana Kannan 1721c2c724c8SSaravana Kannan fw_devlink_parse_fwnode(fwnode); 1722c2c724c8SSaravana Kannan 1723c2c724c8SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 1724c2c724c8SSaravana Kannan fw_devlink_parse_fwtree(child); 1725c2c724c8SSaravana Kannan } 1726c2c724c8SSaravana Kannan 1727d46f3e3eSSaravana Kannan static void fw_devlink_relax_link(struct device_link *link) 1728d46f3e3eSSaravana Kannan { 1729d46f3e3eSSaravana Kannan if (!(link->flags & DL_FLAG_INFERRED)) 1730d46f3e3eSSaravana Kannan return; 1731d46f3e3eSSaravana Kannan 1732d46f3e3eSSaravana Kannan if (link->flags == (DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE)) 1733d46f3e3eSSaravana Kannan return; 1734d46f3e3eSSaravana Kannan 1735d46f3e3eSSaravana Kannan pm_runtime_drop_link(link); 1736d46f3e3eSSaravana Kannan link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; 1737d46f3e3eSSaravana Kannan dev_dbg(link->consumer, "Relaxing link with %s\n", 1738d46f3e3eSSaravana Kannan dev_name(link->supplier)); 1739d46f3e3eSSaravana Kannan } 1740d46f3e3eSSaravana Kannan 1741d46f3e3eSSaravana Kannan static int fw_devlink_no_driver(struct device *dev, void *data) 1742d46f3e3eSSaravana Kannan { 1743d46f3e3eSSaravana Kannan struct device_link *link = to_devlink(dev); 1744d46f3e3eSSaravana Kannan 1745d46f3e3eSSaravana Kannan if (!link->supplier->can_match) 1746d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1747d46f3e3eSSaravana Kannan 1748d46f3e3eSSaravana Kannan return 0; 1749d46f3e3eSSaravana Kannan } 1750d46f3e3eSSaravana Kannan 1751d46f3e3eSSaravana Kannan void fw_devlink_drivers_done(void) 1752d46f3e3eSSaravana Kannan { 1753d46f3e3eSSaravana Kannan fw_devlink_drv_reg_done = true; 1754d46f3e3eSSaravana Kannan device_links_write_lock(); 1755d46f3e3eSSaravana Kannan class_for_each_device(&devlink_class, NULL, NULL, 1756d46f3e3eSSaravana Kannan fw_devlink_no_driver); 1757d46f3e3eSSaravana Kannan device_links_write_unlock(); 1758d46f3e3eSSaravana Kannan } 1759d46f3e3eSSaravana Kannan 17602f8c3ae8SSaravana Kannan /** 17612f8c3ae8SSaravana Kannan * wait_for_init_devices_probe - Try to probe any device needed for init 17622f8c3ae8SSaravana Kannan * 17632f8c3ae8SSaravana Kannan * Some devices might need to be probed and bound successfully before the kernel 17642f8c3ae8SSaravana Kannan * boot sequence can finish and move on to init/userspace. For example, a 17652f8c3ae8SSaravana Kannan * network interface might need to be bound to be able to mount a NFS rootfs. 17662f8c3ae8SSaravana Kannan * 17672f8c3ae8SSaravana Kannan * With fw_devlink=on by default, some of these devices might be blocked from 17682f8c3ae8SSaravana Kannan * probing because they are waiting on a optional supplier that doesn't have a 17692f8c3ae8SSaravana Kannan * driver. While fw_devlink will eventually identify such devices and unblock 17702f8c3ae8SSaravana Kannan * the probing automatically, it might be too late by the time it unblocks the 17712f8c3ae8SSaravana Kannan * probing of devices. For example, the IP4 autoconfig might timeout before 17722f8c3ae8SSaravana Kannan * fw_devlink unblocks probing of the network interface. 17732f8c3ae8SSaravana Kannan * 17742f8c3ae8SSaravana Kannan * This function is available to temporarily try and probe all devices that have 17752f8c3ae8SSaravana Kannan * a driver even if some of their suppliers haven't been added or don't have 17762f8c3ae8SSaravana Kannan * drivers. 17772f8c3ae8SSaravana Kannan * 17782f8c3ae8SSaravana Kannan * The drivers can then decide which of the suppliers are optional vs mandatory 17792f8c3ae8SSaravana Kannan * and probe the device if possible. By the time this function returns, all such 17802f8c3ae8SSaravana Kannan * "best effort" probes are guaranteed to be completed. If a device successfully 17812f8c3ae8SSaravana Kannan * probes in this mode, we delete all fw_devlink discovered dependencies of that 17822f8c3ae8SSaravana Kannan * device where the supplier hasn't yet probed successfully because they have to 17832f8c3ae8SSaravana Kannan * be optional dependencies. 17842f8c3ae8SSaravana Kannan * 17852f8c3ae8SSaravana Kannan * Any devices that didn't successfully probe go back to being treated as if 17862f8c3ae8SSaravana Kannan * this function was never called. 17872f8c3ae8SSaravana Kannan * 17882f8c3ae8SSaravana Kannan * This also means that some devices that aren't needed for init and could have 17892f8c3ae8SSaravana Kannan * waited for their optional supplier to probe (when the supplier's module is 17902f8c3ae8SSaravana Kannan * loaded later on) would end up probing prematurely with limited functionality. 17912f8c3ae8SSaravana Kannan * So call this function only when boot would fail without it. 17922f8c3ae8SSaravana Kannan */ 17932f8c3ae8SSaravana Kannan void __init wait_for_init_devices_probe(void) 17942f8c3ae8SSaravana Kannan { 17952f8c3ae8SSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive()) 17962f8c3ae8SSaravana Kannan return; 17972f8c3ae8SSaravana Kannan 17982f8c3ae8SSaravana Kannan /* 17992f8c3ae8SSaravana Kannan * Wait for all ongoing probes to finish so that the "best effort" is 18002f8c3ae8SSaravana Kannan * only applied to devices that can't probe otherwise. 18012f8c3ae8SSaravana Kannan */ 18022f8c3ae8SSaravana Kannan wait_for_device_probe(); 18032f8c3ae8SSaravana Kannan 18042f8c3ae8SSaravana Kannan pr_info("Trying to probe devices needed for running init ...\n"); 18052f8c3ae8SSaravana Kannan fw_devlink_best_effort = true; 18062f8c3ae8SSaravana Kannan driver_deferred_probe_trigger(); 18072f8c3ae8SSaravana Kannan 18082f8c3ae8SSaravana Kannan /* 18092f8c3ae8SSaravana Kannan * Wait for all "best effort" probes to finish before going back to 18102f8c3ae8SSaravana Kannan * normal enforcement. 18112f8c3ae8SSaravana Kannan */ 18122f8c3ae8SSaravana Kannan wait_for_device_probe(); 18132f8c3ae8SSaravana Kannan fw_devlink_best_effort = false; 18142f8c3ae8SSaravana Kannan } 18152f8c3ae8SSaravana Kannan 1816d46f3e3eSSaravana Kannan static void fw_devlink_unblock_consumers(struct device *dev) 1817d46f3e3eSSaravana Kannan { 1818d46f3e3eSSaravana Kannan struct device_link *link; 1819d46f3e3eSSaravana Kannan 1820d46f3e3eSSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive()) 1821d46f3e3eSSaravana Kannan return; 1822d46f3e3eSSaravana Kannan 1823d46f3e3eSSaravana Kannan device_links_write_lock(); 1824d46f3e3eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) 1825d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1826d46f3e3eSSaravana Kannan device_links_write_unlock(); 1827d46f3e3eSSaravana Kannan } 1828d46f3e3eSSaravana Kannan 1829f9aa4606SSaravana Kannan /** 1830b0e2fa4fSSaravana Kannan * fw_devlink_relax_cycle - Convert cyclic links to SYNC_STATE_ONLY links 1831b0e2fa4fSSaravana Kannan * @con: Device to check dependencies for. 1832b0e2fa4fSSaravana Kannan * @sup: Device to check against. 1833b0e2fa4fSSaravana Kannan * 1834b0e2fa4fSSaravana Kannan * Check if @sup depends on @con or any device dependent on it (its child or 1835b0e2fa4fSSaravana Kannan * its consumer etc). When such a cyclic dependency is found, convert all 1836b0e2fa4fSSaravana Kannan * device links created solely by fw_devlink into SYNC_STATE_ONLY device links. 1837b0e2fa4fSSaravana Kannan * This is the equivalent of doing fw_devlink=permissive just between the 1838b0e2fa4fSSaravana Kannan * devices in the cycle. We need to do this because, at this point, fw_devlink 1839b0e2fa4fSSaravana Kannan * can't tell which of these dependencies is not a real dependency. 1840b0e2fa4fSSaravana Kannan * 1841b0e2fa4fSSaravana Kannan * Return 1 if a cycle is found. Otherwise, return 0. 1842b0e2fa4fSSaravana Kannan */ 1843c13b8279Skernel test robot static int fw_devlink_relax_cycle(struct device *con, void *sup) 1844b0e2fa4fSSaravana Kannan { 1845b0e2fa4fSSaravana Kannan struct device_link *link; 1846b0e2fa4fSSaravana Kannan int ret; 1847b0e2fa4fSSaravana Kannan 1848b0e2fa4fSSaravana Kannan if (con == sup) 1849b0e2fa4fSSaravana Kannan return 1; 1850b0e2fa4fSSaravana Kannan 1851b0e2fa4fSSaravana Kannan ret = device_for_each_child(con, sup, fw_devlink_relax_cycle); 1852b0e2fa4fSSaravana Kannan if (ret) 1853b0e2fa4fSSaravana Kannan return ret; 1854b0e2fa4fSSaravana Kannan 1855b0e2fa4fSSaravana Kannan list_for_each_entry(link, &con->links.consumers, s_node) { 1856b0e2fa4fSSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 1857b0e2fa4fSSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 1858b0e2fa4fSSaravana Kannan continue; 1859b0e2fa4fSSaravana Kannan 1860b0e2fa4fSSaravana Kannan if (!fw_devlink_relax_cycle(link->consumer, sup)) 1861b0e2fa4fSSaravana Kannan continue; 1862b0e2fa4fSSaravana Kannan 1863b0e2fa4fSSaravana Kannan ret = 1; 1864b0e2fa4fSSaravana Kannan 1865d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1866b0e2fa4fSSaravana Kannan } 1867b0e2fa4fSSaravana Kannan return ret; 1868b0e2fa4fSSaravana Kannan } 1869b0e2fa4fSSaravana Kannan 1870*411c0d58SSaravana Kannan static bool fwnode_init_without_drv(struct fwnode_handle *fwnode) 1871*411c0d58SSaravana Kannan { 1872*411c0d58SSaravana Kannan struct device *dev; 1873*411c0d58SSaravana Kannan bool ret; 1874*411c0d58SSaravana Kannan 1875*411c0d58SSaravana Kannan if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED)) 1876*411c0d58SSaravana Kannan return false; 1877*411c0d58SSaravana Kannan 1878*411c0d58SSaravana Kannan dev = get_dev_from_fwnode(fwnode); 1879*411c0d58SSaravana Kannan ret = !dev || dev->links.status == DL_DEV_NO_DRIVER; 1880*411c0d58SSaravana Kannan put_device(dev); 1881*411c0d58SSaravana Kannan 1882*411c0d58SSaravana Kannan return ret; 1883*411c0d58SSaravana Kannan } 1884*411c0d58SSaravana Kannan 1885*411c0d58SSaravana Kannan static bool fwnode_ancestor_init_without_drv(struct fwnode_handle *fwnode) 1886*411c0d58SSaravana Kannan { 1887*411c0d58SSaravana Kannan struct fwnode_handle *parent; 1888*411c0d58SSaravana Kannan 1889*411c0d58SSaravana Kannan fwnode_for_each_parent_node(fwnode, parent) { 1890*411c0d58SSaravana Kannan if (fwnode_init_without_drv(parent)) { 1891*411c0d58SSaravana Kannan fwnode_handle_put(parent); 1892*411c0d58SSaravana Kannan return true; 1893*411c0d58SSaravana Kannan } 1894*411c0d58SSaravana Kannan } 1895*411c0d58SSaravana Kannan 1896*411c0d58SSaravana Kannan return false; 1897*411c0d58SSaravana Kannan } 1898*411c0d58SSaravana Kannan 1899b0e2fa4fSSaravana Kannan /** 1900f9aa4606SSaravana Kannan * fw_devlink_create_devlink - Create a device link from a consumer to fwnode 190137c52f74SPierre-Louis Bossart * @con: consumer device for the device link 190237c52f74SPierre-Louis Bossart * @sup_handle: fwnode handle of supplier 190337c52f74SPierre-Louis Bossart * @flags: devlink flags 1904f9aa4606SSaravana Kannan * 1905f9aa4606SSaravana Kannan * This function will try to create a device link between the consumer device 1906f9aa4606SSaravana Kannan * @con and the supplier device represented by @sup_handle. 1907f9aa4606SSaravana Kannan * 1908f9aa4606SSaravana Kannan * The supplier has to be provided as a fwnode because incorrect cycles in 1909f9aa4606SSaravana Kannan * fwnode links can sometimes cause the supplier device to never be created. 1910f9aa4606SSaravana Kannan * This function detects such cases and returns an error if it cannot create a 1911f9aa4606SSaravana Kannan * device link from the consumer to a missing supplier. 1912f9aa4606SSaravana Kannan * 1913f9aa4606SSaravana Kannan * Returns, 1914f9aa4606SSaravana Kannan * 0 on successfully creating a device link 1915f9aa4606SSaravana Kannan * -EINVAL if the device link cannot be created as expected 1916f9aa4606SSaravana Kannan * -EAGAIN if the device link cannot be created right now, but it may be 1917f9aa4606SSaravana Kannan * possible to do that in the future 1918f9aa4606SSaravana Kannan */ 1919f9aa4606SSaravana Kannan static int fw_devlink_create_devlink(struct device *con, 1920f9aa4606SSaravana Kannan struct fwnode_handle *sup_handle, u32 flags) 1921f9aa4606SSaravana Kannan { 1922f9aa4606SSaravana Kannan struct device *sup_dev; 1923f9aa4606SSaravana Kannan int ret = 0; 1924f9aa4606SSaravana Kannan 19255501765aSSaravana Kannan /* 19265501765aSSaravana Kannan * In some cases, a device P might also be a supplier to its child node 19275501765aSSaravana Kannan * C. However, this would defer the probe of C until the probe of P 19285501765aSSaravana Kannan * completes successfully. This is perfectly fine in the device driver 19295501765aSSaravana Kannan * model. device_add() doesn't guarantee probe completion of the device 19305501765aSSaravana Kannan * by the time it returns. 19315501765aSSaravana Kannan * 19325501765aSSaravana Kannan * However, there are a few drivers that assume C will finish probing 19335501765aSSaravana Kannan * as soon as it's added and before P finishes probing. So, we provide 19345501765aSSaravana Kannan * a flag to let fw_devlink know not to delay the probe of C until the 19355501765aSSaravana Kannan * probe of P completes successfully. 19365501765aSSaravana Kannan * 19375501765aSSaravana Kannan * When such a flag is set, we can't create device links where P is the 19385501765aSSaravana Kannan * supplier of C as that would delay the probe of C. 19395501765aSSaravana Kannan */ 19405501765aSSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD && 19415501765aSSaravana Kannan fwnode_is_ancestor_of(sup_handle, con->fwnode)) 19425501765aSSaravana Kannan return -EINVAL; 19435501765aSSaravana Kannan 19443a2dbc51SSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE) 19453a2dbc51SSaravana Kannan sup_dev = fwnode_get_next_parent_dev(sup_handle); 19463a2dbc51SSaravana Kannan else 1947f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle); 19483a2dbc51SSaravana Kannan 1949f9aa4606SSaravana Kannan if (sup_dev) { 1950f9aa4606SSaravana Kannan /* 195174c782cfSSaravana Kannan * If it's one of those drivers that don't actually bind to 195274c782cfSSaravana Kannan * their device using driver core, then don't wait on this 195374c782cfSSaravana Kannan * supplier device indefinitely. 195474c782cfSSaravana Kannan */ 195574c782cfSSaravana Kannan if (sup_dev->links.status == DL_DEV_NO_DRIVER && 195674c782cfSSaravana Kannan sup_handle->flags & FWNODE_FLAG_INITIALIZED) { 195774c782cfSSaravana Kannan ret = -EINVAL; 195874c782cfSSaravana Kannan goto out; 195974c782cfSSaravana Kannan } 196074c782cfSSaravana Kannan 196174c782cfSSaravana Kannan /* 1962f9aa4606SSaravana Kannan * If this fails, it is due to cycles in device links. Just 1963f9aa4606SSaravana Kannan * give up on this link and treat it as invalid. 1964f9aa4606SSaravana Kannan */ 1965b0e2fa4fSSaravana Kannan if (!device_link_add(con, sup_dev, flags) && 1966b0e2fa4fSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 1967b0e2fa4fSSaravana Kannan dev_info(con, "Fixing up cyclic dependency with %s\n", 1968b0e2fa4fSSaravana Kannan dev_name(sup_dev)); 1969b0e2fa4fSSaravana Kannan device_links_write_lock(); 1970b0e2fa4fSSaravana Kannan fw_devlink_relax_cycle(con, sup_dev); 1971b0e2fa4fSSaravana Kannan device_links_write_unlock(); 1972b0e2fa4fSSaravana Kannan device_link_add(con, sup_dev, 1973b0e2fa4fSSaravana Kannan FW_DEVLINK_FLAGS_PERMISSIVE); 1974f9aa4606SSaravana Kannan ret = -EINVAL; 1975b0e2fa4fSSaravana Kannan } 1976f9aa4606SSaravana Kannan 1977f9aa4606SSaravana Kannan goto out; 1978f9aa4606SSaravana Kannan } 1979f9aa4606SSaravana Kannan 1980*411c0d58SSaravana Kannan /* 1981*411c0d58SSaravana Kannan * Supplier or supplier's ancestor already initialized without a struct 1982*411c0d58SSaravana Kannan * device or being probed by a driver. 1983*411c0d58SSaravana Kannan */ 1984*411c0d58SSaravana Kannan if (fwnode_init_without_drv(sup_handle) || 1985*411c0d58SSaravana Kannan fwnode_ancestor_init_without_drv(sup_handle)) { 1986*411c0d58SSaravana Kannan dev_dbg(con, "Not linking %pfwP - Might never probe\n", 1987*411c0d58SSaravana Kannan sup_handle); 198874c782cfSSaravana Kannan return -EINVAL; 1989*411c0d58SSaravana Kannan } 199074c782cfSSaravana Kannan 1991f9aa4606SSaravana Kannan /* 1992f9aa4606SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY doesn't block probing and supports 1993f9aa4606SSaravana Kannan * cycles. So cycle detection isn't necessary and shouldn't be 1994f9aa4606SSaravana Kannan * done. 1995f9aa4606SSaravana Kannan */ 1996f9aa4606SSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) 1997f9aa4606SSaravana Kannan return -EAGAIN; 1998f9aa4606SSaravana Kannan 1999f9aa4606SSaravana Kannan /* 2000f9aa4606SSaravana Kannan * If we can't find the supplier device from its fwnode, it might be 2001f9aa4606SSaravana Kannan * due to a cyclic dependency between fwnodes. Some of these cycles can 2002f9aa4606SSaravana Kannan * be broken by applying logic. Check for these types of cycles and 2003f9aa4606SSaravana Kannan * break them so that devices in the cycle probe properly. 2004f9aa4606SSaravana Kannan * 20052de9d8e0SSaravana Kannan * If the supplier's parent is dependent on the consumer, then the 20062de9d8e0SSaravana Kannan * consumer and supplier have a cyclic dependency. Since fw_devlink 20072de9d8e0SSaravana Kannan * can't tell which of the inferred dependencies are incorrect, don't 20082de9d8e0SSaravana Kannan * enforce probe ordering between any of the devices in this cyclic 20092de9d8e0SSaravana Kannan * dependency. Do this by relaxing all the fw_devlink device links in 20102de9d8e0SSaravana Kannan * this cycle and by treating the fwnode link between the consumer and 20112de9d8e0SSaravana Kannan * the supplier as an invalid dependency. 2012f9aa4606SSaravana Kannan */ 2013f9aa4606SSaravana Kannan sup_dev = fwnode_get_next_parent_dev(sup_handle); 2014f9aa4606SSaravana Kannan if (sup_dev && device_is_dependent(con, sup_dev)) { 20152de9d8e0SSaravana Kannan dev_info(con, "Fixing up cyclic dependency with %pfwP (%s)\n", 20162de9d8e0SSaravana Kannan sup_handle, dev_name(sup_dev)); 20172de9d8e0SSaravana Kannan device_links_write_lock(); 20182de9d8e0SSaravana Kannan fw_devlink_relax_cycle(con, sup_dev); 20192de9d8e0SSaravana Kannan device_links_write_unlock(); 2020f9aa4606SSaravana Kannan ret = -EINVAL; 2021f9aa4606SSaravana Kannan } else { 2022f9aa4606SSaravana Kannan /* 2023f9aa4606SSaravana Kannan * Can't check for cycles or no cycles. So let's try 2024f9aa4606SSaravana Kannan * again later. 2025f9aa4606SSaravana Kannan */ 2026f9aa4606SSaravana Kannan ret = -EAGAIN; 2027f9aa4606SSaravana Kannan } 2028f9aa4606SSaravana Kannan 2029f9aa4606SSaravana Kannan out: 2030f9aa4606SSaravana Kannan put_device(sup_dev); 2031f9aa4606SSaravana Kannan return ret; 2032f9aa4606SSaravana Kannan } 2033f9aa4606SSaravana Kannan 2034f9aa4606SSaravana Kannan /** 2035f9aa4606SSaravana Kannan * __fw_devlink_link_to_consumers - Create device links to consumers of a device 203637c52f74SPierre-Louis Bossart * @dev: Device that needs to be linked to its consumers 2037f9aa4606SSaravana Kannan * 2038f9aa4606SSaravana Kannan * This function looks at all the consumer fwnodes of @dev and creates device 2039f9aa4606SSaravana Kannan * links between the consumer device and @dev (supplier). 2040f9aa4606SSaravana Kannan * 2041f9aa4606SSaravana Kannan * If the consumer device has not been added yet, then this function creates a 2042f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link between @dev (supplier) and the closest ancestor device 2043f9aa4606SSaravana Kannan * of the consumer fwnode. This is necessary to make sure @dev doesn't get a 2044f9aa4606SSaravana Kannan * sync_state() callback before the real consumer device gets to be added and 2045f9aa4606SSaravana Kannan * then probed. 2046f9aa4606SSaravana Kannan * 2047f9aa4606SSaravana Kannan * Once device links are created from the real consumer to @dev (supplier), the 2048f9aa4606SSaravana Kannan * fwnode links are deleted. 2049f9aa4606SSaravana Kannan */ 2050f9aa4606SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev) 2051f9aa4606SSaravana Kannan { 2052f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 2053f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 2054f9aa4606SSaravana Kannan 2055f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { 2056f9aa4606SSaravana Kannan u32 dl_flags = fw_devlink_get_flags(); 2057f9aa4606SSaravana Kannan struct device *con_dev; 2058f9aa4606SSaravana Kannan bool own_link = true; 2059f9aa4606SSaravana Kannan int ret; 2060f9aa4606SSaravana Kannan 2061f9aa4606SSaravana Kannan con_dev = get_dev_from_fwnode(link->consumer); 2062f9aa4606SSaravana Kannan /* 2063f9aa4606SSaravana Kannan * If consumer device is not available yet, make a "proxy" 2064f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link from the consumer's parent device to 2065f9aa4606SSaravana Kannan * the supplier device. This is necessary to make sure the 2066f9aa4606SSaravana Kannan * supplier doesn't get a sync_state() callback before the real 2067f9aa4606SSaravana Kannan * consumer can create a device link to the supplier. 2068f9aa4606SSaravana Kannan * 2069f9aa4606SSaravana Kannan * This proxy link step is needed to handle the case where the 2070f9aa4606SSaravana Kannan * consumer's parent device is added before the supplier. 2071f9aa4606SSaravana Kannan */ 2072f9aa4606SSaravana Kannan if (!con_dev) { 2073f9aa4606SSaravana Kannan con_dev = fwnode_get_next_parent_dev(link->consumer); 2074f9aa4606SSaravana Kannan /* 2075f9aa4606SSaravana Kannan * However, if the consumer's parent device is also the 2076f9aa4606SSaravana Kannan * parent of the supplier, don't create a 2077f9aa4606SSaravana Kannan * consumer-supplier link from the parent to its child 2078f9aa4606SSaravana Kannan * device. Such a dependency is impossible. 2079f9aa4606SSaravana Kannan */ 2080f9aa4606SSaravana Kannan if (con_dev && 2081f9aa4606SSaravana Kannan fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { 2082f9aa4606SSaravana Kannan put_device(con_dev); 2083f9aa4606SSaravana Kannan con_dev = NULL; 2084f9aa4606SSaravana Kannan } else { 2085f9aa4606SSaravana Kannan own_link = false; 2086b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 2087f9aa4606SSaravana Kannan } 2088f9aa4606SSaravana Kannan } 2089f9aa4606SSaravana Kannan 2090f9aa4606SSaravana Kannan if (!con_dev) 2091f9aa4606SSaravana Kannan continue; 2092f9aa4606SSaravana Kannan 2093f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(con_dev, fwnode, dl_flags); 2094f9aa4606SSaravana Kannan put_device(con_dev); 2095f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 2096f9aa4606SSaravana Kannan continue; 2097f9aa4606SSaravana Kannan 209876f13081SSaravana Kannan __fwnode_link_del(link); 2099f9aa4606SSaravana Kannan } 2100f9aa4606SSaravana Kannan } 2101f9aa4606SSaravana Kannan 2102f9aa4606SSaravana Kannan /** 2103f9aa4606SSaravana Kannan * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device 210437c52f74SPierre-Louis Bossart * @dev: The consumer device that needs to be linked to its suppliers 210537c52f74SPierre-Louis Bossart * @fwnode: Root of the fwnode tree that is used to create device links 2106f9aa4606SSaravana Kannan * 2107f9aa4606SSaravana Kannan * This function looks at all the supplier fwnodes of fwnode tree rooted at 2108f9aa4606SSaravana Kannan * @fwnode and creates device links between @dev (consumer) and all the 2109f9aa4606SSaravana Kannan * supplier devices of the entire fwnode tree at @fwnode. 2110f9aa4606SSaravana Kannan * 2111f9aa4606SSaravana Kannan * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev 2112f9aa4606SSaravana Kannan * and the real suppliers of @dev. Once these device links are created, the 2113f9aa4606SSaravana Kannan * fwnode links are deleted. When such device links are successfully created, 2114f9aa4606SSaravana Kannan * this function is called recursively on those supplier devices. This is 2115f9aa4606SSaravana Kannan * needed to detect and break some invalid cycles in fwnode links. See 2116f9aa4606SSaravana Kannan * fw_devlink_create_devlink() for more details. 2117f9aa4606SSaravana Kannan * 2118f9aa4606SSaravana Kannan * In addition, it also looks at all the suppliers of the entire fwnode tree 2119f9aa4606SSaravana Kannan * because some of the child devices of @dev that have not been added yet 2120f9aa4606SSaravana Kannan * (because @dev hasn't probed) might already have their suppliers added to 2121f9aa4606SSaravana Kannan * driver core. So, this function creates SYNC_STATE_ONLY device links between 2122f9aa4606SSaravana Kannan * @dev (consumer) and these suppliers to make sure they don't execute their 2123f9aa4606SSaravana Kannan * sync_state() callbacks before these child devices have a chance to create 2124f9aa4606SSaravana Kannan * their device links. The fwnode links that correspond to the child devices 2125f9aa4606SSaravana Kannan * aren't delete because they are needed later to create the device links 2126f9aa4606SSaravana Kannan * between the real consumer and supplier devices. 2127f9aa4606SSaravana Kannan */ 2128f9aa4606SSaravana Kannan static void __fw_devlink_link_to_suppliers(struct device *dev, 2129f9aa4606SSaravana Kannan struct fwnode_handle *fwnode) 2130f9aa4606SSaravana Kannan { 2131f9aa4606SSaravana Kannan bool own_link = (dev->fwnode == fwnode); 2132f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 2133f9aa4606SSaravana Kannan struct fwnode_handle *child = NULL; 2134f9aa4606SSaravana Kannan u32 dl_flags; 2135f9aa4606SSaravana Kannan 2136f9aa4606SSaravana Kannan if (own_link) 2137f9aa4606SSaravana Kannan dl_flags = fw_devlink_get_flags(); 2138f9aa4606SSaravana Kannan else 2139b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 2140f9aa4606SSaravana Kannan 2141f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { 2142f9aa4606SSaravana Kannan int ret; 2143f9aa4606SSaravana Kannan struct device *sup_dev; 2144f9aa4606SSaravana Kannan struct fwnode_handle *sup = link->supplier; 2145f9aa4606SSaravana Kannan 2146f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(dev, sup, dl_flags); 2147f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 2148f9aa4606SSaravana Kannan continue; 2149f9aa4606SSaravana Kannan 215076f13081SSaravana Kannan __fwnode_link_del(link); 2151f9aa4606SSaravana Kannan 2152f9aa4606SSaravana Kannan /* If no device link was created, nothing more to do. */ 2153f9aa4606SSaravana Kannan if (ret) 2154f9aa4606SSaravana Kannan continue; 2155f9aa4606SSaravana Kannan 2156f9aa4606SSaravana Kannan /* 2157f9aa4606SSaravana Kannan * If a device link was successfully created to a supplier, we 2158f9aa4606SSaravana Kannan * now need to try and link the supplier to all its suppliers. 2159f9aa4606SSaravana Kannan * 2160f9aa4606SSaravana Kannan * This is needed to detect and delete false dependencies in 2161f9aa4606SSaravana Kannan * fwnode links that haven't been converted to a device link 2162f9aa4606SSaravana Kannan * yet. See comments in fw_devlink_create_devlink() for more 2163f9aa4606SSaravana Kannan * details on the false dependency. 2164f9aa4606SSaravana Kannan * 2165f9aa4606SSaravana Kannan * Without deleting these false dependencies, some devices will 2166f9aa4606SSaravana Kannan * never probe because they'll keep waiting for their false 2167f9aa4606SSaravana Kannan * dependency fwnode links to be converted to device links. 2168f9aa4606SSaravana Kannan */ 2169f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup); 2170f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(sup_dev, sup_dev->fwnode); 2171f9aa4606SSaravana Kannan put_device(sup_dev); 2172f9aa4606SSaravana Kannan } 2173f9aa4606SSaravana Kannan 2174f9aa4606SSaravana Kannan /* 2175f9aa4606SSaravana Kannan * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of 2176f9aa4606SSaravana Kannan * all the descendants. This proxy link step is needed to handle the 2177f9aa4606SSaravana Kannan * case where the supplier is added before the consumer's parent device 2178f9aa4606SSaravana Kannan * (@dev). 2179f9aa4606SSaravana Kannan */ 2180f9aa4606SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 2181f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, child); 2182f9aa4606SSaravana Kannan } 2183f9aa4606SSaravana Kannan 21845f5377eaSSaravana Kannan static void fw_devlink_link_device(struct device *dev) 21855f5377eaSSaravana Kannan { 2186f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 21875f5377eaSSaravana Kannan 2188f9aa4606SSaravana Kannan if (!fw_devlink_flags) 2189f9aa4606SSaravana Kannan return; 21905f5377eaSSaravana Kannan 2191f9aa4606SSaravana Kannan fw_devlink_parse_fwtree(fwnode); 2192f9aa4606SSaravana Kannan 2193f9aa4606SSaravana Kannan mutex_lock(&fwnode_link_lock); 2194f9aa4606SSaravana Kannan __fw_devlink_link_to_consumers(dev); 2195f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, fwnode); 2196f9aa4606SSaravana Kannan mutex_unlock(&fwnode_link_lock); 21975f5377eaSSaravana Kannan } 21985f5377eaSSaravana Kannan 21999ed98953SRafael J. Wysocki /* Device links support end. */ 22009ed98953SRafael J. Wysocki 22011da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 22021da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 2203e105b8bfSDan Williams static struct kobject *dev_kobj; 2204e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 2205e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 22061da177e4SLinus Torvalds 22075e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 22085e33bc41SRafael J. Wysocki 22095e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 22105e33bc41SRafael J. Wysocki { 22115e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 22125e33bc41SRafael J. Wysocki } 22135e33bc41SRafael J. Wysocki 22145e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 22155e33bc41SRafael J. Wysocki { 22165e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 22175e33bc41SRafael J. Wysocki } 22185e33bc41SRafael J. Wysocki 22195e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 22205e33bc41SRafael J. Wysocki { 22215e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 22225e33bc41SRafael J. Wysocki return 0; 22235e33bc41SRafael J. Wysocki 22245e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 22255e33bc41SRafael J. Wysocki msleep(5); 22265e33bc41SRafael J. Wysocki return restart_syscall(); 22275e33bc41SRafael J. Wysocki } 22285e33bc41SRafael J. Wysocki 22294e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 22304e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 22314e886c29SGreg Kroah-Hartman { 22324e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 22334e886c29SGreg Kroah-Hartman } 22344e886c29SGreg Kroah-Hartman #else 22354e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 22364e886c29SGreg Kroah-Hartman { 22374e886c29SGreg Kroah-Hartman return 1; 22384e886c29SGreg Kroah-Hartman } 22394e886c29SGreg Kroah-Hartman #endif 22401da177e4SLinus Torvalds 2241b2ebd9ddSRafael J. Wysocki static void device_platform_notify(struct device *dev) 224207de0e86SHeikki Krogerus { 2243d0b8e398SRafael J. Wysocki acpi_device_notify(dev); 22447847a145SHeikki Krogerus 2245b2ebd9ddSRafael J. Wysocki software_node_notify(dev); 22467847a145SHeikki Krogerus 2247b2ebd9ddSRafael J. Wysocki if (platform_notify) 224807de0e86SHeikki Krogerus platform_notify(dev); 2249b2ebd9ddSRafael J. Wysocki } 2250b2ebd9ddSRafael J. Wysocki 2251b2ebd9ddSRafael J. Wysocki static void device_platform_notify_remove(struct device *dev) 2252b2ebd9ddSRafael J. Wysocki { 2253d0b8e398SRafael J. Wysocki acpi_device_notify_remove(dev); 225407de0e86SHeikki Krogerus 2255384f5a85SRafael J. Wysocki software_node_notify_remove(dev); 22561da177e4SLinus Torvalds 2257b2ebd9ddSRafael J. Wysocki if (platform_notify_remove) 22581da177e4SLinus Torvalds platform_notify_remove(dev); 22591da177e4SLinus Torvalds } 22601da177e4SLinus Torvalds 22613e95637aSAlan Stern /** 22623e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 22633e95637aSAlan Stern * @dev: struct device to get the name of 22643e95637aSAlan Stern * 22653e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 22669169c012Syan * the device is not bound to a driver, it will return the name of the bus 22673e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 22683e95637aSAlan Stern * string will be returned. 22693e95637aSAlan Stern */ 2270bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 22713e95637aSAlan Stern { 22723589972eSAlan Stern struct device_driver *drv; 22733589972eSAlan Stern 22743589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 22753589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 22763589972eSAlan Stern * never change once they are set, so they don't need special care. 22773589972eSAlan Stern */ 22786aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 2279e020ff61SSaravana Kannan return drv ? drv->name : dev_bus_name(dev); 22803e95637aSAlan Stern } 2281310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 22823e95637aSAlan Stern 22831da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 22841da177e4SLinus Torvalds 22854a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 22864a3ad20cSGreg Kroah-Hartman char *buf) 22871da177e4SLinus Torvalds { 22881da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2289b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 22904a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 22911da177e4SLinus Torvalds 22921da177e4SLinus Torvalds if (dev_attr->show) 229354b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 2294815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 2295a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 2296a52668c6SSergey Senozhatsky dev_attr->show); 2297815d2d50SAndrew Morton } 22981da177e4SLinus Torvalds return ret; 22991da177e4SLinus Torvalds } 23001da177e4SLinus Torvalds 23014a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 23021da177e4SLinus Torvalds const char *buf, size_t count) 23031da177e4SLinus Torvalds { 23041da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2305b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 23064a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 23071da177e4SLinus Torvalds 23081da177e4SLinus Torvalds if (dev_attr->store) 230954b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 23101da177e4SLinus Torvalds return ret; 23111da177e4SLinus Torvalds } 23121da177e4SLinus Torvalds 231352cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 23141da177e4SLinus Torvalds .show = dev_attr_show, 23151da177e4SLinus Torvalds .store = dev_attr_store, 23161da177e4SLinus Torvalds }; 23171da177e4SLinus Torvalds 2318ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 2319ca22e56dSKay Sievers 2320ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 2321ca22e56dSKay Sievers struct device_attribute *attr, 2322ca22e56dSKay Sievers const char *buf, size_t size) 2323ca22e56dSKay Sievers { 2324ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2325f88184bfSKaitao cheng int ret; 2326f88184bfSKaitao cheng unsigned long new; 2327f88184bfSKaitao cheng 2328f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 2329f88184bfSKaitao cheng if (ret) 2330f88184bfSKaitao cheng return ret; 2331ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 2332ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2333ca22e56dSKay Sievers return size; 2334ca22e56dSKay Sievers } 2335ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 2336ca22e56dSKay Sievers 2337ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 2338ca22e56dSKay Sievers struct device_attribute *attr, 2339ca22e56dSKay Sievers char *buf) 2340ca22e56dSKay Sievers { 2341ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2342aa838896SJoe Perches return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); 2343ca22e56dSKay Sievers } 2344ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 2345ca22e56dSKay Sievers 2346ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 2347ca22e56dSKay Sievers struct device_attribute *attr, 2348ca22e56dSKay Sievers const char *buf, size_t size) 2349ca22e56dSKay Sievers { 2350ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2351f88184bfSKaitao cheng int ret; 2352f88184bfSKaitao cheng long new; 2353f88184bfSKaitao cheng 2354f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 2355f88184bfSKaitao cheng if (ret) 2356f88184bfSKaitao cheng return ret; 2357f88184bfSKaitao cheng 2358f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 2359ca22e56dSKay Sievers return -EINVAL; 2360ca22e56dSKay Sievers *(int *)(ea->var) = new; 2361ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2362ca22e56dSKay Sievers return size; 2363ca22e56dSKay Sievers } 2364ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 2365ca22e56dSKay Sievers 2366ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 2367ca22e56dSKay Sievers struct device_attribute *attr, 2368ca22e56dSKay Sievers char *buf) 2369ca22e56dSKay Sievers { 2370ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2371ca22e56dSKay Sievers 2372aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); 2373ca22e56dSKay Sievers } 2374ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 23751da177e4SLinus Torvalds 237691872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 237791872392SBorislav Petkov const char *buf, size_t size) 237891872392SBorislav Petkov { 237991872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 238091872392SBorislav Petkov 238173060022SChristophe JAILLET if (kstrtobool(buf, ea->var) < 0) 238291872392SBorislav Petkov return -EINVAL; 238391872392SBorislav Petkov 238491872392SBorislav Petkov return size; 238591872392SBorislav Petkov } 238691872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 238791872392SBorislav Petkov 238891872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 238991872392SBorislav Petkov char *buf) 239091872392SBorislav Petkov { 239191872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 239291872392SBorislav Petkov 2393aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); 239491872392SBorislav Petkov } 239591872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 239691872392SBorislav Petkov 23971da177e4SLinus Torvalds /** 23981da177e4SLinus Torvalds * device_release - free device structure. 23991da177e4SLinus Torvalds * @kobj: device's kobject. 24001da177e4SLinus Torvalds * 24011da177e4SLinus Torvalds * This is called once the reference count for the object 24021da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 24031da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 24041da177e4SLinus Torvalds */ 24051da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 24061da177e4SLinus Torvalds { 2407b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2408fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 24091da177e4SLinus Torvalds 2410a525a3ddSMing Lei /* 2411a525a3ddSMing Lei * Some platform devices are driven without driver attached 2412a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 2413a525a3ddSMing Lei * all resources are released. 2414a525a3ddSMing Lei * 2415a525a3ddSMing Lei * Drivers still can add resources into device after device 2416a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 2417a525a3ddSMing Lei * possible memory leak. 2418a525a3ddSMing Lei */ 2419a525a3ddSMing Lei devres_release_all(dev); 2420a525a3ddSMing Lei 2421e0d07278SJim Quinlan kfree(dev->dma_range_map); 2422e0d07278SJim Quinlan 24231da177e4SLinus Torvalds if (dev->release) 24241da177e4SLinus Torvalds dev->release(dev); 2425f9f852dfSKay Sievers else if (dev->type && dev->type->release) 2426f9f852dfSKay Sievers dev->type->release(dev); 24272620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 24282620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 2429f810a5cfSArjan van de Ven else 24300c1bc6b8SMauro Carvalho Chehab WARN(1, KERN_ERR "Device '%s' does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kobject.rst.\n", 24311e0b2cf9SKay Sievers dev_name(dev)); 2432fb069a5dSGreg Kroah-Hartman kfree(p); 24331da177e4SLinus Torvalds } 24341da177e4SLinus Torvalds 243502a476d9SGreg Kroah-Hartman static const void *device_namespace(const struct kobject *kobj) 2436bc451f20SEric W. Biederman { 2437fa627348SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 2438bc451f20SEric W. Biederman const void *ns = NULL; 2439bc451f20SEric W. Biederman 2440bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 2441bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 2442bc451f20SEric W. Biederman 2443bc451f20SEric W. Biederman return ns; 2444bc451f20SEric W. Biederman } 2445bc451f20SEric W. Biederman 244602a476d9SGreg Kroah-Hartman static void device_get_ownership(const struct kobject *kobj, kuid_t *uid, kgid_t *gid) 24479944e894SDmitry Torokhov { 2448fa627348SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 24499944e894SDmitry Torokhov 24509944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 24519944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 24529944e894SDmitry Torokhov } 24539944e894SDmitry Torokhov 2454c83d9ab4SThomas Weißschuh static const struct kobj_type device_ktype = { 24551da177e4SLinus Torvalds .release = device_release, 24561da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 2457bc451f20SEric W. Biederman .namespace = device_namespace, 24589944e894SDmitry Torokhov .get_ownership = device_get_ownership, 24591da177e4SLinus Torvalds }; 24601da177e4SLinus Torvalds 24611da177e4SLinus Torvalds 2462c45a88bbSGreg Kroah-Hartman static int dev_uevent_filter(const struct kobject *kobj) 24631da177e4SLinus Torvalds { 2464ee6d3dd4SWedson Almeida Filho const struct kobj_type *ktype = get_ktype(kobj); 24651da177e4SLinus Torvalds 24668f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 2467c45a88bbSGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 24681da177e4SLinus Torvalds if (dev->bus) 24691da177e4SLinus Torvalds return 1; 247023681e47SGreg Kroah-Hartman if (dev->class) 247123681e47SGreg Kroah-Hartman return 1; 24721da177e4SLinus Torvalds } 24731da177e4SLinus Torvalds return 0; 24741da177e4SLinus Torvalds } 24751da177e4SLinus Torvalds 2476a53d1accSGreg Kroah-Hartman static const char *dev_uevent_name(const struct kobject *kobj) 24771da177e4SLinus Torvalds { 2478a53d1accSGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 24791da177e4SLinus Torvalds 248023681e47SGreg Kroah-Hartman if (dev->bus) 24811da177e4SLinus Torvalds return dev->bus->name; 248223681e47SGreg Kroah-Hartman if (dev->class) 248323681e47SGreg Kroah-Hartman return dev->class->name; 248423681e47SGreg Kroah-Hartman return NULL; 24851da177e4SLinus Torvalds } 24861da177e4SLinus Torvalds 248756d5f362SGreg Kroah-Hartman static int dev_uevent(const struct kobject *kobj, struct kobj_uevent_env *env) 24881da177e4SLinus Torvalds { 248956d5f362SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 24901da177e4SLinus Torvalds int retval = 0; 24911da177e4SLinus Torvalds 24926fcf53acSKay Sievers /* add device node properties if present */ 249323681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 24946fcf53acSKay Sievers const char *tmp; 24956fcf53acSKay Sievers const char *name; 24962c9ede55SAl Viro umode_t mode = 0; 24974e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 24984e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 24996fcf53acSKay Sievers 25007eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 25017eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 25023c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 25036fcf53acSKay Sievers if (name) { 25046fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 2505e454cea2SKay Sievers if (mode) 2506e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 25074e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 25084e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 25094e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 25104e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 25113c2670e6SKay Sievers kfree(tmp); 25126fcf53acSKay Sievers } 251323681e47SGreg Kroah-Hartman } 251423681e47SGreg Kroah-Hartman 2515414264f9SKay Sievers if (dev->type && dev->type->name) 25167eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 2517414264f9SKay Sievers 2518239378f1SKay Sievers if (dev->driver) 25197eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 2520239378f1SKay Sievers 252107d57a32SGrant Likely /* Add common DT information about the device */ 252207d57a32SGrant Likely of_device_uevent(dev, env); 252307d57a32SGrant Likely 25241da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 25257eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 25267eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 2527f9f852dfSKay Sievers if (retval) 25287dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 25291e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 25301da177e4SLinus Torvalds } 25311da177e4SLinus Torvalds 25322620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 25337eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 25347eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 2535f9f852dfSKay Sievers if (retval) 25367dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 25371e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 25382b3a302aSHarvey Harrison __func__, retval); 25392620efefSGreg Kroah-Hartman } 2540f9f852dfSKay Sievers 2541eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 25427eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 25437eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 2544f9f852dfSKay Sievers if (retval) 25457dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 25461e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 25472b3a302aSHarvey Harrison __func__, retval); 25482620efefSGreg Kroah-Hartman } 25492620efefSGreg Kroah-Hartman 25501da177e4SLinus Torvalds return retval; 25511da177e4SLinus Torvalds } 25521da177e4SLinus Torvalds 25539cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 2554312c004dSKay Sievers .filter = dev_uevent_filter, 2555312c004dSKay Sievers .name = dev_uevent_name, 2556312c004dSKay Sievers .uevent = dev_uevent, 25571da177e4SLinus Torvalds }; 25581da177e4SLinus Torvalds 2559c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 256016574dccSKay Sievers char *buf) 256116574dccSKay Sievers { 256216574dccSKay Sievers struct kobject *top_kobj; 256316574dccSKay Sievers struct kset *kset; 25647eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 256516574dccSKay Sievers int i; 2566948b3edbSJoe Perches int len = 0; 256716574dccSKay Sievers int retval; 256816574dccSKay Sievers 256916574dccSKay Sievers /* search the kset, the device belongs to */ 257016574dccSKay Sievers top_kobj = &dev->kobj; 25715c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 257216574dccSKay Sievers top_kobj = top_kobj->parent; 257316574dccSKay Sievers if (!top_kobj->kset) 257416574dccSKay Sievers goto out; 25755c5daf65SKay Sievers 257616574dccSKay Sievers kset = top_kobj->kset; 257716574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 257816574dccSKay Sievers goto out; 257916574dccSKay Sievers 258016574dccSKay Sievers /* respect filter */ 258116574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 2582cf6299b6SGreg Kroah-Hartman if (!kset->uevent_ops->filter(&dev->kobj)) 258316574dccSKay Sievers goto out; 258416574dccSKay Sievers 25857eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 25867eff2e7aSKay Sievers if (!env) 2587c7308c81SGreg Kroah-Hartman return -ENOMEM; 2588c7308c81SGreg Kroah-Hartman 258916574dccSKay Sievers /* let the kset specific function add its keys */ 2590cf6299b6SGreg Kroah-Hartman retval = kset->uevent_ops->uevent(&dev->kobj, env); 259116574dccSKay Sievers if (retval) 259216574dccSKay Sievers goto out; 259316574dccSKay Sievers 259416574dccSKay Sievers /* copy keys to file */ 25957eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 2596948b3edbSJoe Perches len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); 259716574dccSKay Sievers out: 25987eff2e7aSKay Sievers kfree(env); 2599948b3edbSJoe Perches return len; 260016574dccSKay Sievers } 260116574dccSKay Sievers 2602c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 2603a7fd6706SKay Sievers const char *buf, size_t count) 2604a7fd6706SKay Sievers { 2605df44b479SPeter Rajnoha int rc; 2606df44b479SPeter Rajnoha 2607df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 2608df44b479SPeter Rajnoha 2609df44b479SPeter Rajnoha if (rc) { 26106bb7ea3aSBrian Norris dev_err(dev, "uevent: failed to send synthetic uevent: %d\n", rc); 2611df44b479SPeter Rajnoha return rc; 2612df44b479SPeter Rajnoha } 261360a96a59SKay Sievers 2614a7fd6706SKay Sievers return count; 2615a7fd6706SKay Sievers } 2616c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 2617a7fd6706SKay Sievers 2618c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 26194f3549d7SRafael J. Wysocki char *buf) 26204f3549d7SRafael J. Wysocki { 26214f3549d7SRafael J. Wysocki bool val; 26224f3549d7SRafael J. Wysocki 26235e33bc41SRafael J. Wysocki device_lock(dev); 26244f3549d7SRafael J. Wysocki val = !dev->offline; 26255e33bc41SRafael J. Wysocki device_unlock(dev); 2626aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 26274f3549d7SRafael J. Wysocki } 26284f3549d7SRafael J. Wysocki 2629c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 26304f3549d7SRafael J. Wysocki const char *buf, size_t count) 26314f3549d7SRafael J. Wysocki { 26324f3549d7SRafael J. Wysocki bool val; 26334f3549d7SRafael J. Wysocki int ret; 26344f3549d7SRafael J. Wysocki 263573060022SChristophe JAILLET ret = kstrtobool(buf, &val); 26364f3549d7SRafael J. Wysocki if (ret < 0) 26374f3549d7SRafael J. Wysocki return ret; 26384f3549d7SRafael J. Wysocki 26395e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 26405e33bc41SRafael J. Wysocki if (ret) 26415e33bc41SRafael J. Wysocki return ret; 26425e33bc41SRafael J. Wysocki 26434f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 26444f3549d7SRafael J. Wysocki unlock_device_hotplug(); 26454f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 26464f3549d7SRafael J. Wysocki } 2647c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 26484f3549d7SRafael J. Wysocki 264970f400d4SRajat Jain static ssize_t removable_show(struct device *dev, struct device_attribute *attr, 265070f400d4SRajat Jain char *buf) 265170f400d4SRajat Jain { 265270f400d4SRajat Jain const char *loc; 265370f400d4SRajat Jain 265470f400d4SRajat Jain switch (dev->removable) { 265570f400d4SRajat Jain case DEVICE_REMOVABLE: 265670f400d4SRajat Jain loc = "removable"; 265770f400d4SRajat Jain break; 265870f400d4SRajat Jain case DEVICE_FIXED: 265970f400d4SRajat Jain loc = "fixed"; 266070f400d4SRajat Jain break; 266170f400d4SRajat Jain default: 266270f400d4SRajat Jain loc = "unknown"; 266370f400d4SRajat Jain } 266470f400d4SRajat Jain return sysfs_emit(buf, "%s\n", loc); 266570f400d4SRajat Jain } 266670f400d4SRajat Jain static DEVICE_ATTR_RO(removable); 266770f400d4SRajat Jain 2668fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 2669621a1672SDmitry Torokhov { 26703e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 2671621a1672SDmitry Torokhov } 2672a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 2673621a1672SDmitry Torokhov 2674fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 2675a4dbd674SDavid Brownell const struct attribute_group **groups) 2676621a1672SDmitry Torokhov { 26773e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 2678621a1672SDmitry Torokhov } 2679a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 2680de0ff00dSGreg Kroah-Hartman 268157b8ff07SDmitry Torokhov union device_attr_group_devres { 268257b8ff07SDmitry Torokhov const struct attribute_group *group; 268357b8ff07SDmitry Torokhov const struct attribute_group **groups; 268457b8ff07SDmitry Torokhov }; 268557b8ff07SDmitry Torokhov 268657b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 268757b8ff07SDmitry Torokhov { 268857b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 268957b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 269057b8ff07SDmitry Torokhov 269157b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 269257b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 269357b8ff07SDmitry Torokhov } 269457b8ff07SDmitry Torokhov 269557b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 269657b8ff07SDmitry Torokhov { 269757b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 269857b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 269957b8ff07SDmitry Torokhov 270057b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 270157b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 270257b8ff07SDmitry Torokhov } 270357b8ff07SDmitry Torokhov 270457b8ff07SDmitry Torokhov /** 270557b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 270657b8ff07SDmitry Torokhov * @dev: The device to create the group for 270757b8ff07SDmitry Torokhov * @grp: The attribute group to create 270857b8ff07SDmitry Torokhov * 270957b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 271057b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 271157b8ff07SDmitry Torokhov * 271257b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 271357b8ff07SDmitry Torokhov */ 271457b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 271557b8ff07SDmitry Torokhov { 271657b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 271757b8ff07SDmitry Torokhov int error; 271857b8ff07SDmitry Torokhov 271957b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 272057b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 272157b8ff07SDmitry Torokhov if (!devres) 272257b8ff07SDmitry Torokhov return -ENOMEM; 272357b8ff07SDmitry Torokhov 272457b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 272557b8ff07SDmitry Torokhov if (error) { 272657b8ff07SDmitry Torokhov devres_free(devres); 272757b8ff07SDmitry Torokhov return error; 272857b8ff07SDmitry Torokhov } 272957b8ff07SDmitry Torokhov 273057b8ff07SDmitry Torokhov devres->group = grp; 273157b8ff07SDmitry Torokhov devres_add(dev, devres); 273257b8ff07SDmitry Torokhov return 0; 273357b8ff07SDmitry Torokhov } 273457b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 273557b8ff07SDmitry Torokhov 273657b8ff07SDmitry Torokhov /** 273757b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 273857b8ff07SDmitry Torokhov * @dev: The device to create the group for 273957b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 274057b8ff07SDmitry Torokhov * 274157b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 274257b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 274357b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 274457b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 274557b8ff07SDmitry Torokhov * attribute files being created already exist. 274657b8ff07SDmitry Torokhov * 274757b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 274857b8ff07SDmitry Torokhov */ 274957b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 275057b8ff07SDmitry Torokhov const struct attribute_group **groups) 275157b8ff07SDmitry Torokhov { 275257b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 275357b8ff07SDmitry Torokhov int error; 275457b8ff07SDmitry Torokhov 275557b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 275657b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 275757b8ff07SDmitry Torokhov if (!devres) 275857b8ff07SDmitry Torokhov return -ENOMEM; 275957b8ff07SDmitry Torokhov 276057b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 276157b8ff07SDmitry Torokhov if (error) { 276257b8ff07SDmitry Torokhov devres_free(devres); 276357b8ff07SDmitry Torokhov return error; 276457b8ff07SDmitry Torokhov } 276557b8ff07SDmitry Torokhov 276657b8ff07SDmitry Torokhov devres->groups = groups; 276757b8ff07SDmitry Torokhov devres_add(dev, devres); 276857b8ff07SDmitry Torokhov return 0; 276957b8ff07SDmitry Torokhov } 277057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 277157b8ff07SDmitry Torokhov 27722620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 27732620efefSGreg Kroah-Hartman { 27742620efefSGreg Kroah-Hartman struct class *class = dev->class; 2775aed65af1SStephen Hemminger const struct device_type *type = dev->type; 2776621a1672SDmitry Torokhov int error; 27772620efefSGreg Kroah-Hartman 2778621a1672SDmitry Torokhov if (class) { 2779d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 27802620efefSGreg Kroah-Hartman if (error) 2781621a1672SDmitry Torokhov return error; 2782f9f852dfSKay Sievers } 2783f9f852dfSKay Sievers 2784621a1672SDmitry Torokhov if (type) { 2785621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 2786f9f852dfSKay Sievers if (error) 2787a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 2788f9f852dfSKay Sievers } 2789621a1672SDmitry Torokhov 2790621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 2791f9f852dfSKay Sievers if (error) 2792621a1672SDmitry Torokhov goto err_remove_type_groups; 2793621a1672SDmitry Torokhov 27944f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 2795c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 27964f3549d7SRafael J. Wysocki if (error) 2797ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 27984f3549d7SRafael J. Wysocki } 27994f3549d7SRafael J. Wysocki 280025ac86c6SSaravana Kannan if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { 2801da6d6475SSaravana Kannan error = device_create_file(dev, &dev_attr_waiting_for_supplier); 2802da6d6475SSaravana Kannan if (error) 2803da6d6475SSaravana Kannan goto err_remove_dev_online; 2804da6d6475SSaravana Kannan } 2805da6d6475SSaravana Kannan 280670f400d4SRajat Jain if (dev_removable_is_valid(dev)) { 280770f400d4SRajat Jain error = device_create_file(dev, &dev_attr_removable); 280870f400d4SRajat Jain if (error) 280970f400d4SRajat Jain goto err_remove_dev_waiting_for_supplier; 281070f400d4SRajat Jain } 281170f400d4SRajat Jain 28126423d295SWon Chung if (dev_add_physical_location(dev)) { 28136423d295SWon Chung error = device_add_group(dev, 28146423d295SWon Chung &dev_attr_physical_location_group); 28156423d295SWon Chung if (error) 28166423d295SWon Chung goto err_remove_dev_removable; 28176423d295SWon Chung } 28186423d295SWon Chung 2819621a1672SDmitry Torokhov return 0; 2820621a1672SDmitry Torokhov 28216423d295SWon Chung err_remove_dev_removable: 28226423d295SWon Chung device_remove_file(dev, &dev_attr_removable); 282370f400d4SRajat Jain err_remove_dev_waiting_for_supplier: 282470f400d4SRajat Jain device_remove_file(dev, &dev_attr_waiting_for_supplier); 2825da6d6475SSaravana Kannan err_remove_dev_online: 2826da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_online); 2827ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 2828ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 2829621a1672SDmitry Torokhov err_remove_type_groups: 2830621a1672SDmitry Torokhov if (type) 2831621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2832d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 2833d05a6f96SGreg Kroah-Hartman if (class) 2834d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2835f9f852dfSKay Sievers 28362620efefSGreg Kroah-Hartman return error; 28372620efefSGreg Kroah-Hartman } 28382620efefSGreg Kroah-Hartman 28392620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 28402620efefSGreg Kroah-Hartman { 28412620efefSGreg Kroah-Hartman struct class *class = dev->class; 2842aed65af1SStephen Hemminger const struct device_type *type = dev->type; 28432620efefSGreg Kroah-Hartman 28446423d295SWon Chung if (dev->physical_location) { 28456423d295SWon Chung device_remove_group(dev, &dev_attr_physical_location_group); 28466423d295SWon Chung kfree(dev->physical_location); 28476423d295SWon Chung } 28486423d295SWon Chung 284970f400d4SRajat Jain device_remove_file(dev, &dev_attr_removable); 2850da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 2851c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 2852621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 2853f9f852dfSKay Sievers 2854621a1672SDmitry Torokhov if (type) 2855621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2856621a1672SDmitry Torokhov 2857a6b01dedSGreg Kroah-Hartman if (class) 2858d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2859c97415a7SStefan Achatz } 28602620efefSGreg Kroah-Hartman 2861c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 286223681e47SGreg Kroah-Hartman char *buf) 286323681e47SGreg Kroah-Hartman { 286423681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 286523681e47SGreg Kroah-Hartman } 2866c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 2867ad6a1e1cSTejun Heo 2868ca22e56dSKay Sievers /* /sys/devices/ */ 2869881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 28701da177e4SLinus Torvalds 28711da177e4SLinus Torvalds /** 287252cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 287352cdbdd4SGrygorii Strashko * @deva: Device to move. 287452cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 287552cdbdd4SGrygorii Strashko */ 287652cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 287752cdbdd4SGrygorii Strashko { 287852cdbdd4SGrygorii Strashko if (!devices_kset) 287952cdbdd4SGrygorii Strashko return; 288052cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 288152cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 288252cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 288352cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 288452cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 288552cdbdd4SGrygorii Strashko } 288652cdbdd4SGrygorii Strashko 288752cdbdd4SGrygorii Strashko /** 288852cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 288952cdbdd4SGrygorii Strashko * @deva: Device to move 289052cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 289152cdbdd4SGrygorii Strashko */ 289252cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 289352cdbdd4SGrygorii Strashko { 289452cdbdd4SGrygorii Strashko if (!devices_kset) 289552cdbdd4SGrygorii Strashko return; 289652cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 289752cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 289852cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 289952cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 290052cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 290152cdbdd4SGrygorii Strashko } 290252cdbdd4SGrygorii Strashko 290352cdbdd4SGrygorii Strashko /** 290452cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 290552cdbdd4SGrygorii Strashko * @dev: device to move 290652cdbdd4SGrygorii Strashko */ 290752cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 290852cdbdd4SGrygorii Strashko { 290952cdbdd4SGrygorii Strashko if (!devices_kset) 291052cdbdd4SGrygorii Strashko return; 291152cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 291252cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 291352cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 291452cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 291552cdbdd4SGrygorii Strashko } 291652cdbdd4SGrygorii Strashko 291752cdbdd4SGrygorii Strashko /** 29181da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 29191da177e4SLinus Torvalds * @dev: device. 29201da177e4SLinus Torvalds * @attr: device attribute descriptor. 29211da177e4SLinus Torvalds */ 292226579ab7SPhil Carmody int device_create_file(struct device *dev, 292326579ab7SPhil Carmody const struct device_attribute *attr) 29241da177e4SLinus Torvalds { 29251da177e4SLinus Torvalds int error = 0; 29268f46baaaSFelipe Balbi 29278f46baaaSFelipe Balbi if (dev) { 29288f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 292997521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 293097521978Sdyoung@redhat.com attr->attr.name); 29318f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 293297521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 293397521978Sdyoung@redhat.com attr->attr.name); 29341da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 29358f46baaaSFelipe Balbi } 29368f46baaaSFelipe Balbi 29371da177e4SLinus Torvalds return error; 29381da177e4SLinus Torvalds } 293986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 29401da177e4SLinus Torvalds 29411da177e4SLinus Torvalds /** 29421da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 29431da177e4SLinus Torvalds * @dev: device. 29441da177e4SLinus Torvalds * @attr: device attribute descriptor. 29451da177e4SLinus Torvalds */ 294626579ab7SPhil Carmody void device_remove_file(struct device *dev, 294726579ab7SPhil Carmody const struct device_attribute *attr) 29481da177e4SLinus Torvalds { 29490c98b19fSCornelia Huck if (dev) 29501da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 29511da177e4SLinus Torvalds } 295286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 29531da177e4SLinus Torvalds 29542589f188SGreg Kroah-Hartman /** 29556b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 29566b0afc2aSTejun Heo * @dev: device. 29576b0afc2aSTejun Heo * @attr: device attribute descriptor. 29586b0afc2aSTejun Heo * 29596b0afc2aSTejun Heo * See kernfs_remove_self() for details. 29606b0afc2aSTejun Heo */ 29616b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 29626b0afc2aSTejun Heo const struct device_attribute *attr) 29636b0afc2aSTejun Heo { 29646b0afc2aSTejun Heo if (dev) 29656b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 29666b0afc2aSTejun Heo else 29676b0afc2aSTejun Heo return false; 29686b0afc2aSTejun Heo } 29696b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 29706b0afc2aSTejun Heo 29716b0afc2aSTejun Heo /** 29722589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 29732589f188SGreg Kroah-Hartman * @dev: device. 29742589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 29752589f188SGreg Kroah-Hartman */ 297666ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 297766ecb92bSPhil Carmody const struct bin_attribute *attr) 29782589f188SGreg Kroah-Hartman { 29792589f188SGreg Kroah-Hartman int error = -EINVAL; 29802589f188SGreg Kroah-Hartman if (dev) 29812589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 29822589f188SGreg Kroah-Hartman return error; 29832589f188SGreg Kroah-Hartman } 29842589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 29852589f188SGreg Kroah-Hartman 29862589f188SGreg Kroah-Hartman /** 29872589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 29882589f188SGreg Kroah-Hartman * @dev: device. 29892589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 29902589f188SGreg Kroah-Hartman */ 299166ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 299266ecb92bSPhil Carmody const struct bin_attribute *attr) 29932589f188SGreg Kroah-Hartman { 29942589f188SGreg Kroah-Hartman if (dev) 29952589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 29962589f188SGreg Kroah-Hartman } 29972589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 29982589f188SGreg Kroah-Hartman 299934bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 300034bb61f9SJames Bottomley { 3001f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 3002f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 300334bb61f9SJames Bottomley 300434bb61f9SJames Bottomley get_device(dev); 300534bb61f9SJames Bottomley } 300634bb61f9SJames Bottomley 300734bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 300834bb61f9SJames Bottomley { 3009f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 3010f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 301134bb61f9SJames Bottomley 301234bb61f9SJames Bottomley put_device(dev); 301334bb61f9SJames Bottomley } 301434bb61f9SJames Bottomley 30151da177e4SLinus Torvalds /** 30161da177e4SLinus Torvalds * device_initialize - init device structure. 30171da177e4SLinus Torvalds * @dev: device. 30181da177e4SLinus Torvalds * 30195739411aSCornelia Huck * This prepares the device for use by other layers by initializing 30205739411aSCornelia Huck * its fields. 30211da177e4SLinus Torvalds * It is the first half of device_register(), if called by 30225739411aSCornelia Huck * that function, though it can also be called separately, so one 30235739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 30245739411aSCornelia Huck * may be used for reference counting of @dev after calling this 30255739411aSCornelia Huck * function. 30265739411aSCornelia Huck * 3027b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 3028b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 3029b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 3030b10d5efdSAlan Stern * @dev. 3031b10d5efdSAlan Stern * 30325739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 30335739411aSCornelia Huck * @dev directly once you have called this function. 30341da177e4SLinus Torvalds */ 30351da177e4SLinus Torvalds void device_initialize(struct device *dev) 30361da177e4SLinus Torvalds { 3037881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 3038f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 30391da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 30403142788bSThomas Gleixner mutex_init(&dev->mutex); 30411704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 30429ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 30439ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 30443b98aeafSAlan Stern device_pm_init(dev); 3045d460d7f7SMax Gurtovoy set_dev_node(dev, NUMA_NO_NODE); 30469ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 30479ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 30483b052a3eSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 30499ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 30506d4e9a8eSChristoph Hellwig #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \ 30516d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \ 30526d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) 30536d4e9a8eSChristoph Hellwig dev->dma_coherent = dma_default_coherent; 30546d4e9a8eSChristoph Hellwig #endif 305569031f50SClaire Chang #ifdef CONFIG_SWIOTLB 3056463e862aSWill Deacon dev->dma_io_tlb_mem = &io_tlb_default_mem; 305769031f50SClaire Chang #endif 30581da177e4SLinus Torvalds } 305986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 30601da177e4SLinus Torvalds 3061d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 3062f0ee61a6SGreg Kroah-Hartman { 3063f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 3064f0ee61a6SGreg Kroah-Hartman 3065f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 30664ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 3067881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 3068f0ee61a6SGreg Kroah-Hartman 306986406245SKay Sievers return virtual_dir; 3070f0ee61a6SGreg Kroah-Hartman } 3071f0ee61a6SGreg Kroah-Hartman 3072bc451f20SEric W. Biederman struct class_dir { 3073bc451f20SEric W. Biederman struct kobject kobj; 3074bc451f20SEric W. Biederman struct class *class; 3075bc451f20SEric W. Biederman }; 3076bc451f20SEric W. Biederman 3077bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 3078bc451f20SEric W. Biederman 3079bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 3080bc451f20SEric W. Biederman { 3081bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 3082bc451f20SEric W. Biederman kfree(dir); 3083bc451f20SEric W. Biederman } 3084bc451f20SEric W. Biederman 3085bc451f20SEric W. Biederman static const 308602a476d9SGreg Kroah-Hartman struct kobj_ns_type_operations *class_dir_child_ns_type(const struct kobject *kobj) 3087bc451f20SEric W. Biederman { 308802a476d9SGreg Kroah-Hartman const struct class_dir *dir = to_class_dir(kobj); 3089bc451f20SEric W. Biederman return dir->class->ns_type; 3090bc451f20SEric W. Biederman } 3091bc451f20SEric W. Biederman 3092c83d9ab4SThomas Weißschuh static const struct kobj_type class_dir_ktype = { 3093bc451f20SEric W. Biederman .release = class_dir_release, 3094bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 3095bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 3096bc451f20SEric W. Biederman }; 3097bc451f20SEric W. Biederman 3098bc451f20SEric W. Biederman static struct kobject * 3099bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 3100bc451f20SEric W. Biederman { 3101bc451f20SEric W. Biederman struct class_dir *dir; 3102bc451f20SEric W. Biederman int retval; 3103bc451f20SEric W. Biederman 3104bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 3105bc451f20SEric W. Biederman if (!dir) 310684d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 3107bc451f20SEric W. Biederman 3108bc451f20SEric W. Biederman dir->class = class; 3109bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 3110bc451f20SEric W. Biederman 31116b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 3112bc451f20SEric W. Biederman 3113bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 3114bc451f20SEric W. Biederman if (retval < 0) { 3115bc451f20SEric W. Biederman kobject_put(&dir->kobj); 311684d0c27dSTetsuo Handa return ERR_PTR(retval); 3117bc451f20SEric W. Biederman } 3118bc451f20SEric W. Biederman return &dir->kobj; 3119bc451f20SEric W. Biederman } 3120bc451f20SEric W. Biederman 3121e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 3122bc451f20SEric W. Biederman 3123c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 3124c744aeaeSCornelia Huck struct device *parent) 312540fa5422SGreg Kroah-Hartman { 312686406245SKay Sievers if (dev->class) { 312786406245SKay Sievers struct kobject *kobj = NULL; 312886406245SKay Sievers struct kobject *parent_kobj; 312986406245SKay Sievers struct kobject *k; 313086406245SKay Sievers 3131ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 313239aba963SKay Sievers /* block disks show up in /sys/block */ 3133e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 313439aba963SKay Sievers if (parent && parent->class == &block_class) 313539aba963SKay Sievers return &parent->kobj; 31366b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 313739aba963SKay Sievers } 3138ead454feSRandy Dunlap #endif 3139e52eec13SAndi Kleen 314086406245SKay Sievers /* 314186406245SKay Sievers * If we have no parent, we live in "virtual". 31420f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 31430f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 314486406245SKay Sievers */ 314586406245SKay Sievers if (parent == NULL) 314686406245SKay Sievers parent_kobj = virtual_device_parent(dev); 314724b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 314886406245SKay Sievers return &parent->kobj; 314986406245SKay Sievers else 315086406245SKay Sievers parent_kobj = &parent->kobj; 315186406245SKay Sievers 315277d3d7c1STejun Heo mutex_lock(&gdp_mutex); 315377d3d7c1STejun Heo 315486406245SKay Sievers /* find our class-directory at the parent and reference it */ 31556b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 31566b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 315786406245SKay Sievers if (k->parent == parent_kobj) { 315886406245SKay Sievers kobj = kobject_get(k); 315986406245SKay Sievers break; 316086406245SKay Sievers } 31616b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 316277d3d7c1STejun Heo if (kobj) { 316377d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 316486406245SKay Sievers return kobj; 316577d3d7c1STejun Heo } 316686406245SKay Sievers 316786406245SKay Sievers /* or create a new class-directory at the parent device */ 3168bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 31690f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 317077d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 317143968d2fSGreg Kroah-Hartman return k; 317286406245SKay Sievers } 317386406245SKay Sievers 3174ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 3175ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 3176ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 3177ca22e56dSKay Sievers 317886406245SKay Sievers if (parent) 3179c744aeaeSCornelia Huck return &parent->kobj; 3180c744aeaeSCornelia Huck return NULL; 3181c744aeaeSCornelia Huck } 3182da231fd5SKay Sievers 3183cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 3184cebf8fd1SMing Lei struct device *dev) 3185cebf8fd1SMing Lei { 3186cebf8fd1SMing Lei if (!kobj || !dev->class || 3187cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 3188cebf8fd1SMing Lei return false; 3189cebf8fd1SMing Lei return true; 3190cebf8fd1SMing Lei } 3191cebf8fd1SMing Lei 3192cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 3193cebf8fd1SMing Lei { 3194cebf8fd1SMing Lei return dev->kobj.parent; 3195cebf8fd1SMing Lei } 3196cebf8fd1SMing Lei 3197f0832664SIngo Molnar /** 3198f0832664SIngo Molnar * kobject_has_children - Returns whether a kobject has children. 3199f0832664SIngo Molnar * @kobj: the object to test 3200f0832664SIngo Molnar * 3201f0832664SIngo Molnar * This will return whether a kobject has other kobjects as children. 3202f0832664SIngo Molnar * 3203f0832664SIngo Molnar * It does NOT account for the presence of attribute files, only sub 3204f0832664SIngo Molnar * directories. It also assumes there is no concurrent addition or 3205f0832664SIngo Molnar * removal of such children, and thus relies on external locking. 3206f0832664SIngo Molnar */ 3207f0832664SIngo Molnar static inline bool kobject_has_children(struct kobject *kobj) 3208f0832664SIngo Molnar { 3209f0832664SIngo Molnar WARN_ON_ONCE(kref_read(&kobj->kref) == 0); 3210f0832664SIngo Molnar 3211f0832664SIngo Molnar return kobj->sd && kobj->sd->dir.subdirs; 3212f0832664SIngo Molnar } 3213f0832664SIngo Molnar 3214cebf8fd1SMing Lei /* 3215cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 3216cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 3217cebf8fd1SMing Lei * global lock 3218cebf8fd1SMing Lei */ 321963b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 3220da231fd5SKay Sievers { 3221ac43432cSMuchun Song unsigned int ref; 3222ac43432cSMuchun Song 32230f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 3224cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 3225da231fd5SKay Sievers return; 3226da231fd5SKay Sievers 3227e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 3228ac43432cSMuchun Song /** 3229ac43432cSMuchun Song * There is a race condition between removing glue directory 3230ac43432cSMuchun Song * and adding a new device under the glue directory. 3231ac43432cSMuchun Song * 3232ac43432cSMuchun Song * CPU1: CPU2: 3233ac43432cSMuchun Song * 3234ac43432cSMuchun Song * device_add() 3235ac43432cSMuchun Song * get_device_parent() 3236ac43432cSMuchun Song * class_dir_create_and_add() 3237ac43432cSMuchun Song * kobject_add_internal() 3238ac43432cSMuchun Song * create_dir() // create glue_dir 3239ac43432cSMuchun Song * 3240ac43432cSMuchun Song * device_add() 3241ac43432cSMuchun Song * get_device_parent() 3242ac43432cSMuchun Song * kobject_get() // get glue_dir 3243ac43432cSMuchun Song * 3244ac43432cSMuchun Song * device_del() 3245ac43432cSMuchun Song * cleanup_glue_dir() 3246ac43432cSMuchun Song * kobject_del(glue_dir) 3247ac43432cSMuchun Song * 3248ac43432cSMuchun Song * kobject_add() 3249ac43432cSMuchun Song * kobject_add_internal() 3250ac43432cSMuchun Song * create_dir() // in glue_dir 3251ac43432cSMuchun Song * sysfs_create_dir_ns() 3252ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 3253ac43432cSMuchun Song * 3254ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 3255ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 3256ac43432cSMuchun Song * 3257ac43432cSMuchun Song * // sd is freed 3258ac43432cSMuchun Song * kernfs_new_node(sd) 3259ac43432cSMuchun Song * kernfs_get(glue_dir) 3260ac43432cSMuchun Song * kernfs_add_one() 3261ac43432cSMuchun Song * kernfs_put() 3262ac43432cSMuchun Song * 3263ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 3264ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 3265ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 3266ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 3267ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 3268ac43432cSMuchun Song * 3269ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 3270ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 3271ac43432cSMuchun Song * 3272ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 3273ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 3274ac43432cSMuchun Song * for glue_dir kobj is 1. 3275ac43432cSMuchun Song */ 3276ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 3277ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 3278726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 32790f4dafc0SKay Sievers kobject_put(glue_dir); 3280e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 3281da231fd5SKay Sievers } 328263b6971aSCornelia Huck 32832ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 32842ee97cafSCornelia Huck { 32855590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 32862ee97cafSCornelia Huck int error; 32872ee97cafSCornelia Huck 32885590f319SBenjamin Herrenschmidt if (of_node) { 32890c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 32905590f319SBenjamin Herrenschmidt if (error) 32915590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 32925590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 32935590f319SBenjamin Herrenschmidt } 32945590f319SBenjamin Herrenschmidt 32952ee97cafSCornelia Huck if (!dev->class) 32962ee97cafSCornelia Huck return 0; 3297da231fd5SKay Sievers 32981fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 32996b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 33002ee97cafSCornelia Huck "subsystem"); 33012ee97cafSCornelia Huck if (error) 33025590f319SBenjamin Herrenschmidt goto out_devnode; 3303da231fd5SKay Sievers 33044e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 33054f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 33064f01a757SDmitry Torokhov "device"); 33074f01a757SDmitry Torokhov if (error) 330839aba963SKay Sievers goto out_subsys; 33092ee97cafSCornelia Huck } 331039aba963SKay Sievers 3311ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 331239aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 3313e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 331439aba963SKay Sievers return 0; 3315ead454feSRandy Dunlap #endif 331639aba963SKay Sievers 331739aba963SKay Sievers /* link in the class directory pointing to the device */ 33186b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 331939aba963SKay Sievers &dev->kobj, dev_name(dev)); 332039aba963SKay Sievers if (error) 332139aba963SKay Sievers goto out_device; 332239aba963SKay Sievers 33232ee97cafSCornelia Huck return 0; 33242ee97cafSCornelia Huck 332539aba963SKay Sievers out_device: 332639aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 3327da231fd5SKay Sievers 33282ee97cafSCornelia Huck out_subsys: 33292ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 33305590f319SBenjamin Herrenschmidt out_devnode: 33315590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 33322ee97cafSCornelia Huck return error; 33332ee97cafSCornelia Huck } 33342ee97cafSCornelia Huck 33352ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 33362ee97cafSCornelia Huck { 33375590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 33385590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 33395590f319SBenjamin Herrenschmidt 33402ee97cafSCornelia Huck if (!dev->class) 33412ee97cafSCornelia Huck return; 3342da231fd5SKay Sievers 33434e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 3344da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 33452ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 3346ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 3347e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 334839aba963SKay Sievers return; 3349ead454feSRandy Dunlap #endif 33506b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 33512ee97cafSCornelia Huck } 33522ee97cafSCornelia Huck 33531da177e4SLinus Torvalds /** 3354413c239fSStephen Rothwell * dev_set_name - set a device name 3355413c239fSStephen Rothwell * @dev: device 335646232366SRandy Dunlap * @fmt: format string for the device's name 3357413c239fSStephen Rothwell */ 3358413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 3359413c239fSStephen Rothwell { 3360413c239fSStephen Rothwell va_list vargs; 33611fa5ae85SKay Sievers int err; 3362413c239fSStephen Rothwell 3363413c239fSStephen Rothwell va_start(vargs, fmt); 33641fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 3365413c239fSStephen Rothwell va_end(vargs); 33661fa5ae85SKay Sievers return err; 3367413c239fSStephen Rothwell } 3368413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 3369413c239fSStephen Rothwell 3370413c239fSStephen Rothwell /** 3371e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 3372e105b8bfSDan Williams * @dev: device 3373e105b8bfSDan Williams * 3374e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 3375e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 3376e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 3377e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 33780d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 33790d4e293cSPeter Korsgaard * the link. 3380e105b8bfSDan Williams */ 3381e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 3382e105b8bfSDan Williams { 3383e105b8bfSDan Williams struct kobject *kobj; 3384e105b8bfSDan Williams 3385e105b8bfSDan Williams if (dev->class) 3386e105b8bfSDan Williams kobj = dev->class->dev_kobj; 3387e105b8bfSDan Williams else 3388e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 3389e105b8bfSDan Williams 3390e105b8bfSDan Williams return kobj; 3391e105b8bfSDan Williams } 3392e105b8bfSDan Williams 3393e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 3394e105b8bfSDan Williams { 3395e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3396e105b8bfSDan Williams int error = 0; 3397e105b8bfSDan Williams char devt_str[15]; 3398e105b8bfSDan Williams 3399e105b8bfSDan Williams if (kobj) { 3400e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3401e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 3402e105b8bfSDan Williams } 3403e105b8bfSDan Williams 3404e105b8bfSDan Williams return error; 3405e105b8bfSDan Williams } 3406e105b8bfSDan Williams 3407e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 3408e105b8bfSDan Williams { 3409e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3410e105b8bfSDan Williams char devt_str[15]; 3411e105b8bfSDan Williams 3412e105b8bfSDan Williams if (kobj) { 3413e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3414e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 3415e105b8bfSDan Williams } 3416e105b8bfSDan Williams } 3417e105b8bfSDan Williams 341846d3a037SShaokun Zhang static int device_private_init(struct device *dev) 3419b4028437SGreg Kroah-Hartman { 3420b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 3421b4028437SGreg Kroah-Hartman if (!dev->p) 3422b4028437SGreg Kroah-Hartman return -ENOMEM; 3423b4028437SGreg Kroah-Hartman dev->p->device = dev; 3424b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 3425b4028437SGreg Kroah-Hartman klist_children_put); 3426ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 3427b4028437SGreg Kroah-Hartman return 0; 3428b4028437SGreg Kroah-Hartman } 3429b4028437SGreg Kroah-Hartman 3430e105b8bfSDan Williams /** 34311da177e4SLinus Torvalds * device_add - add device to device hierarchy. 34321da177e4SLinus Torvalds * @dev: device. 34331da177e4SLinus Torvalds * 34341da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 34351da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 34361da177e4SLinus Torvalds * 34375739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 34381da177e4SLinus Torvalds * to the global and sibling lists for the device, then 34391da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 34405739411aSCornelia Huck * 3441b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 3442b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 3443b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 3444b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 3445b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 3446b10d5efdSAlan Stern * and register a fresh new struct device instead. 3447b10d5efdSAlan Stern * 34485739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 34495739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 34505739411aSCornelia Huck * reference instead. 3451affada72SBorislav Petkov * 3452affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 3453affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 3454affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 3455affada72SBorislav Petkov * count. 34561da177e4SLinus Torvalds */ 34571da177e4SLinus Torvalds int device_add(struct device *dev) 34581da177e4SLinus Torvalds { 345935dbf4efSViresh Kumar struct device *parent; 3460ca22e56dSKay Sievers struct kobject *kobj; 3461c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 34625f5377eaSSaravana Kannan int error = -EINVAL; 3463cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3464775b64d2SRafael J. Wysocki 34651da177e4SLinus Torvalds dev = get_device(dev); 3466c906a48aSGreg Kroah-Hartman if (!dev) 3467c906a48aSGreg Kroah-Hartman goto done; 3468c906a48aSGreg Kroah-Hartman 3469fb069a5dSGreg Kroah-Hartman if (!dev->p) { 3470b4028437SGreg Kroah-Hartman error = device_private_init(dev); 3471b4028437SGreg Kroah-Hartman if (error) 3472fb069a5dSGreg Kroah-Hartman goto done; 3473fb069a5dSGreg Kroah-Hartman } 3474fb069a5dSGreg Kroah-Hartman 34751fa5ae85SKay Sievers /* 34761fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 34771fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 34781fa5ae85SKay Sievers * the name, and force the use of dev_name() 34791fa5ae85SKay Sievers */ 34801fa5ae85SKay Sievers if (dev->init_name) { 3481acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 34821fa5ae85SKay Sievers dev->init_name = NULL; 34831fa5ae85SKay Sievers } 3484c906a48aSGreg Kroah-Hartman 3485ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 3486ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 3487ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 3488ca22e56dSKay Sievers 3489e6309e75SThomas Gleixner if (!dev_name(dev)) { 3490e6309e75SThomas Gleixner error = -EINVAL; 34915c8563d7SKay Sievers goto name_error; 3492e6309e75SThomas Gleixner } 34931da177e4SLinus Torvalds 34941e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 3495c205ef48SGreg Kroah-Hartman 34961da177e4SLinus Torvalds parent = get_device(dev->parent); 3497ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 349884d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 349984d0c27dSTetsuo Handa error = PTR_ERR(kobj); 350084d0c27dSTetsuo Handa goto parent_error; 350184d0c27dSTetsuo Handa } 3502ca22e56dSKay Sievers if (kobj) 3503ca22e56dSKay Sievers dev->kobj.parent = kobj; 35041da177e4SLinus Torvalds 35050d358f22SYinghai Lu /* use parent numa_node */ 350656f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 35070d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 35080d358f22SYinghai Lu 35091da177e4SLinus Torvalds /* first, register with generic layer. */ 35108a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 35118a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 3512cebf8fd1SMing Lei if (error) { 35136977b1a5SZhengchao Shao glue_dir = kobj; 35141da177e4SLinus Torvalds goto Error; 3515cebf8fd1SMing Lei } 3516a7fd6706SKay Sievers 351737022644SBrian Walsh /* notify platform of device entry */ 3518b2ebd9ddSRafael J. Wysocki device_platform_notify(dev); 351937022644SBrian Walsh 3520c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 3521a306eea4SCornelia Huck if (error) 3522a306eea4SCornelia Huck goto attrError; 3523a7fd6706SKay Sievers 35242ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 35252ee97cafSCornelia Huck if (error) 35262ee97cafSCornelia Huck goto SymlinkError; 3527dc0afa83SCornelia Huck error = device_add_attrs(dev); 3528dc0afa83SCornelia Huck if (error) 35292620efefSGreg Kroah-Hartman goto AttrsError; 3530dc0afa83SCornelia Huck error = bus_add_device(dev); 3531dc0afa83SCornelia Huck if (error) 35321da177e4SLinus Torvalds goto BusError; 35333b98aeafSAlan Stern error = dpm_sysfs_add(dev); 353457eee3d2SRafael J. Wysocki if (error) 35353b98aeafSAlan Stern goto DPMError; 35363b98aeafSAlan Stern device_pm_add(dev); 3537ec0676eeSAlan Stern 35380cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 35390cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 35400cd75047SSergey Klyaus if (error) 35410cd75047SSergey Klyaus goto DevAttrError; 35420cd75047SSergey Klyaus 35430cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 35440cd75047SSergey Klyaus if (error) 35450cd75047SSergey Klyaus goto SysEntryError; 35460cd75047SSergey Klyaus 35470cd75047SSergey Klyaus devtmpfs_create_node(dev); 35480cd75047SSergey Klyaus } 35490cd75047SSergey Klyaus 3550ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 3551268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 3552ec0676eeSAlan Stern */ 3553ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_ADD_DEVICE); 355453877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 3555372a67c0SSaravana Kannan 3556e2ae9bccSSaravana Kannan /* 3557e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 3558e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 3559e2ae9bccSSaravana Kannan * link to it. 3560e2ae9bccSSaravana Kannan * 3561e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 3562e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 3563e2ae9bccSSaravana Kannan * 35642cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure 3565e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 3566e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 3567e2ae9bccSSaravana Kannan */ 35682cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 35692cd38fd1SSaravana Kannan dev->fwnode->dev = dev; 35705f5377eaSSaravana Kannan fw_devlink_link_device(dev); 357103324507SSaravana Kannan } 3572e2ae9bccSSaravana Kannan 35732023c610SAlan Stern bus_probe_device(dev); 3574d46f3e3eSSaravana Kannan 3575d46f3e3eSSaravana Kannan /* 3576d46f3e3eSSaravana Kannan * If all driver registration is done and a newly added device doesn't 3577d46f3e3eSSaravana Kannan * match with any driver, don't block its consumers from probing in 3578d46f3e3eSSaravana Kannan * case the consumer device is able to operate without this supplier. 3579d46f3e3eSSaravana Kannan */ 3580d46f3e3eSSaravana Kannan if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) 3581d46f3e3eSSaravana Kannan fw_devlink_unblock_consumers(dev); 3582d46f3e3eSSaravana Kannan 35831da177e4SLinus Torvalds if (parent) 3584f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3585f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 35861da177e4SLinus Torvalds 35875d9fd169SGreg Kroah-Hartman if (dev->class) { 3588ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3589c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 3590570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 35916b6e39a6SKay Sievers &dev->class->p->klist_devices); 3592c47ed219SGreg Kroah-Hartman 3593c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 3594184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3595ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3596c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 3597c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 3598ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 35995d9fd169SGreg Kroah-Hartman } 3600c906a48aSGreg Kroah-Hartman done: 36011da177e4SLinus Torvalds put_device(dev); 36021da177e4SLinus Torvalds return error; 36030cd75047SSergey Klyaus SysEntryError: 36040cd75047SSergey Klyaus if (MAJOR(dev->devt)) 36050cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 36060cd75047SSergey Klyaus DevAttrError: 36070cd75047SSergey Klyaus device_pm_remove(dev); 36080cd75047SSergey Klyaus dpm_sysfs_remove(dev); 36093b98aeafSAlan Stern DPMError: 3610f6837f34SYang Yingliang dev->driver = NULL; 361157eee3d2SRafael J. Wysocki bus_remove_device(dev); 361257eee3d2SRafael J. Wysocki BusError: 36132620efefSGreg Kroah-Hartman device_remove_attrs(dev); 36142620efefSGreg Kroah-Hartman AttrsError: 36152ee97cafSCornelia Huck device_remove_class_symlinks(dev); 36162ee97cafSCornelia Huck SymlinkError: 3617c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 361823681e47SGreg Kroah-Hartman attrError: 3619b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev); 3620312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3621cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 36221da177e4SLinus Torvalds kobject_del(&dev->kobj); 36231da177e4SLinus Torvalds Error: 3624cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 362584d0c27dSTetsuo Handa parent_error: 36261da177e4SLinus Torvalds put_device(parent); 36275c8563d7SKay Sievers name_error: 36285c8563d7SKay Sievers kfree(dev->p); 36295c8563d7SKay Sievers dev->p = NULL; 3630c906a48aSGreg Kroah-Hartman goto done; 36311da177e4SLinus Torvalds } 363286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 36331da177e4SLinus Torvalds 36341da177e4SLinus Torvalds /** 36351da177e4SLinus Torvalds * device_register - register a device with the system. 36361da177e4SLinus Torvalds * @dev: pointer to the device structure 36371da177e4SLinus Torvalds * 36381da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 36391da177e4SLinus Torvalds * and add it to the system. The two steps can be called 36401da177e4SLinus Torvalds * separately, but this is the easiest and most common. 36411da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 36421da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 36431da177e4SLinus Torvalds * before it is added to the hierarchy. 36445739411aSCornelia Huck * 3645b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 3646b10d5efdSAlan Stern * and device_add(). 3647b10d5efdSAlan Stern * 36485739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 36495739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 36505739411aSCornelia Huck * reference initialized in this function instead. 36511da177e4SLinus Torvalds */ 36521da177e4SLinus Torvalds int device_register(struct device *dev) 36531da177e4SLinus Torvalds { 36541da177e4SLinus Torvalds device_initialize(dev); 36551da177e4SLinus Torvalds return device_add(dev); 36561da177e4SLinus Torvalds } 365786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 36581da177e4SLinus Torvalds 36591da177e4SLinus Torvalds /** 36601da177e4SLinus Torvalds * get_device - increment reference count for device. 36611da177e4SLinus Torvalds * @dev: device. 36621da177e4SLinus Torvalds * 36631da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 36641da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 36651da177e4SLinus Torvalds * pointer passed in. 36661da177e4SLinus Torvalds */ 36671da177e4SLinus Torvalds struct device *get_device(struct device *dev) 36681da177e4SLinus Torvalds { 3669b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 36701da177e4SLinus Torvalds } 367186df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 36721da177e4SLinus Torvalds 36731da177e4SLinus Torvalds /** 36741da177e4SLinus Torvalds * put_device - decrement reference count. 36751da177e4SLinus Torvalds * @dev: device in question. 36761da177e4SLinus Torvalds */ 36771da177e4SLinus Torvalds void put_device(struct device *dev) 36781da177e4SLinus Torvalds { 3679edfaa7c3SKay Sievers /* might_sleep(); */ 36801da177e4SLinus Torvalds if (dev) 36811da177e4SLinus Torvalds kobject_put(&dev->kobj); 36821da177e4SLinus Torvalds } 368386df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 36841da177e4SLinus Torvalds 368500289cd8SDan Williams bool kill_device(struct device *dev) 368600289cd8SDan Williams { 368700289cd8SDan Williams /* 368800289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 368900289cd8SDan Williams * the update behavior is consistent with the other bitfields near 369000289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 369100289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 369200289cd8SDan Williams * underneath the device. 369300289cd8SDan Williams */ 36948c60a141SJulian Wiedmann device_lock_assert(dev); 369500289cd8SDan Williams 369600289cd8SDan Williams if (dev->p->dead) 369700289cd8SDan Williams return false; 369800289cd8SDan Williams dev->p->dead = true; 369900289cd8SDan Williams return true; 370000289cd8SDan Williams } 370100289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 370200289cd8SDan Williams 37031da177e4SLinus Torvalds /** 37041da177e4SLinus Torvalds * device_del - delete device from system. 37051da177e4SLinus Torvalds * @dev: device. 37061da177e4SLinus Torvalds * 37071da177e4SLinus Torvalds * This is the first part of the device unregistration 37081da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 37091da177e4SLinus Torvalds * from here, has it removed from the other driver model 37101da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 37111da177e4SLinus Torvalds * from the kobject hierarchy. 37121da177e4SLinus Torvalds * 37131da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 37141da177e4SLinus Torvalds * also called manually. 37151da177e4SLinus Torvalds */ 37161da177e4SLinus Torvalds void device_del(struct device *dev) 37171da177e4SLinus Torvalds { 37181da177e4SLinus Torvalds struct device *parent = dev->parent; 3719cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3720c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 3721b8530017SOliver Neukum unsigned int noio_flag; 37221da177e4SLinus Torvalds 37233451a495SAlexander Duyck device_lock(dev); 372400289cd8SDan Williams kill_device(dev); 37253451a495SAlexander Duyck device_unlock(dev); 37263451a495SAlexander Duyck 3727372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 3728372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 3729372a67c0SSaravana Kannan 3730ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 3731ec0676eeSAlan Stern * before dpm_sysfs_remove(). 3732ec0676eeSAlan Stern */ 3733b8530017SOliver Neukum noio_flag = memalloc_noio_save(); 3734ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_DEL_DEVICE); 37359ed98953SRafael J. Wysocki 37363b98aeafSAlan Stern dpm_sysfs_remove(dev); 37371da177e4SLinus Torvalds if (parent) 3738f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 3739e105b8bfSDan Williams if (MAJOR(dev->devt)) { 37402b2af54aSKay Sievers devtmpfs_delete_node(dev); 3741e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 3742c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 3743e105b8bfSDan Williams } 3744b9d9c82bSKay Sievers if (dev->class) { 3745da231fd5SKay Sievers device_remove_class_symlinks(dev); 374699ef3ef8SKay Sievers 3747ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3748c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 3749184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3750ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3751c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 3752c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 3753c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 3754570d0200SWei Yang klist_del(&dev->p->knode_class); 3755ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 3756b9d9c82bSKay Sievers } 3757c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 37582620efefSGreg Kroah-Hartman device_remove_attrs(dev); 375928953533SBenjamin Herrenschmidt bus_remove_device(dev); 37604b6d1f12SLongX Zhang device_pm_remove(dev); 3761d1c3414cSGrant Likely driver_deferred_probe_del(dev); 3762b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev); 37632ec16150SJeffy Chen device_links_purge(dev); 37641da177e4SLinus Torvalds 3765ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_REMOVED_DEVICE); 3766312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3767cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 37681da177e4SLinus Torvalds kobject_del(&dev->kobj); 3769cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 3770b8530017SOliver Neukum memalloc_noio_restore(noio_flag); 37711da177e4SLinus Torvalds put_device(parent); 37721da177e4SLinus Torvalds } 377386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 37741da177e4SLinus Torvalds 37751da177e4SLinus Torvalds /** 37761da177e4SLinus Torvalds * device_unregister - unregister device from system. 37771da177e4SLinus Torvalds * @dev: device going away. 37781da177e4SLinus Torvalds * 37791da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 37801da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 37811da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 37821da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 37831da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 37841da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 37851da177e4SLinus Torvalds */ 37861da177e4SLinus Torvalds void device_unregister(struct device *dev) 37871da177e4SLinus Torvalds { 37881e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 37891da177e4SLinus Torvalds device_del(dev); 37901da177e4SLinus Torvalds put_device(dev); 37911da177e4SLinus Torvalds } 379286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 37931da177e4SLinus Torvalds 37943d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 37953d060aebSAndy Shevchenko { 37963d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 37973d060aebSAndy Shevchenko struct device *dev = NULL; 37983d060aebSAndy Shevchenko struct device_private *p; 37993d060aebSAndy Shevchenko 38003d060aebSAndy Shevchenko if (n) { 38013d060aebSAndy Shevchenko p = to_device_private_parent(n); 38023d060aebSAndy Shevchenko dev = p->device; 38033d060aebSAndy Shevchenko } 38043d060aebSAndy Shevchenko return dev; 38053d060aebSAndy Shevchenko } 38063d060aebSAndy Shevchenko 380736239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 380836239577Smochel@digitalimplant.org { 380936239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 3810f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 3811f791b8c8SGreg Kroah-Hartman struct device_private *p; 3812f791b8c8SGreg Kroah-Hartman 3813f791b8c8SGreg Kroah-Hartman if (n) { 3814f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 3815f791b8c8SGreg Kroah-Hartman dev = p->device; 3816f791b8c8SGreg Kroah-Hartman } 3817f791b8c8SGreg Kroah-Hartman return dev; 381836239577Smochel@digitalimplant.org } 381936239577Smochel@digitalimplant.org 38201da177e4SLinus Torvalds /** 3821e454cea2SKay Sievers * device_get_devnode - path of device node file 38226fcf53acSKay Sievers * @dev: device 3823e454cea2SKay Sievers * @mode: returned file access mode 38243c2670e6SKay Sievers * @uid: returned file owner 38253c2670e6SKay Sievers * @gid: returned file group 38266fcf53acSKay Sievers * @tmp: possibly allocated string 38276fcf53acSKay Sievers * 38286fcf53acSKay Sievers * Return the relative path of a possible device node. 38296fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 38306fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 38316fcf53acSKay Sievers * freed by the caller. 38326fcf53acSKay Sievers */ 383342bb5be8SGreg Kroah-Hartman const char *device_get_devnode(const struct device *dev, 38344e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 38353c2670e6SKay Sievers const char **tmp) 38366fcf53acSKay Sievers { 38376fcf53acSKay Sievers char *s; 38386fcf53acSKay Sievers 38396fcf53acSKay Sievers *tmp = NULL; 38406fcf53acSKay Sievers 38416fcf53acSKay Sievers /* the device type may provide a specific name */ 3842e454cea2SKay Sievers if (dev->type && dev->type->devnode) 38433c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 38446fcf53acSKay Sievers if (*tmp) 38456fcf53acSKay Sievers return *tmp; 38466fcf53acSKay Sievers 38476fcf53acSKay Sievers /* the class may provide a specific name */ 3848e454cea2SKay Sievers if (dev->class && dev->class->devnode) 3849e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 38506fcf53acSKay Sievers if (*tmp) 38516fcf53acSKay Sievers return *tmp; 38526fcf53acSKay Sievers 38536fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 38546fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 38556fcf53acSKay Sievers return dev_name(dev); 38566fcf53acSKay Sievers 38576fcf53acSKay Sievers /* replace '!' in the name with '/' */ 3858a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 3859a29fd614SRasmus Villemoes if (!s) 38606fcf53acSKay Sievers return NULL; 3861a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 3862a29fd614SRasmus Villemoes return *tmp = s; 38636fcf53acSKay Sievers } 38646fcf53acSKay Sievers 38656fcf53acSKay Sievers /** 38661da177e4SLinus Torvalds * device_for_each_child - device child iterator. 3867c41455fbSRandy Dunlap * @parent: parent struct device. 38681da177e4SLinus Torvalds * @fn: function to be called for each device. 3869f8878dcbSRobert P. J. Day * @data: data for the callback. 38701da177e4SLinus Torvalds * 3871c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 38721da177e4SLinus Torvalds * passing it @data. 38731da177e4SLinus Torvalds * 38741da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 38751da177e4SLinus Torvalds * other than 0, we break out and return that value. 38761da177e4SLinus Torvalds */ 387736239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 38784a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 38791da177e4SLinus Torvalds { 388036239577Smochel@digitalimplant.org struct klist_iter i; 38811da177e4SLinus Torvalds struct device *child; 38821da177e4SLinus Torvalds int error = 0; 38831da177e4SLinus Torvalds 3884014c90dbSGreg Kroah-Hartman if (!parent->p) 3885014c90dbSGreg Kroah-Hartman return 0; 3886014c90dbSGreg Kroah-Hartman 3887f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 388893ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 388936239577Smochel@digitalimplant.org error = fn(child, data); 389036239577Smochel@digitalimplant.org klist_iter_exit(&i); 38911da177e4SLinus Torvalds return error; 38921da177e4SLinus Torvalds } 389386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 38941da177e4SLinus Torvalds 38955ab69981SCornelia Huck /** 38963d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 38973d060aebSAndy Shevchenko * @parent: parent struct device. 38983d060aebSAndy Shevchenko * @fn: function to be called for each device. 38993d060aebSAndy Shevchenko * @data: data for the callback. 39003d060aebSAndy Shevchenko * 39013d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 39023d060aebSAndy Shevchenko * passing it @data. 39033d060aebSAndy Shevchenko * 39043d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 39053d060aebSAndy Shevchenko * other than 0, we break out and return that value. 39063d060aebSAndy Shevchenko */ 39073d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 39083d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 39093d060aebSAndy Shevchenko { 39103d060aebSAndy Shevchenko struct klist_iter i; 39113d060aebSAndy Shevchenko struct device *child; 39123d060aebSAndy Shevchenko int error = 0; 39133d060aebSAndy Shevchenko 39143d060aebSAndy Shevchenko if (!parent->p) 39153d060aebSAndy Shevchenko return 0; 39163d060aebSAndy Shevchenko 39173d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 39183d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 39193d060aebSAndy Shevchenko error = fn(child, data); 39203d060aebSAndy Shevchenko klist_iter_exit(&i); 39213d060aebSAndy Shevchenko return error; 39223d060aebSAndy Shevchenko } 39233d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 39243d060aebSAndy Shevchenko 39253d060aebSAndy Shevchenko /** 39265ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 39275ab69981SCornelia Huck * @parent: parent struct device 39285ab69981SCornelia Huck * @match: Callback function to check device 3929f8878dcbSRobert P. J. Day * @data: Data to pass to match function 39305ab69981SCornelia Huck * 39315ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 39325ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 39335ab69981SCornelia Huck * determined by the @match callback. 39345ab69981SCornelia Huck * 39355ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 39365ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 39375ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 39385ab69981SCornelia Huck * and not iterate over any more devices. 3939a4e2400aSFederico Vaga * 3940a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 39415ab69981SCornelia Huck */ 39425ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 39434a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 39445ab69981SCornelia Huck { 39455ab69981SCornelia Huck struct klist_iter i; 39465ab69981SCornelia Huck struct device *child; 39475ab69981SCornelia Huck 39485ab69981SCornelia Huck if (!parent) 39495ab69981SCornelia Huck return NULL; 39505ab69981SCornelia Huck 3951f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 39525ab69981SCornelia Huck while ((child = next_device(&i))) 39535ab69981SCornelia Huck if (match(child, data) && get_device(child)) 39545ab69981SCornelia Huck break; 39555ab69981SCornelia Huck klist_iter_exit(&i); 39565ab69981SCornelia Huck return child; 39575ab69981SCornelia Huck } 395886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 39595ab69981SCornelia Huck 3960dad9bb01SHeikki Krogerus /** 3961dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 3962dad9bb01SHeikki Krogerus * @parent: parent struct device 3963dad9bb01SHeikki Krogerus * @name: name of the child device 3964dad9bb01SHeikki Krogerus * 3965dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 3966dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 3967dad9bb01SHeikki Krogerus * 3968dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 3969dad9bb01SHeikki Krogerus */ 3970dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 3971dad9bb01SHeikki Krogerus const char *name) 3972dad9bb01SHeikki Krogerus { 3973dad9bb01SHeikki Krogerus struct klist_iter i; 3974dad9bb01SHeikki Krogerus struct device *child; 3975dad9bb01SHeikki Krogerus 3976dad9bb01SHeikki Krogerus if (!parent) 3977dad9bb01SHeikki Krogerus return NULL; 3978dad9bb01SHeikki Krogerus 3979dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 3980dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 3981c77f520dSDan Williams if (sysfs_streq(dev_name(child), name) && get_device(child)) 3982dad9bb01SHeikki Krogerus break; 3983dad9bb01SHeikki Krogerus klist_iter_exit(&i); 3984dad9bb01SHeikki Krogerus return child; 3985dad9bb01SHeikki Krogerus } 3986dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 3987dad9bb01SHeikki Krogerus 398882b070beSAndy Shevchenko static int match_any(struct device *dev, void *unused) 398982b070beSAndy Shevchenko { 399082b070beSAndy Shevchenko return 1; 399182b070beSAndy Shevchenko } 399282b070beSAndy Shevchenko 399382b070beSAndy Shevchenko /** 399482b070beSAndy Shevchenko * device_find_any_child - device iterator for locating a child device, if any. 399582b070beSAndy Shevchenko * @parent: parent struct device 399682b070beSAndy Shevchenko * 399782b070beSAndy Shevchenko * This is similar to the device_find_child() function above, but it 399882b070beSAndy Shevchenko * returns a reference to a child device, if any. 399982b070beSAndy Shevchenko * 400082b070beSAndy Shevchenko * NOTE: you will need to drop the reference with put_device() after use. 400182b070beSAndy Shevchenko */ 400282b070beSAndy Shevchenko struct device *device_find_any_child(struct device *parent) 400382b070beSAndy Shevchenko { 400482b070beSAndy Shevchenko return device_find_child(parent, NULL, match_any); 400582b070beSAndy Shevchenko } 400682b070beSAndy Shevchenko EXPORT_SYMBOL_GPL(device_find_any_child); 400782b070beSAndy Shevchenko 40081da177e4SLinus Torvalds int __init devices_init(void) 40091da177e4SLinus Torvalds { 4010881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 4011881c6cfdSGreg Kroah-Hartman if (!devices_kset) 4012881c6cfdSGreg Kroah-Hartman return -ENOMEM; 4013e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 4014e105b8bfSDan Williams if (!dev_kobj) 4015e105b8bfSDan Williams goto dev_kobj_err; 4016e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 4017e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 4018e105b8bfSDan Williams goto block_kobj_err; 4019e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 4020e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 4021e105b8bfSDan Williams goto char_kobj_err; 4022e105b8bfSDan Williams 4023881c6cfdSGreg Kroah-Hartman return 0; 4024e105b8bfSDan Williams 4025e105b8bfSDan Williams char_kobj_err: 4026e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 4027e105b8bfSDan Williams block_kobj_err: 4028e105b8bfSDan Williams kobject_put(dev_kobj); 4029e105b8bfSDan Williams dev_kobj_err: 4030e105b8bfSDan Williams kset_unregister(devices_kset); 4031e105b8bfSDan Williams return -ENOMEM; 40321da177e4SLinus Torvalds } 40331da177e4SLinus Torvalds 40344f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 40354f3549d7SRafael J. Wysocki { 40364f3549d7SRafael J. Wysocki int ret; 40374f3549d7SRafael J. Wysocki 40384f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 40394f3549d7SRafael J. Wysocki if (ret) 40404f3549d7SRafael J. Wysocki return ret; 40414f3549d7SRafael J. Wysocki 40424f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 40434f3549d7SRafael J. Wysocki } 40444f3549d7SRafael J. Wysocki 40454f3549d7SRafael J. Wysocki /** 40464f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 40474f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 40484f3549d7SRafael J. Wysocki * 40494f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 40504f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 40514f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 40524f3549d7SRafael J. Wysocki * is executed. 40534f3549d7SRafael J. Wysocki * 40544f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 40554f3549d7SRafael J. Wysocki */ 40564f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 40574f3549d7SRafael J. Wysocki { 40584f3549d7SRafael J. Wysocki int ret; 40594f3549d7SRafael J. Wysocki 40604f3549d7SRafael J. Wysocki if (dev->offline_disabled) 40614f3549d7SRafael J. Wysocki return -EPERM; 40624f3549d7SRafael J. Wysocki 40634f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 40644f3549d7SRafael J. Wysocki if (ret) 40654f3549d7SRafael J. Wysocki return ret; 40664f3549d7SRafael J. Wysocki 40674f3549d7SRafael J. Wysocki device_lock(dev); 40684f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 40694f3549d7SRafael J. Wysocki if (dev->offline) { 40704f3549d7SRafael J. Wysocki ret = 1; 40714f3549d7SRafael J. Wysocki } else { 40724f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 40734f3549d7SRafael J. Wysocki if (!ret) { 40744f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 40754f3549d7SRafael J. Wysocki dev->offline = true; 40764f3549d7SRafael J. Wysocki } 40774f3549d7SRafael J. Wysocki } 40784f3549d7SRafael J. Wysocki } 40794f3549d7SRafael J. Wysocki device_unlock(dev); 40804f3549d7SRafael J. Wysocki 40814f3549d7SRafael J. Wysocki return ret; 40824f3549d7SRafael J. Wysocki } 40834f3549d7SRafael J. Wysocki 40844f3549d7SRafael J. Wysocki /** 40854f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 40864f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 40874f3549d7SRafael J. Wysocki * 40884f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 40894f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 40904f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 40914f3549d7SRafael J. Wysocki * 40924f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 40934f3549d7SRafael J. Wysocki */ 40944f3549d7SRafael J. Wysocki int device_online(struct device *dev) 40954f3549d7SRafael J. Wysocki { 40964f3549d7SRafael J. Wysocki int ret = 0; 40974f3549d7SRafael J. Wysocki 40984f3549d7SRafael J. Wysocki device_lock(dev); 40994f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 41004f3549d7SRafael J. Wysocki if (dev->offline) { 41014f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 41024f3549d7SRafael J. Wysocki if (!ret) { 41034f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 41044f3549d7SRafael J. Wysocki dev->offline = false; 41054f3549d7SRafael J. Wysocki } 41064f3549d7SRafael J. Wysocki } else { 41074f3549d7SRafael J. Wysocki ret = 1; 41084f3549d7SRafael J. Wysocki } 41094f3549d7SRafael J. Wysocki } 41104f3549d7SRafael J. Wysocki device_unlock(dev); 41114f3549d7SRafael J. Wysocki 41124f3549d7SRafael J. Wysocki return ret; 41134f3549d7SRafael J. Wysocki } 41144f3549d7SRafael J. Wysocki 41157f100d15SKarthigan Srinivasan struct root_device { 41160aa0dc41SMark McLoughlin struct device dev; 41170aa0dc41SMark McLoughlin struct module *owner; 41180aa0dc41SMark McLoughlin }; 41190aa0dc41SMark McLoughlin 412093058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 4121481e2079SFerenc Wagner { 4122481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 4123481e2079SFerenc Wagner } 41240aa0dc41SMark McLoughlin 41250aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 41260aa0dc41SMark McLoughlin { 41270aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 41280aa0dc41SMark McLoughlin } 41290aa0dc41SMark McLoughlin 41300aa0dc41SMark McLoughlin /** 41310aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 41320aa0dc41SMark McLoughlin * @name: root device name 41330aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 41340aa0dc41SMark McLoughlin * 41350aa0dc41SMark McLoughlin * This function allocates a root device and registers it 41360aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 41370aa0dc41SMark McLoughlin * device, use root_device_unregister(). 41380aa0dc41SMark McLoughlin * 41390aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 41400aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 41410aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 41420aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 41430aa0dc41SMark McLoughlin * 41440aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 41450aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 41460aa0dc41SMark McLoughlin * in sysfs. 41470aa0dc41SMark McLoughlin * 4148f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 4149f0eae0edSJani Nikula * 41500aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 41510aa0dc41SMark McLoughlin */ 41520aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 41530aa0dc41SMark McLoughlin { 41540aa0dc41SMark McLoughlin struct root_device *root; 41550aa0dc41SMark McLoughlin int err = -ENOMEM; 41560aa0dc41SMark McLoughlin 41570aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 41580aa0dc41SMark McLoughlin if (!root) 41590aa0dc41SMark McLoughlin return ERR_PTR(err); 41600aa0dc41SMark McLoughlin 4161acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 41620aa0dc41SMark McLoughlin if (err) { 41630aa0dc41SMark McLoughlin kfree(root); 41640aa0dc41SMark McLoughlin return ERR_PTR(err); 41650aa0dc41SMark McLoughlin } 41660aa0dc41SMark McLoughlin 41670aa0dc41SMark McLoughlin root->dev.release = root_device_release; 41680aa0dc41SMark McLoughlin 41690aa0dc41SMark McLoughlin err = device_register(&root->dev); 41700aa0dc41SMark McLoughlin if (err) { 41710aa0dc41SMark McLoughlin put_device(&root->dev); 41720aa0dc41SMark McLoughlin return ERR_PTR(err); 41730aa0dc41SMark McLoughlin } 41740aa0dc41SMark McLoughlin 41751d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 41760aa0dc41SMark McLoughlin if (owner) { 41770aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 41780aa0dc41SMark McLoughlin 41790aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 41800aa0dc41SMark McLoughlin if (err) { 41810aa0dc41SMark McLoughlin device_unregister(&root->dev); 41820aa0dc41SMark McLoughlin return ERR_PTR(err); 41830aa0dc41SMark McLoughlin } 41840aa0dc41SMark McLoughlin root->owner = owner; 41850aa0dc41SMark McLoughlin } 41860aa0dc41SMark McLoughlin #endif 41870aa0dc41SMark McLoughlin 41880aa0dc41SMark McLoughlin return &root->dev; 41890aa0dc41SMark McLoughlin } 41900aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 41910aa0dc41SMark McLoughlin 41920aa0dc41SMark McLoughlin /** 41930aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 41947cbcf225SRandy Dunlap * @dev: device going away 41950aa0dc41SMark McLoughlin * 41960aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 41970aa0dc41SMark McLoughlin * root_device_register(). 41980aa0dc41SMark McLoughlin */ 41990aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 42000aa0dc41SMark McLoughlin { 42010aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 42020aa0dc41SMark McLoughlin 42030aa0dc41SMark McLoughlin if (root->owner) 42040aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 42050aa0dc41SMark McLoughlin 42060aa0dc41SMark McLoughlin device_unregister(dev); 42070aa0dc41SMark McLoughlin } 42080aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 42090aa0dc41SMark McLoughlin 421023681e47SGreg Kroah-Hartman 421123681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 421223681e47SGreg Kroah-Hartman { 42131e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 421423681e47SGreg Kroah-Hartman kfree(dev); 421523681e47SGreg Kroah-Hartman } 421623681e47SGreg Kroah-Hartman 42176a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 421839ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 421939ef3112SGuenter Roeck dev_t devt, void *drvdata, 422039ef3112SGuenter Roeck const struct attribute_group **groups, 422139ef3112SGuenter Roeck const char *fmt, va_list args) 422239ef3112SGuenter Roeck { 422339ef3112SGuenter Roeck struct device *dev = NULL; 422439ef3112SGuenter Roeck int retval = -ENODEV; 422539ef3112SGuenter Roeck 4226d70590d5SYang Yingliang if (IS_ERR_OR_NULL(class)) 422739ef3112SGuenter Roeck goto error; 422839ef3112SGuenter Roeck 422939ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 423039ef3112SGuenter Roeck if (!dev) { 423139ef3112SGuenter Roeck retval = -ENOMEM; 423239ef3112SGuenter Roeck goto error; 423339ef3112SGuenter Roeck } 423439ef3112SGuenter Roeck 4235bbc780f8SDavid Herrmann device_initialize(dev); 423639ef3112SGuenter Roeck dev->devt = devt; 423739ef3112SGuenter Roeck dev->class = class; 423839ef3112SGuenter Roeck dev->parent = parent; 423939ef3112SGuenter Roeck dev->groups = groups; 424039ef3112SGuenter Roeck dev->release = device_create_release; 424139ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 424239ef3112SGuenter Roeck 424339ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 424439ef3112SGuenter Roeck if (retval) 424539ef3112SGuenter Roeck goto error; 424639ef3112SGuenter Roeck 4247bbc780f8SDavid Herrmann retval = device_add(dev); 424839ef3112SGuenter Roeck if (retval) 424939ef3112SGuenter Roeck goto error; 425039ef3112SGuenter Roeck 425139ef3112SGuenter Roeck return dev; 425239ef3112SGuenter Roeck 425339ef3112SGuenter Roeck error: 425439ef3112SGuenter Roeck put_device(dev); 425539ef3112SGuenter Roeck return ERR_PTR(retval); 425639ef3112SGuenter Roeck } 425739ef3112SGuenter Roeck 425823681e47SGreg Kroah-Hartman /** 42594e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 42608882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 42618882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 42628882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 42638882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 42648882b394SGreg Kroah-Hartman * @fmt: string for the device's name 42658882b394SGreg Kroah-Hartman * 42668882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 42678882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 42688882b394SGreg Kroah-Hartman * 42698882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 42708882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 42718882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 42728882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 42738882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 42748882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 42758882b394SGreg Kroah-Hartman * pointer. 42768882b394SGreg Kroah-Hartman * 4277f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 4278f0eae0edSJani Nikula * 42798882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 42808882b394SGreg Kroah-Hartman * been created with a call to class_create(). 42818882b394SGreg Kroah-Hartman */ 42824e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 42834e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 42848882b394SGreg Kroah-Hartman { 42858882b394SGreg Kroah-Hartman va_list vargs; 42868882b394SGreg Kroah-Hartman struct device *dev; 42878882b394SGreg Kroah-Hartman 42888882b394SGreg Kroah-Hartman va_start(vargs, fmt); 42894c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL, 42904c747466SChristoph Hellwig fmt, vargs); 42918882b394SGreg Kroah-Hartman va_end(vargs); 42928882b394SGreg Kroah-Hartman return dev; 42938882b394SGreg Kroah-Hartman } 42944e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 42958882b394SGreg Kroah-Hartman 429639ef3112SGuenter Roeck /** 429739ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 429839ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 429939ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 430039ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 430139ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 430239ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 430339ef3112SGuenter Roeck * @fmt: string for the device's name 430439ef3112SGuenter Roeck * 430539ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 430639ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 430739ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 430839ef3112SGuenter Roeck * be created automatically. 430939ef3112SGuenter Roeck * 431039ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 431139ef3112SGuenter Roeck * the dev_t is not 0,0. 431239ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 431339ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 431439ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 431539ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 431639ef3112SGuenter Roeck * pointer. 431739ef3112SGuenter Roeck * 431839ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 431939ef3112SGuenter Roeck * 432039ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 432139ef3112SGuenter Roeck * been created with a call to class_create(). 432239ef3112SGuenter Roeck */ 432339ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 432439ef3112SGuenter Roeck struct device *parent, dev_t devt, 432539ef3112SGuenter Roeck void *drvdata, 432639ef3112SGuenter Roeck const struct attribute_group **groups, 432739ef3112SGuenter Roeck const char *fmt, ...) 432839ef3112SGuenter Roeck { 432939ef3112SGuenter Roeck va_list vargs; 433039ef3112SGuenter Roeck struct device *dev; 433139ef3112SGuenter Roeck 433239ef3112SGuenter Roeck va_start(vargs, fmt); 433339ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 433439ef3112SGuenter Roeck fmt, vargs); 433539ef3112SGuenter Roeck va_end(vargs); 433639ef3112SGuenter Roeck return dev; 433739ef3112SGuenter Roeck } 433839ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 433939ef3112SGuenter Roeck 4340775b64d2SRafael J. Wysocki /** 4341775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 4342775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 4343775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 4344775b64d2SRafael J. Wysocki * 4345775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 4346775b64d2SRafael J. Wysocki * call to device_create(). 4347775b64d2SRafael J. Wysocki */ 4348775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 4349775b64d2SRafael J. Wysocki { 4350775b64d2SRafael J. Wysocki struct device *dev; 4351775b64d2SRafael J. Wysocki 43524495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 4353cd35449bSDave Young if (dev) { 4354cd35449bSDave Young put_device(dev); 435523681e47SGreg Kroah-Hartman device_unregister(dev); 435623681e47SGreg Kroah-Hartman } 4357cd35449bSDave Young } 435823681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 4359a2de48caSGreg Kroah-Hartman 4360a2de48caSGreg Kroah-Hartman /** 4361a2de48caSGreg Kroah-Hartman * device_rename - renames a device 4362a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 4363a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 4364030c1d2bSEric W. Biederman * 4365030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 4366030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 4367030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 4368030c1d2bSEric W. Biederman * won't conflict with other devices. 4369c6c0ac66SMichael Ellerman * 4370a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 4371a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 4372a5462516STimur Tabi * some insight: 4373a5462516STimur Tabi * 4374a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 4375a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 4376a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 4377a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 4378a5462516STimur Tabi * 4379a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 4380a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 4381a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 4382a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 4383a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 4384a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 4385a5462516STimur Tabi * 4386a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 4387a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 4388a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 4389a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 4390a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 4391a5462516STimur Tabi * reasons. 4392a5462516STimur Tabi * 4393a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 4394a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 4395a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 4396a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 4397a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 4398a2de48caSGreg Kroah-Hartman */ 43996937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 4400a2de48caSGreg Kroah-Hartman { 44014b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 44022ee97cafSCornelia Huck char *old_device_name = NULL; 4403a2de48caSGreg Kroah-Hartman int error; 4404a2de48caSGreg Kroah-Hartman 4405a2de48caSGreg Kroah-Hartman dev = get_device(dev); 4406a2de48caSGreg Kroah-Hartman if (!dev) 4407a2de48caSGreg Kroah-Hartman return -EINVAL; 4408a2de48caSGreg Kroah-Hartman 440969df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 4410a2de48caSGreg Kroah-Hartman 44111fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 44122ee97cafSCornelia Huck if (!old_device_name) { 4413952ab431SJesper Juhl error = -ENOMEM; 44142ee97cafSCornelia Huck goto out; 4415952ab431SJesper Juhl } 4416a2de48caSGreg Kroah-Hartman 4417f349cf34SEric W. Biederman if (dev->class) { 44184b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 44194b30ee58STejun Heo kobj, old_device_name, 44204b30ee58STejun Heo new_name, kobject_namespace(kobj)); 4421f349cf34SEric W. Biederman if (error) 4422f349cf34SEric W. Biederman goto out; 4423f349cf34SEric W. Biederman } 442439aba963SKay Sievers 44254b30ee58STejun Heo error = kobject_rename(kobj, new_name); 44261fa5ae85SKay Sievers if (error) 44272ee97cafSCornelia Huck goto out; 4428a2de48caSGreg Kroah-Hartman 44292ee97cafSCornelia Huck out: 4430a2de48caSGreg Kroah-Hartman put_device(dev); 4431a2de48caSGreg Kroah-Hartman 44322ee97cafSCornelia Huck kfree(old_device_name); 4433a2de48caSGreg Kroah-Hartman 4434a2de48caSGreg Kroah-Hartman return error; 4435a2de48caSGreg Kroah-Hartman } 4436a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 44378a82472fSCornelia Huck 44388a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 44398a82472fSCornelia Huck struct device *old_parent, 44408a82472fSCornelia Huck struct device *new_parent) 44418a82472fSCornelia Huck { 4442f7f3461dSGreg Kroah-Hartman int error = 0; 44438a82472fSCornelia Huck 4444f7f3461dSGreg Kroah-Hartman if (old_parent) 4445f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 4446f7f3461dSGreg Kroah-Hartman if (new_parent) 4447f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 4448f7f3461dSGreg Kroah-Hartman "device"); 4449f7f3461dSGreg Kroah-Hartman return error; 44508a82472fSCornelia Huck } 44518a82472fSCornelia Huck 44528a82472fSCornelia Huck /** 44538a82472fSCornelia Huck * device_move - moves a device to a new parent 44548a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 445513509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 4456ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 44578a82472fSCornelia Huck */ 4458ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 4459ffa6a705SCornelia Huck enum dpm_order dpm_order) 44608a82472fSCornelia Huck { 44618a82472fSCornelia Huck int error; 44628a82472fSCornelia Huck struct device *old_parent; 4463c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 44648a82472fSCornelia Huck 44658a82472fSCornelia Huck dev = get_device(dev); 44668a82472fSCornelia Huck if (!dev) 44678a82472fSCornelia Huck return -EINVAL; 44688a82472fSCornelia Huck 4469ffa6a705SCornelia Huck device_pm_lock(); 44708a82472fSCornelia Huck new_parent = get_device(new_parent); 4471c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 447284d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 447384d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 447484d0c27dSTetsuo Handa put_device(new_parent); 447584d0c27dSTetsuo Handa goto out; 447684d0c27dSTetsuo Handa } 447763b6971aSCornelia Huck 44781e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 44791e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 4480c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 44818a82472fSCornelia Huck if (error) { 448263b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 44838a82472fSCornelia Huck put_device(new_parent); 44848a82472fSCornelia Huck goto out; 44858a82472fSCornelia Huck } 44868a82472fSCornelia Huck old_parent = dev->parent; 44878a82472fSCornelia Huck dev->parent = new_parent; 44888a82472fSCornelia Huck if (old_parent) 4489f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 44900d358f22SYinghai Lu if (new_parent) { 4491f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4492f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 44930d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 44940d358f22SYinghai Lu } 44950d358f22SYinghai Lu 4496bdd4034dSRabin Vincent if (dev->class) { 44978a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 44988a82472fSCornelia Huck if (error) { 44998a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 45008a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 45018a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 4502c744aeaeSCornelia Huck if (new_parent) 4503f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 45040d358f22SYinghai Lu dev->parent = old_parent; 45050d358f22SYinghai Lu if (old_parent) { 4506f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4507f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 45080d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 45090d358f22SYinghai Lu } 45108a82472fSCornelia Huck } 451163b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 45128a82472fSCornelia Huck put_device(new_parent); 45138a82472fSCornelia Huck goto out; 45148a82472fSCornelia Huck } 4515bdd4034dSRabin Vincent } 4516ffa6a705SCornelia Huck switch (dpm_order) { 4517ffa6a705SCornelia Huck case DPM_ORDER_NONE: 4518ffa6a705SCornelia Huck break; 4519ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 4520ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 452152cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 4522ffa6a705SCornelia Huck break; 4523ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 4524ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 452552cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 4526ffa6a705SCornelia Huck break; 4527ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 4528ffa6a705SCornelia Huck device_pm_move_last(dev); 452952cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 4530ffa6a705SCornelia Huck break; 4531ffa6a705SCornelia Huck } 4532bdd4034dSRabin Vincent 45338a82472fSCornelia Huck put_device(old_parent); 45348a82472fSCornelia Huck out: 4535ffa6a705SCornelia Huck device_pm_unlock(); 45368a82472fSCornelia Huck put_device(dev); 45378a82472fSCornelia Huck return error; 45388a82472fSCornelia Huck } 45398a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 454037b0c020SGreg Kroah-Hartman 4541b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 4542b8f33e5dSChristian Brauner kgid_t kgid) 4543b8f33e5dSChristian Brauner { 4544b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4545b8f33e5dSChristian Brauner struct class *class = dev->class; 4546b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 4547b8f33e5dSChristian Brauner int error; 4548b8f33e5dSChristian Brauner 4549b8f33e5dSChristian Brauner if (class) { 4550b8f33e5dSChristian Brauner /* 4551b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 4552b8f33e5dSChristian Brauner * @kuid/@kgid. 4553b8f33e5dSChristian Brauner */ 4554b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 4555b8f33e5dSChristian Brauner kgid); 4556b8f33e5dSChristian Brauner if (error) 4557b8f33e5dSChristian Brauner return error; 4558b8f33e5dSChristian Brauner } 4559b8f33e5dSChristian Brauner 4560b8f33e5dSChristian Brauner if (type) { 4561b8f33e5dSChristian Brauner /* 4562b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 4563b8f33e5dSChristian Brauner * @kuid/@kgid. 4564b8f33e5dSChristian Brauner */ 4565b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 4566b8f33e5dSChristian Brauner kgid); 4567b8f33e5dSChristian Brauner if (error) 4568b8f33e5dSChristian Brauner return error; 4569b8f33e5dSChristian Brauner } 4570b8f33e5dSChristian Brauner 4571b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 4572b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 4573b8f33e5dSChristian Brauner if (error) 4574b8f33e5dSChristian Brauner return error; 4575b8f33e5dSChristian Brauner 4576b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 4577b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 4578b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 4579b8f33e5dSChristian Brauner kuid, kgid); 4580b8f33e5dSChristian Brauner if (error) 4581b8f33e5dSChristian Brauner return error; 4582b8f33e5dSChristian Brauner } 4583b8f33e5dSChristian Brauner 4584b8f33e5dSChristian Brauner return 0; 4585b8f33e5dSChristian Brauner } 4586b8f33e5dSChristian Brauner 4587b8f33e5dSChristian Brauner /** 4588b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 4589b8f33e5dSChristian Brauner * @dev: device. 4590b8f33e5dSChristian Brauner * @kuid: new owner's kuid 4591b8f33e5dSChristian Brauner * @kgid: new owner's kgid 4592b8f33e5dSChristian Brauner * 4593b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 4594b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 4595b8f33e5dSChristian Brauner * core. 4596b8f33e5dSChristian Brauner * 4597b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 4598b8f33e5dSChristian Brauner */ 4599b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 4600b8f33e5dSChristian Brauner { 4601b8f33e5dSChristian Brauner int error; 4602b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4603b8f33e5dSChristian Brauner 4604b8f33e5dSChristian Brauner dev = get_device(dev); 4605b8f33e5dSChristian Brauner if (!dev) 4606b8f33e5dSChristian Brauner return -EINVAL; 4607b8f33e5dSChristian Brauner 4608b8f33e5dSChristian Brauner /* 4609b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 4610b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 4611b8f33e5dSChristian Brauner */ 4612b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 4613b8f33e5dSChristian Brauner if (error) 4614b8f33e5dSChristian Brauner goto out; 4615b8f33e5dSChristian Brauner 4616b8f33e5dSChristian Brauner /* 4617b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 4618b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 4619b8f33e5dSChristian Brauner * that step here. 4620b8f33e5dSChristian Brauner */ 4621b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 4622b8f33e5dSChristian Brauner kgid); 4623b8f33e5dSChristian Brauner if (error) 4624b8f33e5dSChristian Brauner goto out; 4625b8f33e5dSChristian Brauner 4626b8f33e5dSChristian Brauner /* 4627b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 4628b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 4629b8f33e5dSChristian Brauner * to @kuid/@kgid. 4630b8f33e5dSChristian Brauner */ 4631b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 4632b8f33e5dSChristian Brauner if (error) 4633b8f33e5dSChristian Brauner goto out; 4634b8f33e5dSChristian Brauner 46353b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 46363b52fc5dSChristian Brauner if (error) 46373b52fc5dSChristian Brauner goto out; 46383b52fc5dSChristian Brauner 4639b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 4640b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 4641b8f33e5dSChristian Brauner goto out; 4642b8f33e5dSChristian Brauner #endif 4643b8f33e5dSChristian Brauner 4644b8f33e5dSChristian Brauner /* 4645b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 4646b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 4647b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 4648b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 4649b8f33e5dSChristian Brauner */ 4650b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 4651b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 4652b8f33e5dSChristian Brauner if (error) 4653b8f33e5dSChristian Brauner goto out; 4654b8f33e5dSChristian Brauner 4655b8f33e5dSChristian Brauner out: 4656b8f33e5dSChristian Brauner put_device(dev); 4657b8f33e5dSChristian Brauner return error; 4658b8f33e5dSChristian Brauner } 4659b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 4660b8f33e5dSChristian Brauner 466137b0c020SGreg Kroah-Hartman /** 466237b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 466337b0c020SGreg Kroah-Hartman */ 466437b0c020SGreg Kroah-Hartman void device_shutdown(void) 466537b0c020SGreg Kroah-Hartman { 4666f123db8eSBenson Leung struct device *dev, *parent; 466737b0c020SGreg Kroah-Hartman 46683297c8fcSPingfan Liu wait_for_device_probe(); 46693297c8fcSPingfan Liu device_block_probing(); 46703297c8fcSPingfan Liu 467165650b35SRafael J. Wysocki cpufreq_suspend(); 467265650b35SRafael J. Wysocki 46736245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 46746245838fSHugh Daschbach /* 46756245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 46766245838fSHugh Daschbach * Beware that device unplug events may also start pulling 46776245838fSHugh Daschbach * devices offline, even as the system is shutting down. 46786245838fSHugh Daschbach */ 46796245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 46806245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 46816245838fSHugh Daschbach kobj.entry); 4682d1c6c030SMing Lei 4683d1c6c030SMing Lei /* 4684d1c6c030SMing Lei * hold reference count of device's parent to 4685d1c6c030SMing Lei * prevent it from being freed because parent's 4686d1c6c030SMing Lei * lock is to be held 4687d1c6c030SMing Lei */ 4688f123db8eSBenson Leung parent = get_device(dev->parent); 46896245838fSHugh Daschbach get_device(dev); 46906245838fSHugh Daschbach /* 46916245838fSHugh Daschbach * Make sure the device is off the kset list, in the 46926245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 46936245838fSHugh Daschbach */ 46946245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 46956245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 4696fe6b91f4SAlan Stern 4697d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 4698f123db8eSBenson Leung if (parent) 4699f123db8eSBenson Leung device_lock(parent); 4700d1c6c030SMing Lei device_lock(dev); 4701d1c6c030SMing Lei 4702fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 4703fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 4704fe6b91f4SAlan Stern pm_runtime_barrier(dev); 47056245838fSHugh Daschbach 47067521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 4707f77af151SJosh Zimmerman if (initcall_debug) 47087521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 47097521621eSMichal Suchanek dev->class->shutdown_pre(dev); 47107521621eSMichal Suchanek } 47117521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 47120246c4faSShuoX Liu if (initcall_debug) 47130246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 471437b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 471537b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 47160246c4faSShuoX Liu if (initcall_debug) 47170246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 471837b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 471937b0c020SGreg Kroah-Hartman } 4720d1c6c030SMing Lei 4721d1c6c030SMing Lei device_unlock(dev); 4722f123db8eSBenson Leung if (parent) 4723f123db8eSBenson Leung device_unlock(parent); 4724d1c6c030SMing Lei 47256245838fSHugh Daschbach put_device(dev); 4726f123db8eSBenson Leung put_device(parent); 47276245838fSHugh Daschbach 47286245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 472937b0c020SGreg Kroah-Hartman } 47306245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 473137b0c020SGreg Kroah-Hartman } 473299bcf217SJoe Perches 473399bcf217SJoe Perches /* 473499bcf217SJoe Perches * Device logging functions 473599bcf217SJoe Perches */ 473699bcf217SJoe Perches 473799bcf217SJoe Perches #ifdef CONFIG_PRINTK 473874caba7fSJohn Ogness static void 473974caba7fSJohn Ogness set_dev_info(const struct device *dev, struct dev_printk_info *dev_info) 474099bcf217SJoe Perches { 4741c4e00daaSKay Sievers const char *subsys; 474274caba7fSJohn Ogness 474374caba7fSJohn Ogness memset(dev_info, 0, sizeof(*dev_info)); 474499bcf217SJoe Perches 4745c4e00daaSKay Sievers if (dev->class) 4746c4e00daaSKay Sievers subsys = dev->class->name; 4747c4e00daaSKay Sievers else if (dev->bus) 4748c4e00daaSKay Sievers subsys = dev->bus->name; 4749c4e00daaSKay Sievers else 475074caba7fSJohn Ogness return; 4751c4e00daaSKay Sievers 475274caba7fSJohn Ogness strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); 4753c4e00daaSKay Sievers 4754c4e00daaSKay Sievers /* 4755c4e00daaSKay Sievers * Add device identifier DEVICE=: 4756c4e00daaSKay Sievers * b12:8 block dev_t 4757c4e00daaSKay Sievers * c127:3 char dev_t 4758c4e00daaSKay Sievers * n8 netdev ifindex 4759c4e00daaSKay Sievers * +sound:card0 subsystem:devname 4760c4e00daaSKay Sievers */ 4761c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 4762c4e00daaSKay Sievers char c; 4763c4e00daaSKay Sievers 4764c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 4765c4e00daaSKay Sievers c = 'b'; 4766c4e00daaSKay Sievers else 4767c4e00daaSKay Sievers c = 'c'; 476874caba7fSJohn Ogness 476974caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 477074caba7fSJohn Ogness "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); 4771c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 4772c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 4773c4e00daaSKay Sievers 477474caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 477574caba7fSJohn Ogness "n%u", net->ifindex); 4776c4e00daaSKay Sievers } else { 477774caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 477874caba7fSJohn Ogness "+%s:%s", subsys, dev_name(dev)); 4779c4e00daaSKay Sievers } 478099bcf217SJoe Perches } 4781798efc60SJoe Perches 478205e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 478305e4e5b8SJoe Perches const char *fmt, va_list args) 478405e4e5b8SJoe Perches { 478574caba7fSJohn Ogness struct dev_printk_info dev_info; 478605e4e5b8SJoe Perches 478774caba7fSJohn Ogness set_dev_info(dev, &dev_info); 478805e4e5b8SJoe Perches 478974caba7fSJohn Ogness return vprintk_emit(0, level, &dev_info, fmt, args); 479005e4e5b8SJoe Perches } 479105e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 479205e4e5b8SJoe Perches 479305e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 479405e4e5b8SJoe Perches { 479505e4e5b8SJoe Perches va_list args; 479605e4e5b8SJoe Perches int r; 479705e4e5b8SJoe Perches 479805e4e5b8SJoe Perches va_start(args, fmt); 479905e4e5b8SJoe Perches 480005e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 480105e4e5b8SJoe Perches 480205e4e5b8SJoe Perches va_end(args); 480305e4e5b8SJoe Perches 480405e4e5b8SJoe Perches return r; 480505e4e5b8SJoe Perches } 480605e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 480705e4e5b8SJoe Perches 4808d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 4809798efc60SJoe Perches struct va_format *vaf) 4810798efc60SJoe Perches { 4811d1f1052cSJoe Perches if (dev) 4812d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 4813798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 4814d1f1052cSJoe Perches else 4815d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 4816798efc60SJoe Perches } 481799bcf217SJoe Perches 4818ad7d61f1SChris Down void _dev_printk(const char *level, const struct device *dev, 481999bcf217SJoe Perches const char *fmt, ...) 482099bcf217SJoe Perches { 482199bcf217SJoe Perches struct va_format vaf; 482299bcf217SJoe Perches va_list args; 482399bcf217SJoe Perches 482499bcf217SJoe Perches va_start(args, fmt); 482599bcf217SJoe Perches 482699bcf217SJoe Perches vaf.fmt = fmt; 482799bcf217SJoe Perches vaf.va = &args; 482899bcf217SJoe Perches 4829d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 4830798efc60SJoe Perches 483199bcf217SJoe Perches va_end(args); 483299bcf217SJoe Perches } 4833ad7d61f1SChris Down EXPORT_SYMBOL(_dev_printk); 483499bcf217SJoe Perches 483599bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 4836d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 483799bcf217SJoe Perches { \ 483899bcf217SJoe Perches struct va_format vaf; \ 483999bcf217SJoe Perches va_list args; \ 484099bcf217SJoe Perches \ 484199bcf217SJoe Perches va_start(args, fmt); \ 484299bcf217SJoe Perches \ 484399bcf217SJoe Perches vaf.fmt = fmt; \ 484499bcf217SJoe Perches vaf.va = &args; \ 484599bcf217SJoe Perches \ 4846d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 4847798efc60SJoe Perches \ 484899bcf217SJoe Perches va_end(args); \ 484999bcf217SJoe Perches } \ 485099bcf217SJoe Perches EXPORT_SYMBOL(func); 485199bcf217SJoe Perches 4852663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 4853663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 4854663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 4855663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 4856663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 4857663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 485899bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 485999bcf217SJoe Perches 486099bcf217SJoe Perches #endif 486197badf87SRafael J. Wysocki 4862a787e540SAndrzej Hajda /** 4863a787e540SAndrzej Hajda * dev_err_probe - probe error check and log helper 4864a787e540SAndrzej Hajda * @dev: the pointer to the struct device 4865a787e540SAndrzej Hajda * @err: error value to test 4866a787e540SAndrzej Hajda * @fmt: printf-style format string 4867a787e540SAndrzej Hajda * @...: arguments as specified in the format string 4868a787e540SAndrzej Hajda * 4869a787e540SAndrzej Hajda * This helper implements common pattern present in probe functions for error 4870a787e540SAndrzej Hajda * checking: print debug or error message depending if the error value is 4871a787e540SAndrzej Hajda * -EPROBE_DEFER and propagate error upwards. 4872d090b70eSAndrzej Hajda * In case of -EPROBE_DEFER it sets also defer probe reason, which can be 4873d090b70eSAndrzej Hajda * checked later by reading devices_deferred debugfs attribute. 4874074b3aadSMauro Carvalho Chehab * It replaces code sequence:: 4875074b3aadSMauro Carvalho Chehab * 4876a787e540SAndrzej Hajda * if (err != -EPROBE_DEFER) 4877a787e540SAndrzej Hajda * dev_err(dev, ...); 4878a787e540SAndrzej Hajda * else 4879a787e540SAndrzej Hajda * dev_dbg(dev, ...); 4880a787e540SAndrzej Hajda * return err; 4881074b3aadSMauro Carvalho Chehab * 4882074b3aadSMauro Carvalho Chehab * with:: 4883074b3aadSMauro Carvalho Chehab * 4884a787e540SAndrzej Hajda * return dev_err_probe(dev, err, ...); 4885a787e540SAndrzej Hajda * 48867065f922SDouglas Anderson * Note that it is deemed acceptable to use this function for error 48877065f922SDouglas Anderson * prints during probe even if the @err is known to never be -EPROBE_DEFER. 48887065f922SDouglas Anderson * The benefit compared to a normal dev_err() is the standardized format 48897065f922SDouglas Anderson * of the error code and the fact that the error code is returned. 48907065f922SDouglas Anderson * 4891a787e540SAndrzej Hajda * Returns @err. 4892a787e540SAndrzej Hajda * 4893a787e540SAndrzej Hajda */ 4894a787e540SAndrzej Hajda int dev_err_probe(const struct device *dev, int err, const char *fmt, ...) 4895a787e540SAndrzej Hajda { 4896a787e540SAndrzej Hajda struct va_format vaf; 4897a787e540SAndrzej Hajda va_list args; 4898a787e540SAndrzej Hajda 4899a787e540SAndrzej Hajda va_start(args, fmt); 4900a787e540SAndrzej Hajda vaf.fmt = fmt; 4901a787e540SAndrzej Hajda vaf.va = &args; 4902a787e540SAndrzej Hajda 4903d090b70eSAndrzej Hajda if (err != -EPROBE_DEFER) { 4904693a8e93SMichał Mirosław dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4905d090b70eSAndrzej Hajda } else { 4906d090b70eSAndrzej Hajda device_set_deferred_probe_reason(dev, &vaf); 4907693a8e93SMichał Mirosław dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4908d090b70eSAndrzej Hajda } 4909a787e540SAndrzej Hajda 4910a787e540SAndrzej Hajda va_end(args); 4911a787e540SAndrzej Hajda 4912a787e540SAndrzej Hajda return err; 4913a787e540SAndrzej Hajda } 4914a787e540SAndrzej Hajda EXPORT_SYMBOL_GPL(dev_err_probe); 4915a787e540SAndrzej Hajda 491697badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 491797badf87SRafael J. Wysocki { 491897badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 491997badf87SRafael J. Wysocki } 492097badf87SRafael J. Wysocki 492197badf87SRafael J. Wysocki /** 492297badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 492397badf87SRafael J. Wysocki * @dev: Device to handle. 492497badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 492597badf87SRafael J. Wysocki * 492697badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 492797badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 49283f7bddafSBard Liao * 49293f7bddafSBard Liao * Valid fwnode cases are: 49303f7bddafSBard Liao * - primary --> secondary --> -ENODEV 49313f7bddafSBard Liao * - primary --> NULL 49323f7bddafSBard Liao * - secondary --> -ENODEV 49333f7bddafSBard Liao * - NULL 493497badf87SRafael J. Wysocki */ 493597badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 493697badf87SRafael J. Wysocki { 493799aed922SAndy Shevchenko struct device *parent = dev->parent; 493897badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 493997badf87SRafael J. Wysocki 4940c15e1bddSHeikki Krogerus if (fwnode) { 494197badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 494297badf87SRafael J. Wysocki fn = fn->secondary; 494397badf87SRafael J. Wysocki 494455f89a8aSMika Westerberg if (fn) { 494555f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 494697badf87SRafael J. Wysocki fwnode->secondary = fn; 494755f89a8aSMika Westerberg } 494897badf87SRafael J. Wysocki dev->fwnode = fwnode; 494997badf87SRafael J. Wysocki } else { 4950c15e1bddSHeikki Krogerus if (fwnode_is_primary(fn)) { 4951c15e1bddSHeikki Krogerus dev->fwnode = fn->secondary; 49523f7bddafSBard Liao /* Set fn->secondary = NULL, so fn remains the primary fwnode */ 495399aed922SAndy Shevchenko if (!(parent && fn == parent->fwnode)) 495447f44699SBard Liao fn->secondary = NULL; 4955c15e1bddSHeikki Krogerus } else { 4956c15e1bddSHeikki Krogerus dev->fwnode = NULL; 4957c15e1bddSHeikki Krogerus } 495897badf87SRafael J. Wysocki } 495997badf87SRafael J. Wysocki } 496097badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 496197badf87SRafael J. Wysocki 496297badf87SRafael J. Wysocki /** 496397badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 496497badf87SRafael J. Wysocki * @dev: Device to handle. 496597badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 496697badf87SRafael J. Wysocki * 496797badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 496897badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 496997badf87SRafael J. Wysocki * @fwnode. 497097badf87SRafael J. Wysocki */ 497197badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 497297badf87SRafael J. Wysocki { 497397badf87SRafael J. Wysocki if (fwnode) 497497badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 497597badf87SRafael J. Wysocki 497697badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 497797badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 497897badf87SRafael J. Wysocki else 497997badf87SRafael J. Wysocki dev->fwnode = fwnode; 498097badf87SRafael J. Wysocki } 498196489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 49824e75e1d7SJohan Hovold 49834e75e1d7SJohan Hovold /** 49844e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 49854e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 49864e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 49874e75e1d7SJohan Hovold * 49884e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 49894e75e1d7SJohan Hovold * any reference held to the old node. 49904e75e1d7SJohan Hovold */ 49914e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 49924e75e1d7SJohan Hovold { 49934e75e1d7SJohan Hovold of_node_put(dev->of_node); 49944e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 49954e75e1d7SJohan Hovold dev->of_node_reused = true; 49964e75e1d7SJohan Hovold } 49974e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 499865b66682SSuzuki K Poulose 499943e76d46SIoana Ciornei void device_set_node(struct device *dev, struct fwnode_handle *fwnode) 500043e76d46SIoana Ciornei { 500143e76d46SIoana Ciornei dev->fwnode = fwnode; 500243e76d46SIoana Ciornei dev->of_node = to_of_node(fwnode); 500343e76d46SIoana Ciornei } 500443e76d46SIoana Ciornei EXPORT_SYMBOL_GPL(device_set_node); 500543e76d46SIoana Ciornei 50066cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 50076cda08a2SSuzuki K Poulose { 50086cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 50096cda08a2SSuzuki K Poulose } 50106cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 50116cda08a2SSuzuki K Poulose 501265b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 501365b66682SSuzuki K Poulose { 501465b66682SSuzuki K Poulose return dev->of_node == np; 501565b66682SSuzuki K Poulose } 501665b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 501767843bbaSSuzuki K Poulose 501867843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 501967843bbaSSuzuki K Poulose { 502067843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 502167843bbaSSuzuki K Poulose } 502267843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 50234495dfddSSuzuki K Poulose 50244495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 50254495dfddSSuzuki K Poulose { 50264495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 50274495dfddSSuzuki K Poulose } 50284495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 502900500147SSuzuki K Poulose 503000500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 503100500147SSuzuki K Poulose { 503200500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 503300500147SSuzuki K Poulose } 503400500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 50356bf85ba9SSuzuki K Poulose 5036a164ff53SAndy Shevchenko int device_match_acpi_handle(struct device *dev, const void *handle) 5037a164ff53SAndy Shevchenko { 5038a164ff53SAndy Shevchenko return ACPI_HANDLE(dev) == handle; 5039a164ff53SAndy Shevchenko } 5040a164ff53SAndy Shevchenko EXPORT_SYMBOL(device_match_acpi_handle); 5041a164ff53SAndy Shevchenko 50426bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 50436bf85ba9SSuzuki K Poulose { 50446bf85ba9SSuzuki K Poulose return 1; 50456bf85ba9SSuzuki K Poulose } 50466bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 5047