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> 171da177e4SLinus Torvalds #include <linux/module.h> 181da177e4SLinus Torvalds #include <linux/slab.h> 191da177e4SLinus Torvalds #include <linux/string.h> 2023681e47SGreg Kroah-Hartman #include <linux/kdev_t.h> 21116af378SBenjamin Herrenschmidt #include <linux/notifier.h> 2207d57a32SGrant Likely #include <linux/of.h> 2307d57a32SGrant Likely #include <linux/of_device.h> 24da231fd5SKay Sievers #include <linux/genhd.h> 25f75b1c60SDave Young #include <linux/mutex.h> 26af8db150SPeter Chen #include <linux/pm_runtime.h> 27c4e00daaSKay Sievers #include <linux/netdevice.h> 28174cd4b1SIngo Molnar #include <linux/sched/signal.h> 29b8530017SOliver Neukum #include <linux/sched/mm.h> 30*69031f50SClaire Chang #include <linux/swiotlb.h> 3163967685SGreg Kroah-Hartman #include <linux/sysfs.h> 326d4e9a8eSChristoph Hellwig #include <linux/dma-map-ops.h> /* for dma_default_coherent */ 331da177e4SLinus Torvalds 341da177e4SLinus Torvalds #include "base.h" 351da177e4SLinus Torvalds #include "power/power.h" 361da177e4SLinus Torvalds 37e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 38e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 39e52eec13SAndi Kleen long sysfs_deprecated = 1; 40e52eec13SAndi Kleen #else 41e52eec13SAndi Kleen long sysfs_deprecated = 0; 42e52eec13SAndi Kleen #endif 433454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 44e52eec13SAndi Kleen { 4534da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 46e52eec13SAndi Kleen } 47e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 48e52eec13SAndi Kleen #endif 49e52eec13SAndi Kleen 509ed98953SRafael J. Wysocki /* Device links support. */ 51fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 52fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 537b337cb3SSaravana Kannan static DEFINE_MUTEX(fwnode_link_lock); 5425ac86c6SSaravana Kannan static bool fw_devlink_is_permissive(void); 55d46f3e3eSSaravana Kannan static bool fw_devlink_drv_reg_done; 567b337cb3SSaravana Kannan 577b337cb3SSaravana Kannan /** 587b337cb3SSaravana Kannan * fwnode_link_add - Create a link between two fwnode_handles. 597b337cb3SSaravana Kannan * @con: Consumer end of the link. 607b337cb3SSaravana Kannan * @sup: Supplier end of the link. 617b337cb3SSaravana Kannan * 627b337cb3SSaravana Kannan * Create a fwnode link between fwnode handles @con and @sup. The fwnode link 637b337cb3SSaravana Kannan * represents the detail that the firmware lists @sup fwnode as supplying a 647b337cb3SSaravana Kannan * resource to @con. 657b337cb3SSaravana Kannan * 667b337cb3SSaravana Kannan * The driver core will use the fwnode link to create a device link between the 677b337cb3SSaravana Kannan * two device objects corresponding to @con and @sup when they are created. The 687b337cb3SSaravana Kannan * driver core will automatically delete the fwnode link between @con and @sup 697b337cb3SSaravana Kannan * after doing that. 707b337cb3SSaravana Kannan * 717b337cb3SSaravana Kannan * Attempts to create duplicate links between the same pair of fwnode handles 727b337cb3SSaravana Kannan * are ignored and there is no reference counting. 737b337cb3SSaravana Kannan */ 747b337cb3SSaravana Kannan int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup) 757b337cb3SSaravana Kannan { 767b337cb3SSaravana Kannan struct fwnode_link *link; 777b337cb3SSaravana Kannan int ret = 0; 787b337cb3SSaravana Kannan 797b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 807b337cb3SSaravana Kannan 817b337cb3SSaravana Kannan list_for_each_entry(link, &sup->consumers, s_hook) 827b337cb3SSaravana Kannan if (link->consumer == con) 837b337cb3SSaravana Kannan goto out; 847b337cb3SSaravana Kannan 857b337cb3SSaravana Kannan link = kzalloc(sizeof(*link), GFP_KERNEL); 867b337cb3SSaravana Kannan if (!link) { 877b337cb3SSaravana Kannan ret = -ENOMEM; 887b337cb3SSaravana Kannan goto out; 897b337cb3SSaravana Kannan } 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); 987b337cb3SSaravana Kannan out: 997b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1007b337cb3SSaravana Kannan 1017b337cb3SSaravana Kannan return ret; 1027b337cb3SSaravana Kannan } 1037b337cb3SSaravana Kannan 1047b337cb3SSaravana Kannan /** 1057b337cb3SSaravana Kannan * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle. 1067b337cb3SSaravana Kannan * @fwnode: fwnode whose supplier links need to be deleted 1077b337cb3SSaravana Kannan * 1087b337cb3SSaravana Kannan * Deletes all supplier links connecting directly to @fwnode. 1097b337cb3SSaravana Kannan */ 1107b337cb3SSaravana Kannan static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode) 1117b337cb3SSaravana Kannan { 1127b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1137b337cb3SSaravana Kannan 1147b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 1157b337cb3SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { 1167b337cb3SSaravana Kannan list_del(&link->s_hook); 1177b337cb3SSaravana Kannan list_del(&link->c_hook); 1187b337cb3SSaravana Kannan kfree(link); 1197b337cb3SSaravana Kannan } 1207b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1217b337cb3SSaravana Kannan } 1227b337cb3SSaravana Kannan 1237b337cb3SSaravana Kannan /** 1247b337cb3SSaravana Kannan * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle. 1257b337cb3SSaravana Kannan * @fwnode: fwnode whose consumer links need to be deleted 1267b337cb3SSaravana Kannan * 1277b337cb3SSaravana Kannan * Deletes all consumer links connecting directly to @fwnode. 1287b337cb3SSaravana Kannan */ 1297b337cb3SSaravana Kannan static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode) 1307b337cb3SSaravana Kannan { 1317b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1327b337cb3SSaravana Kannan 1337b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 1347b337cb3SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { 1357b337cb3SSaravana Kannan list_del(&link->s_hook); 1367b337cb3SSaravana Kannan list_del(&link->c_hook); 1377b337cb3SSaravana Kannan kfree(link); 1387b337cb3SSaravana Kannan } 1397b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1407b337cb3SSaravana Kannan } 1417b337cb3SSaravana Kannan 1427b337cb3SSaravana Kannan /** 1437b337cb3SSaravana Kannan * fwnode_links_purge - Delete all links connected to a fwnode_handle. 1447b337cb3SSaravana Kannan * @fwnode: fwnode whose links needs to be deleted 1457b337cb3SSaravana Kannan * 1467b337cb3SSaravana Kannan * Deletes all links connecting directly to a fwnode. 1477b337cb3SSaravana Kannan */ 1487b337cb3SSaravana Kannan void fwnode_links_purge(struct fwnode_handle *fwnode) 1497b337cb3SSaravana Kannan { 1507b337cb3SSaravana Kannan fwnode_links_purge_suppliers(fwnode); 1517b337cb3SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1527b337cb3SSaravana Kannan } 1539ed98953SRafael J. Wysocki 15428ec344bSSaravana Kannan void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode) 1559528e0d9SSaravana Kannan { 1569528e0d9SSaravana Kannan struct fwnode_handle *child; 1579528e0d9SSaravana Kannan 1589528e0d9SSaravana Kannan /* Don't purge consumer links of an added child */ 1599528e0d9SSaravana Kannan if (fwnode->dev) 1609528e0d9SSaravana Kannan return; 1619528e0d9SSaravana Kannan 1629528e0d9SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; 1639528e0d9SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1649528e0d9SSaravana Kannan 1659528e0d9SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child) 1669528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 1679528e0d9SSaravana Kannan } 16828ec344bSSaravana Kannan EXPORT_SYMBOL_GPL(fw_devlink_purge_absent_suppliers); 1699528e0d9SSaravana Kannan 1709ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 1719ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 1729ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 1739ed98953SRafael J. Wysocki 1749ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 1759ed98953SRafael J. Wysocki { 1769ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 1779ed98953SRafael J. Wysocki } 1789ed98953SRafael J. Wysocki 1799ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 1809ed98953SRafael J. Wysocki { 1819ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 1829ed98953SRafael J. Wysocki } 1839ed98953SRafael J. Wysocki 18468464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 1859ed98953SRafael J. Wysocki { 1869ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 1879ed98953SRafael J. Wysocki } 1889ed98953SRafael J. Wysocki 189ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 1909ed98953SRafael J. Wysocki { 1919ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 1929ed98953SRafael J. Wysocki } 193c2fa1e1bSJoel Fernandes (Google) 194c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 195c2fa1e1bSJoel Fernandes (Google) { 196c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 197c2fa1e1bSJoel Fernandes (Google) } 19880dd33cfSRafael J. Wysocki 19980dd33cfSRafael J. Wysocki static void device_link_synchronize_removal(void) 20080dd33cfSRafael J. Wysocki { 20180dd33cfSRafael J. Wysocki synchronize_srcu(&device_links_srcu); 20280dd33cfSRafael J. Wysocki } 2030c871315SRafael J. Wysocki 2040c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link) 2050c871315SRafael J. Wysocki { 2060c871315SRafael J. Wysocki list_del_rcu(&link->s_node); 2070c871315SRafael J. Wysocki list_del_rcu(&link->c_node); 2080c871315SRafael J. Wysocki } 2099ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 2109ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 2119ed98953SRafael J. Wysocki 2129ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 2139ed98953SRafael J. Wysocki { 2149ed98953SRafael J. Wysocki down_write(&device_links_lock); 2159ed98953SRafael J. Wysocki } 2169ed98953SRafael J. Wysocki 2179ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 2189ed98953SRafael J. Wysocki { 2199ed98953SRafael J. Wysocki up_write(&device_links_lock); 2209ed98953SRafael J. Wysocki } 2219ed98953SRafael J. Wysocki 2229ed98953SRafael J. Wysocki int device_links_read_lock(void) 2239ed98953SRafael J. Wysocki { 2249ed98953SRafael J. Wysocki down_read(&device_links_lock); 2259ed98953SRafael J. Wysocki return 0; 2269ed98953SRafael J. Wysocki } 2279ed98953SRafael J. Wysocki 2289ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 2299ed98953SRafael J. Wysocki { 2309ed98953SRafael J. Wysocki up_read(&device_links_lock); 2319ed98953SRafael J. Wysocki } 232c2fa1e1bSJoel Fernandes (Google) 233c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 234c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 235c2fa1e1bSJoel Fernandes (Google) { 236c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 237c2fa1e1bSJoel Fernandes (Google) } 238c2fa1e1bSJoel Fernandes (Google) #endif 23980dd33cfSRafael J. Wysocki 24080dd33cfSRafael J. Wysocki static inline void device_link_synchronize_removal(void) 24180dd33cfSRafael J. Wysocki { 24280dd33cfSRafael J. Wysocki } 2430c871315SRafael J. Wysocki 2440c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link) 2450c871315SRafael J. Wysocki { 2460c871315SRafael J. Wysocki list_del(&link->s_node); 2470c871315SRafael J. Wysocki list_del(&link->c_node); 2480c871315SRafael J. Wysocki } 2499ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 2509ed98953SRafael J. Wysocki 2513d1cf435SRafael J. Wysocki static bool device_is_ancestor(struct device *dev, struct device *target) 2523d1cf435SRafael J. Wysocki { 2533d1cf435SRafael J. Wysocki while (target->parent) { 2543d1cf435SRafael J. Wysocki target = target->parent; 2553d1cf435SRafael J. Wysocki if (dev == target) 2563d1cf435SRafael J. Wysocki return true; 2573d1cf435SRafael J. Wysocki } 2583d1cf435SRafael J. Wysocki return false; 2593d1cf435SRafael J. Wysocki } 2603d1cf435SRafael J. Wysocki 2619ed98953SRafael J. Wysocki /** 2629ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 2639ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 2649ed98953SRafael J. Wysocki * @target: Device to check against. 2659ed98953SRafael J. Wysocki * 2669ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 2679ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 2689ed98953SRafael J. Wysocki */ 2697d34ca38SSaravana Kannan int device_is_dependent(struct device *dev, void *target) 2709ed98953SRafael J. Wysocki { 2719ed98953SRafael J. Wysocki struct device_link *link; 2729ed98953SRafael J. Wysocki int ret; 2739ed98953SRafael J. Wysocki 2743d1cf435SRafael J. Wysocki /* 2753d1cf435SRafael J. Wysocki * The "ancestors" check is needed to catch the case when the target 2763d1cf435SRafael J. Wysocki * device has not been completely initialized yet and it is still 2773d1cf435SRafael J. Wysocki * missing from the list of children of its parent device. 2783d1cf435SRafael J. Wysocki */ 2793d1cf435SRafael J. Wysocki if (dev == target || device_is_ancestor(dev, target)) 2809ed98953SRafael J. Wysocki return 1; 2819ed98953SRafael J. Wysocki 2829ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 2839ed98953SRafael J. Wysocki if (ret) 2849ed98953SRafael J. Wysocki return ret; 2859ed98953SRafael J. Wysocki 2869ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 2874b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 2884b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 28905ef983eSSaravana Kannan continue; 29005ef983eSSaravana Kannan 291e16f4f3eSBenjamin Gaignard if (link->consumer == target) 2929ed98953SRafael J. Wysocki return 1; 2939ed98953SRafael J. Wysocki 2949ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 2959ed98953SRafael J. Wysocki if (ret) 2969ed98953SRafael J. Wysocki break; 2979ed98953SRafael J. Wysocki } 2989ed98953SRafael J. Wysocki return ret; 2999ed98953SRafael J. Wysocki } 3009ed98953SRafael J. Wysocki 301515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 302515db266SRafael J. Wysocki struct device *consumer, 303515db266SRafael J. Wysocki struct device *supplier) 304515db266SRafael J. Wysocki { 305515db266SRafael J. Wysocki switch (supplier->links.status) { 306515db266SRafael J. Wysocki case DL_DEV_PROBING: 307515db266SRafael J. Wysocki switch (consumer->links.status) { 308515db266SRafael J. Wysocki case DL_DEV_PROBING: 309515db266SRafael J. Wysocki /* 310515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 311515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 312515db266SRafael J. Wysocki * knows that the supplier is already functional (for 313515db266SRafael J. Wysocki * example, it has just acquired some resources from the 314515db266SRafael J. Wysocki * supplier). 315515db266SRafael J. Wysocki */ 316515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 317515db266SRafael J. Wysocki break; 318515db266SRafael J. Wysocki default: 319515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 320515db266SRafael J. Wysocki break; 321515db266SRafael J. Wysocki } 322515db266SRafael J. Wysocki break; 323515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 324515db266SRafael J. Wysocki switch (consumer->links.status) { 325515db266SRafael J. Wysocki case DL_DEV_PROBING: 326515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 327515db266SRafael J. Wysocki break; 328515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 329515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 330515db266SRafael J. Wysocki break; 331515db266SRafael J. Wysocki default: 332515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 333515db266SRafael J. Wysocki break; 334515db266SRafael J. Wysocki } 335515db266SRafael J. Wysocki break; 336515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 337515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 338515db266SRafael J. Wysocki break; 339515db266SRafael J. Wysocki default: 340515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 341515db266SRafael J. Wysocki break; 342515db266SRafael J. Wysocki } 343515db266SRafael J. Wysocki } 344515db266SRafael J. Wysocki 3459ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 3469ed98953SRafael J. Wysocki { 3479ed98953SRafael J. Wysocki struct device_link *link; 3489ed98953SRafael J. Wysocki 3499ed98953SRafael J. Wysocki /* 3509ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 3519ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 3529ed98953SRafael J. Wysocki */ 3539ed98953SRafael J. Wysocki if (device_is_registered(dev)) 3549ed98953SRafael J. Wysocki devices_kset_move_last(dev); 3559ed98953SRafael J. Wysocki 3569ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 3579ed98953SRafael J. Wysocki device_pm_move_last(dev); 3589ed98953SRafael J. Wysocki 3599ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 36005ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 3614b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 3624b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 36305ef983eSSaravana Kannan continue; 3649ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 36505ef983eSSaravana Kannan } 3669ed98953SRafael J. Wysocki 3679ed98953SRafael J. Wysocki return 0; 3689ed98953SRafael J. Wysocki } 3699ed98953SRafael J. Wysocki 3709ed98953SRafael J. Wysocki /** 371494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 372494fd7b7SFeng Kan * @dev: Device to move 373494fd7b7SFeng Kan * 374494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 375494fd7b7SFeng Kan * 376494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 377494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 378494fd7b7SFeng Kan */ 379494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 380494fd7b7SFeng Kan { 381494fd7b7SFeng Kan int idx; 382494fd7b7SFeng Kan 383494fd7b7SFeng Kan idx = device_links_read_lock(); 384494fd7b7SFeng Kan device_pm_lock(); 385494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 386494fd7b7SFeng Kan device_pm_unlock(); 387494fd7b7SFeng Kan device_links_read_unlock(idx); 388494fd7b7SFeng Kan } 389494fd7b7SFeng Kan 390287905e6SSaravana Kannan #define to_devlink(dev) container_of((dev), struct device_link, link_dev) 391287905e6SSaravana Kannan 392287905e6SSaravana Kannan static ssize_t status_show(struct device *dev, 393287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 394287905e6SSaravana Kannan { 395948b3edbSJoe Perches const char *output; 396287905e6SSaravana Kannan 397287905e6SSaravana Kannan switch (to_devlink(dev)->status) { 398287905e6SSaravana Kannan case DL_STATE_NONE: 399948b3edbSJoe Perches output = "not tracked"; 400948b3edbSJoe Perches break; 401287905e6SSaravana Kannan case DL_STATE_DORMANT: 402948b3edbSJoe Perches output = "dormant"; 403948b3edbSJoe Perches break; 404287905e6SSaravana Kannan case DL_STATE_AVAILABLE: 405948b3edbSJoe Perches output = "available"; 406948b3edbSJoe Perches break; 407287905e6SSaravana Kannan case DL_STATE_CONSUMER_PROBE: 408948b3edbSJoe Perches output = "consumer probing"; 409948b3edbSJoe Perches break; 410287905e6SSaravana Kannan case DL_STATE_ACTIVE: 411948b3edbSJoe Perches output = "active"; 412948b3edbSJoe Perches break; 413287905e6SSaravana Kannan case DL_STATE_SUPPLIER_UNBIND: 414948b3edbSJoe Perches output = "supplier unbinding"; 415948b3edbSJoe Perches break; 416287905e6SSaravana Kannan default: 417948b3edbSJoe Perches output = "unknown"; 418948b3edbSJoe Perches break; 419287905e6SSaravana Kannan } 420948b3edbSJoe Perches 421948b3edbSJoe Perches return sysfs_emit(buf, "%s\n", output); 422287905e6SSaravana Kannan } 423287905e6SSaravana Kannan static DEVICE_ATTR_RO(status); 424287905e6SSaravana Kannan 425287905e6SSaravana Kannan static ssize_t auto_remove_on_show(struct device *dev, 426287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 427287905e6SSaravana Kannan { 428287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 429973c3911SJoe Perches const char *output; 430287905e6SSaravana Kannan 431287905e6SSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 432973c3911SJoe Perches output = "supplier unbind"; 433287905e6SSaravana Kannan else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 434973c3911SJoe Perches output = "consumer unbind"; 435287905e6SSaravana Kannan else 436973c3911SJoe Perches output = "never"; 437287905e6SSaravana Kannan 438973c3911SJoe Perches return sysfs_emit(buf, "%s\n", output); 439287905e6SSaravana Kannan } 440287905e6SSaravana Kannan static DEVICE_ATTR_RO(auto_remove_on); 441287905e6SSaravana Kannan 442287905e6SSaravana Kannan static ssize_t runtime_pm_show(struct device *dev, 443287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 444287905e6SSaravana Kannan { 445287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 446287905e6SSaravana Kannan 447aa838896SJoe Perches return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); 448287905e6SSaravana Kannan } 449287905e6SSaravana Kannan static DEVICE_ATTR_RO(runtime_pm); 450287905e6SSaravana Kannan 451287905e6SSaravana Kannan static ssize_t sync_state_only_show(struct device *dev, 452287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 453287905e6SSaravana Kannan { 454287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 455287905e6SSaravana Kannan 456aa838896SJoe Perches return sysfs_emit(buf, "%d\n", 457aa838896SJoe Perches !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 458287905e6SSaravana Kannan } 459287905e6SSaravana Kannan static DEVICE_ATTR_RO(sync_state_only); 460287905e6SSaravana Kannan 461287905e6SSaravana Kannan static struct attribute *devlink_attrs[] = { 462287905e6SSaravana Kannan &dev_attr_status.attr, 463287905e6SSaravana Kannan &dev_attr_auto_remove_on.attr, 464287905e6SSaravana Kannan &dev_attr_runtime_pm.attr, 465287905e6SSaravana Kannan &dev_attr_sync_state_only.attr, 466287905e6SSaravana Kannan NULL, 467287905e6SSaravana Kannan }; 468287905e6SSaravana Kannan ATTRIBUTE_GROUPS(devlink); 469287905e6SSaravana Kannan 47080dd33cfSRafael J. Wysocki static void device_link_release_fn(struct work_struct *work) 471843e600bSSaravana Kannan { 47280dd33cfSRafael J. Wysocki struct device_link *link = container_of(work, struct device_link, rm_work); 47380dd33cfSRafael J. Wysocki 47480dd33cfSRafael J. Wysocki /* Ensure that all references to the link object have been dropped. */ 47580dd33cfSRafael J. Wysocki device_link_synchronize_removal(); 47680dd33cfSRafael J. Wysocki 477843e600bSSaravana Kannan while (refcount_dec_not_one(&link->rpm_active)) 478843e600bSSaravana Kannan pm_runtime_put(link->supplier); 479843e600bSSaravana Kannan 480843e600bSSaravana Kannan put_device(link->consumer); 481843e600bSSaravana Kannan put_device(link->supplier); 482843e600bSSaravana Kannan kfree(link); 483843e600bSSaravana Kannan } 484843e600bSSaravana Kannan 485287905e6SSaravana Kannan static void devlink_dev_release(struct device *dev) 486287905e6SSaravana Kannan { 487843e600bSSaravana Kannan struct device_link *link = to_devlink(dev); 488843e600bSSaravana Kannan 48980dd33cfSRafael J. Wysocki INIT_WORK(&link->rm_work, device_link_release_fn); 49080dd33cfSRafael J. Wysocki /* 49180dd33cfSRafael J. Wysocki * It may take a while to complete this work because of the SRCU 49280dd33cfSRafael J. Wysocki * synchronization in device_link_release_fn() and if the consumer or 49380dd33cfSRafael J. Wysocki * supplier devices get deleted when it runs, so put it into the "long" 49480dd33cfSRafael J. Wysocki * workqueue. 49580dd33cfSRafael J. Wysocki */ 49680dd33cfSRafael J. Wysocki queue_work(system_long_wq, &link->rm_work); 497287905e6SSaravana Kannan } 498287905e6SSaravana Kannan 499287905e6SSaravana Kannan static struct class devlink_class = { 500287905e6SSaravana Kannan .name = "devlink", 501287905e6SSaravana Kannan .owner = THIS_MODULE, 502287905e6SSaravana Kannan .dev_groups = devlink_groups, 503287905e6SSaravana Kannan .dev_release = devlink_dev_release, 504287905e6SSaravana Kannan }; 505287905e6SSaravana Kannan 506287905e6SSaravana Kannan static int devlink_add_symlinks(struct device *dev, 507287905e6SSaravana Kannan struct class_interface *class_intf) 508287905e6SSaravana Kannan { 509287905e6SSaravana Kannan int ret; 510287905e6SSaravana Kannan size_t len; 511287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 512287905e6SSaravana Kannan struct device *sup = link->supplier; 513287905e6SSaravana Kannan struct device *con = link->consumer; 514287905e6SSaravana Kannan char *buf; 515287905e6SSaravana Kannan 516e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 517e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 518e020ff61SSaravana Kannan len += strlen(":"); 519287905e6SSaravana Kannan len += strlen("supplier:") + 1; 520287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 521287905e6SSaravana Kannan if (!buf) 522287905e6SSaravana Kannan return -ENOMEM; 523287905e6SSaravana Kannan 524287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); 525287905e6SSaravana Kannan if (ret) 526287905e6SSaravana Kannan goto out; 527287905e6SSaravana Kannan 528287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); 529287905e6SSaravana Kannan if (ret) 530287905e6SSaravana Kannan goto err_con; 531287905e6SSaravana Kannan 532e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 533287905e6SSaravana Kannan ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); 534287905e6SSaravana Kannan if (ret) 535287905e6SSaravana Kannan goto err_con_dev; 536287905e6SSaravana Kannan 537e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 538287905e6SSaravana Kannan ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); 539287905e6SSaravana Kannan if (ret) 540287905e6SSaravana Kannan goto err_sup_dev; 541287905e6SSaravana Kannan 542287905e6SSaravana Kannan goto out; 543287905e6SSaravana Kannan 544287905e6SSaravana Kannan err_sup_dev: 545e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 546287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 547287905e6SSaravana Kannan err_con_dev: 548287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 549287905e6SSaravana Kannan err_con: 550287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 551287905e6SSaravana Kannan out: 552287905e6SSaravana Kannan kfree(buf); 553287905e6SSaravana Kannan return ret; 554287905e6SSaravana Kannan } 555287905e6SSaravana Kannan 556287905e6SSaravana Kannan static void devlink_remove_symlinks(struct device *dev, 557287905e6SSaravana Kannan struct class_interface *class_intf) 558287905e6SSaravana Kannan { 559287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 560287905e6SSaravana Kannan size_t len; 561287905e6SSaravana Kannan struct device *sup = link->supplier; 562287905e6SSaravana Kannan struct device *con = link->consumer; 563287905e6SSaravana Kannan char *buf; 564287905e6SSaravana Kannan 565287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 566287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 567287905e6SSaravana Kannan 568e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 569e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 570e020ff61SSaravana Kannan len += strlen(":"); 571287905e6SSaravana Kannan len += strlen("supplier:") + 1; 572287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 573287905e6SSaravana Kannan if (!buf) { 574287905e6SSaravana Kannan WARN(1, "Unable to properly free device link symlinks!\n"); 575287905e6SSaravana Kannan return; 576287905e6SSaravana Kannan } 577287905e6SSaravana Kannan 578e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 579287905e6SSaravana Kannan sysfs_remove_link(&con->kobj, buf); 580e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 581287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 582287905e6SSaravana Kannan kfree(buf); 583287905e6SSaravana Kannan } 584287905e6SSaravana Kannan 585287905e6SSaravana Kannan static struct class_interface devlink_class_intf = { 586287905e6SSaravana Kannan .class = &devlink_class, 587287905e6SSaravana Kannan .add_dev = devlink_add_symlinks, 588287905e6SSaravana Kannan .remove_dev = devlink_remove_symlinks, 589287905e6SSaravana Kannan }; 590287905e6SSaravana Kannan 591287905e6SSaravana Kannan static int __init devlink_class_init(void) 592287905e6SSaravana Kannan { 593287905e6SSaravana Kannan int ret; 594287905e6SSaravana Kannan 595287905e6SSaravana Kannan ret = class_register(&devlink_class); 596287905e6SSaravana Kannan if (ret) 597287905e6SSaravana Kannan return ret; 598287905e6SSaravana Kannan 599287905e6SSaravana Kannan ret = class_interface_register(&devlink_class_intf); 600287905e6SSaravana Kannan if (ret) 601287905e6SSaravana Kannan class_unregister(&devlink_class); 602287905e6SSaravana Kannan 603287905e6SSaravana Kannan return ret; 604287905e6SSaravana Kannan } 605287905e6SSaravana Kannan postcore_initcall(devlink_class_init); 606287905e6SSaravana Kannan 607515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 608515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 60905ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 6104b9bbb29SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY | \ 6114b9bbb29SSaravana Kannan DL_FLAG_INFERRED) 612515db266SRafael J. Wysocki 613fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 614fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 615fb583c8eSRafael J. Wysocki 616494fd7b7SFeng Kan /** 6179ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 6189ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 6199ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 6209ed98953SRafael J. Wysocki * @flags: Link flags. 6219ed98953SRafael J. Wysocki * 62221d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 62321d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 62421d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 62521d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 62621d5c57bSRafael J. Wysocki * be forced into the active meta state and reference-counted upon the creation 62721d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 62821d5c57bSRafael J. Wysocki * ignored. 62921d5c57bSRafael J. Wysocki * 630515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 631515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 632515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 63372175d4eSRafael J. Wysocki * 63472175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 63572175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 63672175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 63772175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 63872175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 63972175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 64072175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 64172175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 64272175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 64372175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 64472175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 645c8d50986SRafael J. Wysocki * 646e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 647e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 648e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 649d475f8eaSThierry Reding * be used to request the driver core to automatically probe for a consumer 650e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 651e7dd4010SRafael J. Wysocki * 652515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 653515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 654515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 655515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 656515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 657515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 658515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 659515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 660515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 661515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 6629ed98953SRafael J. Wysocki * 6639ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 6649ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 6659ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 6669ed98953SRafael J. Wysocki * not been registered when this function is called). 6679ed98953SRafael J. Wysocki * 6689ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 6699ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 67064df1148SLukas Wunner * not be registered, however. 6719ed98953SRafael J. Wysocki */ 6729ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 6739ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 6749ed98953SRafael J. Wysocki { 6759ed98953SRafael J. Wysocki struct device_link *link; 6769ed98953SRafael J. Wysocki 677fb583c8eSRafael J. Wysocki if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || 678515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 67905ef983eSSaravana Kannan (flags & DL_FLAG_SYNC_STATE_ONLY && 6804b9bbb29SSaravana Kannan (flags & ~DL_FLAG_INFERRED) != DL_FLAG_SYNC_STATE_ONLY) || 681e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 682e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 683e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 6849ed98953SRafael J. Wysocki return NULL; 6859ed98953SRafael J. Wysocki 6865db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 6875db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 6885db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 6895db25c9eSRafael J. Wysocki return NULL; 6905db25c9eSRafael J. Wysocki } 6915db25c9eSRafael J. Wysocki } 6925db25c9eSRafael J. Wysocki 693515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 694515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 695515db266SRafael J. Wysocki 6969ed98953SRafael J. Wysocki device_links_write_lock(); 6979ed98953SRafael J. Wysocki device_pm_lock(); 6989ed98953SRafael J. Wysocki 6999ed98953SRafael J. Wysocki /* 7009ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 70105ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 70205ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 70305ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 70405ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 7059ed98953SRafael J. Wysocki */ 7069ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 70705ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 70805ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 7099ed98953SRafael J. Wysocki link = NULL; 7109ed98953SRafael J. Wysocki goto out; 7119ed98953SRafael J. Wysocki } 7129ed98953SRafael J. Wysocki 71372175d4eSRafael J. Wysocki /* 714ac66c5bbSSaravana Kannan * SYNC_STATE_ONLY links are useless once a consumer device has probed. 715ac66c5bbSSaravana Kannan * So, only create it if the consumer hasn't probed yet. 716ac66c5bbSSaravana Kannan */ 717ac66c5bbSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY && 718ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_NO_DRIVER && 719ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_PROBING) { 720ac66c5bbSSaravana Kannan link = NULL; 721ac66c5bbSSaravana Kannan goto out; 722ac66c5bbSSaravana Kannan } 723ac66c5bbSSaravana Kannan 724ac66c5bbSSaravana Kannan /* 72572175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 72672175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 72772175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 72872175d4eSRafael J. Wysocki */ 72972175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 73072175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 73172175d4eSRafael J. Wysocki 732f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 733f265df55SRafael J. Wysocki if (link->consumer != consumer) 734f265df55SRafael J. Wysocki continue; 735f265df55SRafael J. Wysocki 7364b9bbb29SSaravana Kannan if (link->flags & DL_FLAG_INFERRED && 7374b9bbb29SSaravana Kannan !(flags & DL_FLAG_INFERRED)) 7384b9bbb29SSaravana Kannan link->flags &= ~DL_FLAG_INFERRED; 7394b9bbb29SSaravana Kannan 740e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 741e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 7424c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 743e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 744e2f3cd83SRafael J. Wysocki } 745e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 74636003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 747e2f3cd83SRafael J. Wysocki } 748e2f3cd83SRafael J. Wysocki 74972175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 750ead18c23SLukas Wunner kref_get(&link->kref); 75121c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 75244e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 75344e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 75405ef983eSSaravana Kannan goto reorder; 75544e96049SSaravana Kannan } else { 75644e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 7579ed98953SRafael J. Wysocki goto out; 758ead18c23SLukas Wunner } 75944e96049SSaravana Kannan } 7609ed98953SRafael J. Wysocki 76172175d4eSRafael J. Wysocki /* 76272175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 76372175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 76472175d4eSRafael J. Wysocki * update the existing link to stay around longer. 76572175d4eSRafael J. Wysocki */ 76672175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 76772175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 76872175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 76972175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 77072175d4eSRafael J. Wysocki } 77172175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 77272175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 77372175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 77472175d4eSRafael J. Wysocki } 775515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 776515db266SRafael J. Wysocki kref_get(&link->kref); 777515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 778515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 779515db266SRafael J. Wysocki } 78005ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 78105ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 78205ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 78305ef983eSSaravana Kannan goto reorder; 78405ef983eSSaravana Kannan } 78505ef983eSSaravana Kannan 78672175d4eSRafael J. Wysocki goto out; 78772175d4eSRafael J. Wysocki } 78872175d4eSRafael J. Wysocki 78921d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 7909ed98953SRafael J. Wysocki if (!link) 7919ed98953SRafael J. Wysocki goto out; 7929ed98953SRafael J. Wysocki 793e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 794e2f3cd83SRafael J. Wysocki 7959ed98953SRafael J. Wysocki get_device(supplier); 7969ed98953SRafael J. Wysocki link->supplier = supplier; 7979ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 7989ed98953SRafael J. Wysocki get_device(consumer); 7999ed98953SRafael J. Wysocki link->consumer = consumer; 8009ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 8019ed98953SRafael J. Wysocki link->flags = flags; 802ead18c23SLukas Wunner kref_init(&link->kref); 8039ed98953SRafael J. Wysocki 804287905e6SSaravana Kannan link->link_dev.class = &devlink_class; 805287905e6SSaravana Kannan device_set_pm_not_required(&link->link_dev); 806e020ff61SSaravana Kannan dev_set_name(&link->link_dev, "%s:%s--%s:%s", 807e020ff61SSaravana Kannan dev_bus_name(supplier), dev_name(supplier), 808e020ff61SSaravana Kannan dev_bus_name(consumer), dev_name(consumer)); 809287905e6SSaravana Kannan if (device_register(&link->link_dev)) { 810287905e6SSaravana Kannan put_device(consumer); 811287905e6SSaravana Kannan put_device(supplier); 812287905e6SSaravana Kannan kfree(link); 813287905e6SSaravana Kannan link = NULL; 814287905e6SSaravana Kannan goto out; 815287905e6SSaravana Kannan } 816287905e6SSaravana Kannan 817287905e6SSaravana Kannan if (flags & DL_FLAG_PM_RUNTIME) { 818287905e6SSaravana Kannan if (flags & DL_FLAG_RPM_ACTIVE) 819287905e6SSaravana Kannan refcount_inc(&link->rpm_active); 820287905e6SSaravana Kannan 821287905e6SSaravana Kannan pm_runtime_new_link(consumer); 822287905e6SSaravana Kannan } 823287905e6SSaravana Kannan 82464df1148SLukas Wunner /* Determine the initial link state. */ 825515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 8269ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 827515db266SRafael J. Wysocki else 828515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 8299ed98953SRafael J. Wysocki 8309ed98953SRafael J. Wysocki /* 83115cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 83215cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 83315cfb094SRafael J. Wysocki */ 83415cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 83515cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 83615cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 83715cfb094SRafael J. Wysocki 83821c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 83921c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 84021c27f06SSaravana Kannan 84105ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 84205ef983eSSaravana Kannan dev_dbg(consumer, 84305ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 84405ef983eSSaravana Kannan dev_name(supplier)); 84505ef983eSSaravana Kannan goto out; 84605ef983eSSaravana Kannan } 84721c27f06SSaravana Kannan 84805ef983eSSaravana Kannan reorder: 84915cfb094SRafael J. Wysocki /* 8509ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 8519ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 8529ed98953SRafael J. Wysocki * 8539ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 8549ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 8559ed98953SRafael J. Wysocki */ 8569ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 8579ed98953SRafael J. Wysocki 8588a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 8599ed98953SRafael J. Wysocki 8609ed98953SRafael J. Wysocki out: 8619ed98953SRafael J. Wysocki device_pm_unlock(); 8629ed98953SRafael J. Wysocki device_links_write_unlock(); 8635db25c9eSRafael J. Wysocki 864e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 8655db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 8665db25c9eSRafael J. Wysocki 8679ed98953SRafael J. Wysocki return link; 8689ed98953SRafael J. Wysocki } 8699ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 8709ed98953SRafael J. Wysocki 871ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 8729ed98953SRafael J. Wysocki { 873ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 874ead18c23SLukas Wunner 8758a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 8769ed98953SRafael J. Wysocki dev_name(link->supplier)); 8779ed98953SRafael J. Wysocki 878e0e398e2SRafael J. Wysocki pm_runtime_drop_link(link); 879baa8809fSRafael J. Wysocki 8800c871315SRafael J. Wysocki device_link_remove_from_lists(link); 881843e600bSSaravana Kannan device_unregister(&link->link_dev); 8829ed98953SRafael J. Wysocki } 8839ed98953SRafael J. Wysocki 88472175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 88572175d4eSRafael J. Wysocki { 88672175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 88772175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 88872175d4eSRafael J. Wysocki else 88972175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 89072175d4eSRafael J. Wysocki } 89172175d4eSRafael J. Wysocki 8929ed98953SRafael J. Wysocki /** 89372175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 8949ed98953SRafael J. Wysocki * @link: Device link to delete. 8959ed98953SRafael J. Wysocki * 8969ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 897ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 898ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 899ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 9009ed98953SRafael J. Wysocki */ 9019ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 9029ed98953SRafael J. Wysocki { 9039ed98953SRafael J. Wysocki device_links_write_lock(); 90472175d4eSRafael J. Wysocki device_link_put_kref(link); 9059ed98953SRafael J. Wysocki device_links_write_unlock(); 9069ed98953SRafael J. Wysocki } 9079ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 9089ed98953SRafael J. Wysocki 909d8842211Spascal paillet /** 91072175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 911d8842211Spascal paillet * @consumer: Consumer end of the link. 912d8842211Spascal paillet * @supplier: Supplier end of the link. 913d8842211Spascal paillet * 914d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 915d8842211Spascal paillet * PM. 916d8842211Spascal paillet */ 917d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 918d8842211Spascal paillet { 919d8842211Spascal paillet struct device_link *link; 920d8842211Spascal paillet 921d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 922d8842211Spascal paillet return; 923d8842211Spascal paillet 924d8842211Spascal paillet device_links_write_lock(); 925d8842211Spascal paillet 926d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 927d8842211Spascal paillet if (link->consumer == consumer) { 92872175d4eSRafael J. Wysocki device_link_put_kref(link); 929d8842211Spascal paillet break; 930d8842211Spascal paillet } 931d8842211Spascal paillet } 932d8842211Spascal paillet 933d8842211Spascal paillet device_links_write_unlock(); 934d8842211Spascal paillet } 935d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 936d8842211Spascal paillet 9379ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 9389ed98953SRafael J. Wysocki { 9399ed98953SRafael J. Wysocki struct device_link *link; 9409ed98953SRafael J. Wysocki 9418c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) { 9428c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE) 9438c3e315dSSaravana Kannan continue; 9448c3e315dSSaravana Kannan 9458c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 9469ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 9478c3e315dSSaravana Kannan } else { 9488c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 9498c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 9508c3e315dSSaravana Kannan } 9518c3e315dSSaravana Kannan } 9529ed98953SRafael J. Wysocki } 9539ed98953SRafael J. Wysocki 9549ed98953SRafael J. Wysocki /** 9559ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 9569ed98953SRafael J. Wysocki * @dev: Consumer device. 9579ed98953SRafael J. Wysocki * 9589ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 9599ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 9609ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 9619ed98953SRafael J. Wysocki * 9629ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 9639ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 9649ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 9659ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 9669ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 9679ed98953SRafael J. Wysocki * 968515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9699ed98953SRafael J. Wysocki */ 9709ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 9719ed98953SRafael J. Wysocki { 9729ed98953SRafael J. Wysocki struct device_link *link; 9739ed98953SRafael J. Wysocki int ret = 0; 9749ed98953SRafael J. Wysocki 975e2ae9bccSSaravana Kannan /* 976e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 977e2ae9bccSSaravana Kannan * probe. 978e2ae9bccSSaravana Kannan */ 97925ac86c6SSaravana Kannan mutex_lock(&fwnode_link_lock); 98025ac86c6SSaravana Kannan if (dev->fwnode && !list_empty(&dev->fwnode->suppliers) && 98125ac86c6SSaravana Kannan !fw_devlink_is_permissive()) { 9821f0dfa05SSaravana Kannan dev_dbg(dev, "probe deferral - wait for supplier %pfwP\n", 9831f0dfa05SSaravana Kannan list_first_entry(&dev->fwnode->suppliers, 9841f0dfa05SSaravana Kannan struct fwnode_link, 9851f0dfa05SSaravana Kannan c_hook)->supplier); 98625ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock); 987e2ae9bccSSaravana Kannan return -EPROBE_DEFER; 988e2ae9bccSSaravana Kannan } 98925ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock); 990e2ae9bccSSaravana Kannan 9919ed98953SRafael J. Wysocki device_links_write_lock(); 9929ed98953SRafael J. Wysocki 9939ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 9948c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 9959ed98953SRafael J. Wysocki continue; 9969ed98953SRafael J. Wysocki 9978c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE && 9988c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { 9999ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 10001f0dfa05SSaravana Kannan dev_dbg(dev, "probe deferral - supplier %s not ready\n", 10011f0dfa05SSaravana Kannan dev_name(link->supplier)); 10029ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 10039ed98953SRafael J. Wysocki break; 10049ed98953SRafael J. Wysocki } 10059ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 10069ed98953SRafael J. Wysocki } 10079ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 10089ed98953SRafael J. Wysocki 10099ed98953SRafael J. Wysocki device_links_write_unlock(); 10109ed98953SRafael J. Wysocki return ret; 10119ed98953SRafael J. Wysocki } 10129ed98953SRafael J. Wysocki 101326e77708SSaravana Kannan /** 101426e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 101526e77708SSaravana Kannan * @dev: Device to call sync_state() on 101626e77708SSaravana Kannan * @list: List head to queue the @dev on 101726e77708SSaravana Kannan * 101826e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 101926e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 102026e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 102126e77708SSaravana Kannan * device_links_write_lock() held. 102226e77708SSaravana Kannan * 102326e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 102426e77708SSaravana Kannan * on this list. 102526e77708SSaravana Kannan * 102626e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 102726e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 102826e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 102926e77708SSaravana Kannan * put_device() is called on this device. 103026e77708SSaravana Kannan */ 103126e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 103226e77708SSaravana Kannan struct list_head *list) 1033fc5a251dSSaravana Kannan { 1034fc5a251dSSaravana Kannan struct device_link *link; 1035fc5a251dSSaravana Kannan 103677036165SSaravana Kannan if (!dev_has_sync_state(dev)) 103777036165SSaravana Kannan return; 1038fc5a251dSSaravana Kannan if (dev->state_synced) 1039fc5a251dSSaravana Kannan return; 1040fc5a251dSSaravana Kannan 1041fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 1042fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1043fc5a251dSSaravana Kannan continue; 1044fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 1045fc5a251dSSaravana Kannan return; 1046fc5a251dSSaravana Kannan } 1047fc5a251dSSaravana Kannan 104826e77708SSaravana Kannan /* 104926e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 105026e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 105126e77708SSaravana Kannan * and probed before the list is flushed. 105226e77708SSaravana Kannan */ 105326e77708SSaravana Kannan dev->state_synced = true; 105426e77708SSaravana Kannan 10553b052a3eSSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 105626e77708SSaravana Kannan return; 105726e77708SSaravana Kannan 105826e77708SSaravana Kannan get_device(dev); 10593b052a3eSSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 106026e77708SSaravana Kannan } 106126e77708SSaravana Kannan 106226e77708SSaravana Kannan /** 106326e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 106426e77708SSaravana Kannan * @list: List of devices to call sync_state() on 106521eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 106626e77708SSaravana Kannan * 106726e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 106821eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 106921eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 107021eb93f4SSaravana Kannan * context where a device lock is already held. 107126e77708SSaravana Kannan */ 107221eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 107321eb93f4SSaravana Kannan struct device *dont_lock_dev) 107426e77708SSaravana Kannan { 107526e77708SSaravana Kannan struct device *dev, *tmp; 107626e77708SSaravana Kannan 10773b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 10783b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 107926e77708SSaravana Kannan 108021eb93f4SSaravana Kannan if (dev != dont_lock_dev) 108126e77708SSaravana Kannan device_lock(dev); 108226e77708SSaravana Kannan 1083fc5a251dSSaravana Kannan if (dev->bus->sync_state) 1084fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 1085fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 1086fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 1087fc5a251dSSaravana Kannan 108821eb93f4SSaravana Kannan if (dev != dont_lock_dev) 108926e77708SSaravana Kannan device_unlock(dev); 109026e77708SSaravana Kannan 109126e77708SSaravana Kannan put_device(dev); 109226e77708SSaravana Kannan } 1093fc5a251dSSaravana Kannan } 1094fc5a251dSSaravana Kannan 1095fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 1096fc5a251dSSaravana Kannan { 1097fc5a251dSSaravana Kannan device_links_write_lock(); 1098fc5a251dSSaravana Kannan defer_sync_state_count++; 1099fc5a251dSSaravana Kannan device_links_write_unlock(); 1100fc5a251dSSaravana Kannan } 1101fc5a251dSSaravana Kannan 1102fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 1103fc5a251dSSaravana Kannan { 1104fc5a251dSSaravana Kannan struct device *dev, *tmp; 110526e77708SSaravana Kannan LIST_HEAD(sync_list); 1106fc5a251dSSaravana Kannan 1107fc5a251dSSaravana Kannan device_links_write_lock(); 1108fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 1109fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 1110fc5a251dSSaravana Kannan goto out; 1111fc5a251dSSaravana Kannan } 1112fc5a251dSSaravana Kannan defer_sync_state_count--; 1113fc5a251dSSaravana Kannan if (defer_sync_state_count) 1114fc5a251dSSaravana Kannan goto out; 1115fc5a251dSSaravana Kannan 11163b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 111726e77708SSaravana Kannan /* 111826e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 11193b052a3eSSaravana Kannan * sync_list because defer_sync is used for both lists. 112026e77708SSaravana Kannan */ 11213b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 112226e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 1123fc5a251dSSaravana Kannan } 1124fc5a251dSSaravana Kannan out: 1125fc5a251dSSaravana Kannan device_links_write_unlock(); 112626e77708SSaravana Kannan 112721eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 1128fc5a251dSSaravana Kannan } 1129fc5a251dSSaravana Kannan 1130fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 1131fc5a251dSSaravana Kannan { 1132fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 1133fc5a251dSSaravana Kannan return 0; 1134fc5a251dSSaravana Kannan } 1135fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 1136fc5a251dSSaravana Kannan 1137fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 1138fc5a251dSSaravana Kannan { 11393b052a3eSSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 11403b052a3eSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 1141fc5a251dSSaravana Kannan } 1142fc5a251dSSaravana Kannan 114321c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link) 114421c27f06SSaravana Kannan { 114521c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED; 114621c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE); 114721c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del); 114821c27f06SSaravana Kannan } 114921c27f06SSaravana Kannan 1150da6d6475SSaravana Kannan static ssize_t waiting_for_supplier_show(struct device *dev, 1151da6d6475SSaravana Kannan struct device_attribute *attr, 1152da6d6475SSaravana Kannan char *buf) 1153da6d6475SSaravana Kannan { 1154da6d6475SSaravana Kannan bool val; 1155da6d6475SSaravana Kannan 1156da6d6475SSaravana Kannan device_lock(dev); 115725ac86c6SSaravana Kannan val = !list_empty(&dev->fwnode->suppliers); 1158da6d6475SSaravana Kannan device_unlock(dev); 1159aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 1160da6d6475SSaravana Kannan } 1161da6d6475SSaravana Kannan static DEVICE_ATTR_RO(waiting_for_supplier); 1162da6d6475SSaravana Kannan 11639ed98953SRafael J. Wysocki /** 1164b6f617dfSSaravana Kannan * device_links_force_bind - Prepares device to be force bound 1165b6f617dfSSaravana Kannan * @dev: Consumer device. 1166b6f617dfSSaravana Kannan * 1167b6f617dfSSaravana Kannan * device_bind_driver() force binds a device to a driver without calling any 1168b6f617dfSSaravana Kannan * driver probe functions. So the consumer really isn't going to wait for any 1169b6f617dfSSaravana Kannan * supplier before it's bound to the driver. We still want the device link 1170b6f617dfSSaravana Kannan * states to be sensible when this happens. 1171b6f617dfSSaravana Kannan * 1172b6f617dfSSaravana Kannan * In preparation for device_bind_driver(), this function goes through each 1173b6f617dfSSaravana Kannan * supplier device links and checks if the supplier is bound. If it is, then 1174b6f617dfSSaravana Kannan * the device link status is set to CONSUMER_PROBE. Otherwise, the device link 1175b6f617dfSSaravana Kannan * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored. 1176b6f617dfSSaravana Kannan */ 1177b6f617dfSSaravana Kannan void device_links_force_bind(struct device *dev) 1178b6f617dfSSaravana Kannan { 1179b6f617dfSSaravana Kannan struct device_link *link, *ln; 1180b6f617dfSSaravana Kannan 1181b6f617dfSSaravana Kannan device_links_write_lock(); 1182b6f617dfSSaravana Kannan 1183b6f617dfSSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 1184b6f617dfSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1185b6f617dfSSaravana Kannan continue; 1186b6f617dfSSaravana Kannan 1187b6f617dfSSaravana Kannan if (link->status != DL_STATE_AVAILABLE) { 1188b6f617dfSSaravana Kannan device_link_drop_managed(link); 1189b6f617dfSSaravana Kannan continue; 1190b6f617dfSSaravana Kannan } 1191b6f617dfSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 1192b6f617dfSSaravana Kannan } 1193b6f617dfSSaravana Kannan dev->links.status = DL_DEV_PROBING; 1194b6f617dfSSaravana Kannan 1195b6f617dfSSaravana Kannan device_links_write_unlock(); 1196b6f617dfSSaravana Kannan } 1197b6f617dfSSaravana Kannan 1198b6f617dfSSaravana Kannan /** 11999ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 12009ed98953SRafael J. Wysocki * @dev: Device to update the links for. 12019ed98953SRafael J. Wysocki * 12029ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 12039ed98953SRafael J. Wysocki * consumers by changing their status to "available". 12049ed98953SRafael J. Wysocki * 12059ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 12069ed98953SRafael J. Wysocki * 1207515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 12089ed98953SRafael J. Wysocki */ 12099ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 12109ed98953SRafael J. Wysocki { 121121c27f06SSaravana Kannan struct device_link *link, *ln; 121226e77708SSaravana Kannan LIST_HEAD(sync_list); 12139ed98953SRafael J. Wysocki 1214bcbbcfd5SSaravana Kannan /* 12159528e0d9SSaravana Kannan * If a device binds successfully, it's expected to have created all 1216bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 12179528e0d9SSaravana Kannan * them. So, fw_devlink no longer needs to create device links to any 12189528e0d9SSaravana Kannan * of the device's suppliers. 12199528e0d9SSaravana Kannan * 12209528e0d9SSaravana Kannan * Also, if a child firmware node of this bound device is not added as 12219528e0d9SSaravana Kannan * a device by now, assume it is never going to be added and make sure 12229528e0d9SSaravana Kannan * other devices don't defer probe indefinitely by waiting for such a 12239528e0d9SSaravana Kannan * child device. 1224bcbbcfd5SSaravana Kannan */ 12259528e0d9SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) { 12269528e0d9SSaravana Kannan struct fwnode_handle *child; 1227f9aa4606SSaravana Kannan fwnode_links_purge_suppliers(dev->fwnode); 12289528e0d9SSaravana Kannan fwnode_for_each_available_child_node(dev->fwnode, child) 12299528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 12309528e0d9SSaravana Kannan } 1231da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 1232bcbbcfd5SSaravana Kannan 12339ed98953SRafael J. Wysocki device_links_write_lock(); 12349ed98953SRafael J. Wysocki 12359ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1236515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 12379ed98953SRafael J. Wysocki continue; 12389ed98953SRafael J. Wysocki 123915cfb094SRafael J. Wysocki /* 124015cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 124115cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 124215cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 124315cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 124415cfb094SRafael J. Wysocki */ 124515cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 124615cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 124715cfb094SRafael J. Wysocki continue; 124815cfb094SRafael J. Wysocki 12499ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 12509ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 1251e7dd4010SRafael J. Wysocki 1252e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 1253e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 12549ed98953SRafael J. Wysocki } 12559ed98953SRafael J. Wysocki 125621eb93f4SSaravana Kannan if (defer_sync_state_count) 125721eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 125821eb93f4SSaravana Kannan else 125921eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 126021eb93f4SSaravana Kannan 126121c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 126221c27f06SSaravana Kannan struct device *supplier; 126321c27f06SSaravana Kannan 1264515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 12659ed98953SRafael J. Wysocki continue; 12669ed98953SRafael J. Wysocki 126721c27f06SSaravana Kannan supplier = link->supplier; 126821c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { 126921c27f06SSaravana Kannan /* 127021c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no 127121c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's 127221c27f06SSaravana Kannan * save to drop the managed link completely. 127321c27f06SSaravana Kannan */ 127421c27f06SSaravana Kannan device_link_drop_managed(link); 127521c27f06SSaravana Kannan } else { 12769ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 12779ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 127821c27f06SSaravana Kannan } 1279fc5a251dSSaravana Kannan 128021c27f06SSaravana Kannan /* 128121c27f06SSaravana Kannan * This needs to be done even for the deleted 128221c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last 128321c27f06SSaravana Kannan * device link that was preventing the supplier from getting a 128421c27f06SSaravana Kannan * sync_state() call. 128521c27f06SSaravana Kannan */ 1286fc5a251dSSaravana Kannan if (defer_sync_state_count) 128721c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier); 1288fc5a251dSSaravana Kannan else 128921c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list); 12909ed98953SRafael J. Wysocki } 12919ed98953SRafael J. Wysocki 12929ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 12939ed98953SRafael J. Wysocki 12949ed98953SRafael J. Wysocki device_links_write_unlock(); 129526e77708SSaravana Kannan 129621eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 12979ed98953SRafael J. Wysocki } 12989ed98953SRafael J. Wysocki 12999ed98953SRafael J. Wysocki /** 13009ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 13019ed98953SRafael J. Wysocki * @dev: Device without a drvier. 13029ed98953SRafael J. Wysocki * 13039ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 13049ed98953SRafael J. Wysocki * 13059ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 13069ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 13079ed98953SRafael J. Wysocki * case they need not be updated. 13089ed98953SRafael J. Wysocki * 1309515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 13109ed98953SRafael J. Wysocki */ 13119ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 13129ed98953SRafael J. Wysocki { 13139ed98953SRafael J. Wysocki struct device_link *link, *ln; 13149ed98953SRafael J. Wysocki 13159ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 1316515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13179ed98953SRafael J. Wysocki continue; 13189ed98953SRafael J. Wysocki 13198c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 1320515db266SRafael J. Wysocki device_link_drop_managed(link); 13218c3e315dSSaravana Kannan continue; 13228c3e315dSSaravana Kannan } 13238c3e315dSSaravana Kannan 13248c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE && 13258c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE) 13268c3e315dSSaravana Kannan continue; 13278c3e315dSSaravana Kannan 13288c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 13299ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 13308c3e315dSSaravana Kannan } else { 13318c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 13328c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 13338c3e315dSSaravana Kannan } 13349ed98953SRafael J. Wysocki } 13359ed98953SRafael J. Wysocki 13369ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 13379ed98953SRafael J. Wysocki } 13389ed98953SRafael J. Wysocki 133915cfb094SRafael J. Wysocki /** 134015cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 134115cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 134215cfb094SRafael J. Wysocki * 134315cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 134415cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 134515cfb094SRafael J. Wysocki * appropriate. 134615cfb094SRafael J. Wysocki * 1347515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 134815cfb094SRafael J. Wysocki */ 13499ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 13509ed98953SRafael J. Wysocki { 135115cfb094SRafael J. Wysocki struct device_link *link; 135215cfb094SRafael J. Wysocki 13539ed98953SRafael J. Wysocki device_links_write_lock(); 135415cfb094SRafael J. Wysocki 135515cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1356515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 135715cfb094SRafael J. Wysocki continue; 135815cfb094SRafael J. Wysocki 135915cfb094SRafael J. Wysocki /* 136015cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 136115cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 136215cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 136315cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 136415cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 136515cfb094SRafael J. Wysocki */ 136615cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 136715cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 136815cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 136915cfb094SRafael J. Wysocki } 137015cfb094SRafael J. Wysocki 13719ed98953SRafael J. Wysocki __device_links_no_driver(dev); 137215cfb094SRafael J. Wysocki 13739ed98953SRafael J. Wysocki device_links_write_unlock(); 13749ed98953SRafael J. Wysocki } 13759ed98953SRafael J. Wysocki 13769ed98953SRafael J. Wysocki /** 13779ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 13789ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 13799ed98953SRafael J. Wysocki * 13809ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 13819ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 13829ed98953SRafael J. Wysocki * appropriate. 13839ed98953SRafael J. Wysocki * 1384515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 13859ed98953SRafael J. Wysocki */ 13869ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 13879ed98953SRafael J. Wysocki { 1388c8d50986SRafael J. Wysocki struct device_link *link, *ln; 13899ed98953SRafael J. Wysocki 13909ed98953SRafael J. Wysocki device_links_write_lock(); 13919ed98953SRafael J. Wysocki 1392c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1393515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13949ed98953SRafael J. Wysocki continue; 13959ed98953SRafael J. Wysocki 1396e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 13979ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 13981689cac5SVivek Gautam 13991689cac5SVivek Gautam /* 14001689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 14011689cac5SVivek Gautam * devices that are not active, i.e. where the link state 14021689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 14031689cac5SVivek Gautam */ 14041689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 14051689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1406515db266SRafael J. Wysocki device_link_drop_managed(link); 14071689cac5SVivek Gautam 14089ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 14099ed98953SRafael J. Wysocki } 14109ed98953SRafael J. Wysocki 14113b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 14129ed98953SRafael J. Wysocki __device_links_no_driver(dev); 14139ed98953SRafael J. Wysocki 14149ed98953SRafael J. Wysocki device_links_write_unlock(); 14159ed98953SRafael J. Wysocki } 14169ed98953SRafael J. Wysocki 14179ed98953SRafael J. Wysocki /** 14189ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 14199ed98953SRafael J. Wysocki * @dev: Device to check. 14209ed98953SRafael J. Wysocki * 14219ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 14229ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 14239ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 14249ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 14259ed98953SRafael J. Wysocki * successfully going forward. 14269ed98953SRafael J. Wysocki * 14279ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 14289ed98953SRafael J. Wysocki * 1429515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14309ed98953SRafael J. Wysocki */ 14319ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 14329ed98953SRafael J. Wysocki { 14339ed98953SRafael J. Wysocki struct device_link *link; 14349ed98953SRafael J. Wysocki bool ret = false; 14359ed98953SRafael J. Wysocki 14369ed98953SRafael J. Wysocki device_links_write_lock(); 14379ed98953SRafael J. Wysocki 14389ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1439515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 14409ed98953SRafael J. Wysocki continue; 14419ed98953SRafael J. Wysocki 14429ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 14439ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 14449ed98953SRafael J. Wysocki ret = true; 14459ed98953SRafael J. Wysocki break; 14469ed98953SRafael J. Wysocki } 14479ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 14489ed98953SRafael J. Wysocki } 14499ed98953SRafael J. Wysocki 14509ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 14519ed98953SRafael J. Wysocki 14529ed98953SRafael J. Wysocki device_links_write_unlock(); 14539ed98953SRafael J. Wysocki return ret; 14549ed98953SRafael J. Wysocki } 14559ed98953SRafael J. Wysocki 14569ed98953SRafael J. Wysocki /** 14579ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 14589ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 14599ed98953SRafael J. Wysocki * 14609ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 14619ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 14629ed98953SRafael J. Wysocki * and start over. 14639ed98953SRafael J. Wysocki * 14649ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 14659ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 14669ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 14679ed98953SRafael J. Wysocki * changed the state of the link already). 14689ed98953SRafael J. Wysocki * 1469515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14709ed98953SRafael J. Wysocki */ 14719ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 14729ed98953SRafael J. Wysocki { 14739ed98953SRafael J. Wysocki struct device_link *link; 14749ed98953SRafael J. Wysocki 14759ed98953SRafael J. Wysocki start: 14769ed98953SRafael J. Wysocki device_links_write_lock(); 14779ed98953SRafael J. Wysocki 14789ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 14799ed98953SRafael J. Wysocki enum device_link_state status; 14809ed98953SRafael J. Wysocki 148105ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 148205ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 14839ed98953SRafael J. Wysocki continue; 14849ed98953SRafael J. Wysocki 14859ed98953SRafael J. Wysocki status = link->status; 14869ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 14879ed98953SRafael J. Wysocki device_links_write_unlock(); 14889ed98953SRafael J. Wysocki 14899ed98953SRafael J. Wysocki wait_for_device_probe(); 14909ed98953SRafael J. Wysocki goto start; 14919ed98953SRafael J. Wysocki } 14929ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 14939ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 14949ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 14959ed98953SRafael J. Wysocki 14969ed98953SRafael J. Wysocki get_device(consumer); 14979ed98953SRafael J. Wysocki 14989ed98953SRafael J. Wysocki device_links_write_unlock(); 14999ed98953SRafael J. Wysocki 15009ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 15019ed98953SRafael J. Wysocki consumer->parent); 15029ed98953SRafael J. Wysocki put_device(consumer); 15039ed98953SRafael J. Wysocki goto start; 15049ed98953SRafael J. Wysocki } 15059ed98953SRafael J. Wysocki } 15069ed98953SRafael J. Wysocki 15079ed98953SRafael J. Wysocki device_links_write_unlock(); 15089ed98953SRafael J. Wysocki } 15099ed98953SRafael J. Wysocki 15109ed98953SRafael J. Wysocki /** 15119ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 15129ed98953SRafael J. Wysocki * @dev: Target device. 15139ed98953SRafael J. Wysocki */ 15149ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 15159ed98953SRafael J. Wysocki { 15169ed98953SRafael J. Wysocki struct device_link *link, *ln; 15179ed98953SRafael J. Wysocki 1518287905e6SSaravana Kannan if (dev->class == &devlink_class) 1519287905e6SSaravana Kannan return; 1520287905e6SSaravana Kannan 15219ed98953SRafael J. Wysocki /* 15229ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 15239ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 15249ed98953SRafael J. Wysocki */ 15259ed98953SRafael J. Wysocki device_links_write_lock(); 15269ed98953SRafael J. Wysocki 15279ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 15289ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1529ead18c23SLukas Wunner __device_link_del(&link->kref); 15309ed98953SRafael J. Wysocki } 15319ed98953SRafael J. Wysocki 15329ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 15339ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 15349ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1535ead18c23SLukas Wunner __device_link_del(&link->kref); 15369ed98953SRafael J. Wysocki } 15379ed98953SRafael J. Wysocki 15389ed98953SRafael J. Wysocki device_links_write_unlock(); 15399ed98953SRafael J. Wysocki } 15409ed98953SRafael J. Wysocki 1541b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_PERMISSIVE (DL_FLAG_INFERRED | \ 1542b90fb8f6SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 1543b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_ON (DL_FLAG_INFERRED | \ 1544b90fb8f6SSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER) 1545b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_RPM (FW_DEVLINK_FLAGS_ON | \ 1546b90fb8f6SSaravana Kannan DL_FLAG_PM_RUNTIME) 1547b90fb8f6SSaravana Kannan 1548ea718c69SSaravana Kannan static u32 fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 154942926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 155042926ac3SSaravana Kannan { 155142926ac3SSaravana Kannan if (!arg) 155242926ac3SSaravana Kannan return -EINVAL; 155342926ac3SSaravana Kannan 155442926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 155542926ac3SSaravana Kannan fw_devlink_flags = 0; 155642926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 1557b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 155842926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 1559b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 156042926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 1561b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_RPM; 156242926ac3SSaravana Kannan } 156342926ac3SSaravana Kannan return 0; 156442926ac3SSaravana Kannan } 156542926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 156642926ac3SSaravana Kannan 156719d0f5f6SSaravana Kannan static bool fw_devlink_strict; 156819d0f5f6SSaravana Kannan static int __init fw_devlink_strict_setup(char *arg) 156919d0f5f6SSaravana Kannan { 157019d0f5f6SSaravana Kannan return strtobool(arg, &fw_devlink_strict); 157119d0f5f6SSaravana Kannan } 157219d0f5f6SSaravana Kannan early_param("fw_devlink.strict", fw_devlink_strict_setup); 157319d0f5f6SSaravana Kannan 157442926ac3SSaravana Kannan u32 fw_devlink_get_flags(void) 157542926ac3SSaravana Kannan { 157642926ac3SSaravana Kannan return fw_devlink_flags; 157742926ac3SSaravana Kannan } 157842926ac3SSaravana Kannan 157942926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 158042926ac3SSaravana Kannan { 1581b90fb8f6SSaravana Kannan return fw_devlink_flags == FW_DEVLINK_FLAGS_PERMISSIVE; 158242926ac3SSaravana Kannan } 158342926ac3SSaravana Kannan 158419d0f5f6SSaravana Kannan bool fw_devlink_is_strict(void) 158519d0f5f6SSaravana Kannan { 158619d0f5f6SSaravana Kannan return fw_devlink_strict && !fw_devlink_is_permissive(); 15879ed98953SRafael J. Wysocki } 15889ed98953SRafael J. Wysocki 1589c2c724c8SSaravana Kannan static void fw_devlink_parse_fwnode(struct fwnode_handle *fwnode) 1590c2c724c8SSaravana Kannan { 1591c2c724c8SSaravana Kannan if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) 1592c2c724c8SSaravana Kannan return; 1593c2c724c8SSaravana Kannan 15942d09e6ebSSaravana Kannan fwnode_call_int_op(fwnode, add_links); 1595c2c724c8SSaravana Kannan fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; 1596c2c724c8SSaravana Kannan } 1597c2c724c8SSaravana Kannan 1598c2c724c8SSaravana Kannan static void fw_devlink_parse_fwtree(struct fwnode_handle *fwnode) 1599c2c724c8SSaravana Kannan { 1600c2c724c8SSaravana Kannan struct fwnode_handle *child = NULL; 1601c2c724c8SSaravana Kannan 1602c2c724c8SSaravana Kannan fw_devlink_parse_fwnode(fwnode); 1603c2c724c8SSaravana Kannan 1604c2c724c8SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 1605c2c724c8SSaravana Kannan fw_devlink_parse_fwtree(child); 1606c2c724c8SSaravana Kannan } 1607c2c724c8SSaravana Kannan 1608d46f3e3eSSaravana Kannan static void fw_devlink_relax_link(struct device_link *link) 1609d46f3e3eSSaravana Kannan { 1610d46f3e3eSSaravana Kannan if (!(link->flags & DL_FLAG_INFERRED)) 1611d46f3e3eSSaravana Kannan return; 1612d46f3e3eSSaravana Kannan 1613d46f3e3eSSaravana Kannan if (link->flags == (DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE)) 1614d46f3e3eSSaravana Kannan return; 1615d46f3e3eSSaravana Kannan 1616d46f3e3eSSaravana Kannan pm_runtime_drop_link(link); 1617d46f3e3eSSaravana Kannan link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; 1618d46f3e3eSSaravana Kannan dev_dbg(link->consumer, "Relaxing link with %s\n", 1619d46f3e3eSSaravana Kannan dev_name(link->supplier)); 1620d46f3e3eSSaravana Kannan } 1621d46f3e3eSSaravana Kannan 1622d46f3e3eSSaravana Kannan static int fw_devlink_no_driver(struct device *dev, void *data) 1623d46f3e3eSSaravana Kannan { 1624d46f3e3eSSaravana Kannan struct device_link *link = to_devlink(dev); 1625d46f3e3eSSaravana Kannan 1626d46f3e3eSSaravana Kannan if (!link->supplier->can_match) 1627d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1628d46f3e3eSSaravana Kannan 1629d46f3e3eSSaravana Kannan return 0; 1630d46f3e3eSSaravana Kannan } 1631d46f3e3eSSaravana Kannan 1632d46f3e3eSSaravana Kannan void fw_devlink_drivers_done(void) 1633d46f3e3eSSaravana Kannan { 1634d46f3e3eSSaravana Kannan fw_devlink_drv_reg_done = true; 1635d46f3e3eSSaravana Kannan device_links_write_lock(); 1636d46f3e3eSSaravana Kannan class_for_each_device(&devlink_class, NULL, NULL, 1637d46f3e3eSSaravana Kannan fw_devlink_no_driver); 1638d46f3e3eSSaravana Kannan device_links_write_unlock(); 1639d46f3e3eSSaravana Kannan } 1640d46f3e3eSSaravana Kannan 1641d46f3e3eSSaravana Kannan static void fw_devlink_unblock_consumers(struct device *dev) 1642d46f3e3eSSaravana Kannan { 1643d46f3e3eSSaravana Kannan struct device_link *link; 1644d46f3e3eSSaravana Kannan 1645d46f3e3eSSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive()) 1646d46f3e3eSSaravana Kannan return; 1647d46f3e3eSSaravana Kannan 1648d46f3e3eSSaravana Kannan device_links_write_lock(); 1649d46f3e3eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) 1650d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1651d46f3e3eSSaravana Kannan device_links_write_unlock(); 1652d46f3e3eSSaravana Kannan } 1653d46f3e3eSSaravana Kannan 1654f9aa4606SSaravana Kannan /** 1655b0e2fa4fSSaravana Kannan * fw_devlink_relax_cycle - Convert cyclic links to SYNC_STATE_ONLY links 1656b0e2fa4fSSaravana Kannan * @con: Device to check dependencies for. 1657b0e2fa4fSSaravana Kannan * @sup: Device to check against. 1658b0e2fa4fSSaravana Kannan * 1659b0e2fa4fSSaravana Kannan * Check if @sup depends on @con or any device dependent on it (its child or 1660b0e2fa4fSSaravana Kannan * its consumer etc). When such a cyclic dependency is found, convert all 1661b0e2fa4fSSaravana Kannan * device links created solely by fw_devlink into SYNC_STATE_ONLY device links. 1662b0e2fa4fSSaravana Kannan * This is the equivalent of doing fw_devlink=permissive just between the 1663b0e2fa4fSSaravana Kannan * devices in the cycle. We need to do this because, at this point, fw_devlink 1664b0e2fa4fSSaravana Kannan * can't tell which of these dependencies is not a real dependency. 1665b0e2fa4fSSaravana Kannan * 1666b0e2fa4fSSaravana Kannan * Return 1 if a cycle is found. Otherwise, return 0. 1667b0e2fa4fSSaravana Kannan */ 1668c13b8279Skernel test robot static int fw_devlink_relax_cycle(struct device *con, void *sup) 1669b0e2fa4fSSaravana Kannan { 1670b0e2fa4fSSaravana Kannan struct device_link *link; 1671b0e2fa4fSSaravana Kannan int ret; 1672b0e2fa4fSSaravana Kannan 1673b0e2fa4fSSaravana Kannan if (con == sup) 1674b0e2fa4fSSaravana Kannan return 1; 1675b0e2fa4fSSaravana Kannan 1676b0e2fa4fSSaravana Kannan ret = device_for_each_child(con, sup, fw_devlink_relax_cycle); 1677b0e2fa4fSSaravana Kannan if (ret) 1678b0e2fa4fSSaravana Kannan return ret; 1679b0e2fa4fSSaravana Kannan 1680b0e2fa4fSSaravana Kannan list_for_each_entry(link, &con->links.consumers, s_node) { 1681b0e2fa4fSSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 1682b0e2fa4fSSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 1683b0e2fa4fSSaravana Kannan continue; 1684b0e2fa4fSSaravana Kannan 1685b0e2fa4fSSaravana Kannan if (!fw_devlink_relax_cycle(link->consumer, sup)) 1686b0e2fa4fSSaravana Kannan continue; 1687b0e2fa4fSSaravana Kannan 1688b0e2fa4fSSaravana Kannan ret = 1; 1689b0e2fa4fSSaravana Kannan 1690d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1691b0e2fa4fSSaravana Kannan } 1692b0e2fa4fSSaravana Kannan return ret; 1693b0e2fa4fSSaravana Kannan } 1694b0e2fa4fSSaravana Kannan 1695b0e2fa4fSSaravana Kannan /** 1696f9aa4606SSaravana Kannan * fw_devlink_create_devlink - Create a device link from a consumer to fwnode 169737c52f74SPierre-Louis Bossart * @con: consumer device for the device link 169837c52f74SPierre-Louis Bossart * @sup_handle: fwnode handle of supplier 169937c52f74SPierre-Louis Bossart * @flags: devlink flags 1700f9aa4606SSaravana Kannan * 1701f9aa4606SSaravana Kannan * This function will try to create a device link between the consumer device 1702f9aa4606SSaravana Kannan * @con and the supplier device represented by @sup_handle. 1703f9aa4606SSaravana Kannan * 1704f9aa4606SSaravana Kannan * The supplier has to be provided as a fwnode because incorrect cycles in 1705f9aa4606SSaravana Kannan * fwnode links can sometimes cause the supplier device to never be created. 1706f9aa4606SSaravana Kannan * This function detects such cases and returns an error if it cannot create a 1707f9aa4606SSaravana Kannan * device link from the consumer to a missing supplier. 1708f9aa4606SSaravana Kannan * 1709f9aa4606SSaravana Kannan * Returns, 1710f9aa4606SSaravana Kannan * 0 on successfully creating a device link 1711f9aa4606SSaravana Kannan * -EINVAL if the device link cannot be created as expected 1712f9aa4606SSaravana Kannan * -EAGAIN if the device link cannot be created right now, but it may be 1713f9aa4606SSaravana Kannan * possible to do that in the future 1714f9aa4606SSaravana Kannan */ 1715f9aa4606SSaravana Kannan static int fw_devlink_create_devlink(struct device *con, 1716f9aa4606SSaravana Kannan struct fwnode_handle *sup_handle, u32 flags) 1717f9aa4606SSaravana Kannan { 1718f9aa4606SSaravana Kannan struct device *sup_dev; 1719f9aa4606SSaravana Kannan int ret = 0; 1720f9aa4606SSaravana Kannan 1721f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle); 1722f9aa4606SSaravana Kannan if (sup_dev) { 1723f9aa4606SSaravana Kannan /* 172474c782cfSSaravana Kannan * If it's one of those drivers that don't actually bind to 172574c782cfSSaravana Kannan * their device using driver core, then don't wait on this 172674c782cfSSaravana Kannan * supplier device indefinitely. 172774c782cfSSaravana Kannan */ 172874c782cfSSaravana Kannan if (sup_dev->links.status == DL_DEV_NO_DRIVER && 172974c782cfSSaravana Kannan sup_handle->flags & FWNODE_FLAG_INITIALIZED) { 173074c782cfSSaravana Kannan ret = -EINVAL; 173174c782cfSSaravana Kannan goto out; 173274c782cfSSaravana Kannan } 173374c782cfSSaravana Kannan 173474c782cfSSaravana Kannan /* 1735f9aa4606SSaravana Kannan * If this fails, it is due to cycles in device links. Just 1736f9aa4606SSaravana Kannan * give up on this link and treat it as invalid. 1737f9aa4606SSaravana Kannan */ 1738b0e2fa4fSSaravana Kannan if (!device_link_add(con, sup_dev, flags) && 1739b0e2fa4fSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 1740b0e2fa4fSSaravana Kannan dev_info(con, "Fixing up cyclic dependency with %s\n", 1741b0e2fa4fSSaravana Kannan dev_name(sup_dev)); 1742b0e2fa4fSSaravana Kannan device_links_write_lock(); 1743b0e2fa4fSSaravana Kannan fw_devlink_relax_cycle(con, sup_dev); 1744b0e2fa4fSSaravana Kannan device_links_write_unlock(); 1745b0e2fa4fSSaravana Kannan device_link_add(con, sup_dev, 1746b0e2fa4fSSaravana Kannan FW_DEVLINK_FLAGS_PERMISSIVE); 1747f9aa4606SSaravana Kannan ret = -EINVAL; 1748b0e2fa4fSSaravana Kannan } 1749f9aa4606SSaravana Kannan 1750f9aa4606SSaravana Kannan goto out; 1751f9aa4606SSaravana Kannan } 1752f9aa4606SSaravana Kannan 175374c782cfSSaravana Kannan /* Supplier that's already initialized without a struct device. */ 175474c782cfSSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_INITIALIZED) 175574c782cfSSaravana Kannan return -EINVAL; 175674c782cfSSaravana Kannan 1757f9aa4606SSaravana Kannan /* 1758f9aa4606SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY doesn't block probing and supports 1759f9aa4606SSaravana Kannan * cycles. So cycle detection isn't necessary and shouldn't be 1760f9aa4606SSaravana Kannan * done. 1761f9aa4606SSaravana Kannan */ 1762f9aa4606SSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) 1763f9aa4606SSaravana Kannan return -EAGAIN; 1764f9aa4606SSaravana Kannan 1765f9aa4606SSaravana Kannan /* 1766f9aa4606SSaravana Kannan * If we can't find the supplier device from its fwnode, it might be 1767f9aa4606SSaravana Kannan * due to a cyclic dependency between fwnodes. Some of these cycles can 1768f9aa4606SSaravana Kannan * be broken by applying logic. Check for these types of cycles and 1769f9aa4606SSaravana Kannan * break them so that devices in the cycle probe properly. 1770f9aa4606SSaravana Kannan * 1771f9aa4606SSaravana Kannan * If the supplier's parent is dependent on the consumer, then 1772f9aa4606SSaravana Kannan * the consumer-supplier dependency is a false dependency. So, 1773f9aa4606SSaravana Kannan * treat it as an invalid link. 1774f9aa4606SSaravana Kannan */ 1775f9aa4606SSaravana Kannan sup_dev = fwnode_get_next_parent_dev(sup_handle); 1776f9aa4606SSaravana Kannan if (sup_dev && device_is_dependent(con, sup_dev)) { 1777f9aa4606SSaravana Kannan dev_dbg(con, "Not linking to %pfwP - False link\n", 1778f9aa4606SSaravana Kannan sup_handle); 1779f9aa4606SSaravana Kannan ret = -EINVAL; 1780f9aa4606SSaravana Kannan } else { 1781f9aa4606SSaravana Kannan /* 1782f9aa4606SSaravana Kannan * Can't check for cycles or no cycles. So let's try 1783f9aa4606SSaravana Kannan * again later. 1784f9aa4606SSaravana Kannan */ 1785f9aa4606SSaravana Kannan ret = -EAGAIN; 1786f9aa4606SSaravana Kannan } 1787f9aa4606SSaravana Kannan 1788f9aa4606SSaravana Kannan out: 1789f9aa4606SSaravana Kannan put_device(sup_dev); 1790f9aa4606SSaravana Kannan return ret; 1791f9aa4606SSaravana Kannan } 1792f9aa4606SSaravana Kannan 1793f9aa4606SSaravana Kannan /** 1794f9aa4606SSaravana Kannan * __fw_devlink_link_to_consumers - Create device links to consumers of a device 179537c52f74SPierre-Louis Bossart * @dev: Device that needs to be linked to its consumers 1796f9aa4606SSaravana Kannan * 1797f9aa4606SSaravana Kannan * This function looks at all the consumer fwnodes of @dev and creates device 1798f9aa4606SSaravana Kannan * links between the consumer device and @dev (supplier). 1799f9aa4606SSaravana Kannan * 1800f9aa4606SSaravana Kannan * If the consumer device has not been added yet, then this function creates a 1801f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link between @dev (supplier) and the closest ancestor device 1802f9aa4606SSaravana Kannan * of the consumer fwnode. This is necessary to make sure @dev doesn't get a 1803f9aa4606SSaravana Kannan * sync_state() callback before the real consumer device gets to be added and 1804f9aa4606SSaravana Kannan * then probed. 1805f9aa4606SSaravana Kannan * 1806f9aa4606SSaravana Kannan * Once device links are created from the real consumer to @dev (supplier), the 1807f9aa4606SSaravana Kannan * fwnode links are deleted. 1808f9aa4606SSaravana Kannan */ 1809f9aa4606SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev) 1810f9aa4606SSaravana Kannan { 1811f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 1812f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 1813f9aa4606SSaravana Kannan 1814f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { 1815f9aa4606SSaravana Kannan u32 dl_flags = fw_devlink_get_flags(); 1816f9aa4606SSaravana Kannan struct device *con_dev; 1817f9aa4606SSaravana Kannan bool own_link = true; 1818f9aa4606SSaravana Kannan int ret; 1819f9aa4606SSaravana Kannan 1820f9aa4606SSaravana Kannan con_dev = get_dev_from_fwnode(link->consumer); 1821f9aa4606SSaravana Kannan /* 1822f9aa4606SSaravana Kannan * If consumer device is not available yet, make a "proxy" 1823f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link from the consumer's parent device to 1824f9aa4606SSaravana Kannan * the supplier device. This is necessary to make sure the 1825f9aa4606SSaravana Kannan * supplier doesn't get a sync_state() callback before the real 1826f9aa4606SSaravana Kannan * consumer can create a device link to the supplier. 1827f9aa4606SSaravana Kannan * 1828f9aa4606SSaravana Kannan * This proxy link step is needed to handle the case where the 1829f9aa4606SSaravana Kannan * consumer's parent device is added before the supplier. 1830f9aa4606SSaravana Kannan */ 1831f9aa4606SSaravana Kannan if (!con_dev) { 1832f9aa4606SSaravana Kannan con_dev = fwnode_get_next_parent_dev(link->consumer); 1833f9aa4606SSaravana Kannan /* 1834f9aa4606SSaravana Kannan * However, if the consumer's parent device is also the 1835f9aa4606SSaravana Kannan * parent of the supplier, don't create a 1836f9aa4606SSaravana Kannan * consumer-supplier link from the parent to its child 1837f9aa4606SSaravana Kannan * device. Such a dependency is impossible. 1838f9aa4606SSaravana Kannan */ 1839f9aa4606SSaravana Kannan if (con_dev && 1840f9aa4606SSaravana Kannan fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { 1841f9aa4606SSaravana Kannan put_device(con_dev); 1842f9aa4606SSaravana Kannan con_dev = NULL; 1843f9aa4606SSaravana Kannan } else { 1844f9aa4606SSaravana Kannan own_link = false; 1845b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 1846f9aa4606SSaravana Kannan } 1847f9aa4606SSaravana Kannan } 1848f9aa4606SSaravana Kannan 1849f9aa4606SSaravana Kannan if (!con_dev) 1850f9aa4606SSaravana Kannan continue; 1851f9aa4606SSaravana Kannan 1852f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(con_dev, fwnode, dl_flags); 1853f9aa4606SSaravana Kannan put_device(con_dev); 1854f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 1855f9aa4606SSaravana Kannan continue; 1856f9aa4606SSaravana Kannan 1857f9aa4606SSaravana Kannan list_del(&link->s_hook); 1858f9aa4606SSaravana Kannan list_del(&link->c_hook); 1859f9aa4606SSaravana Kannan kfree(link); 1860f9aa4606SSaravana Kannan } 1861f9aa4606SSaravana Kannan } 1862f9aa4606SSaravana Kannan 1863f9aa4606SSaravana Kannan /** 1864f9aa4606SSaravana Kannan * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device 186537c52f74SPierre-Louis Bossart * @dev: The consumer device that needs to be linked to its suppliers 186637c52f74SPierre-Louis Bossart * @fwnode: Root of the fwnode tree that is used to create device links 1867f9aa4606SSaravana Kannan * 1868f9aa4606SSaravana Kannan * This function looks at all the supplier fwnodes of fwnode tree rooted at 1869f9aa4606SSaravana Kannan * @fwnode and creates device links between @dev (consumer) and all the 1870f9aa4606SSaravana Kannan * supplier devices of the entire fwnode tree at @fwnode. 1871f9aa4606SSaravana Kannan * 1872f9aa4606SSaravana Kannan * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev 1873f9aa4606SSaravana Kannan * and the real suppliers of @dev. Once these device links are created, the 1874f9aa4606SSaravana Kannan * fwnode links are deleted. When such device links are successfully created, 1875f9aa4606SSaravana Kannan * this function is called recursively on those supplier devices. This is 1876f9aa4606SSaravana Kannan * needed to detect and break some invalid cycles in fwnode links. See 1877f9aa4606SSaravana Kannan * fw_devlink_create_devlink() for more details. 1878f9aa4606SSaravana Kannan * 1879f9aa4606SSaravana Kannan * In addition, it also looks at all the suppliers of the entire fwnode tree 1880f9aa4606SSaravana Kannan * because some of the child devices of @dev that have not been added yet 1881f9aa4606SSaravana Kannan * (because @dev hasn't probed) might already have their suppliers added to 1882f9aa4606SSaravana Kannan * driver core. So, this function creates SYNC_STATE_ONLY device links between 1883f9aa4606SSaravana Kannan * @dev (consumer) and these suppliers to make sure they don't execute their 1884f9aa4606SSaravana Kannan * sync_state() callbacks before these child devices have a chance to create 1885f9aa4606SSaravana Kannan * their device links. The fwnode links that correspond to the child devices 1886f9aa4606SSaravana Kannan * aren't delete because they are needed later to create the device links 1887f9aa4606SSaravana Kannan * between the real consumer and supplier devices. 1888f9aa4606SSaravana Kannan */ 1889f9aa4606SSaravana Kannan static void __fw_devlink_link_to_suppliers(struct device *dev, 1890f9aa4606SSaravana Kannan struct fwnode_handle *fwnode) 1891f9aa4606SSaravana Kannan { 1892f9aa4606SSaravana Kannan bool own_link = (dev->fwnode == fwnode); 1893f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 1894f9aa4606SSaravana Kannan struct fwnode_handle *child = NULL; 1895f9aa4606SSaravana Kannan u32 dl_flags; 1896f9aa4606SSaravana Kannan 1897f9aa4606SSaravana Kannan if (own_link) 1898f9aa4606SSaravana Kannan dl_flags = fw_devlink_get_flags(); 1899f9aa4606SSaravana Kannan else 1900b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 1901f9aa4606SSaravana Kannan 1902f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { 1903f9aa4606SSaravana Kannan int ret; 1904f9aa4606SSaravana Kannan struct device *sup_dev; 1905f9aa4606SSaravana Kannan struct fwnode_handle *sup = link->supplier; 1906f9aa4606SSaravana Kannan 1907f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(dev, sup, dl_flags); 1908f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 1909f9aa4606SSaravana Kannan continue; 1910f9aa4606SSaravana Kannan 1911f9aa4606SSaravana Kannan list_del(&link->s_hook); 1912f9aa4606SSaravana Kannan list_del(&link->c_hook); 1913f9aa4606SSaravana Kannan kfree(link); 1914f9aa4606SSaravana Kannan 1915f9aa4606SSaravana Kannan /* If no device link was created, nothing more to do. */ 1916f9aa4606SSaravana Kannan if (ret) 1917f9aa4606SSaravana Kannan continue; 1918f9aa4606SSaravana Kannan 1919f9aa4606SSaravana Kannan /* 1920f9aa4606SSaravana Kannan * If a device link was successfully created to a supplier, we 1921f9aa4606SSaravana Kannan * now need to try and link the supplier to all its suppliers. 1922f9aa4606SSaravana Kannan * 1923f9aa4606SSaravana Kannan * This is needed to detect and delete false dependencies in 1924f9aa4606SSaravana Kannan * fwnode links that haven't been converted to a device link 1925f9aa4606SSaravana Kannan * yet. See comments in fw_devlink_create_devlink() for more 1926f9aa4606SSaravana Kannan * details on the false dependency. 1927f9aa4606SSaravana Kannan * 1928f9aa4606SSaravana Kannan * Without deleting these false dependencies, some devices will 1929f9aa4606SSaravana Kannan * never probe because they'll keep waiting for their false 1930f9aa4606SSaravana Kannan * dependency fwnode links to be converted to device links. 1931f9aa4606SSaravana Kannan */ 1932f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup); 1933f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(sup_dev, sup_dev->fwnode); 1934f9aa4606SSaravana Kannan put_device(sup_dev); 1935f9aa4606SSaravana Kannan } 1936f9aa4606SSaravana Kannan 1937f9aa4606SSaravana Kannan /* 1938f9aa4606SSaravana Kannan * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of 1939f9aa4606SSaravana Kannan * all the descendants. This proxy link step is needed to handle the 1940f9aa4606SSaravana Kannan * case where the supplier is added before the consumer's parent device 1941f9aa4606SSaravana Kannan * (@dev). 1942f9aa4606SSaravana Kannan */ 1943f9aa4606SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 1944f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, child); 1945f9aa4606SSaravana Kannan } 1946f9aa4606SSaravana Kannan 19475f5377eaSSaravana Kannan static void fw_devlink_link_device(struct device *dev) 19485f5377eaSSaravana Kannan { 1949f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 19505f5377eaSSaravana Kannan 1951f9aa4606SSaravana Kannan if (!fw_devlink_flags) 1952f9aa4606SSaravana Kannan return; 19535f5377eaSSaravana Kannan 1954f9aa4606SSaravana Kannan fw_devlink_parse_fwtree(fwnode); 1955f9aa4606SSaravana Kannan 1956f9aa4606SSaravana Kannan mutex_lock(&fwnode_link_lock); 1957f9aa4606SSaravana Kannan __fw_devlink_link_to_consumers(dev); 1958f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, fwnode); 1959f9aa4606SSaravana Kannan mutex_unlock(&fwnode_link_lock); 19605f5377eaSSaravana Kannan } 19615f5377eaSSaravana Kannan 19629ed98953SRafael J. Wysocki /* Device links support end. */ 19639ed98953SRafael J. Wysocki 19641da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 19651da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 1966e105b8bfSDan Williams static struct kobject *dev_kobj; 1967e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 1968e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 19691da177e4SLinus Torvalds 19705e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 19715e33bc41SRafael J. Wysocki 19725e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 19735e33bc41SRafael J. Wysocki { 19745e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 19755e33bc41SRafael J. Wysocki } 19765e33bc41SRafael J. Wysocki 19775e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 19785e33bc41SRafael J. Wysocki { 19795e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 19805e33bc41SRafael J. Wysocki } 19815e33bc41SRafael J. Wysocki 19825e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 19835e33bc41SRafael J. Wysocki { 19845e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 19855e33bc41SRafael J. Wysocki return 0; 19865e33bc41SRafael J. Wysocki 19875e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 19885e33bc41SRafael J. Wysocki msleep(5); 19895e33bc41SRafael J. Wysocki return restart_syscall(); 19905e33bc41SRafael J. Wysocki } 19915e33bc41SRafael J. Wysocki 19924e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 19934e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 19944e886c29SGreg Kroah-Hartman { 19954e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 19964e886c29SGreg Kroah-Hartman } 19974e886c29SGreg Kroah-Hartman #else 19984e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 19994e886c29SGreg Kroah-Hartman { 20004e886c29SGreg Kroah-Hartman return 1; 20014e886c29SGreg Kroah-Hartman } 20024e886c29SGreg Kroah-Hartman #endif 20031da177e4SLinus Torvalds 200407de0e86SHeikki Krogerus static int 200507de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 200607de0e86SHeikki Krogerus { 20077847a145SHeikki Krogerus int ret; 20087847a145SHeikki Krogerus 20097847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 20107847a145SHeikki Krogerus if (ret) 20117847a145SHeikki Krogerus return ret; 20127847a145SHeikki Krogerus 201359abd836SHeikki Krogerus ret = software_node_notify(dev, action); 201459abd836SHeikki Krogerus if (ret) 201559abd836SHeikki Krogerus return ret; 201659abd836SHeikki Krogerus 201707de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 201807de0e86SHeikki Krogerus platform_notify(dev); 201907de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 202007de0e86SHeikki Krogerus platform_notify_remove(dev); 202107de0e86SHeikki Krogerus return 0; 202207de0e86SHeikki Krogerus } 202307de0e86SHeikki Krogerus 20243e95637aSAlan Stern /** 20253e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 20263e95637aSAlan Stern * @dev: struct device to get the name of 20273e95637aSAlan Stern * 20283e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 20299169c012Syan * the device is not bound to a driver, it will return the name of the bus 20303e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 20313e95637aSAlan Stern * string will be returned. 20323e95637aSAlan Stern */ 2033bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 20343e95637aSAlan Stern { 20353589972eSAlan Stern struct device_driver *drv; 20363589972eSAlan Stern 20373589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 20383589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 20393589972eSAlan Stern * never change once they are set, so they don't need special care. 20403589972eSAlan Stern */ 20416aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 2042e020ff61SSaravana Kannan return drv ? drv->name : dev_bus_name(dev); 20433e95637aSAlan Stern } 2044310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 20453e95637aSAlan Stern 20461da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 20471da177e4SLinus Torvalds 20484a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 20494a3ad20cSGreg Kroah-Hartman char *buf) 20501da177e4SLinus Torvalds { 20511da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2052b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 20534a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds if (dev_attr->show) 205654b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 2057815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 2058a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 2059a52668c6SSergey Senozhatsky dev_attr->show); 2060815d2d50SAndrew Morton } 20611da177e4SLinus Torvalds return ret; 20621da177e4SLinus Torvalds } 20631da177e4SLinus Torvalds 20644a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 20651da177e4SLinus Torvalds const char *buf, size_t count) 20661da177e4SLinus Torvalds { 20671da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2068b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 20694a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 20701da177e4SLinus Torvalds 20711da177e4SLinus Torvalds if (dev_attr->store) 207254b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 20731da177e4SLinus Torvalds return ret; 20741da177e4SLinus Torvalds } 20751da177e4SLinus Torvalds 207652cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 20771da177e4SLinus Torvalds .show = dev_attr_show, 20781da177e4SLinus Torvalds .store = dev_attr_store, 20791da177e4SLinus Torvalds }; 20801da177e4SLinus Torvalds 2081ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 2082ca22e56dSKay Sievers 2083ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 2084ca22e56dSKay Sievers struct device_attribute *attr, 2085ca22e56dSKay Sievers const char *buf, size_t size) 2086ca22e56dSKay Sievers { 2087ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2088f88184bfSKaitao cheng int ret; 2089f88184bfSKaitao cheng unsigned long new; 2090f88184bfSKaitao cheng 2091f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 2092f88184bfSKaitao cheng if (ret) 2093f88184bfSKaitao cheng return ret; 2094ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 2095ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2096ca22e56dSKay Sievers return size; 2097ca22e56dSKay Sievers } 2098ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 2099ca22e56dSKay Sievers 2100ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 2101ca22e56dSKay Sievers struct device_attribute *attr, 2102ca22e56dSKay Sievers char *buf) 2103ca22e56dSKay Sievers { 2104ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2105aa838896SJoe Perches return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); 2106ca22e56dSKay Sievers } 2107ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 2108ca22e56dSKay Sievers 2109ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 2110ca22e56dSKay Sievers struct device_attribute *attr, 2111ca22e56dSKay Sievers const char *buf, size_t size) 2112ca22e56dSKay Sievers { 2113ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2114f88184bfSKaitao cheng int ret; 2115f88184bfSKaitao cheng long new; 2116f88184bfSKaitao cheng 2117f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 2118f88184bfSKaitao cheng if (ret) 2119f88184bfSKaitao cheng return ret; 2120f88184bfSKaitao cheng 2121f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 2122ca22e56dSKay Sievers return -EINVAL; 2123ca22e56dSKay Sievers *(int *)(ea->var) = new; 2124ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2125ca22e56dSKay Sievers return size; 2126ca22e56dSKay Sievers } 2127ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 2128ca22e56dSKay Sievers 2129ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 2130ca22e56dSKay Sievers struct device_attribute *attr, 2131ca22e56dSKay Sievers char *buf) 2132ca22e56dSKay Sievers { 2133ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2134ca22e56dSKay Sievers 2135aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); 2136ca22e56dSKay Sievers } 2137ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 21381da177e4SLinus Torvalds 213991872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 214091872392SBorislav Petkov const char *buf, size_t size) 214191872392SBorislav Petkov { 214291872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 214391872392SBorislav Petkov 214491872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 214591872392SBorislav Petkov return -EINVAL; 214691872392SBorislav Petkov 214791872392SBorislav Petkov return size; 214891872392SBorislav Petkov } 214991872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 215091872392SBorislav Petkov 215191872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 215291872392SBorislav Petkov char *buf) 215391872392SBorislav Petkov { 215491872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 215591872392SBorislav Petkov 2156aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); 215791872392SBorislav Petkov } 215891872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 215991872392SBorislav Petkov 21601da177e4SLinus Torvalds /** 21611da177e4SLinus Torvalds * device_release - free device structure. 21621da177e4SLinus Torvalds * @kobj: device's kobject. 21631da177e4SLinus Torvalds * 21641da177e4SLinus Torvalds * This is called once the reference count for the object 21651da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 21661da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 21671da177e4SLinus Torvalds */ 21681da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 21691da177e4SLinus Torvalds { 2170b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2171fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 21721da177e4SLinus Torvalds 2173a525a3ddSMing Lei /* 2174a525a3ddSMing Lei * Some platform devices are driven without driver attached 2175a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 2176a525a3ddSMing Lei * all resources are released. 2177a525a3ddSMing Lei * 2178a525a3ddSMing Lei * Drivers still can add resources into device after device 2179a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 2180a525a3ddSMing Lei * possible memory leak. 2181a525a3ddSMing Lei */ 2182a525a3ddSMing Lei devres_release_all(dev); 2183a525a3ddSMing Lei 2184e0d07278SJim Quinlan kfree(dev->dma_range_map); 2185e0d07278SJim Quinlan 21861da177e4SLinus Torvalds if (dev->release) 21871da177e4SLinus Torvalds dev->release(dev); 2188f9f852dfSKay Sievers else if (dev->type && dev->type->release) 2189f9f852dfSKay Sievers dev->type->release(dev); 21902620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 21912620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 2192f810a5cfSArjan van de Ven else 21930c1bc6b8SMauro 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", 21941e0b2cf9SKay Sievers dev_name(dev)); 2195fb069a5dSGreg Kroah-Hartman kfree(p); 21961da177e4SLinus Torvalds } 21971da177e4SLinus Torvalds 2198bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 2199bc451f20SEric W. Biederman { 2200b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2201bc451f20SEric W. Biederman const void *ns = NULL; 2202bc451f20SEric W. Biederman 2203bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 2204bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 2205bc451f20SEric W. Biederman 2206bc451f20SEric W. Biederman return ns; 2207bc451f20SEric W. Biederman } 2208bc451f20SEric W. Biederman 22099944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 22109944e894SDmitry Torokhov { 22119944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 22129944e894SDmitry Torokhov 22139944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 22149944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 22159944e894SDmitry Torokhov } 22169944e894SDmitry Torokhov 22178f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 22181da177e4SLinus Torvalds .release = device_release, 22191da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 2220bc451f20SEric W. Biederman .namespace = device_namespace, 22219944e894SDmitry Torokhov .get_ownership = device_get_ownership, 22221da177e4SLinus Torvalds }; 22231da177e4SLinus Torvalds 22241da177e4SLinus Torvalds 2225312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 22261da177e4SLinus Torvalds { 22271da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 22281da177e4SLinus Torvalds 22298f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 2230b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 22311da177e4SLinus Torvalds if (dev->bus) 22321da177e4SLinus Torvalds return 1; 223323681e47SGreg Kroah-Hartman if (dev->class) 223423681e47SGreg Kroah-Hartman return 1; 22351da177e4SLinus Torvalds } 22361da177e4SLinus Torvalds return 0; 22371da177e4SLinus Torvalds } 22381da177e4SLinus Torvalds 2239312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 22401da177e4SLinus Torvalds { 2241b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 22421da177e4SLinus Torvalds 224323681e47SGreg Kroah-Hartman if (dev->bus) 22441da177e4SLinus Torvalds return dev->bus->name; 224523681e47SGreg Kroah-Hartman if (dev->class) 224623681e47SGreg Kroah-Hartman return dev->class->name; 224723681e47SGreg Kroah-Hartman return NULL; 22481da177e4SLinus Torvalds } 22491da177e4SLinus Torvalds 22507eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 22517eff2e7aSKay Sievers struct kobj_uevent_env *env) 22521da177e4SLinus Torvalds { 2253b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 22541da177e4SLinus Torvalds int retval = 0; 22551da177e4SLinus Torvalds 22566fcf53acSKay Sievers /* add device node properties if present */ 225723681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 22586fcf53acSKay Sievers const char *tmp; 22596fcf53acSKay Sievers const char *name; 22602c9ede55SAl Viro umode_t mode = 0; 22614e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 22624e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 22636fcf53acSKay Sievers 22647eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 22657eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 22663c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 22676fcf53acSKay Sievers if (name) { 22686fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 2269e454cea2SKay Sievers if (mode) 2270e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 22714e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 22724e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 22734e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 22744e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 22753c2670e6SKay Sievers kfree(tmp); 22766fcf53acSKay Sievers } 227723681e47SGreg Kroah-Hartman } 227823681e47SGreg Kroah-Hartman 2279414264f9SKay Sievers if (dev->type && dev->type->name) 22807eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 2281414264f9SKay Sievers 2282239378f1SKay Sievers if (dev->driver) 22837eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 2284239378f1SKay Sievers 228507d57a32SGrant Likely /* Add common DT information about the device */ 228607d57a32SGrant Likely of_device_uevent(dev, env); 228707d57a32SGrant Likely 22881da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 22897eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 22907eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 2291f9f852dfSKay Sievers if (retval) 22927dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 22931e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 22941da177e4SLinus Torvalds } 22951da177e4SLinus Torvalds 22962620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 22977eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 22987eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 2299f9f852dfSKay Sievers if (retval) 23007dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 23011e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 23022b3a302aSHarvey Harrison __func__, retval); 23032620efefSGreg Kroah-Hartman } 2304f9f852dfSKay Sievers 2305eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 23067eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 23077eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 2308f9f852dfSKay Sievers if (retval) 23097dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 23101e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 23112b3a302aSHarvey Harrison __func__, retval); 23122620efefSGreg Kroah-Hartman } 23132620efefSGreg Kroah-Hartman 23141da177e4SLinus Torvalds return retval; 23151da177e4SLinus Torvalds } 23161da177e4SLinus Torvalds 23179cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 2318312c004dSKay Sievers .filter = dev_uevent_filter, 2319312c004dSKay Sievers .name = dev_uevent_name, 2320312c004dSKay Sievers .uevent = dev_uevent, 23211da177e4SLinus Torvalds }; 23221da177e4SLinus Torvalds 2323c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 232416574dccSKay Sievers char *buf) 232516574dccSKay Sievers { 232616574dccSKay Sievers struct kobject *top_kobj; 232716574dccSKay Sievers struct kset *kset; 23287eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 232916574dccSKay Sievers int i; 2330948b3edbSJoe Perches int len = 0; 233116574dccSKay Sievers int retval; 233216574dccSKay Sievers 233316574dccSKay Sievers /* search the kset, the device belongs to */ 233416574dccSKay Sievers top_kobj = &dev->kobj; 23355c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 233616574dccSKay Sievers top_kobj = top_kobj->parent; 233716574dccSKay Sievers if (!top_kobj->kset) 233816574dccSKay Sievers goto out; 23395c5daf65SKay Sievers 234016574dccSKay Sievers kset = top_kobj->kset; 234116574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 234216574dccSKay Sievers goto out; 234316574dccSKay Sievers 234416574dccSKay Sievers /* respect filter */ 234516574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 234616574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 234716574dccSKay Sievers goto out; 234816574dccSKay Sievers 23497eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 23507eff2e7aSKay Sievers if (!env) 2351c7308c81SGreg Kroah-Hartman return -ENOMEM; 2352c7308c81SGreg Kroah-Hartman 235316574dccSKay Sievers /* let the kset specific function add its keys */ 23547eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 235516574dccSKay Sievers if (retval) 235616574dccSKay Sievers goto out; 235716574dccSKay Sievers 235816574dccSKay Sievers /* copy keys to file */ 23597eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 2360948b3edbSJoe Perches len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); 236116574dccSKay Sievers out: 23627eff2e7aSKay Sievers kfree(env); 2363948b3edbSJoe Perches return len; 236416574dccSKay Sievers } 236516574dccSKay Sievers 2366c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 2367a7fd6706SKay Sievers const char *buf, size_t count) 2368a7fd6706SKay Sievers { 2369df44b479SPeter Rajnoha int rc; 2370df44b479SPeter Rajnoha 2371df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 2372df44b479SPeter Rajnoha 2373df44b479SPeter Rajnoha if (rc) { 2374f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 2375df44b479SPeter Rajnoha return rc; 2376df44b479SPeter Rajnoha } 237760a96a59SKay Sievers 2378a7fd6706SKay Sievers return count; 2379a7fd6706SKay Sievers } 2380c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 2381a7fd6706SKay Sievers 2382c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 23834f3549d7SRafael J. Wysocki char *buf) 23844f3549d7SRafael J. Wysocki { 23854f3549d7SRafael J. Wysocki bool val; 23864f3549d7SRafael J. Wysocki 23875e33bc41SRafael J. Wysocki device_lock(dev); 23884f3549d7SRafael J. Wysocki val = !dev->offline; 23895e33bc41SRafael J. Wysocki device_unlock(dev); 2390aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 23914f3549d7SRafael J. Wysocki } 23924f3549d7SRafael J. Wysocki 2393c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 23944f3549d7SRafael J. Wysocki const char *buf, size_t count) 23954f3549d7SRafael J. Wysocki { 23964f3549d7SRafael J. Wysocki bool val; 23974f3549d7SRafael J. Wysocki int ret; 23984f3549d7SRafael J. Wysocki 23994f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 24004f3549d7SRafael J. Wysocki if (ret < 0) 24014f3549d7SRafael J. Wysocki return ret; 24024f3549d7SRafael J. Wysocki 24035e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 24045e33bc41SRafael J. Wysocki if (ret) 24055e33bc41SRafael J. Wysocki return ret; 24065e33bc41SRafael J. Wysocki 24074f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 24084f3549d7SRafael J. Wysocki unlock_device_hotplug(); 24094f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 24104f3549d7SRafael J. Wysocki } 2411c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 24124f3549d7SRafael J. Wysocki 241370f400d4SRajat Jain static ssize_t removable_show(struct device *dev, struct device_attribute *attr, 241470f400d4SRajat Jain char *buf) 241570f400d4SRajat Jain { 241670f400d4SRajat Jain const char *loc; 241770f400d4SRajat Jain 241870f400d4SRajat Jain switch (dev->removable) { 241970f400d4SRajat Jain case DEVICE_REMOVABLE: 242070f400d4SRajat Jain loc = "removable"; 242170f400d4SRajat Jain break; 242270f400d4SRajat Jain case DEVICE_FIXED: 242370f400d4SRajat Jain loc = "fixed"; 242470f400d4SRajat Jain break; 242570f400d4SRajat Jain default: 242670f400d4SRajat Jain loc = "unknown"; 242770f400d4SRajat Jain } 242870f400d4SRajat Jain return sysfs_emit(buf, "%s\n", loc); 242970f400d4SRajat Jain } 243070f400d4SRajat Jain static DEVICE_ATTR_RO(removable); 243170f400d4SRajat Jain 2432fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 2433621a1672SDmitry Torokhov { 24343e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 2435621a1672SDmitry Torokhov } 2436a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 2437621a1672SDmitry Torokhov 2438fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 2439a4dbd674SDavid Brownell const struct attribute_group **groups) 2440621a1672SDmitry Torokhov { 24413e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 2442621a1672SDmitry Torokhov } 2443a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 2444de0ff00dSGreg Kroah-Hartman 244557b8ff07SDmitry Torokhov union device_attr_group_devres { 244657b8ff07SDmitry Torokhov const struct attribute_group *group; 244757b8ff07SDmitry Torokhov const struct attribute_group **groups; 244857b8ff07SDmitry Torokhov }; 244957b8ff07SDmitry Torokhov 245057b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 245157b8ff07SDmitry Torokhov { 245257b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 245357b8ff07SDmitry Torokhov } 245457b8ff07SDmitry Torokhov 245557b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 245657b8ff07SDmitry Torokhov { 245757b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 245857b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 245957b8ff07SDmitry Torokhov 246057b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 246157b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 246257b8ff07SDmitry Torokhov } 246357b8ff07SDmitry Torokhov 246457b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 246557b8ff07SDmitry Torokhov { 246657b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 246757b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 246857b8ff07SDmitry Torokhov 246957b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 247057b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 247157b8ff07SDmitry Torokhov } 247257b8ff07SDmitry Torokhov 247357b8ff07SDmitry Torokhov /** 247457b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 247557b8ff07SDmitry Torokhov * @dev: The device to create the group for 247657b8ff07SDmitry Torokhov * @grp: The attribute group to create 247757b8ff07SDmitry Torokhov * 247857b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 247957b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 248057b8ff07SDmitry Torokhov * 248157b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 248257b8ff07SDmitry Torokhov */ 248357b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 248457b8ff07SDmitry Torokhov { 248557b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 248657b8ff07SDmitry Torokhov int error; 248757b8ff07SDmitry Torokhov 248857b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 248957b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 249057b8ff07SDmitry Torokhov if (!devres) 249157b8ff07SDmitry Torokhov return -ENOMEM; 249257b8ff07SDmitry Torokhov 249357b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 249457b8ff07SDmitry Torokhov if (error) { 249557b8ff07SDmitry Torokhov devres_free(devres); 249657b8ff07SDmitry Torokhov return error; 249757b8ff07SDmitry Torokhov } 249857b8ff07SDmitry Torokhov 249957b8ff07SDmitry Torokhov devres->group = grp; 250057b8ff07SDmitry Torokhov devres_add(dev, devres); 250157b8ff07SDmitry Torokhov return 0; 250257b8ff07SDmitry Torokhov } 250357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 250457b8ff07SDmitry Torokhov 250557b8ff07SDmitry Torokhov /** 250657b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 250757b8ff07SDmitry Torokhov * @dev: device to remove the group from 250857b8ff07SDmitry Torokhov * @grp: group to remove 250957b8ff07SDmitry Torokhov * 251057b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 251157b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 251257b8ff07SDmitry Torokhov */ 251357b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 251457b8ff07SDmitry Torokhov const struct attribute_group *grp) 251557b8ff07SDmitry Torokhov { 251657b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 251757b8ff07SDmitry Torokhov devm_attr_group_match, 251857b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 251957b8ff07SDmitry Torokhov } 252057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 252157b8ff07SDmitry Torokhov 252257b8ff07SDmitry Torokhov /** 252357b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 252457b8ff07SDmitry Torokhov * @dev: The device to create the group for 252557b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 252657b8ff07SDmitry Torokhov * 252757b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 252857b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 252957b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 253057b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 253157b8ff07SDmitry Torokhov * attribute files being created already exist. 253257b8ff07SDmitry Torokhov * 253357b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 253457b8ff07SDmitry Torokhov */ 253557b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 253657b8ff07SDmitry Torokhov const struct attribute_group **groups) 253757b8ff07SDmitry Torokhov { 253857b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 253957b8ff07SDmitry Torokhov int error; 254057b8ff07SDmitry Torokhov 254157b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 254257b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 254357b8ff07SDmitry Torokhov if (!devres) 254457b8ff07SDmitry Torokhov return -ENOMEM; 254557b8ff07SDmitry Torokhov 254657b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 254757b8ff07SDmitry Torokhov if (error) { 254857b8ff07SDmitry Torokhov devres_free(devres); 254957b8ff07SDmitry Torokhov return error; 255057b8ff07SDmitry Torokhov } 255157b8ff07SDmitry Torokhov 255257b8ff07SDmitry Torokhov devres->groups = groups; 255357b8ff07SDmitry Torokhov devres_add(dev, devres); 255457b8ff07SDmitry Torokhov return 0; 255557b8ff07SDmitry Torokhov } 255657b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 255757b8ff07SDmitry Torokhov 255857b8ff07SDmitry Torokhov /** 255957b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 256057b8ff07SDmitry Torokhov * 256157b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 256257b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 256357b8ff07SDmitry Torokhov * 256457b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 256557b8ff07SDmitry Torokhov */ 256657b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 256757b8ff07SDmitry Torokhov const struct attribute_group **groups) 256857b8ff07SDmitry Torokhov { 256957b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 257057b8ff07SDmitry Torokhov devm_attr_group_match, 257157b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 257257b8ff07SDmitry Torokhov } 257357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 25741da177e4SLinus Torvalds 25752620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 25762620efefSGreg Kroah-Hartman { 25772620efefSGreg Kroah-Hartman struct class *class = dev->class; 2578aed65af1SStephen Hemminger const struct device_type *type = dev->type; 2579621a1672SDmitry Torokhov int error; 25802620efefSGreg Kroah-Hartman 2581621a1672SDmitry Torokhov if (class) { 2582d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 25832620efefSGreg Kroah-Hartman if (error) 2584621a1672SDmitry Torokhov return error; 2585f9f852dfSKay Sievers } 2586f9f852dfSKay Sievers 2587621a1672SDmitry Torokhov if (type) { 2588621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 2589f9f852dfSKay Sievers if (error) 2590a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 2591f9f852dfSKay Sievers } 2592621a1672SDmitry Torokhov 2593621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 2594f9f852dfSKay Sievers if (error) 2595621a1672SDmitry Torokhov goto err_remove_type_groups; 2596621a1672SDmitry Torokhov 25974f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 2598c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 25994f3549d7SRafael J. Wysocki if (error) 2600ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 26014f3549d7SRafael J. Wysocki } 26024f3549d7SRafael J. Wysocki 260325ac86c6SSaravana Kannan if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { 2604da6d6475SSaravana Kannan error = device_create_file(dev, &dev_attr_waiting_for_supplier); 2605da6d6475SSaravana Kannan if (error) 2606da6d6475SSaravana Kannan goto err_remove_dev_online; 2607da6d6475SSaravana Kannan } 2608da6d6475SSaravana Kannan 260970f400d4SRajat Jain if (dev_removable_is_valid(dev)) { 261070f400d4SRajat Jain error = device_create_file(dev, &dev_attr_removable); 261170f400d4SRajat Jain if (error) 261270f400d4SRajat Jain goto err_remove_dev_waiting_for_supplier; 261370f400d4SRajat Jain } 261470f400d4SRajat Jain 2615621a1672SDmitry Torokhov return 0; 2616621a1672SDmitry Torokhov 261770f400d4SRajat Jain err_remove_dev_waiting_for_supplier: 261870f400d4SRajat Jain device_remove_file(dev, &dev_attr_waiting_for_supplier); 2619da6d6475SSaravana Kannan err_remove_dev_online: 2620da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_online); 2621ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 2622ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 2623621a1672SDmitry Torokhov err_remove_type_groups: 2624621a1672SDmitry Torokhov if (type) 2625621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2626d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 2627d05a6f96SGreg Kroah-Hartman if (class) 2628d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2629f9f852dfSKay Sievers 26302620efefSGreg Kroah-Hartman return error; 26312620efefSGreg Kroah-Hartman } 26322620efefSGreg Kroah-Hartman 26332620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 26342620efefSGreg Kroah-Hartman { 26352620efefSGreg Kroah-Hartman struct class *class = dev->class; 2636aed65af1SStephen Hemminger const struct device_type *type = dev->type; 26372620efefSGreg Kroah-Hartman 263870f400d4SRajat Jain device_remove_file(dev, &dev_attr_removable); 2639da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 2640c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 2641621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 2642f9f852dfSKay Sievers 2643621a1672SDmitry Torokhov if (type) 2644621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2645621a1672SDmitry Torokhov 2646a6b01dedSGreg Kroah-Hartman if (class) 2647d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2648c97415a7SStefan Achatz } 26492620efefSGreg Kroah-Hartman 2650c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 265123681e47SGreg Kroah-Hartman char *buf) 265223681e47SGreg Kroah-Hartman { 265323681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 265423681e47SGreg Kroah-Hartman } 2655c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 2656ad6a1e1cSTejun Heo 2657ca22e56dSKay Sievers /* /sys/devices/ */ 2658881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 26591da177e4SLinus Torvalds 26601da177e4SLinus Torvalds /** 266152cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 266252cdbdd4SGrygorii Strashko * @deva: Device to move. 266352cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 266452cdbdd4SGrygorii Strashko */ 266552cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 266652cdbdd4SGrygorii Strashko { 266752cdbdd4SGrygorii Strashko if (!devices_kset) 266852cdbdd4SGrygorii Strashko return; 266952cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 267052cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 267152cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 267252cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 267352cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 267452cdbdd4SGrygorii Strashko } 267552cdbdd4SGrygorii Strashko 267652cdbdd4SGrygorii Strashko /** 267752cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 267852cdbdd4SGrygorii Strashko * @deva: Device to move 267952cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 268052cdbdd4SGrygorii Strashko */ 268152cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 268252cdbdd4SGrygorii Strashko { 268352cdbdd4SGrygorii Strashko if (!devices_kset) 268452cdbdd4SGrygorii Strashko return; 268552cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 268652cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 268752cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 268852cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 268952cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 269052cdbdd4SGrygorii Strashko } 269152cdbdd4SGrygorii Strashko 269252cdbdd4SGrygorii Strashko /** 269352cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 269452cdbdd4SGrygorii Strashko * @dev: device to move 269552cdbdd4SGrygorii Strashko */ 269652cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 269752cdbdd4SGrygorii Strashko { 269852cdbdd4SGrygorii Strashko if (!devices_kset) 269952cdbdd4SGrygorii Strashko return; 270052cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 270152cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 270252cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 270352cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 270452cdbdd4SGrygorii Strashko } 270552cdbdd4SGrygorii Strashko 270652cdbdd4SGrygorii Strashko /** 27071da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 27081da177e4SLinus Torvalds * @dev: device. 27091da177e4SLinus Torvalds * @attr: device attribute descriptor. 27101da177e4SLinus Torvalds */ 271126579ab7SPhil Carmody int device_create_file(struct device *dev, 271226579ab7SPhil Carmody const struct device_attribute *attr) 27131da177e4SLinus Torvalds { 27141da177e4SLinus Torvalds int error = 0; 27158f46baaaSFelipe Balbi 27168f46baaaSFelipe Balbi if (dev) { 27178f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 271897521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 271997521978Sdyoung@redhat.com attr->attr.name); 27208f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 272197521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 272297521978Sdyoung@redhat.com attr->attr.name); 27231da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 27248f46baaaSFelipe Balbi } 27258f46baaaSFelipe Balbi 27261da177e4SLinus Torvalds return error; 27271da177e4SLinus Torvalds } 272886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 27291da177e4SLinus Torvalds 27301da177e4SLinus Torvalds /** 27311da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 27321da177e4SLinus Torvalds * @dev: device. 27331da177e4SLinus Torvalds * @attr: device attribute descriptor. 27341da177e4SLinus Torvalds */ 273526579ab7SPhil Carmody void device_remove_file(struct device *dev, 273626579ab7SPhil Carmody const struct device_attribute *attr) 27371da177e4SLinus Torvalds { 27380c98b19fSCornelia Huck if (dev) 27391da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 27401da177e4SLinus Torvalds } 274186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 27421da177e4SLinus Torvalds 27432589f188SGreg Kroah-Hartman /** 27446b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 27456b0afc2aSTejun Heo * @dev: device. 27466b0afc2aSTejun Heo * @attr: device attribute descriptor. 27476b0afc2aSTejun Heo * 27486b0afc2aSTejun Heo * See kernfs_remove_self() for details. 27496b0afc2aSTejun Heo */ 27506b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 27516b0afc2aSTejun Heo const struct device_attribute *attr) 27526b0afc2aSTejun Heo { 27536b0afc2aSTejun Heo if (dev) 27546b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 27556b0afc2aSTejun Heo else 27566b0afc2aSTejun Heo return false; 27576b0afc2aSTejun Heo } 27586b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 27596b0afc2aSTejun Heo 27606b0afc2aSTejun Heo /** 27612589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 27622589f188SGreg Kroah-Hartman * @dev: device. 27632589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 27642589f188SGreg Kroah-Hartman */ 276566ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 276666ecb92bSPhil Carmody const struct bin_attribute *attr) 27672589f188SGreg Kroah-Hartman { 27682589f188SGreg Kroah-Hartman int error = -EINVAL; 27692589f188SGreg Kroah-Hartman if (dev) 27702589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 27712589f188SGreg Kroah-Hartman return error; 27722589f188SGreg Kroah-Hartman } 27732589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 27742589f188SGreg Kroah-Hartman 27752589f188SGreg Kroah-Hartman /** 27762589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 27772589f188SGreg Kroah-Hartman * @dev: device. 27782589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 27792589f188SGreg Kroah-Hartman */ 278066ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 278166ecb92bSPhil Carmody const struct bin_attribute *attr) 27822589f188SGreg Kroah-Hartman { 27832589f188SGreg Kroah-Hartman if (dev) 27842589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 27852589f188SGreg Kroah-Hartman } 27862589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 27872589f188SGreg Kroah-Hartman 278834bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 278934bb61f9SJames Bottomley { 2790f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2791f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 279234bb61f9SJames Bottomley 279334bb61f9SJames Bottomley get_device(dev); 279434bb61f9SJames Bottomley } 279534bb61f9SJames Bottomley 279634bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 279734bb61f9SJames Bottomley { 2798f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2799f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 280034bb61f9SJames Bottomley 280134bb61f9SJames Bottomley put_device(dev); 280234bb61f9SJames Bottomley } 280334bb61f9SJames Bottomley 28041da177e4SLinus Torvalds /** 28051da177e4SLinus Torvalds * device_initialize - init device structure. 28061da177e4SLinus Torvalds * @dev: device. 28071da177e4SLinus Torvalds * 28085739411aSCornelia Huck * This prepares the device for use by other layers by initializing 28095739411aSCornelia Huck * its fields. 28101da177e4SLinus Torvalds * It is the first half of device_register(), if called by 28115739411aSCornelia Huck * that function, though it can also be called separately, so one 28125739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 28135739411aSCornelia Huck * may be used for reference counting of @dev after calling this 28145739411aSCornelia Huck * function. 28155739411aSCornelia Huck * 2816b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 2817b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 2818b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 2819b10d5efdSAlan Stern * @dev. 2820b10d5efdSAlan Stern * 28215739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 28225739411aSCornelia Huck * @dev directly once you have called this function. 28231da177e4SLinus Torvalds */ 28241da177e4SLinus Torvalds void device_initialize(struct device *dev) 28251da177e4SLinus Torvalds { 2826881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 2827f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 28281da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 28293142788bSThomas Gleixner mutex_init(&dev->mutex); 283087a30e1fSDan Williams #ifdef CONFIG_PROVE_LOCKING 283187a30e1fSDan Williams mutex_init(&dev->lockdep_mutex); 283287a30e1fSDan Williams #endif 28331704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 28349ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 28359ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 28363b98aeafSAlan Stern device_pm_init(dev); 283787348136SChristoph Hellwig set_dev_node(dev, -1); 28384a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 28394a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 28404a7cc831SJiang Liu #endif 28419ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 28429ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 28433b052a3eSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 28449ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 28456d4e9a8eSChristoph Hellwig #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \ 28466d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \ 28476d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) 28486d4e9a8eSChristoph Hellwig dev->dma_coherent = dma_default_coherent; 28496d4e9a8eSChristoph Hellwig #endif 2850*69031f50SClaire Chang #ifdef CONFIG_SWIOTLB 2851*69031f50SClaire Chang dev->dma_io_tlb_mem = io_tlb_default_mem; 2852*69031f50SClaire Chang #endif 28531da177e4SLinus Torvalds } 285486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 28551da177e4SLinus Torvalds 2856d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 2857f0ee61a6SGreg Kroah-Hartman { 2858f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 2859f0ee61a6SGreg Kroah-Hartman 2860f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 28614ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 2862881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 2863f0ee61a6SGreg Kroah-Hartman 286486406245SKay Sievers return virtual_dir; 2865f0ee61a6SGreg Kroah-Hartman } 2866f0ee61a6SGreg Kroah-Hartman 2867bc451f20SEric W. Biederman struct class_dir { 2868bc451f20SEric W. Biederman struct kobject kobj; 2869bc451f20SEric W. Biederman struct class *class; 2870bc451f20SEric W. Biederman }; 2871bc451f20SEric W. Biederman 2872bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 2873bc451f20SEric W. Biederman 2874bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 2875bc451f20SEric W. Biederman { 2876bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2877bc451f20SEric W. Biederman kfree(dir); 2878bc451f20SEric W. Biederman } 2879bc451f20SEric W. Biederman 2880bc451f20SEric W. Biederman static const 2881bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 2882bc451f20SEric W. Biederman { 2883bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2884bc451f20SEric W. Biederman return dir->class->ns_type; 2885bc451f20SEric W. Biederman } 2886bc451f20SEric W. Biederman 2887bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 2888bc451f20SEric W. Biederman .release = class_dir_release, 2889bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 2890bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 2891bc451f20SEric W. Biederman }; 2892bc451f20SEric W. Biederman 2893bc451f20SEric W. Biederman static struct kobject * 2894bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 2895bc451f20SEric W. Biederman { 2896bc451f20SEric W. Biederman struct class_dir *dir; 2897bc451f20SEric W. Biederman int retval; 2898bc451f20SEric W. Biederman 2899bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 2900bc451f20SEric W. Biederman if (!dir) 290184d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 2902bc451f20SEric W. Biederman 2903bc451f20SEric W. Biederman dir->class = class; 2904bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 2905bc451f20SEric W. Biederman 29066b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 2907bc451f20SEric W. Biederman 2908bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 2909bc451f20SEric W. Biederman if (retval < 0) { 2910bc451f20SEric W. Biederman kobject_put(&dir->kobj); 291184d0c27dSTetsuo Handa return ERR_PTR(retval); 2912bc451f20SEric W. Biederman } 2913bc451f20SEric W. Biederman return &dir->kobj; 2914bc451f20SEric W. Biederman } 2915bc451f20SEric W. Biederman 2916e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 2917bc451f20SEric W. Biederman 2918c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 2919c744aeaeSCornelia Huck struct device *parent) 292040fa5422SGreg Kroah-Hartman { 292186406245SKay Sievers if (dev->class) { 292286406245SKay Sievers struct kobject *kobj = NULL; 292386406245SKay Sievers struct kobject *parent_kobj; 292486406245SKay Sievers struct kobject *k; 292586406245SKay Sievers 2926ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 292739aba963SKay Sievers /* block disks show up in /sys/block */ 2928e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 292939aba963SKay Sievers if (parent && parent->class == &block_class) 293039aba963SKay Sievers return &parent->kobj; 29316b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 293239aba963SKay Sievers } 2933ead454feSRandy Dunlap #endif 2934e52eec13SAndi Kleen 293586406245SKay Sievers /* 293686406245SKay Sievers * If we have no parent, we live in "virtual". 29370f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 29380f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 293986406245SKay Sievers */ 294086406245SKay Sievers if (parent == NULL) 294186406245SKay Sievers parent_kobj = virtual_device_parent(dev); 294224b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 294386406245SKay Sievers return &parent->kobj; 294486406245SKay Sievers else 294586406245SKay Sievers parent_kobj = &parent->kobj; 294686406245SKay Sievers 294777d3d7c1STejun Heo mutex_lock(&gdp_mutex); 294877d3d7c1STejun Heo 294986406245SKay Sievers /* find our class-directory at the parent and reference it */ 29506b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 29516b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 295286406245SKay Sievers if (k->parent == parent_kobj) { 295386406245SKay Sievers kobj = kobject_get(k); 295486406245SKay Sievers break; 295586406245SKay Sievers } 29566b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 295777d3d7c1STejun Heo if (kobj) { 295877d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 295986406245SKay Sievers return kobj; 296077d3d7c1STejun Heo } 296186406245SKay Sievers 296286406245SKay Sievers /* or create a new class-directory at the parent device */ 2963bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 29640f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 296577d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 296643968d2fSGreg Kroah-Hartman return k; 296786406245SKay Sievers } 296886406245SKay Sievers 2969ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 2970ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 2971ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 2972ca22e56dSKay Sievers 297386406245SKay Sievers if (parent) 2974c744aeaeSCornelia Huck return &parent->kobj; 2975c744aeaeSCornelia Huck return NULL; 2976c744aeaeSCornelia Huck } 2977da231fd5SKay Sievers 2978cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 2979cebf8fd1SMing Lei struct device *dev) 2980cebf8fd1SMing Lei { 2981cebf8fd1SMing Lei if (!kobj || !dev->class || 2982cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 2983cebf8fd1SMing Lei return false; 2984cebf8fd1SMing Lei return true; 2985cebf8fd1SMing Lei } 2986cebf8fd1SMing Lei 2987cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 2988cebf8fd1SMing Lei { 2989cebf8fd1SMing Lei return dev->kobj.parent; 2990cebf8fd1SMing Lei } 2991cebf8fd1SMing Lei 2992cebf8fd1SMing Lei /* 2993cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 2994cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 2995cebf8fd1SMing Lei * global lock 2996cebf8fd1SMing Lei */ 299763b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 2998da231fd5SKay Sievers { 2999ac43432cSMuchun Song unsigned int ref; 3000ac43432cSMuchun Song 30010f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 3002cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 3003da231fd5SKay Sievers return; 3004da231fd5SKay Sievers 3005e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 3006ac43432cSMuchun Song /** 3007ac43432cSMuchun Song * There is a race condition between removing glue directory 3008ac43432cSMuchun Song * and adding a new device under the glue directory. 3009ac43432cSMuchun Song * 3010ac43432cSMuchun Song * CPU1: CPU2: 3011ac43432cSMuchun Song * 3012ac43432cSMuchun Song * device_add() 3013ac43432cSMuchun Song * get_device_parent() 3014ac43432cSMuchun Song * class_dir_create_and_add() 3015ac43432cSMuchun Song * kobject_add_internal() 3016ac43432cSMuchun Song * create_dir() // create glue_dir 3017ac43432cSMuchun Song * 3018ac43432cSMuchun Song * device_add() 3019ac43432cSMuchun Song * get_device_parent() 3020ac43432cSMuchun Song * kobject_get() // get glue_dir 3021ac43432cSMuchun Song * 3022ac43432cSMuchun Song * device_del() 3023ac43432cSMuchun Song * cleanup_glue_dir() 3024ac43432cSMuchun Song * kobject_del(glue_dir) 3025ac43432cSMuchun Song * 3026ac43432cSMuchun Song * kobject_add() 3027ac43432cSMuchun Song * kobject_add_internal() 3028ac43432cSMuchun Song * create_dir() // in glue_dir 3029ac43432cSMuchun Song * sysfs_create_dir_ns() 3030ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 3031ac43432cSMuchun Song * 3032ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 3033ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 3034ac43432cSMuchun Song * 3035ac43432cSMuchun Song * // sd is freed 3036ac43432cSMuchun Song * kernfs_new_node(sd) 3037ac43432cSMuchun Song * kernfs_get(glue_dir) 3038ac43432cSMuchun Song * kernfs_add_one() 3039ac43432cSMuchun Song * kernfs_put() 3040ac43432cSMuchun Song * 3041ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 3042ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 3043ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 3044ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 3045ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 3046ac43432cSMuchun Song * 3047ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 3048ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 3049ac43432cSMuchun Song * 3050ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 3051ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 3052ac43432cSMuchun Song * for glue_dir kobj is 1. 3053ac43432cSMuchun Song */ 3054ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 3055ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 3056726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 30570f4dafc0SKay Sievers kobject_put(glue_dir); 3058e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 3059da231fd5SKay Sievers } 306063b6971aSCornelia Huck 30612ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 30622ee97cafSCornelia Huck { 30635590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 30642ee97cafSCornelia Huck int error; 30652ee97cafSCornelia Huck 30665590f319SBenjamin Herrenschmidt if (of_node) { 30670c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 30685590f319SBenjamin Herrenschmidt if (error) 30695590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 30705590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 30715590f319SBenjamin Herrenschmidt } 30725590f319SBenjamin Herrenschmidt 30732ee97cafSCornelia Huck if (!dev->class) 30742ee97cafSCornelia Huck return 0; 3075da231fd5SKay Sievers 30761fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 30776b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 30782ee97cafSCornelia Huck "subsystem"); 30792ee97cafSCornelia Huck if (error) 30805590f319SBenjamin Herrenschmidt goto out_devnode; 3081da231fd5SKay Sievers 30824e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 30834f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 30844f01a757SDmitry Torokhov "device"); 30854f01a757SDmitry Torokhov if (error) 308639aba963SKay Sievers goto out_subsys; 30872ee97cafSCornelia Huck } 308839aba963SKay Sievers 3089ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 309039aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 3091e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 309239aba963SKay Sievers return 0; 3093ead454feSRandy Dunlap #endif 309439aba963SKay Sievers 309539aba963SKay Sievers /* link in the class directory pointing to the device */ 30966b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 309739aba963SKay Sievers &dev->kobj, dev_name(dev)); 309839aba963SKay Sievers if (error) 309939aba963SKay Sievers goto out_device; 310039aba963SKay Sievers 31012ee97cafSCornelia Huck return 0; 31022ee97cafSCornelia Huck 310339aba963SKay Sievers out_device: 310439aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 3105da231fd5SKay Sievers 31062ee97cafSCornelia Huck out_subsys: 31072ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 31085590f319SBenjamin Herrenschmidt out_devnode: 31095590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 31102ee97cafSCornelia Huck return error; 31112ee97cafSCornelia Huck } 31122ee97cafSCornelia Huck 31132ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 31142ee97cafSCornelia Huck { 31155590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 31165590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 31175590f319SBenjamin Herrenschmidt 31182ee97cafSCornelia Huck if (!dev->class) 31192ee97cafSCornelia Huck return; 3120da231fd5SKay Sievers 31214e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 3122da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 31232ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 3124ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 3125e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 312639aba963SKay Sievers return; 3127ead454feSRandy Dunlap #endif 31286b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 31292ee97cafSCornelia Huck } 31302ee97cafSCornelia Huck 31311da177e4SLinus Torvalds /** 3132413c239fSStephen Rothwell * dev_set_name - set a device name 3133413c239fSStephen Rothwell * @dev: device 313446232366SRandy Dunlap * @fmt: format string for the device's name 3135413c239fSStephen Rothwell */ 3136413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 3137413c239fSStephen Rothwell { 3138413c239fSStephen Rothwell va_list vargs; 31391fa5ae85SKay Sievers int err; 3140413c239fSStephen Rothwell 3141413c239fSStephen Rothwell va_start(vargs, fmt); 31421fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 3143413c239fSStephen Rothwell va_end(vargs); 31441fa5ae85SKay Sievers return err; 3145413c239fSStephen Rothwell } 3146413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 3147413c239fSStephen Rothwell 3148413c239fSStephen Rothwell /** 3149e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 3150e105b8bfSDan Williams * @dev: device 3151e105b8bfSDan Williams * 3152e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 3153e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 3154e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 3155e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 31560d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 31570d4e293cSPeter Korsgaard * the link. 3158e105b8bfSDan Williams */ 3159e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 3160e105b8bfSDan Williams { 3161e105b8bfSDan Williams struct kobject *kobj; 3162e105b8bfSDan Williams 3163e105b8bfSDan Williams if (dev->class) 3164e105b8bfSDan Williams kobj = dev->class->dev_kobj; 3165e105b8bfSDan Williams else 3166e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 3167e105b8bfSDan Williams 3168e105b8bfSDan Williams return kobj; 3169e105b8bfSDan Williams } 3170e105b8bfSDan Williams 3171e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 3172e105b8bfSDan Williams { 3173e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3174e105b8bfSDan Williams int error = 0; 3175e105b8bfSDan Williams char devt_str[15]; 3176e105b8bfSDan Williams 3177e105b8bfSDan Williams if (kobj) { 3178e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3179e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 3180e105b8bfSDan Williams } 3181e105b8bfSDan Williams 3182e105b8bfSDan Williams return error; 3183e105b8bfSDan Williams } 3184e105b8bfSDan Williams 3185e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 3186e105b8bfSDan Williams { 3187e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3188e105b8bfSDan Williams char devt_str[15]; 3189e105b8bfSDan Williams 3190e105b8bfSDan Williams if (kobj) { 3191e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3192e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 3193e105b8bfSDan Williams } 3194e105b8bfSDan Williams } 3195e105b8bfSDan Williams 319646d3a037SShaokun Zhang static int device_private_init(struct device *dev) 3197b4028437SGreg Kroah-Hartman { 3198b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 3199b4028437SGreg Kroah-Hartman if (!dev->p) 3200b4028437SGreg Kroah-Hartman return -ENOMEM; 3201b4028437SGreg Kroah-Hartman dev->p->device = dev; 3202b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 3203b4028437SGreg Kroah-Hartman klist_children_put); 3204ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 3205b4028437SGreg Kroah-Hartman return 0; 3206b4028437SGreg Kroah-Hartman } 3207b4028437SGreg Kroah-Hartman 3208e105b8bfSDan Williams /** 32091da177e4SLinus Torvalds * device_add - add device to device hierarchy. 32101da177e4SLinus Torvalds * @dev: device. 32111da177e4SLinus Torvalds * 32121da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 32131da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 32141da177e4SLinus Torvalds * 32155739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 32161da177e4SLinus Torvalds * to the global and sibling lists for the device, then 32171da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 32185739411aSCornelia Huck * 3219b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 3220b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 3221b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 3222b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 3223b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 3224b10d5efdSAlan Stern * and register a fresh new struct device instead. 3225b10d5efdSAlan Stern * 32265739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 32275739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 32285739411aSCornelia Huck * reference instead. 3229affada72SBorislav Petkov * 3230affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 3231affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 3232affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 3233affada72SBorislav Petkov * count. 32341da177e4SLinus Torvalds */ 32351da177e4SLinus Torvalds int device_add(struct device *dev) 32361da177e4SLinus Torvalds { 323735dbf4efSViresh Kumar struct device *parent; 3238ca22e56dSKay Sievers struct kobject *kobj; 3239c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 32405f5377eaSSaravana Kannan int error = -EINVAL; 3241cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3242775b64d2SRafael J. Wysocki 32431da177e4SLinus Torvalds dev = get_device(dev); 3244c906a48aSGreg Kroah-Hartman if (!dev) 3245c906a48aSGreg Kroah-Hartman goto done; 3246c906a48aSGreg Kroah-Hartman 3247fb069a5dSGreg Kroah-Hartman if (!dev->p) { 3248b4028437SGreg Kroah-Hartman error = device_private_init(dev); 3249b4028437SGreg Kroah-Hartman if (error) 3250fb069a5dSGreg Kroah-Hartman goto done; 3251fb069a5dSGreg Kroah-Hartman } 3252fb069a5dSGreg Kroah-Hartman 32531fa5ae85SKay Sievers /* 32541fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 32551fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 32561fa5ae85SKay Sievers * the name, and force the use of dev_name() 32571fa5ae85SKay Sievers */ 32581fa5ae85SKay Sievers if (dev->init_name) { 3259acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 32601fa5ae85SKay Sievers dev->init_name = NULL; 32611fa5ae85SKay Sievers } 3262c906a48aSGreg Kroah-Hartman 3263ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 3264ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 3265ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 3266ca22e56dSKay Sievers 3267e6309e75SThomas Gleixner if (!dev_name(dev)) { 3268e6309e75SThomas Gleixner error = -EINVAL; 32695c8563d7SKay Sievers goto name_error; 3270e6309e75SThomas Gleixner } 32711da177e4SLinus Torvalds 32721e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 3273c205ef48SGreg Kroah-Hartman 32741da177e4SLinus Torvalds parent = get_device(dev->parent); 3275ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 327684d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 327784d0c27dSTetsuo Handa error = PTR_ERR(kobj); 327884d0c27dSTetsuo Handa goto parent_error; 327984d0c27dSTetsuo Handa } 3280ca22e56dSKay Sievers if (kobj) 3281ca22e56dSKay Sievers dev->kobj.parent = kobj; 32821da177e4SLinus Torvalds 32830d358f22SYinghai Lu /* use parent numa_node */ 328456f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 32850d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 32860d358f22SYinghai Lu 32871da177e4SLinus Torvalds /* first, register with generic layer. */ 32888a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 32898a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 3290cebf8fd1SMing Lei if (error) { 3291cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 32921da177e4SLinus Torvalds goto Error; 3293cebf8fd1SMing Lei } 3294a7fd6706SKay Sievers 329537022644SBrian Walsh /* notify platform of device entry */ 329607de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 329707de0e86SHeikki Krogerus if (error) 329807de0e86SHeikki Krogerus goto platform_error; 329937022644SBrian Walsh 3300c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 3301a306eea4SCornelia Huck if (error) 3302a306eea4SCornelia Huck goto attrError; 3303a7fd6706SKay Sievers 33042ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 33052ee97cafSCornelia Huck if (error) 33062ee97cafSCornelia Huck goto SymlinkError; 3307dc0afa83SCornelia Huck error = device_add_attrs(dev); 3308dc0afa83SCornelia Huck if (error) 33092620efefSGreg Kroah-Hartman goto AttrsError; 3310dc0afa83SCornelia Huck error = bus_add_device(dev); 3311dc0afa83SCornelia Huck if (error) 33121da177e4SLinus Torvalds goto BusError; 33133b98aeafSAlan Stern error = dpm_sysfs_add(dev); 331457eee3d2SRafael J. Wysocki if (error) 33153b98aeafSAlan Stern goto DPMError; 33163b98aeafSAlan Stern device_pm_add(dev); 3317ec0676eeSAlan Stern 33180cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 33190cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 33200cd75047SSergey Klyaus if (error) 33210cd75047SSergey Klyaus goto DevAttrError; 33220cd75047SSergey Klyaus 33230cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 33240cd75047SSergey Klyaus if (error) 33250cd75047SSergey Klyaus goto SysEntryError; 33260cd75047SSergey Klyaus 33270cd75047SSergey Klyaus devtmpfs_create_node(dev); 33280cd75047SSergey Klyaus } 33290cd75047SSergey Klyaus 3330ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 3331268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 3332ec0676eeSAlan Stern */ 3333ec0676eeSAlan Stern if (dev->bus) 3334ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3335ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 3336ec0676eeSAlan Stern 333753877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 3338372a67c0SSaravana Kannan 3339e2ae9bccSSaravana Kannan /* 3340e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 3341e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 3342e2ae9bccSSaravana Kannan * link to it. 3343e2ae9bccSSaravana Kannan * 3344e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 3345e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 3346e2ae9bccSSaravana Kannan * 33472cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure 3348e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 3349e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 3350e2ae9bccSSaravana Kannan */ 33512cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 33522cd38fd1SSaravana Kannan dev->fwnode->dev = dev; 33535f5377eaSSaravana Kannan fw_devlink_link_device(dev); 335403324507SSaravana Kannan } 3355e2ae9bccSSaravana Kannan 33562023c610SAlan Stern bus_probe_device(dev); 3357d46f3e3eSSaravana Kannan 3358d46f3e3eSSaravana Kannan /* 3359d46f3e3eSSaravana Kannan * If all driver registration is done and a newly added device doesn't 3360d46f3e3eSSaravana Kannan * match with any driver, don't block its consumers from probing in 3361d46f3e3eSSaravana Kannan * case the consumer device is able to operate without this supplier. 3362d46f3e3eSSaravana Kannan */ 3363d46f3e3eSSaravana Kannan if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) 3364d46f3e3eSSaravana Kannan fw_devlink_unblock_consumers(dev); 3365d46f3e3eSSaravana Kannan 33661da177e4SLinus Torvalds if (parent) 3367f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3368f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 33691da177e4SLinus Torvalds 33705d9fd169SGreg Kroah-Hartman if (dev->class) { 3371ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3372c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 3373570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 33746b6e39a6SKay Sievers &dev->class->p->klist_devices); 3375c47ed219SGreg Kroah-Hartman 3376c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 3377184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3378ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3379c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 3380c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 3381ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 33825d9fd169SGreg Kroah-Hartman } 3383c906a48aSGreg Kroah-Hartman done: 33841da177e4SLinus Torvalds put_device(dev); 33851da177e4SLinus Torvalds return error; 33860cd75047SSergey Klyaus SysEntryError: 33870cd75047SSergey Klyaus if (MAJOR(dev->devt)) 33880cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 33890cd75047SSergey Klyaus DevAttrError: 33900cd75047SSergey Klyaus device_pm_remove(dev); 33910cd75047SSergey Klyaus dpm_sysfs_remove(dev); 33923b98aeafSAlan Stern DPMError: 339357eee3d2SRafael J. Wysocki bus_remove_device(dev); 339457eee3d2SRafael J. Wysocki BusError: 33952620efefSGreg Kroah-Hartman device_remove_attrs(dev); 33962620efefSGreg Kroah-Hartman AttrsError: 33972ee97cafSCornelia Huck device_remove_class_symlinks(dev); 33982ee97cafSCornelia Huck SymlinkError: 3399c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 340023681e47SGreg Kroah-Hartman attrError: 340107de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 340207de0e86SHeikki Krogerus platform_error: 3403312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3404cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 34051da177e4SLinus Torvalds kobject_del(&dev->kobj); 34061da177e4SLinus Torvalds Error: 3407cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 340884d0c27dSTetsuo Handa parent_error: 34091da177e4SLinus Torvalds put_device(parent); 34105c8563d7SKay Sievers name_error: 34115c8563d7SKay Sievers kfree(dev->p); 34125c8563d7SKay Sievers dev->p = NULL; 3413c906a48aSGreg Kroah-Hartman goto done; 34141da177e4SLinus Torvalds } 341586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 34161da177e4SLinus Torvalds 34171da177e4SLinus Torvalds /** 34181da177e4SLinus Torvalds * device_register - register a device with the system. 34191da177e4SLinus Torvalds * @dev: pointer to the device structure 34201da177e4SLinus Torvalds * 34211da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 34221da177e4SLinus Torvalds * and add it to the system. The two steps can be called 34231da177e4SLinus Torvalds * separately, but this is the easiest and most common. 34241da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 34251da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 34261da177e4SLinus Torvalds * before it is added to the hierarchy. 34275739411aSCornelia Huck * 3428b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 3429b10d5efdSAlan Stern * and device_add(). 3430b10d5efdSAlan Stern * 34315739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 34325739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 34335739411aSCornelia Huck * reference initialized in this function instead. 34341da177e4SLinus Torvalds */ 34351da177e4SLinus Torvalds int device_register(struct device *dev) 34361da177e4SLinus Torvalds { 34371da177e4SLinus Torvalds device_initialize(dev); 34381da177e4SLinus Torvalds return device_add(dev); 34391da177e4SLinus Torvalds } 344086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 34411da177e4SLinus Torvalds 34421da177e4SLinus Torvalds /** 34431da177e4SLinus Torvalds * get_device - increment reference count for device. 34441da177e4SLinus Torvalds * @dev: device. 34451da177e4SLinus Torvalds * 34461da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 34471da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 34481da177e4SLinus Torvalds * pointer passed in. 34491da177e4SLinus Torvalds */ 34501da177e4SLinus Torvalds struct device *get_device(struct device *dev) 34511da177e4SLinus Torvalds { 3452b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 34531da177e4SLinus Torvalds } 345486df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 34551da177e4SLinus Torvalds 34561da177e4SLinus Torvalds /** 34571da177e4SLinus Torvalds * put_device - decrement reference count. 34581da177e4SLinus Torvalds * @dev: device in question. 34591da177e4SLinus Torvalds */ 34601da177e4SLinus Torvalds void put_device(struct device *dev) 34611da177e4SLinus Torvalds { 3462edfaa7c3SKay Sievers /* might_sleep(); */ 34631da177e4SLinus Torvalds if (dev) 34641da177e4SLinus Torvalds kobject_put(&dev->kobj); 34651da177e4SLinus Torvalds } 346686df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 34671da177e4SLinus Torvalds 346800289cd8SDan Williams bool kill_device(struct device *dev) 346900289cd8SDan Williams { 347000289cd8SDan Williams /* 347100289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 347200289cd8SDan Williams * the update behavior is consistent with the other bitfields near 347300289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 347400289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 347500289cd8SDan Williams * underneath the device. 347600289cd8SDan Williams */ 34778c60a141SJulian Wiedmann device_lock_assert(dev); 347800289cd8SDan Williams 347900289cd8SDan Williams if (dev->p->dead) 348000289cd8SDan Williams return false; 348100289cd8SDan Williams dev->p->dead = true; 348200289cd8SDan Williams return true; 348300289cd8SDan Williams } 348400289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 348500289cd8SDan Williams 34861da177e4SLinus Torvalds /** 34871da177e4SLinus Torvalds * device_del - delete device from system. 34881da177e4SLinus Torvalds * @dev: device. 34891da177e4SLinus Torvalds * 34901da177e4SLinus Torvalds * This is the first part of the device unregistration 34911da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 34921da177e4SLinus Torvalds * from here, has it removed from the other driver model 34931da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 34941da177e4SLinus Torvalds * from the kobject hierarchy. 34951da177e4SLinus Torvalds * 34961da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 34971da177e4SLinus Torvalds * also called manually. 34981da177e4SLinus Torvalds */ 34991da177e4SLinus Torvalds void device_del(struct device *dev) 35001da177e4SLinus Torvalds { 35011da177e4SLinus Torvalds struct device *parent = dev->parent; 3502cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3503c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 3504b8530017SOliver Neukum unsigned int noio_flag; 35051da177e4SLinus Torvalds 35063451a495SAlexander Duyck device_lock(dev); 350700289cd8SDan Williams kill_device(dev); 35083451a495SAlexander Duyck device_unlock(dev); 35093451a495SAlexander Duyck 3510372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 3511372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 3512372a67c0SSaravana Kannan 3513ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 3514ec0676eeSAlan Stern * before dpm_sysfs_remove(). 3515ec0676eeSAlan Stern */ 3516b8530017SOliver Neukum noio_flag = memalloc_noio_save(); 3517ec0676eeSAlan Stern if (dev->bus) 3518ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3519ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 35209ed98953SRafael J. Wysocki 35213b98aeafSAlan Stern dpm_sysfs_remove(dev); 35221da177e4SLinus Torvalds if (parent) 3523f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 3524e105b8bfSDan Williams if (MAJOR(dev->devt)) { 35252b2af54aSKay Sievers devtmpfs_delete_node(dev); 3526e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 3527c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 3528e105b8bfSDan Williams } 3529b9d9c82bSKay Sievers if (dev->class) { 3530da231fd5SKay Sievers device_remove_class_symlinks(dev); 353199ef3ef8SKay Sievers 3532ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3533c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 3534184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3535ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3536c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 3537c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 3538c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 3539570d0200SWei Yang klist_del(&dev->p->knode_class); 3540ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 3541b9d9c82bSKay Sievers } 3542c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 35432620efefSGreg Kroah-Hartman device_remove_attrs(dev); 354428953533SBenjamin Herrenschmidt bus_remove_device(dev); 35454b6d1f12SLongX Zhang device_pm_remove(dev); 3546d1c3414cSGrant Likely driver_deferred_probe_del(dev); 354707de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 3548478573c9SLukas Wunner device_remove_properties(dev); 35492ec16150SJeffy Chen device_links_purge(dev); 35501da177e4SLinus Torvalds 3551599bad38SJoerg Roedel if (dev->bus) 3552599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3553599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 3554312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3555cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 35561da177e4SLinus Torvalds kobject_del(&dev->kobj); 3557cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 3558b8530017SOliver Neukum memalloc_noio_restore(noio_flag); 35591da177e4SLinus Torvalds put_device(parent); 35601da177e4SLinus Torvalds } 356186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 35621da177e4SLinus Torvalds 35631da177e4SLinus Torvalds /** 35641da177e4SLinus Torvalds * device_unregister - unregister device from system. 35651da177e4SLinus Torvalds * @dev: device going away. 35661da177e4SLinus Torvalds * 35671da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 35681da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 35691da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 35701da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 35711da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 35721da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 35731da177e4SLinus Torvalds */ 35741da177e4SLinus Torvalds void device_unregister(struct device *dev) 35751da177e4SLinus Torvalds { 35761e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 35771da177e4SLinus Torvalds device_del(dev); 35781da177e4SLinus Torvalds put_device(dev); 35791da177e4SLinus Torvalds } 358086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 35811da177e4SLinus Torvalds 35823d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 35833d060aebSAndy Shevchenko { 35843d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 35853d060aebSAndy Shevchenko struct device *dev = NULL; 35863d060aebSAndy Shevchenko struct device_private *p; 35873d060aebSAndy Shevchenko 35883d060aebSAndy Shevchenko if (n) { 35893d060aebSAndy Shevchenko p = to_device_private_parent(n); 35903d060aebSAndy Shevchenko dev = p->device; 35913d060aebSAndy Shevchenko } 35923d060aebSAndy Shevchenko return dev; 35933d060aebSAndy Shevchenko } 35943d060aebSAndy Shevchenko 359536239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 359636239577Smochel@digitalimplant.org { 359736239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 3598f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 3599f791b8c8SGreg Kroah-Hartman struct device_private *p; 3600f791b8c8SGreg Kroah-Hartman 3601f791b8c8SGreg Kroah-Hartman if (n) { 3602f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 3603f791b8c8SGreg Kroah-Hartman dev = p->device; 3604f791b8c8SGreg Kroah-Hartman } 3605f791b8c8SGreg Kroah-Hartman return dev; 360636239577Smochel@digitalimplant.org } 360736239577Smochel@digitalimplant.org 36081da177e4SLinus Torvalds /** 3609e454cea2SKay Sievers * device_get_devnode - path of device node file 36106fcf53acSKay Sievers * @dev: device 3611e454cea2SKay Sievers * @mode: returned file access mode 36123c2670e6SKay Sievers * @uid: returned file owner 36133c2670e6SKay Sievers * @gid: returned file group 36146fcf53acSKay Sievers * @tmp: possibly allocated string 36156fcf53acSKay Sievers * 36166fcf53acSKay Sievers * Return the relative path of a possible device node. 36176fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 36186fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 36196fcf53acSKay Sievers * freed by the caller. 36206fcf53acSKay Sievers */ 3621e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 36224e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 36233c2670e6SKay Sievers const char **tmp) 36246fcf53acSKay Sievers { 36256fcf53acSKay Sievers char *s; 36266fcf53acSKay Sievers 36276fcf53acSKay Sievers *tmp = NULL; 36286fcf53acSKay Sievers 36296fcf53acSKay Sievers /* the device type may provide a specific name */ 3630e454cea2SKay Sievers if (dev->type && dev->type->devnode) 36313c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 36326fcf53acSKay Sievers if (*tmp) 36336fcf53acSKay Sievers return *tmp; 36346fcf53acSKay Sievers 36356fcf53acSKay Sievers /* the class may provide a specific name */ 3636e454cea2SKay Sievers if (dev->class && dev->class->devnode) 3637e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 36386fcf53acSKay Sievers if (*tmp) 36396fcf53acSKay Sievers return *tmp; 36406fcf53acSKay Sievers 36416fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 36426fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 36436fcf53acSKay Sievers return dev_name(dev); 36446fcf53acSKay Sievers 36456fcf53acSKay Sievers /* replace '!' in the name with '/' */ 3646a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 3647a29fd614SRasmus Villemoes if (!s) 36486fcf53acSKay Sievers return NULL; 3649a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 3650a29fd614SRasmus Villemoes return *tmp = s; 36516fcf53acSKay Sievers } 36526fcf53acSKay Sievers 36536fcf53acSKay Sievers /** 36541da177e4SLinus Torvalds * device_for_each_child - device child iterator. 3655c41455fbSRandy Dunlap * @parent: parent struct device. 36561da177e4SLinus Torvalds * @fn: function to be called for each device. 3657f8878dcbSRobert P. J. Day * @data: data for the callback. 36581da177e4SLinus Torvalds * 3659c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 36601da177e4SLinus Torvalds * passing it @data. 36611da177e4SLinus Torvalds * 36621da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 36631da177e4SLinus Torvalds * other than 0, we break out and return that value. 36641da177e4SLinus Torvalds */ 366536239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 36664a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 36671da177e4SLinus Torvalds { 366836239577Smochel@digitalimplant.org struct klist_iter i; 36691da177e4SLinus Torvalds struct device *child; 36701da177e4SLinus Torvalds int error = 0; 36711da177e4SLinus Torvalds 3672014c90dbSGreg Kroah-Hartman if (!parent->p) 3673014c90dbSGreg Kroah-Hartman return 0; 3674014c90dbSGreg Kroah-Hartman 3675f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 367693ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 367736239577Smochel@digitalimplant.org error = fn(child, data); 367836239577Smochel@digitalimplant.org klist_iter_exit(&i); 36791da177e4SLinus Torvalds return error; 36801da177e4SLinus Torvalds } 368186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 36821da177e4SLinus Torvalds 36835ab69981SCornelia Huck /** 36843d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 36853d060aebSAndy Shevchenko * @parent: parent struct device. 36863d060aebSAndy Shevchenko * @fn: function to be called for each device. 36873d060aebSAndy Shevchenko * @data: data for the callback. 36883d060aebSAndy Shevchenko * 36893d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 36903d060aebSAndy Shevchenko * passing it @data. 36913d060aebSAndy Shevchenko * 36923d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 36933d060aebSAndy Shevchenko * other than 0, we break out and return that value. 36943d060aebSAndy Shevchenko */ 36953d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 36963d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 36973d060aebSAndy Shevchenko { 36983d060aebSAndy Shevchenko struct klist_iter i; 36993d060aebSAndy Shevchenko struct device *child; 37003d060aebSAndy Shevchenko int error = 0; 37013d060aebSAndy Shevchenko 37023d060aebSAndy Shevchenko if (!parent->p) 37033d060aebSAndy Shevchenko return 0; 37043d060aebSAndy Shevchenko 37053d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 37063d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 37073d060aebSAndy Shevchenko error = fn(child, data); 37083d060aebSAndy Shevchenko klist_iter_exit(&i); 37093d060aebSAndy Shevchenko return error; 37103d060aebSAndy Shevchenko } 37113d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 37123d060aebSAndy Shevchenko 37133d060aebSAndy Shevchenko /** 37145ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 37155ab69981SCornelia Huck * @parent: parent struct device 37165ab69981SCornelia Huck * @match: Callback function to check device 3717f8878dcbSRobert P. J. Day * @data: Data to pass to match function 37185ab69981SCornelia Huck * 37195ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 37205ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 37215ab69981SCornelia Huck * determined by the @match callback. 37225ab69981SCornelia Huck * 37235ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 37245ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 37255ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 37265ab69981SCornelia Huck * and not iterate over any more devices. 3727a4e2400aSFederico Vaga * 3728a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 37295ab69981SCornelia Huck */ 37305ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 37314a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 37325ab69981SCornelia Huck { 37335ab69981SCornelia Huck struct klist_iter i; 37345ab69981SCornelia Huck struct device *child; 37355ab69981SCornelia Huck 37365ab69981SCornelia Huck if (!parent) 37375ab69981SCornelia Huck return NULL; 37385ab69981SCornelia Huck 3739f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 37405ab69981SCornelia Huck while ((child = next_device(&i))) 37415ab69981SCornelia Huck if (match(child, data) && get_device(child)) 37425ab69981SCornelia Huck break; 37435ab69981SCornelia Huck klist_iter_exit(&i); 37445ab69981SCornelia Huck return child; 37455ab69981SCornelia Huck } 374686df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 37475ab69981SCornelia Huck 3748dad9bb01SHeikki Krogerus /** 3749dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 3750dad9bb01SHeikki Krogerus * @parent: parent struct device 3751dad9bb01SHeikki Krogerus * @name: name of the child device 3752dad9bb01SHeikki Krogerus * 3753dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 3754dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 3755dad9bb01SHeikki Krogerus * 3756dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 3757dad9bb01SHeikki Krogerus */ 3758dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 3759dad9bb01SHeikki Krogerus const char *name) 3760dad9bb01SHeikki Krogerus { 3761dad9bb01SHeikki Krogerus struct klist_iter i; 3762dad9bb01SHeikki Krogerus struct device *child; 3763dad9bb01SHeikki Krogerus 3764dad9bb01SHeikki Krogerus if (!parent) 3765dad9bb01SHeikki Krogerus return NULL; 3766dad9bb01SHeikki Krogerus 3767dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 3768dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 3769c77f520dSDan Williams if (sysfs_streq(dev_name(child), name) && get_device(child)) 3770dad9bb01SHeikki Krogerus break; 3771dad9bb01SHeikki Krogerus klist_iter_exit(&i); 3772dad9bb01SHeikki Krogerus return child; 3773dad9bb01SHeikki Krogerus } 3774dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 3775dad9bb01SHeikki Krogerus 37761da177e4SLinus Torvalds int __init devices_init(void) 37771da177e4SLinus Torvalds { 3778881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 3779881c6cfdSGreg Kroah-Hartman if (!devices_kset) 3780881c6cfdSGreg Kroah-Hartman return -ENOMEM; 3781e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 3782e105b8bfSDan Williams if (!dev_kobj) 3783e105b8bfSDan Williams goto dev_kobj_err; 3784e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 3785e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 3786e105b8bfSDan Williams goto block_kobj_err; 3787e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 3788e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 3789e105b8bfSDan Williams goto char_kobj_err; 3790e105b8bfSDan Williams 3791881c6cfdSGreg Kroah-Hartman return 0; 3792e105b8bfSDan Williams 3793e105b8bfSDan Williams char_kobj_err: 3794e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 3795e105b8bfSDan Williams block_kobj_err: 3796e105b8bfSDan Williams kobject_put(dev_kobj); 3797e105b8bfSDan Williams dev_kobj_err: 3798e105b8bfSDan Williams kset_unregister(devices_kset); 3799e105b8bfSDan Williams return -ENOMEM; 38001da177e4SLinus Torvalds } 38011da177e4SLinus Torvalds 38024f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 38034f3549d7SRafael J. Wysocki { 38044f3549d7SRafael J. Wysocki int ret; 38054f3549d7SRafael J. Wysocki 38064f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 38074f3549d7SRafael J. Wysocki if (ret) 38084f3549d7SRafael J. Wysocki return ret; 38094f3549d7SRafael J. Wysocki 38104f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 38114f3549d7SRafael J. Wysocki } 38124f3549d7SRafael J. Wysocki 38134f3549d7SRafael J. Wysocki /** 38144f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 38154f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 38164f3549d7SRafael J. Wysocki * 38174f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 38184f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 38194f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 38204f3549d7SRafael J. Wysocki * is executed. 38214f3549d7SRafael J. Wysocki * 38224f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 38234f3549d7SRafael J. Wysocki */ 38244f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 38254f3549d7SRafael J. Wysocki { 38264f3549d7SRafael J. Wysocki int ret; 38274f3549d7SRafael J. Wysocki 38284f3549d7SRafael J. Wysocki if (dev->offline_disabled) 38294f3549d7SRafael J. Wysocki return -EPERM; 38304f3549d7SRafael J. Wysocki 38314f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 38324f3549d7SRafael J. Wysocki if (ret) 38334f3549d7SRafael J. Wysocki return ret; 38344f3549d7SRafael J. Wysocki 38354f3549d7SRafael J. Wysocki device_lock(dev); 38364f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 38374f3549d7SRafael J. Wysocki if (dev->offline) { 38384f3549d7SRafael J. Wysocki ret = 1; 38394f3549d7SRafael J. Wysocki } else { 38404f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 38414f3549d7SRafael J. Wysocki if (!ret) { 38424f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 38434f3549d7SRafael J. Wysocki dev->offline = true; 38444f3549d7SRafael J. Wysocki } 38454f3549d7SRafael J. Wysocki } 38464f3549d7SRafael J. Wysocki } 38474f3549d7SRafael J. Wysocki device_unlock(dev); 38484f3549d7SRafael J. Wysocki 38494f3549d7SRafael J. Wysocki return ret; 38504f3549d7SRafael J. Wysocki } 38514f3549d7SRafael J. Wysocki 38524f3549d7SRafael J. Wysocki /** 38534f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 38544f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 38554f3549d7SRafael J. Wysocki * 38564f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 38574f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 38584f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 38594f3549d7SRafael J. Wysocki * 38604f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 38614f3549d7SRafael J. Wysocki */ 38624f3549d7SRafael J. Wysocki int device_online(struct device *dev) 38634f3549d7SRafael J. Wysocki { 38644f3549d7SRafael J. Wysocki int ret = 0; 38654f3549d7SRafael J. Wysocki 38664f3549d7SRafael J. Wysocki device_lock(dev); 38674f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 38684f3549d7SRafael J. Wysocki if (dev->offline) { 38694f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 38704f3549d7SRafael J. Wysocki if (!ret) { 38714f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 38724f3549d7SRafael J. Wysocki dev->offline = false; 38734f3549d7SRafael J. Wysocki } 38744f3549d7SRafael J. Wysocki } else { 38754f3549d7SRafael J. Wysocki ret = 1; 38764f3549d7SRafael J. Wysocki } 38774f3549d7SRafael J. Wysocki } 38784f3549d7SRafael J. Wysocki device_unlock(dev); 38794f3549d7SRafael J. Wysocki 38804f3549d7SRafael J. Wysocki return ret; 38814f3549d7SRafael J. Wysocki } 38824f3549d7SRafael J. Wysocki 38837f100d15SKarthigan Srinivasan struct root_device { 38840aa0dc41SMark McLoughlin struct device dev; 38850aa0dc41SMark McLoughlin struct module *owner; 38860aa0dc41SMark McLoughlin }; 38870aa0dc41SMark McLoughlin 388893058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 3889481e2079SFerenc Wagner { 3890481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 3891481e2079SFerenc Wagner } 38920aa0dc41SMark McLoughlin 38930aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 38940aa0dc41SMark McLoughlin { 38950aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 38960aa0dc41SMark McLoughlin } 38970aa0dc41SMark McLoughlin 38980aa0dc41SMark McLoughlin /** 38990aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 39000aa0dc41SMark McLoughlin * @name: root device name 39010aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 39020aa0dc41SMark McLoughlin * 39030aa0dc41SMark McLoughlin * This function allocates a root device and registers it 39040aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 39050aa0dc41SMark McLoughlin * device, use root_device_unregister(). 39060aa0dc41SMark McLoughlin * 39070aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 39080aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 39090aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 39100aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 39110aa0dc41SMark McLoughlin * 39120aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 39130aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 39140aa0dc41SMark McLoughlin * in sysfs. 39150aa0dc41SMark McLoughlin * 3916f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3917f0eae0edSJani Nikula * 39180aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 39190aa0dc41SMark McLoughlin */ 39200aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 39210aa0dc41SMark McLoughlin { 39220aa0dc41SMark McLoughlin struct root_device *root; 39230aa0dc41SMark McLoughlin int err = -ENOMEM; 39240aa0dc41SMark McLoughlin 39250aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 39260aa0dc41SMark McLoughlin if (!root) 39270aa0dc41SMark McLoughlin return ERR_PTR(err); 39280aa0dc41SMark McLoughlin 3929acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 39300aa0dc41SMark McLoughlin if (err) { 39310aa0dc41SMark McLoughlin kfree(root); 39320aa0dc41SMark McLoughlin return ERR_PTR(err); 39330aa0dc41SMark McLoughlin } 39340aa0dc41SMark McLoughlin 39350aa0dc41SMark McLoughlin root->dev.release = root_device_release; 39360aa0dc41SMark McLoughlin 39370aa0dc41SMark McLoughlin err = device_register(&root->dev); 39380aa0dc41SMark McLoughlin if (err) { 39390aa0dc41SMark McLoughlin put_device(&root->dev); 39400aa0dc41SMark McLoughlin return ERR_PTR(err); 39410aa0dc41SMark McLoughlin } 39420aa0dc41SMark McLoughlin 39431d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 39440aa0dc41SMark McLoughlin if (owner) { 39450aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 39460aa0dc41SMark McLoughlin 39470aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 39480aa0dc41SMark McLoughlin if (err) { 39490aa0dc41SMark McLoughlin device_unregister(&root->dev); 39500aa0dc41SMark McLoughlin return ERR_PTR(err); 39510aa0dc41SMark McLoughlin } 39520aa0dc41SMark McLoughlin root->owner = owner; 39530aa0dc41SMark McLoughlin } 39540aa0dc41SMark McLoughlin #endif 39550aa0dc41SMark McLoughlin 39560aa0dc41SMark McLoughlin return &root->dev; 39570aa0dc41SMark McLoughlin } 39580aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 39590aa0dc41SMark McLoughlin 39600aa0dc41SMark McLoughlin /** 39610aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 39627cbcf225SRandy Dunlap * @dev: device going away 39630aa0dc41SMark McLoughlin * 39640aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 39650aa0dc41SMark McLoughlin * root_device_register(). 39660aa0dc41SMark McLoughlin */ 39670aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 39680aa0dc41SMark McLoughlin { 39690aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 39700aa0dc41SMark McLoughlin 39710aa0dc41SMark McLoughlin if (root->owner) 39720aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 39730aa0dc41SMark McLoughlin 39740aa0dc41SMark McLoughlin device_unregister(dev); 39750aa0dc41SMark McLoughlin } 39760aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 39770aa0dc41SMark McLoughlin 397823681e47SGreg Kroah-Hartman 397923681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 398023681e47SGreg Kroah-Hartman { 39811e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 398223681e47SGreg Kroah-Hartman kfree(dev); 398323681e47SGreg Kroah-Hartman } 398423681e47SGreg Kroah-Hartman 39856a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 398639ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 398739ef3112SGuenter Roeck dev_t devt, void *drvdata, 398839ef3112SGuenter Roeck const struct attribute_group **groups, 398939ef3112SGuenter Roeck const char *fmt, va_list args) 399039ef3112SGuenter Roeck { 399139ef3112SGuenter Roeck struct device *dev = NULL; 399239ef3112SGuenter Roeck int retval = -ENODEV; 399339ef3112SGuenter Roeck 399439ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 399539ef3112SGuenter Roeck goto error; 399639ef3112SGuenter Roeck 399739ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 399839ef3112SGuenter Roeck if (!dev) { 399939ef3112SGuenter Roeck retval = -ENOMEM; 400039ef3112SGuenter Roeck goto error; 400139ef3112SGuenter Roeck } 400239ef3112SGuenter Roeck 4003bbc780f8SDavid Herrmann device_initialize(dev); 400439ef3112SGuenter Roeck dev->devt = devt; 400539ef3112SGuenter Roeck dev->class = class; 400639ef3112SGuenter Roeck dev->parent = parent; 400739ef3112SGuenter Roeck dev->groups = groups; 400839ef3112SGuenter Roeck dev->release = device_create_release; 400939ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 401039ef3112SGuenter Roeck 401139ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 401239ef3112SGuenter Roeck if (retval) 401339ef3112SGuenter Roeck goto error; 401439ef3112SGuenter Roeck 4015bbc780f8SDavid Herrmann retval = device_add(dev); 401639ef3112SGuenter Roeck if (retval) 401739ef3112SGuenter Roeck goto error; 401839ef3112SGuenter Roeck 401939ef3112SGuenter Roeck return dev; 402039ef3112SGuenter Roeck 402139ef3112SGuenter Roeck error: 402239ef3112SGuenter Roeck put_device(dev); 402339ef3112SGuenter Roeck return ERR_PTR(retval); 402439ef3112SGuenter Roeck } 402539ef3112SGuenter Roeck 402623681e47SGreg Kroah-Hartman /** 40274e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 40288882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 40298882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 40308882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 40318882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 40328882b394SGreg Kroah-Hartman * @fmt: string for the device's name 40338882b394SGreg Kroah-Hartman * 40348882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 40358882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 40368882b394SGreg Kroah-Hartman * 40378882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 40388882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 40398882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 40408882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 40418882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 40428882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 40438882b394SGreg Kroah-Hartman * pointer. 40448882b394SGreg Kroah-Hartman * 4045f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 4046f0eae0edSJani Nikula * 40478882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 40488882b394SGreg Kroah-Hartman * been created with a call to class_create(). 40498882b394SGreg Kroah-Hartman */ 40504e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 40514e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 40528882b394SGreg Kroah-Hartman { 40538882b394SGreg Kroah-Hartman va_list vargs; 40548882b394SGreg Kroah-Hartman struct device *dev; 40558882b394SGreg Kroah-Hartman 40568882b394SGreg Kroah-Hartman va_start(vargs, fmt); 40574c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL, 40584c747466SChristoph Hellwig fmt, vargs); 40598882b394SGreg Kroah-Hartman va_end(vargs); 40608882b394SGreg Kroah-Hartman return dev; 40618882b394SGreg Kroah-Hartman } 40624e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 40638882b394SGreg Kroah-Hartman 406439ef3112SGuenter Roeck /** 406539ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 406639ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 406739ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 406839ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 406939ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 407039ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 407139ef3112SGuenter Roeck * @fmt: string for the device's name 407239ef3112SGuenter Roeck * 407339ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 407439ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 407539ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 407639ef3112SGuenter Roeck * be created automatically. 407739ef3112SGuenter Roeck * 407839ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 407939ef3112SGuenter Roeck * the dev_t is not 0,0. 408039ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 408139ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 408239ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 408339ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 408439ef3112SGuenter Roeck * pointer. 408539ef3112SGuenter Roeck * 408639ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 408739ef3112SGuenter Roeck * 408839ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 408939ef3112SGuenter Roeck * been created with a call to class_create(). 409039ef3112SGuenter Roeck */ 409139ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 409239ef3112SGuenter Roeck struct device *parent, dev_t devt, 409339ef3112SGuenter Roeck void *drvdata, 409439ef3112SGuenter Roeck const struct attribute_group **groups, 409539ef3112SGuenter Roeck const char *fmt, ...) 409639ef3112SGuenter Roeck { 409739ef3112SGuenter Roeck va_list vargs; 409839ef3112SGuenter Roeck struct device *dev; 409939ef3112SGuenter Roeck 410039ef3112SGuenter Roeck va_start(vargs, fmt); 410139ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 410239ef3112SGuenter Roeck fmt, vargs); 410339ef3112SGuenter Roeck va_end(vargs); 410439ef3112SGuenter Roeck return dev; 410539ef3112SGuenter Roeck } 410639ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 410739ef3112SGuenter Roeck 4108775b64d2SRafael J. Wysocki /** 4109775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 4110775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 4111775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 4112775b64d2SRafael J. Wysocki * 4113775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 4114775b64d2SRafael J. Wysocki * call to device_create(). 4115775b64d2SRafael J. Wysocki */ 4116775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 4117775b64d2SRafael J. Wysocki { 4118775b64d2SRafael J. Wysocki struct device *dev; 4119775b64d2SRafael J. Wysocki 41204495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 4121cd35449bSDave Young if (dev) { 4122cd35449bSDave Young put_device(dev); 412323681e47SGreg Kroah-Hartman device_unregister(dev); 412423681e47SGreg Kroah-Hartman } 4125cd35449bSDave Young } 412623681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 4127a2de48caSGreg Kroah-Hartman 4128a2de48caSGreg Kroah-Hartman /** 4129a2de48caSGreg Kroah-Hartman * device_rename - renames a device 4130a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 4131a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 4132030c1d2bSEric W. Biederman * 4133030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 4134030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 4135030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 4136030c1d2bSEric W. Biederman * won't conflict with other devices. 4137c6c0ac66SMichael Ellerman * 4138a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 4139a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 4140a5462516STimur Tabi * some insight: 4141a5462516STimur Tabi * 4142a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 4143a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 4144a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 4145a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 4146a5462516STimur Tabi * 4147a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 4148a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 4149a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 4150a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 4151a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 4152a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 4153a5462516STimur Tabi * 4154a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 4155a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 4156a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 4157a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 4158a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 4159a5462516STimur Tabi * reasons. 4160a5462516STimur Tabi * 4161a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 4162a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 4163a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 4164a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 4165a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 4166a2de48caSGreg Kroah-Hartman */ 41676937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 4168a2de48caSGreg Kroah-Hartman { 41694b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 41702ee97cafSCornelia Huck char *old_device_name = NULL; 4171a2de48caSGreg Kroah-Hartman int error; 4172a2de48caSGreg Kroah-Hartman 4173a2de48caSGreg Kroah-Hartman dev = get_device(dev); 4174a2de48caSGreg Kroah-Hartman if (!dev) 4175a2de48caSGreg Kroah-Hartman return -EINVAL; 4176a2de48caSGreg Kroah-Hartman 417769df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 4178a2de48caSGreg Kroah-Hartman 41791fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 41802ee97cafSCornelia Huck if (!old_device_name) { 4181952ab431SJesper Juhl error = -ENOMEM; 41822ee97cafSCornelia Huck goto out; 4183952ab431SJesper Juhl } 4184a2de48caSGreg Kroah-Hartman 4185f349cf34SEric W. Biederman if (dev->class) { 41864b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 41874b30ee58STejun Heo kobj, old_device_name, 41884b30ee58STejun Heo new_name, kobject_namespace(kobj)); 4189f349cf34SEric W. Biederman if (error) 4190f349cf34SEric W. Biederman goto out; 4191f349cf34SEric W. Biederman } 419239aba963SKay Sievers 41934b30ee58STejun Heo error = kobject_rename(kobj, new_name); 41941fa5ae85SKay Sievers if (error) 41952ee97cafSCornelia Huck goto out; 4196a2de48caSGreg Kroah-Hartman 41972ee97cafSCornelia Huck out: 4198a2de48caSGreg Kroah-Hartman put_device(dev); 4199a2de48caSGreg Kroah-Hartman 42002ee97cafSCornelia Huck kfree(old_device_name); 4201a2de48caSGreg Kroah-Hartman 4202a2de48caSGreg Kroah-Hartman return error; 4203a2de48caSGreg Kroah-Hartman } 4204a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 42058a82472fSCornelia Huck 42068a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 42078a82472fSCornelia Huck struct device *old_parent, 42088a82472fSCornelia Huck struct device *new_parent) 42098a82472fSCornelia Huck { 4210f7f3461dSGreg Kroah-Hartman int error = 0; 42118a82472fSCornelia Huck 4212f7f3461dSGreg Kroah-Hartman if (old_parent) 4213f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 4214f7f3461dSGreg Kroah-Hartman if (new_parent) 4215f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 4216f7f3461dSGreg Kroah-Hartman "device"); 4217f7f3461dSGreg Kroah-Hartman return error; 42188a82472fSCornelia Huck } 42198a82472fSCornelia Huck 42208a82472fSCornelia Huck /** 42218a82472fSCornelia Huck * device_move - moves a device to a new parent 42228a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 422313509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 4224ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 42258a82472fSCornelia Huck */ 4226ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 4227ffa6a705SCornelia Huck enum dpm_order dpm_order) 42288a82472fSCornelia Huck { 42298a82472fSCornelia Huck int error; 42308a82472fSCornelia Huck struct device *old_parent; 4231c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 42328a82472fSCornelia Huck 42338a82472fSCornelia Huck dev = get_device(dev); 42348a82472fSCornelia Huck if (!dev) 42358a82472fSCornelia Huck return -EINVAL; 42368a82472fSCornelia Huck 4237ffa6a705SCornelia Huck device_pm_lock(); 42388a82472fSCornelia Huck new_parent = get_device(new_parent); 4239c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 424084d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 424184d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 424284d0c27dSTetsuo Handa put_device(new_parent); 424384d0c27dSTetsuo Handa goto out; 424484d0c27dSTetsuo Handa } 424563b6971aSCornelia Huck 42461e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 42471e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 4248c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 42498a82472fSCornelia Huck if (error) { 425063b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 42518a82472fSCornelia Huck put_device(new_parent); 42528a82472fSCornelia Huck goto out; 42538a82472fSCornelia Huck } 42548a82472fSCornelia Huck old_parent = dev->parent; 42558a82472fSCornelia Huck dev->parent = new_parent; 42568a82472fSCornelia Huck if (old_parent) 4257f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 42580d358f22SYinghai Lu if (new_parent) { 4259f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4260f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 42610d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 42620d358f22SYinghai Lu } 42630d358f22SYinghai Lu 4264bdd4034dSRabin Vincent if (dev->class) { 42658a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 42668a82472fSCornelia Huck if (error) { 42678a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 42688a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 42698a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 4270c744aeaeSCornelia Huck if (new_parent) 4271f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 42720d358f22SYinghai Lu dev->parent = old_parent; 42730d358f22SYinghai Lu if (old_parent) { 4274f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4275f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 42760d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 42770d358f22SYinghai Lu } 42788a82472fSCornelia Huck } 427963b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 42808a82472fSCornelia Huck put_device(new_parent); 42818a82472fSCornelia Huck goto out; 42828a82472fSCornelia Huck } 4283bdd4034dSRabin Vincent } 4284ffa6a705SCornelia Huck switch (dpm_order) { 4285ffa6a705SCornelia Huck case DPM_ORDER_NONE: 4286ffa6a705SCornelia Huck break; 4287ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 4288ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 428952cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 4290ffa6a705SCornelia Huck break; 4291ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 4292ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 429352cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 4294ffa6a705SCornelia Huck break; 4295ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 4296ffa6a705SCornelia Huck device_pm_move_last(dev); 429752cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 4298ffa6a705SCornelia Huck break; 4299ffa6a705SCornelia Huck } 4300bdd4034dSRabin Vincent 43018a82472fSCornelia Huck put_device(old_parent); 43028a82472fSCornelia Huck out: 4303ffa6a705SCornelia Huck device_pm_unlock(); 43048a82472fSCornelia Huck put_device(dev); 43058a82472fSCornelia Huck return error; 43068a82472fSCornelia Huck } 43078a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 430837b0c020SGreg Kroah-Hartman 4309b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 4310b8f33e5dSChristian Brauner kgid_t kgid) 4311b8f33e5dSChristian Brauner { 4312b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4313b8f33e5dSChristian Brauner struct class *class = dev->class; 4314b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 4315b8f33e5dSChristian Brauner int error; 4316b8f33e5dSChristian Brauner 4317b8f33e5dSChristian Brauner if (class) { 4318b8f33e5dSChristian Brauner /* 4319b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 4320b8f33e5dSChristian Brauner * @kuid/@kgid. 4321b8f33e5dSChristian Brauner */ 4322b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 4323b8f33e5dSChristian Brauner kgid); 4324b8f33e5dSChristian Brauner if (error) 4325b8f33e5dSChristian Brauner return error; 4326b8f33e5dSChristian Brauner } 4327b8f33e5dSChristian Brauner 4328b8f33e5dSChristian Brauner if (type) { 4329b8f33e5dSChristian Brauner /* 4330b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 4331b8f33e5dSChristian Brauner * @kuid/@kgid. 4332b8f33e5dSChristian Brauner */ 4333b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 4334b8f33e5dSChristian Brauner kgid); 4335b8f33e5dSChristian Brauner if (error) 4336b8f33e5dSChristian Brauner return error; 4337b8f33e5dSChristian Brauner } 4338b8f33e5dSChristian Brauner 4339b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 4340b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 4341b8f33e5dSChristian Brauner if (error) 4342b8f33e5dSChristian Brauner return error; 4343b8f33e5dSChristian Brauner 4344b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 4345b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 4346b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 4347b8f33e5dSChristian Brauner kuid, kgid); 4348b8f33e5dSChristian Brauner if (error) 4349b8f33e5dSChristian Brauner return error; 4350b8f33e5dSChristian Brauner } 4351b8f33e5dSChristian Brauner 4352b8f33e5dSChristian Brauner return 0; 4353b8f33e5dSChristian Brauner } 4354b8f33e5dSChristian Brauner 4355b8f33e5dSChristian Brauner /** 4356b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 4357b8f33e5dSChristian Brauner * @dev: device. 4358b8f33e5dSChristian Brauner * @kuid: new owner's kuid 4359b8f33e5dSChristian Brauner * @kgid: new owner's kgid 4360b8f33e5dSChristian Brauner * 4361b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 4362b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 4363b8f33e5dSChristian Brauner * core. 4364b8f33e5dSChristian Brauner * 4365b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 4366b8f33e5dSChristian Brauner */ 4367b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 4368b8f33e5dSChristian Brauner { 4369b8f33e5dSChristian Brauner int error; 4370b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4371b8f33e5dSChristian Brauner 4372b8f33e5dSChristian Brauner dev = get_device(dev); 4373b8f33e5dSChristian Brauner if (!dev) 4374b8f33e5dSChristian Brauner return -EINVAL; 4375b8f33e5dSChristian Brauner 4376b8f33e5dSChristian Brauner /* 4377b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 4378b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 4379b8f33e5dSChristian Brauner */ 4380b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 4381b8f33e5dSChristian Brauner if (error) 4382b8f33e5dSChristian Brauner goto out; 4383b8f33e5dSChristian Brauner 4384b8f33e5dSChristian Brauner /* 4385b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 4386b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 4387b8f33e5dSChristian Brauner * that step here. 4388b8f33e5dSChristian Brauner */ 4389b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 4390b8f33e5dSChristian Brauner kgid); 4391b8f33e5dSChristian Brauner if (error) 4392b8f33e5dSChristian Brauner goto out; 4393b8f33e5dSChristian Brauner 4394b8f33e5dSChristian Brauner /* 4395b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 4396b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 4397b8f33e5dSChristian Brauner * to @kuid/@kgid. 4398b8f33e5dSChristian Brauner */ 4399b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 4400b8f33e5dSChristian Brauner if (error) 4401b8f33e5dSChristian Brauner goto out; 4402b8f33e5dSChristian Brauner 44033b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 44043b52fc5dSChristian Brauner if (error) 44053b52fc5dSChristian Brauner goto out; 44063b52fc5dSChristian Brauner 4407b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 4408b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 4409b8f33e5dSChristian Brauner goto out; 4410b8f33e5dSChristian Brauner #endif 4411b8f33e5dSChristian Brauner 4412b8f33e5dSChristian Brauner /* 4413b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 4414b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 4415b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 4416b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 4417b8f33e5dSChristian Brauner */ 4418b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 4419b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 4420b8f33e5dSChristian Brauner if (error) 4421b8f33e5dSChristian Brauner goto out; 4422b8f33e5dSChristian Brauner 4423b8f33e5dSChristian Brauner out: 4424b8f33e5dSChristian Brauner put_device(dev); 4425b8f33e5dSChristian Brauner return error; 4426b8f33e5dSChristian Brauner } 4427b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 4428b8f33e5dSChristian Brauner 442937b0c020SGreg Kroah-Hartman /** 443037b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 443137b0c020SGreg Kroah-Hartman */ 443237b0c020SGreg Kroah-Hartman void device_shutdown(void) 443337b0c020SGreg Kroah-Hartman { 4434f123db8eSBenson Leung struct device *dev, *parent; 443537b0c020SGreg Kroah-Hartman 44363297c8fcSPingfan Liu wait_for_device_probe(); 44373297c8fcSPingfan Liu device_block_probing(); 44383297c8fcSPingfan Liu 443965650b35SRafael J. Wysocki cpufreq_suspend(); 444065650b35SRafael J. Wysocki 44416245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 44426245838fSHugh Daschbach /* 44436245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 44446245838fSHugh Daschbach * Beware that device unplug events may also start pulling 44456245838fSHugh Daschbach * devices offline, even as the system is shutting down. 44466245838fSHugh Daschbach */ 44476245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 44486245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 44496245838fSHugh Daschbach kobj.entry); 4450d1c6c030SMing Lei 4451d1c6c030SMing Lei /* 4452d1c6c030SMing Lei * hold reference count of device's parent to 4453d1c6c030SMing Lei * prevent it from being freed because parent's 4454d1c6c030SMing Lei * lock is to be held 4455d1c6c030SMing Lei */ 4456f123db8eSBenson Leung parent = get_device(dev->parent); 44576245838fSHugh Daschbach get_device(dev); 44586245838fSHugh Daschbach /* 44596245838fSHugh Daschbach * Make sure the device is off the kset list, in the 44606245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 44616245838fSHugh Daschbach */ 44626245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 44636245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 4464fe6b91f4SAlan Stern 4465d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 4466f123db8eSBenson Leung if (parent) 4467f123db8eSBenson Leung device_lock(parent); 4468d1c6c030SMing Lei device_lock(dev); 4469d1c6c030SMing Lei 4470fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 4471fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 4472fe6b91f4SAlan Stern pm_runtime_barrier(dev); 44736245838fSHugh Daschbach 44747521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 4475f77af151SJosh Zimmerman if (initcall_debug) 44767521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 44777521621eSMichal Suchanek dev->class->shutdown_pre(dev); 44787521621eSMichal Suchanek } 44797521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 44800246c4faSShuoX Liu if (initcall_debug) 44810246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 448237b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 448337b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 44840246c4faSShuoX Liu if (initcall_debug) 44850246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 448637b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 448737b0c020SGreg Kroah-Hartman } 4488d1c6c030SMing Lei 4489d1c6c030SMing Lei device_unlock(dev); 4490f123db8eSBenson Leung if (parent) 4491f123db8eSBenson Leung device_unlock(parent); 4492d1c6c030SMing Lei 44936245838fSHugh Daschbach put_device(dev); 4494f123db8eSBenson Leung put_device(parent); 44956245838fSHugh Daschbach 44966245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 449737b0c020SGreg Kroah-Hartman } 44986245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 449937b0c020SGreg Kroah-Hartman } 450099bcf217SJoe Perches 450199bcf217SJoe Perches /* 450299bcf217SJoe Perches * Device logging functions 450399bcf217SJoe Perches */ 450499bcf217SJoe Perches 450599bcf217SJoe Perches #ifdef CONFIG_PRINTK 450674caba7fSJohn Ogness static void 450774caba7fSJohn Ogness set_dev_info(const struct device *dev, struct dev_printk_info *dev_info) 450899bcf217SJoe Perches { 4509c4e00daaSKay Sievers const char *subsys; 451074caba7fSJohn Ogness 451174caba7fSJohn Ogness memset(dev_info, 0, sizeof(*dev_info)); 451299bcf217SJoe Perches 4513c4e00daaSKay Sievers if (dev->class) 4514c4e00daaSKay Sievers subsys = dev->class->name; 4515c4e00daaSKay Sievers else if (dev->bus) 4516c4e00daaSKay Sievers subsys = dev->bus->name; 4517c4e00daaSKay Sievers else 451874caba7fSJohn Ogness return; 4519c4e00daaSKay Sievers 452074caba7fSJohn Ogness strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); 4521c4e00daaSKay Sievers 4522c4e00daaSKay Sievers /* 4523c4e00daaSKay Sievers * Add device identifier DEVICE=: 4524c4e00daaSKay Sievers * b12:8 block dev_t 4525c4e00daaSKay Sievers * c127:3 char dev_t 4526c4e00daaSKay Sievers * n8 netdev ifindex 4527c4e00daaSKay Sievers * +sound:card0 subsystem:devname 4528c4e00daaSKay Sievers */ 4529c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 4530c4e00daaSKay Sievers char c; 4531c4e00daaSKay Sievers 4532c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 4533c4e00daaSKay Sievers c = 'b'; 4534c4e00daaSKay Sievers else 4535c4e00daaSKay Sievers c = 'c'; 453674caba7fSJohn Ogness 453774caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 453874caba7fSJohn Ogness "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); 4539c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 4540c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 4541c4e00daaSKay Sievers 454274caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 454374caba7fSJohn Ogness "n%u", net->ifindex); 4544c4e00daaSKay Sievers } else { 454574caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 454674caba7fSJohn Ogness "+%s:%s", subsys, dev_name(dev)); 4547c4e00daaSKay Sievers } 454899bcf217SJoe Perches } 4549798efc60SJoe Perches 455005e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 455105e4e5b8SJoe Perches const char *fmt, va_list args) 455205e4e5b8SJoe Perches { 455374caba7fSJohn Ogness struct dev_printk_info dev_info; 455405e4e5b8SJoe Perches 455574caba7fSJohn Ogness set_dev_info(dev, &dev_info); 455605e4e5b8SJoe Perches 455774caba7fSJohn Ogness return vprintk_emit(0, level, &dev_info, fmt, args); 455805e4e5b8SJoe Perches } 455905e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 456005e4e5b8SJoe Perches 456105e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 456205e4e5b8SJoe Perches { 456305e4e5b8SJoe Perches va_list args; 456405e4e5b8SJoe Perches int r; 456505e4e5b8SJoe Perches 456605e4e5b8SJoe Perches va_start(args, fmt); 456705e4e5b8SJoe Perches 456805e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 456905e4e5b8SJoe Perches 457005e4e5b8SJoe Perches va_end(args); 457105e4e5b8SJoe Perches 457205e4e5b8SJoe Perches return r; 457305e4e5b8SJoe Perches } 457405e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 457505e4e5b8SJoe Perches 4576d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 4577798efc60SJoe Perches struct va_format *vaf) 4578798efc60SJoe Perches { 4579d1f1052cSJoe Perches if (dev) 4580d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 4581798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 4582d1f1052cSJoe Perches else 4583d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 4584798efc60SJoe Perches } 458599bcf217SJoe Perches 4586d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 458799bcf217SJoe Perches const char *fmt, ...) 458899bcf217SJoe Perches { 458999bcf217SJoe Perches struct va_format vaf; 459099bcf217SJoe Perches va_list args; 459199bcf217SJoe Perches 459299bcf217SJoe Perches va_start(args, fmt); 459399bcf217SJoe Perches 459499bcf217SJoe Perches vaf.fmt = fmt; 459599bcf217SJoe Perches vaf.va = &args; 459699bcf217SJoe Perches 4597d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 4598798efc60SJoe Perches 459999bcf217SJoe Perches va_end(args); 460099bcf217SJoe Perches } 460199bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 460299bcf217SJoe Perches 460399bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 4604d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 460599bcf217SJoe Perches { \ 460699bcf217SJoe Perches struct va_format vaf; \ 460799bcf217SJoe Perches va_list args; \ 460899bcf217SJoe Perches \ 460999bcf217SJoe Perches va_start(args, fmt); \ 461099bcf217SJoe Perches \ 461199bcf217SJoe Perches vaf.fmt = fmt; \ 461299bcf217SJoe Perches vaf.va = &args; \ 461399bcf217SJoe Perches \ 4614d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 4615798efc60SJoe Perches \ 461699bcf217SJoe Perches va_end(args); \ 461799bcf217SJoe Perches } \ 461899bcf217SJoe Perches EXPORT_SYMBOL(func); 461999bcf217SJoe Perches 4620663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 4621663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 4622663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 4623663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 4624663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 4625663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 462699bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 462799bcf217SJoe Perches 462899bcf217SJoe Perches #endif 462997badf87SRafael J. Wysocki 4630a787e540SAndrzej Hajda /** 4631a787e540SAndrzej Hajda * dev_err_probe - probe error check and log helper 4632a787e540SAndrzej Hajda * @dev: the pointer to the struct device 4633a787e540SAndrzej Hajda * @err: error value to test 4634a787e540SAndrzej Hajda * @fmt: printf-style format string 4635a787e540SAndrzej Hajda * @...: arguments as specified in the format string 4636a787e540SAndrzej Hajda * 4637a787e540SAndrzej Hajda * This helper implements common pattern present in probe functions for error 4638a787e540SAndrzej Hajda * checking: print debug or error message depending if the error value is 4639a787e540SAndrzej Hajda * -EPROBE_DEFER and propagate error upwards. 4640d090b70eSAndrzej Hajda * In case of -EPROBE_DEFER it sets also defer probe reason, which can be 4641d090b70eSAndrzej Hajda * checked later by reading devices_deferred debugfs attribute. 4642074b3aadSMauro Carvalho Chehab * It replaces code sequence:: 4643074b3aadSMauro Carvalho Chehab * 4644a787e540SAndrzej Hajda * if (err != -EPROBE_DEFER) 4645a787e540SAndrzej Hajda * dev_err(dev, ...); 4646a787e540SAndrzej Hajda * else 4647a787e540SAndrzej Hajda * dev_dbg(dev, ...); 4648a787e540SAndrzej Hajda * return err; 4649074b3aadSMauro Carvalho Chehab * 4650074b3aadSMauro Carvalho Chehab * with:: 4651074b3aadSMauro Carvalho Chehab * 4652a787e540SAndrzej Hajda * return dev_err_probe(dev, err, ...); 4653a787e540SAndrzej Hajda * 4654a787e540SAndrzej Hajda * Returns @err. 4655a787e540SAndrzej Hajda * 4656a787e540SAndrzej Hajda */ 4657a787e540SAndrzej Hajda int dev_err_probe(const struct device *dev, int err, const char *fmt, ...) 4658a787e540SAndrzej Hajda { 4659a787e540SAndrzej Hajda struct va_format vaf; 4660a787e540SAndrzej Hajda va_list args; 4661a787e540SAndrzej Hajda 4662a787e540SAndrzej Hajda va_start(args, fmt); 4663a787e540SAndrzej Hajda vaf.fmt = fmt; 4664a787e540SAndrzej Hajda vaf.va = &args; 4665a787e540SAndrzej Hajda 4666d090b70eSAndrzej Hajda if (err != -EPROBE_DEFER) { 4667693a8e93SMichał Mirosław dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4668d090b70eSAndrzej Hajda } else { 4669d090b70eSAndrzej Hajda device_set_deferred_probe_reason(dev, &vaf); 4670693a8e93SMichał Mirosław dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4671d090b70eSAndrzej Hajda } 4672a787e540SAndrzej Hajda 4673a787e540SAndrzej Hajda va_end(args); 4674a787e540SAndrzej Hajda 4675a787e540SAndrzej Hajda return err; 4676a787e540SAndrzej Hajda } 4677a787e540SAndrzej Hajda EXPORT_SYMBOL_GPL(dev_err_probe); 4678a787e540SAndrzej Hajda 467997badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 468097badf87SRafael J. Wysocki { 468197badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 468297badf87SRafael J. Wysocki } 468397badf87SRafael J. Wysocki 468497badf87SRafael J. Wysocki /** 468597badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 468697badf87SRafael J. Wysocki * @dev: Device to handle. 468797badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 468897badf87SRafael J. Wysocki * 468997badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 469097badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 46913f7bddafSBard Liao * 46923f7bddafSBard Liao * Valid fwnode cases are: 46933f7bddafSBard Liao * - primary --> secondary --> -ENODEV 46943f7bddafSBard Liao * - primary --> NULL 46953f7bddafSBard Liao * - secondary --> -ENODEV 46963f7bddafSBard Liao * - NULL 469797badf87SRafael J. Wysocki */ 469897badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 469997badf87SRafael J. Wysocki { 470099aed922SAndy Shevchenko struct device *parent = dev->parent; 470197badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 470297badf87SRafael J. Wysocki 4703c15e1bddSHeikki Krogerus if (fwnode) { 470497badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 470597badf87SRafael J. Wysocki fn = fn->secondary; 470697badf87SRafael J. Wysocki 470755f89a8aSMika Westerberg if (fn) { 470855f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 470997badf87SRafael J. Wysocki fwnode->secondary = fn; 471055f89a8aSMika Westerberg } 471197badf87SRafael J. Wysocki dev->fwnode = fwnode; 471297badf87SRafael J. Wysocki } else { 4713c15e1bddSHeikki Krogerus if (fwnode_is_primary(fn)) { 4714c15e1bddSHeikki Krogerus dev->fwnode = fn->secondary; 47153f7bddafSBard Liao /* Set fn->secondary = NULL, so fn remains the primary fwnode */ 471699aed922SAndy Shevchenko if (!(parent && fn == parent->fwnode)) 471747f44699SBard Liao fn->secondary = NULL; 4718c15e1bddSHeikki Krogerus } else { 4719c15e1bddSHeikki Krogerus dev->fwnode = NULL; 4720c15e1bddSHeikki Krogerus } 472197badf87SRafael J. Wysocki } 472297badf87SRafael J. Wysocki } 472397badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 472497badf87SRafael J. Wysocki 472597badf87SRafael J. Wysocki /** 472697badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 472797badf87SRafael J. Wysocki * @dev: Device to handle. 472897badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 472997badf87SRafael J. Wysocki * 473097badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 473197badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 473297badf87SRafael J. Wysocki * @fwnode. 473397badf87SRafael J. Wysocki */ 473497badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 473597badf87SRafael J. Wysocki { 473697badf87SRafael J. Wysocki if (fwnode) 473797badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 473897badf87SRafael J. Wysocki 473997badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 474097badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 474197badf87SRafael J. Wysocki else 474297badf87SRafael J. Wysocki dev->fwnode = fwnode; 474397badf87SRafael J. Wysocki } 474496489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 47454e75e1d7SJohan Hovold 47464e75e1d7SJohan Hovold /** 47474e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 47484e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 47494e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 47504e75e1d7SJohan Hovold * 47514e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 47524e75e1d7SJohan Hovold * any reference held to the old node. 47534e75e1d7SJohan Hovold */ 47544e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 47554e75e1d7SJohan Hovold { 47564e75e1d7SJohan Hovold of_node_put(dev->of_node); 47574e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 47584e75e1d7SJohan Hovold dev->of_node_reused = true; 47594e75e1d7SJohan Hovold } 47604e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 476165b66682SSuzuki K Poulose 476243e76d46SIoana Ciornei void device_set_node(struct device *dev, struct fwnode_handle *fwnode) 476343e76d46SIoana Ciornei { 476443e76d46SIoana Ciornei dev->fwnode = fwnode; 476543e76d46SIoana Ciornei dev->of_node = to_of_node(fwnode); 476643e76d46SIoana Ciornei } 476743e76d46SIoana Ciornei EXPORT_SYMBOL_GPL(device_set_node); 476843e76d46SIoana Ciornei 47696cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 47706cda08a2SSuzuki K Poulose { 47716cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 47726cda08a2SSuzuki K Poulose } 47736cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 47746cda08a2SSuzuki K Poulose 477565b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 477665b66682SSuzuki K Poulose { 477765b66682SSuzuki K Poulose return dev->of_node == np; 477865b66682SSuzuki K Poulose } 477965b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 478067843bbaSSuzuki K Poulose 478167843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 478267843bbaSSuzuki K Poulose { 478367843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 478467843bbaSSuzuki K Poulose } 478567843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 47864495dfddSSuzuki K Poulose 47874495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 47884495dfddSSuzuki K Poulose { 47894495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 47904495dfddSSuzuki K Poulose } 47914495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 479200500147SSuzuki K Poulose 479300500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 479400500147SSuzuki K Poulose { 479500500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 479600500147SSuzuki K Poulose } 479700500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 47986bf85ba9SSuzuki K Poulose 47996bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 48006bf85ba9SSuzuki K Poulose { 48016bf85ba9SSuzuki K Poulose return 1; 48026bf85ba9SSuzuki K Poulose } 48036bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 4804