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> 3063967685SGreg Kroah-Hartman #include <linux/sysfs.h> 316d4e9a8eSChristoph Hellwig #include <linux/dma-map-ops.h> /* for dma_default_coherent */ 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds #include "base.h" 341da177e4SLinus Torvalds #include "power/power.h" 351da177e4SLinus Torvalds 36e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 37e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 38e52eec13SAndi Kleen long sysfs_deprecated = 1; 39e52eec13SAndi Kleen #else 40e52eec13SAndi Kleen long sysfs_deprecated = 0; 41e52eec13SAndi Kleen #endif 423454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 43e52eec13SAndi Kleen { 4434da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 45e52eec13SAndi Kleen } 46e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 47e52eec13SAndi Kleen #endif 48e52eec13SAndi Kleen 499ed98953SRafael J. Wysocki /* Device links support. */ 50fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 51fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 527b337cb3SSaravana Kannan static DEFINE_MUTEX(fwnode_link_lock); 5325ac86c6SSaravana Kannan static bool fw_devlink_is_permissive(void); 547b337cb3SSaravana Kannan 557b337cb3SSaravana Kannan /** 567b337cb3SSaravana Kannan * fwnode_link_add - Create a link between two fwnode_handles. 577b337cb3SSaravana Kannan * @con: Consumer end of the link. 587b337cb3SSaravana Kannan * @sup: Supplier end of the link. 597b337cb3SSaravana Kannan * 607b337cb3SSaravana Kannan * Create a fwnode link between fwnode handles @con and @sup. The fwnode link 617b337cb3SSaravana Kannan * represents the detail that the firmware lists @sup fwnode as supplying a 627b337cb3SSaravana Kannan * resource to @con. 637b337cb3SSaravana Kannan * 647b337cb3SSaravana Kannan * The driver core will use the fwnode link to create a device link between the 657b337cb3SSaravana Kannan * two device objects corresponding to @con and @sup when they are created. The 667b337cb3SSaravana Kannan * driver core will automatically delete the fwnode link between @con and @sup 677b337cb3SSaravana Kannan * after doing that. 687b337cb3SSaravana Kannan * 697b337cb3SSaravana Kannan * Attempts to create duplicate links between the same pair of fwnode handles 707b337cb3SSaravana Kannan * are ignored and there is no reference counting. 717b337cb3SSaravana Kannan */ 727b337cb3SSaravana Kannan int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup) 737b337cb3SSaravana Kannan { 747b337cb3SSaravana Kannan struct fwnode_link *link; 757b337cb3SSaravana Kannan int ret = 0; 767b337cb3SSaravana Kannan 777b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 787b337cb3SSaravana Kannan 797b337cb3SSaravana Kannan list_for_each_entry(link, &sup->consumers, s_hook) 807b337cb3SSaravana Kannan if (link->consumer == con) 817b337cb3SSaravana Kannan goto out; 827b337cb3SSaravana Kannan 837b337cb3SSaravana Kannan link = kzalloc(sizeof(*link), GFP_KERNEL); 847b337cb3SSaravana Kannan if (!link) { 857b337cb3SSaravana Kannan ret = -ENOMEM; 867b337cb3SSaravana Kannan goto out; 877b337cb3SSaravana Kannan } 887b337cb3SSaravana Kannan 897b337cb3SSaravana Kannan link->supplier = sup; 907b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->s_hook); 917b337cb3SSaravana Kannan link->consumer = con; 927b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->c_hook); 937b337cb3SSaravana Kannan 947b337cb3SSaravana Kannan list_add(&link->s_hook, &sup->consumers); 957b337cb3SSaravana Kannan list_add(&link->c_hook, &con->suppliers); 967b337cb3SSaravana Kannan out: 977b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 987b337cb3SSaravana Kannan 997b337cb3SSaravana Kannan return ret; 1007b337cb3SSaravana Kannan } 1017b337cb3SSaravana Kannan 1027b337cb3SSaravana Kannan /** 1037b337cb3SSaravana Kannan * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle. 1047b337cb3SSaravana Kannan * @fwnode: fwnode whose supplier links need to be deleted 1057b337cb3SSaravana Kannan * 1067b337cb3SSaravana Kannan * Deletes all supplier links connecting directly to @fwnode. 1077b337cb3SSaravana Kannan */ 1087b337cb3SSaravana Kannan static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode) 1097b337cb3SSaravana Kannan { 1107b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1117b337cb3SSaravana Kannan 1127b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 1137b337cb3SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { 1147b337cb3SSaravana Kannan list_del(&link->s_hook); 1157b337cb3SSaravana Kannan list_del(&link->c_hook); 1167b337cb3SSaravana Kannan kfree(link); 1177b337cb3SSaravana Kannan } 1187b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1197b337cb3SSaravana Kannan } 1207b337cb3SSaravana Kannan 1217b337cb3SSaravana Kannan /** 1227b337cb3SSaravana Kannan * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle. 1237b337cb3SSaravana Kannan * @fwnode: fwnode whose consumer links need to be deleted 1247b337cb3SSaravana Kannan * 1257b337cb3SSaravana Kannan * Deletes all consumer links connecting directly to @fwnode. 1267b337cb3SSaravana Kannan */ 1277b337cb3SSaravana Kannan static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode) 1287b337cb3SSaravana Kannan { 1297b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1307b337cb3SSaravana Kannan 1317b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 1327b337cb3SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { 1337b337cb3SSaravana Kannan list_del(&link->s_hook); 1347b337cb3SSaravana Kannan list_del(&link->c_hook); 1357b337cb3SSaravana Kannan kfree(link); 1367b337cb3SSaravana Kannan } 1377b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1387b337cb3SSaravana Kannan } 1397b337cb3SSaravana Kannan 1407b337cb3SSaravana Kannan /** 1417b337cb3SSaravana Kannan * fwnode_links_purge - Delete all links connected to a fwnode_handle. 1427b337cb3SSaravana Kannan * @fwnode: fwnode whose links needs to be deleted 1437b337cb3SSaravana Kannan * 1447b337cb3SSaravana Kannan * Deletes all links connecting directly to a fwnode. 1457b337cb3SSaravana Kannan */ 1467b337cb3SSaravana Kannan void fwnode_links_purge(struct fwnode_handle *fwnode) 1477b337cb3SSaravana Kannan { 1487b337cb3SSaravana Kannan fwnode_links_purge_suppliers(fwnode); 1497b337cb3SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1507b337cb3SSaravana Kannan } 1519ed98953SRafael J. Wysocki 1529528e0d9SSaravana Kannan static void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode) 1539528e0d9SSaravana Kannan { 1549528e0d9SSaravana Kannan struct fwnode_handle *child; 1559528e0d9SSaravana Kannan 1569528e0d9SSaravana Kannan /* Don't purge consumer links of an added child */ 1579528e0d9SSaravana Kannan if (fwnode->dev) 1589528e0d9SSaravana Kannan return; 1599528e0d9SSaravana Kannan 1609528e0d9SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; 1619528e0d9SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1629528e0d9SSaravana Kannan 1639528e0d9SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child) 1649528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 1659528e0d9SSaravana Kannan } 1669528e0d9SSaravana Kannan 1679ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 1689ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 1699ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 1709ed98953SRafael J. Wysocki 1719ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 1729ed98953SRafael J. Wysocki { 1739ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 1749ed98953SRafael J. Wysocki } 1759ed98953SRafael J. Wysocki 1769ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 1779ed98953SRafael J. Wysocki { 1789ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 1799ed98953SRafael J. Wysocki } 1809ed98953SRafael J. Wysocki 18168464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 1829ed98953SRafael J. Wysocki { 1839ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 1849ed98953SRafael J. Wysocki } 1859ed98953SRafael J. Wysocki 186ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 1879ed98953SRafael J. Wysocki { 1889ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 1899ed98953SRafael J. Wysocki } 190c2fa1e1bSJoel Fernandes (Google) 191c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 192c2fa1e1bSJoel Fernandes (Google) { 193c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 194c2fa1e1bSJoel Fernandes (Google) } 1959ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 1969ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 1979ed98953SRafael J. Wysocki 1989ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 1999ed98953SRafael J. Wysocki { 2009ed98953SRafael J. Wysocki down_write(&device_links_lock); 2019ed98953SRafael J. Wysocki } 2029ed98953SRafael J. Wysocki 2039ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 2049ed98953SRafael J. Wysocki { 2059ed98953SRafael J. Wysocki up_write(&device_links_lock); 2069ed98953SRafael J. Wysocki } 2079ed98953SRafael J. Wysocki 2089ed98953SRafael J. Wysocki int device_links_read_lock(void) 2099ed98953SRafael J. Wysocki { 2109ed98953SRafael J. Wysocki down_read(&device_links_lock); 2119ed98953SRafael J. Wysocki return 0; 2129ed98953SRafael J. Wysocki } 2139ed98953SRafael J. Wysocki 2149ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 2159ed98953SRafael J. Wysocki { 2169ed98953SRafael J. Wysocki up_read(&device_links_lock); 2179ed98953SRafael J. Wysocki } 218c2fa1e1bSJoel Fernandes (Google) 219c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 220c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 221c2fa1e1bSJoel Fernandes (Google) { 222c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 223c2fa1e1bSJoel Fernandes (Google) } 224c2fa1e1bSJoel Fernandes (Google) #endif 2259ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 2269ed98953SRafael J. Wysocki 2273d1cf435SRafael J. Wysocki static bool device_is_ancestor(struct device *dev, struct device *target) 2283d1cf435SRafael J. Wysocki { 2293d1cf435SRafael J. Wysocki while (target->parent) { 2303d1cf435SRafael J. Wysocki target = target->parent; 2313d1cf435SRafael J. Wysocki if (dev == target) 2323d1cf435SRafael J. Wysocki return true; 2333d1cf435SRafael J. Wysocki } 2343d1cf435SRafael J. Wysocki return false; 2353d1cf435SRafael J. Wysocki } 2363d1cf435SRafael J. Wysocki 2379ed98953SRafael J. Wysocki /** 2389ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 2399ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 2409ed98953SRafael J. Wysocki * @target: Device to check against. 2419ed98953SRafael J. Wysocki * 2429ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 2439ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 2449ed98953SRafael J. Wysocki */ 2457d34ca38SSaravana Kannan int device_is_dependent(struct device *dev, void *target) 2469ed98953SRafael J. Wysocki { 2479ed98953SRafael J. Wysocki struct device_link *link; 2489ed98953SRafael J. Wysocki int ret; 2499ed98953SRafael J. Wysocki 2503d1cf435SRafael J. Wysocki /* 2513d1cf435SRafael J. Wysocki * The "ancestors" check is needed to catch the case when the target 2523d1cf435SRafael J. Wysocki * device has not been completely initialized yet and it is still 2533d1cf435SRafael J. Wysocki * missing from the list of children of its parent device. 2543d1cf435SRafael J. Wysocki */ 2553d1cf435SRafael J. Wysocki if (dev == target || device_is_ancestor(dev, target)) 2569ed98953SRafael J. Wysocki return 1; 2579ed98953SRafael J. Wysocki 2589ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 2599ed98953SRafael J. Wysocki if (ret) 2609ed98953SRafael J. Wysocki return ret; 2619ed98953SRafael J. Wysocki 2629ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 2634b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 2644b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 26505ef983eSSaravana Kannan continue; 26605ef983eSSaravana Kannan 267e16f4f3eSBenjamin Gaignard if (link->consumer == target) 2689ed98953SRafael J. Wysocki return 1; 2699ed98953SRafael J. Wysocki 2709ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 2719ed98953SRafael J. Wysocki if (ret) 2729ed98953SRafael J. Wysocki break; 2739ed98953SRafael J. Wysocki } 2749ed98953SRafael J. Wysocki return ret; 2759ed98953SRafael J. Wysocki } 2769ed98953SRafael J. Wysocki 277515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 278515db266SRafael J. Wysocki struct device *consumer, 279515db266SRafael J. Wysocki struct device *supplier) 280515db266SRafael J. Wysocki { 281515db266SRafael J. Wysocki switch (supplier->links.status) { 282515db266SRafael J. Wysocki case DL_DEV_PROBING: 283515db266SRafael J. Wysocki switch (consumer->links.status) { 284515db266SRafael J. Wysocki case DL_DEV_PROBING: 285515db266SRafael J. Wysocki /* 286515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 287515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 288515db266SRafael J. Wysocki * knows that the supplier is already functional (for 289515db266SRafael J. Wysocki * example, it has just acquired some resources from the 290515db266SRafael J. Wysocki * supplier). 291515db266SRafael J. Wysocki */ 292515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 293515db266SRafael J. Wysocki break; 294515db266SRafael J. Wysocki default: 295515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 296515db266SRafael J. Wysocki break; 297515db266SRafael J. Wysocki } 298515db266SRafael J. Wysocki break; 299515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 300515db266SRafael J. Wysocki switch (consumer->links.status) { 301515db266SRafael J. Wysocki case DL_DEV_PROBING: 302515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 303515db266SRafael J. Wysocki break; 304515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 305515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 306515db266SRafael J. Wysocki break; 307515db266SRafael J. Wysocki default: 308515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 309515db266SRafael J. Wysocki break; 310515db266SRafael J. Wysocki } 311515db266SRafael J. Wysocki break; 312515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 313515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 314515db266SRafael J. Wysocki break; 315515db266SRafael J. Wysocki default: 316515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 317515db266SRafael J. Wysocki break; 318515db266SRafael J. Wysocki } 319515db266SRafael J. Wysocki } 320515db266SRafael J. Wysocki 3219ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 3229ed98953SRafael J. Wysocki { 3239ed98953SRafael J. Wysocki struct device_link *link; 3249ed98953SRafael J. Wysocki 3259ed98953SRafael J. Wysocki /* 3269ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 3279ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 3289ed98953SRafael J. Wysocki */ 3299ed98953SRafael J. Wysocki if (device_is_registered(dev)) 3309ed98953SRafael J. Wysocki devices_kset_move_last(dev); 3319ed98953SRafael J. Wysocki 3329ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 3339ed98953SRafael J. Wysocki device_pm_move_last(dev); 3349ed98953SRafael J. Wysocki 3359ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 33605ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 3374b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 3384b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 33905ef983eSSaravana Kannan continue; 3409ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 34105ef983eSSaravana Kannan } 3429ed98953SRafael J. Wysocki 3439ed98953SRafael J. Wysocki return 0; 3449ed98953SRafael J. Wysocki } 3459ed98953SRafael J. Wysocki 3469ed98953SRafael J. Wysocki /** 347494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 348494fd7b7SFeng Kan * @dev: Device to move 349494fd7b7SFeng Kan * 350494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 351494fd7b7SFeng Kan * 352494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 353494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 354494fd7b7SFeng Kan */ 355494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 356494fd7b7SFeng Kan { 357494fd7b7SFeng Kan int idx; 358494fd7b7SFeng Kan 359494fd7b7SFeng Kan idx = device_links_read_lock(); 360494fd7b7SFeng Kan device_pm_lock(); 361494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 362494fd7b7SFeng Kan device_pm_unlock(); 363494fd7b7SFeng Kan device_links_read_unlock(idx); 364494fd7b7SFeng Kan } 365494fd7b7SFeng Kan 366287905e6SSaravana Kannan #define to_devlink(dev) container_of((dev), struct device_link, link_dev) 367287905e6SSaravana Kannan 368287905e6SSaravana Kannan static ssize_t status_show(struct device *dev, 369287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 370287905e6SSaravana Kannan { 371948b3edbSJoe Perches const char *output; 372287905e6SSaravana Kannan 373287905e6SSaravana Kannan switch (to_devlink(dev)->status) { 374287905e6SSaravana Kannan case DL_STATE_NONE: 375948b3edbSJoe Perches output = "not tracked"; 376948b3edbSJoe Perches break; 377287905e6SSaravana Kannan case DL_STATE_DORMANT: 378948b3edbSJoe Perches output = "dormant"; 379948b3edbSJoe Perches break; 380287905e6SSaravana Kannan case DL_STATE_AVAILABLE: 381948b3edbSJoe Perches output = "available"; 382948b3edbSJoe Perches break; 383287905e6SSaravana Kannan case DL_STATE_CONSUMER_PROBE: 384948b3edbSJoe Perches output = "consumer probing"; 385948b3edbSJoe Perches break; 386287905e6SSaravana Kannan case DL_STATE_ACTIVE: 387948b3edbSJoe Perches output = "active"; 388948b3edbSJoe Perches break; 389287905e6SSaravana Kannan case DL_STATE_SUPPLIER_UNBIND: 390948b3edbSJoe Perches output = "supplier unbinding"; 391948b3edbSJoe Perches break; 392287905e6SSaravana Kannan default: 393948b3edbSJoe Perches output = "unknown"; 394948b3edbSJoe Perches break; 395287905e6SSaravana Kannan } 396948b3edbSJoe Perches 397948b3edbSJoe Perches return sysfs_emit(buf, "%s\n", output); 398287905e6SSaravana Kannan } 399287905e6SSaravana Kannan static DEVICE_ATTR_RO(status); 400287905e6SSaravana Kannan 401287905e6SSaravana Kannan static ssize_t auto_remove_on_show(struct device *dev, 402287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 403287905e6SSaravana Kannan { 404287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 405973c3911SJoe Perches const char *output; 406287905e6SSaravana Kannan 407287905e6SSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 408973c3911SJoe Perches output = "supplier unbind"; 409287905e6SSaravana Kannan else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 410973c3911SJoe Perches output = "consumer unbind"; 411287905e6SSaravana Kannan else 412973c3911SJoe Perches output = "never"; 413287905e6SSaravana Kannan 414973c3911SJoe Perches return sysfs_emit(buf, "%s\n", output); 415287905e6SSaravana Kannan } 416287905e6SSaravana Kannan static DEVICE_ATTR_RO(auto_remove_on); 417287905e6SSaravana Kannan 418287905e6SSaravana Kannan static ssize_t runtime_pm_show(struct device *dev, 419287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 420287905e6SSaravana Kannan { 421287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 422287905e6SSaravana Kannan 423aa838896SJoe Perches return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); 424287905e6SSaravana Kannan } 425287905e6SSaravana Kannan static DEVICE_ATTR_RO(runtime_pm); 426287905e6SSaravana Kannan 427287905e6SSaravana Kannan static ssize_t sync_state_only_show(struct device *dev, 428287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 429287905e6SSaravana Kannan { 430287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 431287905e6SSaravana Kannan 432aa838896SJoe Perches return sysfs_emit(buf, "%d\n", 433aa838896SJoe Perches !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 434287905e6SSaravana Kannan } 435287905e6SSaravana Kannan static DEVICE_ATTR_RO(sync_state_only); 436287905e6SSaravana Kannan 437287905e6SSaravana Kannan static struct attribute *devlink_attrs[] = { 438287905e6SSaravana Kannan &dev_attr_status.attr, 439287905e6SSaravana Kannan &dev_attr_auto_remove_on.attr, 440287905e6SSaravana Kannan &dev_attr_runtime_pm.attr, 441287905e6SSaravana Kannan &dev_attr_sync_state_only.attr, 442287905e6SSaravana Kannan NULL, 443287905e6SSaravana Kannan }; 444287905e6SSaravana Kannan ATTRIBUTE_GROUPS(devlink); 445287905e6SSaravana Kannan 446843e600bSSaravana Kannan static void device_link_free(struct device_link *link) 447843e600bSSaravana Kannan { 448843e600bSSaravana Kannan while (refcount_dec_not_one(&link->rpm_active)) 449843e600bSSaravana Kannan pm_runtime_put(link->supplier); 450843e600bSSaravana Kannan 451843e600bSSaravana Kannan put_device(link->consumer); 452843e600bSSaravana Kannan put_device(link->supplier); 453843e600bSSaravana Kannan kfree(link); 454843e600bSSaravana Kannan } 455843e600bSSaravana Kannan 456843e600bSSaravana Kannan #ifdef CONFIG_SRCU 457843e600bSSaravana Kannan static void __device_link_free_srcu(struct rcu_head *rhead) 458843e600bSSaravana Kannan { 459843e600bSSaravana Kannan device_link_free(container_of(rhead, struct device_link, rcu_head)); 460843e600bSSaravana Kannan } 461843e600bSSaravana Kannan 462287905e6SSaravana Kannan static void devlink_dev_release(struct device *dev) 463287905e6SSaravana Kannan { 464843e600bSSaravana Kannan struct device_link *link = to_devlink(dev); 465843e600bSSaravana Kannan 466843e600bSSaravana Kannan call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 467287905e6SSaravana Kannan } 468843e600bSSaravana Kannan #else 469843e600bSSaravana Kannan static void devlink_dev_release(struct device *dev) 470843e600bSSaravana Kannan { 471843e600bSSaravana Kannan device_link_free(to_devlink(dev)); 472843e600bSSaravana Kannan } 473843e600bSSaravana Kannan #endif 474287905e6SSaravana Kannan 475287905e6SSaravana Kannan static struct class devlink_class = { 476287905e6SSaravana Kannan .name = "devlink", 477287905e6SSaravana Kannan .owner = THIS_MODULE, 478287905e6SSaravana Kannan .dev_groups = devlink_groups, 479287905e6SSaravana Kannan .dev_release = devlink_dev_release, 480287905e6SSaravana Kannan }; 481287905e6SSaravana Kannan 482287905e6SSaravana Kannan static int devlink_add_symlinks(struct device *dev, 483287905e6SSaravana Kannan struct class_interface *class_intf) 484287905e6SSaravana Kannan { 485287905e6SSaravana Kannan int ret; 486287905e6SSaravana Kannan size_t len; 487287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 488287905e6SSaravana Kannan struct device *sup = link->supplier; 489287905e6SSaravana Kannan struct device *con = link->consumer; 490287905e6SSaravana Kannan char *buf; 491287905e6SSaravana Kannan 492e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 493e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 494e020ff61SSaravana Kannan len += strlen(":"); 495287905e6SSaravana Kannan len += strlen("supplier:") + 1; 496287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 497287905e6SSaravana Kannan if (!buf) 498287905e6SSaravana Kannan return -ENOMEM; 499287905e6SSaravana Kannan 500287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); 501287905e6SSaravana Kannan if (ret) 502287905e6SSaravana Kannan goto out; 503287905e6SSaravana Kannan 504287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); 505287905e6SSaravana Kannan if (ret) 506287905e6SSaravana Kannan goto err_con; 507287905e6SSaravana Kannan 508e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 509287905e6SSaravana Kannan ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); 510287905e6SSaravana Kannan if (ret) 511287905e6SSaravana Kannan goto err_con_dev; 512287905e6SSaravana Kannan 513e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 514287905e6SSaravana Kannan ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); 515287905e6SSaravana Kannan if (ret) 516287905e6SSaravana Kannan goto err_sup_dev; 517287905e6SSaravana Kannan 518287905e6SSaravana Kannan goto out; 519287905e6SSaravana Kannan 520287905e6SSaravana Kannan err_sup_dev: 521e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 522287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 523287905e6SSaravana Kannan err_con_dev: 524287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 525287905e6SSaravana Kannan err_con: 526287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 527287905e6SSaravana Kannan out: 528287905e6SSaravana Kannan kfree(buf); 529287905e6SSaravana Kannan return ret; 530287905e6SSaravana Kannan } 531287905e6SSaravana Kannan 532287905e6SSaravana Kannan static void devlink_remove_symlinks(struct device *dev, 533287905e6SSaravana Kannan struct class_interface *class_intf) 534287905e6SSaravana Kannan { 535287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 536287905e6SSaravana Kannan size_t len; 537287905e6SSaravana Kannan struct device *sup = link->supplier; 538287905e6SSaravana Kannan struct device *con = link->consumer; 539287905e6SSaravana Kannan char *buf; 540287905e6SSaravana Kannan 541287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 542287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 543287905e6SSaravana Kannan 544e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 545e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 546e020ff61SSaravana Kannan len += strlen(":"); 547287905e6SSaravana Kannan len += strlen("supplier:") + 1; 548287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 549287905e6SSaravana Kannan if (!buf) { 550287905e6SSaravana Kannan WARN(1, "Unable to properly free device link symlinks!\n"); 551287905e6SSaravana Kannan return; 552287905e6SSaravana Kannan } 553287905e6SSaravana Kannan 554e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 555287905e6SSaravana Kannan sysfs_remove_link(&con->kobj, buf); 556e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 557287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 558287905e6SSaravana Kannan kfree(buf); 559287905e6SSaravana Kannan } 560287905e6SSaravana Kannan 561287905e6SSaravana Kannan static struct class_interface devlink_class_intf = { 562287905e6SSaravana Kannan .class = &devlink_class, 563287905e6SSaravana Kannan .add_dev = devlink_add_symlinks, 564287905e6SSaravana Kannan .remove_dev = devlink_remove_symlinks, 565287905e6SSaravana Kannan }; 566287905e6SSaravana Kannan 567287905e6SSaravana Kannan static int __init devlink_class_init(void) 568287905e6SSaravana Kannan { 569287905e6SSaravana Kannan int ret; 570287905e6SSaravana Kannan 571287905e6SSaravana Kannan ret = class_register(&devlink_class); 572287905e6SSaravana Kannan if (ret) 573287905e6SSaravana Kannan return ret; 574287905e6SSaravana Kannan 575287905e6SSaravana Kannan ret = class_interface_register(&devlink_class_intf); 576287905e6SSaravana Kannan if (ret) 577287905e6SSaravana Kannan class_unregister(&devlink_class); 578287905e6SSaravana Kannan 579287905e6SSaravana Kannan return ret; 580287905e6SSaravana Kannan } 581287905e6SSaravana Kannan postcore_initcall(devlink_class_init); 582287905e6SSaravana Kannan 583515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 584515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 58505ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 5864b9bbb29SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY | \ 5874b9bbb29SSaravana Kannan DL_FLAG_INFERRED) 588515db266SRafael J. Wysocki 589fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 590fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 591fb583c8eSRafael J. Wysocki 592494fd7b7SFeng Kan /** 5939ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 5949ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 5959ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 5969ed98953SRafael J. Wysocki * @flags: Link flags. 5979ed98953SRafael J. Wysocki * 59821d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 59921d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 60021d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 60121d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 60221d5c57bSRafael J. Wysocki * be forced into the active meta state and reference-counted upon the creation 60321d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 60421d5c57bSRafael J. Wysocki * ignored. 60521d5c57bSRafael J. Wysocki * 606515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 607515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 608515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 60972175d4eSRafael J. Wysocki * 61072175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 61172175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 61272175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 61372175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 61472175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 61572175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 61672175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 61772175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 61872175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 61972175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 62072175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 621c8d50986SRafael J. Wysocki * 622e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 623e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 624e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 625d475f8eaSThierry Reding * be used to request the driver core to automatically probe for a consumer 626e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 627e7dd4010SRafael J. Wysocki * 628515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 629515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 630515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 631515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 632515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 633515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 634515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 635515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 636515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 637515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 6389ed98953SRafael J. Wysocki * 6399ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 6409ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 6419ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 6429ed98953SRafael J. Wysocki * not been registered when this function is called). 6439ed98953SRafael J. Wysocki * 6449ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 6459ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 64664df1148SLukas Wunner * not be registered, however. 6479ed98953SRafael J. Wysocki */ 6489ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 6499ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 6509ed98953SRafael J. Wysocki { 6519ed98953SRafael J. Wysocki struct device_link *link; 6529ed98953SRafael J. Wysocki 653fb583c8eSRafael J. Wysocki if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || 654515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 65505ef983eSSaravana Kannan (flags & DL_FLAG_SYNC_STATE_ONLY && 6564b9bbb29SSaravana Kannan (flags & ~DL_FLAG_INFERRED) != DL_FLAG_SYNC_STATE_ONLY) || 657e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 658e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 659e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 6609ed98953SRafael J. Wysocki return NULL; 6619ed98953SRafael J. Wysocki 6625db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 6635db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 6645db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 6655db25c9eSRafael J. Wysocki return NULL; 6665db25c9eSRafael J. Wysocki } 6675db25c9eSRafael J. Wysocki } 6685db25c9eSRafael J. Wysocki 669515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 670515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 671515db266SRafael J. Wysocki 6729ed98953SRafael J. Wysocki device_links_write_lock(); 6739ed98953SRafael J. Wysocki device_pm_lock(); 6749ed98953SRafael J. Wysocki 6759ed98953SRafael J. Wysocki /* 6769ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 67705ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 67805ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 67905ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 68005ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 6819ed98953SRafael J. Wysocki */ 6829ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 68305ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 68405ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 6859ed98953SRafael J. Wysocki link = NULL; 6869ed98953SRafael J. Wysocki goto out; 6879ed98953SRafael J. Wysocki } 6889ed98953SRafael J. Wysocki 68972175d4eSRafael J. Wysocki /* 690ac66c5bbSSaravana Kannan * SYNC_STATE_ONLY links are useless once a consumer device has probed. 691ac66c5bbSSaravana Kannan * So, only create it if the consumer hasn't probed yet. 692ac66c5bbSSaravana Kannan */ 693ac66c5bbSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY && 694ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_NO_DRIVER && 695ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_PROBING) { 696ac66c5bbSSaravana Kannan link = NULL; 697ac66c5bbSSaravana Kannan goto out; 698ac66c5bbSSaravana Kannan } 699ac66c5bbSSaravana Kannan 700ac66c5bbSSaravana Kannan /* 70172175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 70272175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 70372175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 70472175d4eSRafael J. Wysocki */ 70572175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 70672175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 70772175d4eSRafael J. Wysocki 708f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 709f265df55SRafael J. Wysocki if (link->consumer != consumer) 710f265df55SRafael J. Wysocki continue; 711f265df55SRafael J. Wysocki 7124b9bbb29SSaravana Kannan if (link->flags & DL_FLAG_INFERRED && 7134b9bbb29SSaravana Kannan !(flags & DL_FLAG_INFERRED)) 7144b9bbb29SSaravana Kannan link->flags &= ~DL_FLAG_INFERRED; 7154b9bbb29SSaravana Kannan 716e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 717e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 7184c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 719e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 720e2f3cd83SRafael J. Wysocki } 721e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 72236003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 723e2f3cd83SRafael J. Wysocki } 724e2f3cd83SRafael J. Wysocki 72572175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 726ead18c23SLukas Wunner kref_get(&link->kref); 72721c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 72844e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 72944e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 73005ef983eSSaravana Kannan goto reorder; 73144e96049SSaravana Kannan } else { 73244e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 7339ed98953SRafael J. Wysocki goto out; 734ead18c23SLukas Wunner } 73544e96049SSaravana Kannan } 7369ed98953SRafael J. Wysocki 73772175d4eSRafael J. Wysocki /* 73872175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 73972175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 74072175d4eSRafael J. Wysocki * update the existing link to stay around longer. 74172175d4eSRafael J. Wysocki */ 74272175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 74372175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 74472175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 74572175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 74672175d4eSRafael J. Wysocki } 74772175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 74872175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 74972175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 75072175d4eSRafael J. Wysocki } 751515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 752515db266SRafael J. Wysocki kref_get(&link->kref); 753515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 754515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 755515db266SRafael J. Wysocki } 75605ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 75705ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 75805ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 75905ef983eSSaravana Kannan goto reorder; 76005ef983eSSaravana Kannan } 76105ef983eSSaravana Kannan 76272175d4eSRafael J. Wysocki goto out; 76372175d4eSRafael J. Wysocki } 76472175d4eSRafael J. Wysocki 76521d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 7669ed98953SRafael J. Wysocki if (!link) 7679ed98953SRafael J. Wysocki goto out; 7689ed98953SRafael J. Wysocki 769e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 770e2f3cd83SRafael J. Wysocki 7719ed98953SRafael J. Wysocki get_device(supplier); 7729ed98953SRafael J. Wysocki link->supplier = supplier; 7739ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 7749ed98953SRafael J. Wysocki get_device(consumer); 7759ed98953SRafael J. Wysocki link->consumer = consumer; 7769ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 7779ed98953SRafael J. Wysocki link->flags = flags; 778ead18c23SLukas Wunner kref_init(&link->kref); 7799ed98953SRafael J. Wysocki 780287905e6SSaravana Kannan link->link_dev.class = &devlink_class; 781287905e6SSaravana Kannan device_set_pm_not_required(&link->link_dev); 782e020ff61SSaravana Kannan dev_set_name(&link->link_dev, "%s:%s--%s:%s", 783e020ff61SSaravana Kannan dev_bus_name(supplier), dev_name(supplier), 784e020ff61SSaravana Kannan dev_bus_name(consumer), dev_name(consumer)); 785287905e6SSaravana Kannan if (device_register(&link->link_dev)) { 786287905e6SSaravana Kannan put_device(consumer); 787287905e6SSaravana Kannan put_device(supplier); 788287905e6SSaravana Kannan kfree(link); 789287905e6SSaravana Kannan link = NULL; 790287905e6SSaravana Kannan goto out; 791287905e6SSaravana Kannan } 792287905e6SSaravana Kannan 793287905e6SSaravana Kannan if (flags & DL_FLAG_PM_RUNTIME) { 794287905e6SSaravana Kannan if (flags & DL_FLAG_RPM_ACTIVE) 795287905e6SSaravana Kannan refcount_inc(&link->rpm_active); 796287905e6SSaravana Kannan 797287905e6SSaravana Kannan pm_runtime_new_link(consumer); 798287905e6SSaravana Kannan } 799287905e6SSaravana Kannan 80064df1148SLukas Wunner /* Determine the initial link state. */ 801515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 8029ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 803515db266SRafael J. Wysocki else 804515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 8059ed98953SRafael J. Wysocki 8069ed98953SRafael J. Wysocki /* 80715cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 80815cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 80915cfb094SRafael J. Wysocki */ 81015cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 81115cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 81215cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 81315cfb094SRafael J. Wysocki 81421c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 81521c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 81621c27f06SSaravana Kannan 81705ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 81805ef983eSSaravana Kannan dev_dbg(consumer, 81905ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 82005ef983eSSaravana Kannan dev_name(supplier)); 82105ef983eSSaravana Kannan goto out; 82205ef983eSSaravana Kannan } 82321c27f06SSaravana Kannan 82405ef983eSSaravana Kannan reorder: 82515cfb094SRafael J. Wysocki /* 8269ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 8279ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 8289ed98953SRafael J. Wysocki * 8299ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 8309ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 8319ed98953SRafael J. Wysocki */ 8329ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 8339ed98953SRafael J. Wysocki 8348a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 8359ed98953SRafael J. Wysocki 8369ed98953SRafael J. Wysocki out: 8379ed98953SRafael J. Wysocki device_pm_unlock(); 8389ed98953SRafael J. Wysocki device_links_write_unlock(); 8395db25c9eSRafael J. Wysocki 840e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 8415db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 8425db25c9eSRafael J. Wysocki 8439ed98953SRafael J. Wysocki return link; 8449ed98953SRafael J. Wysocki } 8459ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 8469ed98953SRafael J. Wysocki 8479ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 848ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 8499ed98953SRafael J. Wysocki { 850ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 851ead18c23SLukas Wunner 8528a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 8539ed98953SRafael J. Wysocki dev_name(link->supplier)); 8549ed98953SRafael J. Wysocki 855e0e398e2SRafael J. Wysocki pm_runtime_drop_link(link); 856baa8809fSRafael J. Wysocki 8579ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 8589ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 859843e600bSSaravana Kannan device_unregister(&link->link_dev); 8609ed98953SRafael J. Wysocki } 8619ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 862ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 8639ed98953SRafael J. Wysocki { 864ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 865ead18c23SLukas Wunner 8669ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 8679ed98953SRafael J. Wysocki dev_name(link->supplier)); 8689ed98953SRafael J. Wysocki 869e0e398e2SRafael J. Wysocki pm_runtime_drop_link(link); 870433986c2SLukas Wunner 8719ed98953SRafael J. Wysocki list_del(&link->s_node); 8729ed98953SRafael J. Wysocki list_del(&link->c_node); 873843e600bSSaravana Kannan device_unregister(&link->link_dev); 8749ed98953SRafael J. Wysocki } 8759ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 8769ed98953SRafael J. Wysocki 87772175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 87872175d4eSRafael J. Wysocki { 87972175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 88072175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 88172175d4eSRafael J. Wysocki else 88272175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 88372175d4eSRafael J. Wysocki } 88472175d4eSRafael J. Wysocki 8859ed98953SRafael J. Wysocki /** 88672175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 8879ed98953SRafael J. Wysocki * @link: Device link to delete. 8889ed98953SRafael J. Wysocki * 8899ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 890ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 891ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 892ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 8939ed98953SRafael J. Wysocki */ 8949ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 8959ed98953SRafael J. Wysocki { 8969ed98953SRafael J. Wysocki device_links_write_lock(); 89772175d4eSRafael J. Wysocki device_link_put_kref(link); 8989ed98953SRafael J. Wysocki device_links_write_unlock(); 8999ed98953SRafael J. Wysocki } 9009ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 9019ed98953SRafael J. Wysocki 902d8842211Spascal paillet /** 90372175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 904d8842211Spascal paillet * @consumer: Consumer end of the link. 905d8842211Spascal paillet * @supplier: Supplier end of the link. 906d8842211Spascal paillet * 907d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 908d8842211Spascal paillet * PM. 909d8842211Spascal paillet */ 910d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 911d8842211Spascal paillet { 912d8842211Spascal paillet struct device_link *link; 913d8842211Spascal paillet 914d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 915d8842211Spascal paillet return; 916d8842211Spascal paillet 917d8842211Spascal paillet device_links_write_lock(); 918d8842211Spascal paillet 919d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 920d8842211Spascal paillet if (link->consumer == consumer) { 92172175d4eSRafael J. Wysocki device_link_put_kref(link); 922d8842211Spascal paillet break; 923d8842211Spascal paillet } 924d8842211Spascal paillet } 925d8842211Spascal paillet 926d8842211Spascal paillet device_links_write_unlock(); 927d8842211Spascal paillet } 928d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 929d8842211Spascal paillet 9309ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 9319ed98953SRafael J. Wysocki { 9329ed98953SRafael J. Wysocki struct device_link *link; 9339ed98953SRafael J. Wysocki 9348c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) { 9358c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE) 9368c3e315dSSaravana Kannan continue; 9378c3e315dSSaravana Kannan 9388c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 9399ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 9408c3e315dSSaravana Kannan } else { 9418c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 9428c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 9438c3e315dSSaravana Kannan } 9448c3e315dSSaravana Kannan } 9459ed98953SRafael J. Wysocki } 9469ed98953SRafael J. Wysocki 9479ed98953SRafael J. Wysocki /** 9489ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 9499ed98953SRafael J. Wysocki * @dev: Consumer device. 9509ed98953SRafael J. Wysocki * 9519ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 9529ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 9539ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 9549ed98953SRafael J. Wysocki * 9559ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 9569ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 9579ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 9589ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 9599ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 9609ed98953SRafael J. Wysocki * 961515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9629ed98953SRafael J. Wysocki */ 9639ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 9649ed98953SRafael J. Wysocki { 9659ed98953SRafael J. Wysocki struct device_link *link; 9669ed98953SRafael J. Wysocki int ret = 0; 9679ed98953SRafael J. Wysocki 968e2ae9bccSSaravana Kannan /* 969e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 970e2ae9bccSSaravana Kannan * probe. 971e2ae9bccSSaravana Kannan */ 97225ac86c6SSaravana Kannan mutex_lock(&fwnode_link_lock); 97325ac86c6SSaravana Kannan if (dev->fwnode && !list_empty(&dev->fwnode->suppliers) && 97425ac86c6SSaravana Kannan !fw_devlink_is_permissive()) { 9751f0dfa05SSaravana Kannan dev_dbg(dev, "probe deferral - wait for supplier %pfwP\n", 9761f0dfa05SSaravana Kannan list_first_entry(&dev->fwnode->suppliers, 9771f0dfa05SSaravana Kannan struct fwnode_link, 9781f0dfa05SSaravana Kannan c_hook)->supplier); 97925ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock); 980e2ae9bccSSaravana Kannan return -EPROBE_DEFER; 981e2ae9bccSSaravana Kannan } 98225ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock); 983e2ae9bccSSaravana Kannan 9849ed98953SRafael J. Wysocki device_links_write_lock(); 9859ed98953SRafael J. Wysocki 9869ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 9878c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 9889ed98953SRafael J. Wysocki continue; 9899ed98953SRafael J. Wysocki 9908c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE && 9918c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { 9929ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 9931f0dfa05SSaravana Kannan dev_dbg(dev, "probe deferral - supplier %s not ready\n", 9941f0dfa05SSaravana Kannan dev_name(link->supplier)); 9959ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 9969ed98953SRafael J. Wysocki break; 9979ed98953SRafael J. Wysocki } 9989ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 9999ed98953SRafael J. Wysocki } 10009ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 10019ed98953SRafael J. Wysocki 10029ed98953SRafael J. Wysocki device_links_write_unlock(); 10039ed98953SRafael J. Wysocki return ret; 10049ed98953SRafael J. Wysocki } 10059ed98953SRafael J. Wysocki 100626e77708SSaravana Kannan /** 100726e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 100826e77708SSaravana Kannan * @dev: Device to call sync_state() on 100926e77708SSaravana Kannan * @list: List head to queue the @dev on 101026e77708SSaravana Kannan * 101126e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 101226e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 101326e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 101426e77708SSaravana Kannan * device_links_write_lock() held. 101526e77708SSaravana Kannan * 101626e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 101726e77708SSaravana Kannan * on this list. 101826e77708SSaravana Kannan * 101926e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 102026e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 102126e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 102226e77708SSaravana Kannan * put_device() is called on this device. 102326e77708SSaravana Kannan */ 102426e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 102526e77708SSaravana Kannan struct list_head *list) 1026fc5a251dSSaravana Kannan { 1027fc5a251dSSaravana Kannan struct device_link *link; 1028fc5a251dSSaravana Kannan 102977036165SSaravana Kannan if (!dev_has_sync_state(dev)) 103077036165SSaravana Kannan return; 1031fc5a251dSSaravana Kannan if (dev->state_synced) 1032fc5a251dSSaravana Kannan return; 1033fc5a251dSSaravana Kannan 1034fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 1035fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1036fc5a251dSSaravana Kannan continue; 1037fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 1038fc5a251dSSaravana Kannan return; 1039fc5a251dSSaravana Kannan } 1040fc5a251dSSaravana Kannan 104126e77708SSaravana Kannan /* 104226e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 104326e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 104426e77708SSaravana Kannan * and probed before the list is flushed. 104526e77708SSaravana Kannan */ 104626e77708SSaravana Kannan dev->state_synced = true; 104726e77708SSaravana Kannan 10483b052a3eSSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 104926e77708SSaravana Kannan return; 105026e77708SSaravana Kannan 105126e77708SSaravana Kannan get_device(dev); 10523b052a3eSSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 105326e77708SSaravana Kannan } 105426e77708SSaravana Kannan 105526e77708SSaravana Kannan /** 105626e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 105726e77708SSaravana Kannan * @list: List of devices to call sync_state() on 105821eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 105926e77708SSaravana Kannan * 106026e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 106121eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 106221eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 106321eb93f4SSaravana Kannan * context where a device lock is already held. 106426e77708SSaravana Kannan */ 106521eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 106621eb93f4SSaravana Kannan struct device *dont_lock_dev) 106726e77708SSaravana Kannan { 106826e77708SSaravana Kannan struct device *dev, *tmp; 106926e77708SSaravana Kannan 10703b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 10713b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 107226e77708SSaravana Kannan 107321eb93f4SSaravana Kannan if (dev != dont_lock_dev) 107426e77708SSaravana Kannan device_lock(dev); 107526e77708SSaravana Kannan 1076fc5a251dSSaravana Kannan if (dev->bus->sync_state) 1077fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 1078fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 1079fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 1080fc5a251dSSaravana Kannan 108121eb93f4SSaravana Kannan if (dev != dont_lock_dev) 108226e77708SSaravana Kannan device_unlock(dev); 108326e77708SSaravana Kannan 108426e77708SSaravana Kannan put_device(dev); 108526e77708SSaravana Kannan } 1086fc5a251dSSaravana Kannan } 1087fc5a251dSSaravana Kannan 1088fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 1089fc5a251dSSaravana Kannan { 1090fc5a251dSSaravana Kannan device_links_write_lock(); 1091fc5a251dSSaravana Kannan defer_sync_state_count++; 1092fc5a251dSSaravana Kannan device_links_write_unlock(); 1093fc5a251dSSaravana Kannan } 1094fc5a251dSSaravana Kannan 1095fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 1096fc5a251dSSaravana Kannan { 1097fc5a251dSSaravana Kannan struct device *dev, *tmp; 109826e77708SSaravana Kannan LIST_HEAD(sync_list); 1099fc5a251dSSaravana Kannan 1100fc5a251dSSaravana Kannan device_links_write_lock(); 1101fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 1102fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 1103fc5a251dSSaravana Kannan goto out; 1104fc5a251dSSaravana Kannan } 1105fc5a251dSSaravana Kannan defer_sync_state_count--; 1106fc5a251dSSaravana Kannan if (defer_sync_state_count) 1107fc5a251dSSaravana Kannan goto out; 1108fc5a251dSSaravana Kannan 11093b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 111026e77708SSaravana Kannan /* 111126e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 11123b052a3eSSaravana Kannan * sync_list because defer_sync is used for both lists. 111326e77708SSaravana Kannan */ 11143b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 111526e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 1116fc5a251dSSaravana Kannan } 1117fc5a251dSSaravana Kannan out: 1118fc5a251dSSaravana Kannan device_links_write_unlock(); 111926e77708SSaravana Kannan 112021eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 1121fc5a251dSSaravana Kannan } 1122fc5a251dSSaravana Kannan 1123fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 1124fc5a251dSSaravana Kannan { 1125fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 1126fc5a251dSSaravana Kannan return 0; 1127fc5a251dSSaravana Kannan } 1128fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 1129fc5a251dSSaravana Kannan 1130fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 1131fc5a251dSSaravana Kannan { 11323b052a3eSSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 11333b052a3eSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 1134fc5a251dSSaravana Kannan } 1135fc5a251dSSaravana Kannan 113621c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link) 113721c27f06SSaravana Kannan { 113821c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED; 113921c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE); 114021c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del); 114121c27f06SSaravana Kannan } 114221c27f06SSaravana Kannan 1143da6d6475SSaravana Kannan static ssize_t waiting_for_supplier_show(struct device *dev, 1144da6d6475SSaravana Kannan struct device_attribute *attr, 1145da6d6475SSaravana Kannan char *buf) 1146da6d6475SSaravana Kannan { 1147da6d6475SSaravana Kannan bool val; 1148da6d6475SSaravana Kannan 1149da6d6475SSaravana Kannan device_lock(dev); 115025ac86c6SSaravana Kannan val = !list_empty(&dev->fwnode->suppliers); 1151da6d6475SSaravana Kannan device_unlock(dev); 1152aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 1153da6d6475SSaravana Kannan } 1154da6d6475SSaravana Kannan static DEVICE_ATTR_RO(waiting_for_supplier); 1155da6d6475SSaravana Kannan 11569ed98953SRafael J. Wysocki /** 1157b6f617dfSSaravana Kannan * device_links_force_bind - Prepares device to be force bound 1158b6f617dfSSaravana Kannan * @dev: Consumer device. 1159b6f617dfSSaravana Kannan * 1160b6f617dfSSaravana Kannan * device_bind_driver() force binds a device to a driver without calling any 1161b6f617dfSSaravana Kannan * driver probe functions. So the consumer really isn't going to wait for any 1162b6f617dfSSaravana Kannan * supplier before it's bound to the driver. We still want the device link 1163b6f617dfSSaravana Kannan * states to be sensible when this happens. 1164b6f617dfSSaravana Kannan * 1165b6f617dfSSaravana Kannan * In preparation for device_bind_driver(), this function goes through each 1166b6f617dfSSaravana Kannan * supplier device links and checks if the supplier is bound. If it is, then 1167b6f617dfSSaravana Kannan * the device link status is set to CONSUMER_PROBE. Otherwise, the device link 1168b6f617dfSSaravana Kannan * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored. 1169b6f617dfSSaravana Kannan */ 1170b6f617dfSSaravana Kannan void device_links_force_bind(struct device *dev) 1171b6f617dfSSaravana Kannan { 1172b6f617dfSSaravana Kannan struct device_link *link, *ln; 1173b6f617dfSSaravana Kannan 1174b6f617dfSSaravana Kannan device_links_write_lock(); 1175b6f617dfSSaravana Kannan 1176b6f617dfSSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 1177b6f617dfSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1178b6f617dfSSaravana Kannan continue; 1179b6f617dfSSaravana Kannan 1180b6f617dfSSaravana Kannan if (link->status != DL_STATE_AVAILABLE) { 1181b6f617dfSSaravana Kannan device_link_drop_managed(link); 1182b6f617dfSSaravana Kannan continue; 1183b6f617dfSSaravana Kannan } 1184b6f617dfSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 1185b6f617dfSSaravana Kannan } 1186b6f617dfSSaravana Kannan dev->links.status = DL_DEV_PROBING; 1187b6f617dfSSaravana Kannan 1188b6f617dfSSaravana Kannan device_links_write_unlock(); 1189b6f617dfSSaravana Kannan } 1190b6f617dfSSaravana Kannan 1191b6f617dfSSaravana Kannan /** 11929ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 11939ed98953SRafael J. Wysocki * @dev: Device to update the links for. 11949ed98953SRafael J. Wysocki * 11959ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 11969ed98953SRafael J. Wysocki * consumers by changing their status to "available". 11979ed98953SRafael J. Wysocki * 11989ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 11999ed98953SRafael J. Wysocki * 1200515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 12019ed98953SRafael J. Wysocki */ 12029ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 12039ed98953SRafael J. Wysocki { 120421c27f06SSaravana Kannan struct device_link *link, *ln; 120526e77708SSaravana Kannan LIST_HEAD(sync_list); 12069ed98953SRafael J. Wysocki 1207bcbbcfd5SSaravana Kannan /* 12089528e0d9SSaravana Kannan * If a device binds successfully, it's expected to have created all 1209bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 12109528e0d9SSaravana Kannan * them. So, fw_devlink no longer needs to create device links to any 12119528e0d9SSaravana Kannan * of the device's suppliers. 12129528e0d9SSaravana Kannan * 12139528e0d9SSaravana Kannan * Also, if a child firmware node of this bound device is not added as 12149528e0d9SSaravana Kannan * a device by now, assume it is never going to be added and make sure 12159528e0d9SSaravana Kannan * other devices don't defer probe indefinitely by waiting for such a 12169528e0d9SSaravana Kannan * child device. 1217bcbbcfd5SSaravana Kannan */ 12189528e0d9SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) { 12199528e0d9SSaravana Kannan struct fwnode_handle *child; 1220f9aa4606SSaravana Kannan fwnode_links_purge_suppliers(dev->fwnode); 12219528e0d9SSaravana Kannan fwnode_for_each_available_child_node(dev->fwnode, child) 12229528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 12239528e0d9SSaravana Kannan } 1224da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 1225bcbbcfd5SSaravana Kannan 12269ed98953SRafael J. Wysocki device_links_write_lock(); 12279ed98953SRafael J. Wysocki 12289ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1229515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 12309ed98953SRafael J. Wysocki continue; 12319ed98953SRafael J. Wysocki 123215cfb094SRafael J. Wysocki /* 123315cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 123415cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 123515cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 123615cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 123715cfb094SRafael J. Wysocki */ 123815cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 123915cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 124015cfb094SRafael J. Wysocki continue; 124115cfb094SRafael J. Wysocki 12429ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 12439ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 1244e7dd4010SRafael J. Wysocki 1245e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 1246e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 12479ed98953SRafael J. Wysocki } 12489ed98953SRafael J. Wysocki 124921eb93f4SSaravana Kannan if (defer_sync_state_count) 125021eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 125121eb93f4SSaravana Kannan else 125221eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 125321eb93f4SSaravana Kannan 125421c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 125521c27f06SSaravana Kannan struct device *supplier; 125621c27f06SSaravana Kannan 1257515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 12589ed98953SRafael J. Wysocki continue; 12599ed98953SRafael J. Wysocki 126021c27f06SSaravana Kannan supplier = link->supplier; 126121c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { 126221c27f06SSaravana Kannan /* 126321c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no 126421c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's 126521c27f06SSaravana Kannan * save to drop the managed link completely. 126621c27f06SSaravana Kannan */ 126721c27f06SSaravana Kannan device_link_drop_managed(link); 126821c27f06SSaravana Kannan } else { 12699ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 12709ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 127121c27f06SSaravana Kannan } 1272fc5a251dSSaravana Kannan 127321c27f06SSaravana Kannan /* 127421c27f06SSaravana Kannan * This needs to be done even for the deleted 127521c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last 127621c27f06SSaravana Kannan * device link that was preventing the supplier from getting a 127721c27f06SSaravana Kannan * sync_state() call. 127821c27f06SSaravana Kannan */ 1279fc5a251dSSaravana Kannan if (defer_sync_state_count) 128021c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier); 1281fc5a251dSSaravana Kannan else 128221c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list); 12839ed98953SRafael J. Wysocki } 12849ed98953SRafael J. Wysocki 12859ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 12869ed98953SRafael J. Wysocki 12879ed98953SRafael J. Wysocki device_links_write_unlock(); 128826e77708SSaravana Kannan 128921eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 12909ed98953SRafael J. Wysocki } 12919ed98953SRafael J. Wysocki 12929ed98953SRafael J. Wysocki /** 12939ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 12949ed98953SRafael J. Wysocki * @dev: Device without a drvier. 12959ed98953SRafael J. Wysocki * 12969ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 12979ed98953SRafael J. Wysocki * 12989ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 12999ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 13009ed98953SRafael J. Wysocki * case they need not be updated. 13019ed98953SRafael J. Wysocki * 1302515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 13039ed98953SRafael J. Wysocki */ 13049ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 13059ed98953SRafael J. Wysocki { 13069ed98953SRafael J. Wysocki struct device_link *link, *ln; 13079ed98953SRafael J. Wysocki 13089ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 1309515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13109ed98953SRafael J. Wysocki continue; 13119ed98953SRafael J. Wysocki 13128c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 1313515db266SRafael J. Wysocki device_link_drop_managed(link); 13148c3e315dSSaravana Kannan continue; 13158c3e315dSSaravana Kannan } 13168c3e315dSSaravana Kannan 13178c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE && 13188c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE) 13198c3e315dSSaravana Kannan continue; 13208c3e315dSSaravana Kannan 13218c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 13229ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 13238c3e315dSSaravana Kannan } else { 13248c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 13258c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 13268c3e315dSSaravana Kannan } 13279ed98953SRafael J. Wysocki } 13289ed98953SRafael J. Wysocki 13299ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 13309ed98953SRafael J. Wysocki } 13319ed98953SRafael J. Wysocki 133215cfb094SRafael J. Wysocki /** 133315cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 133415cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 133515cfb094SRafael J. Wysocki * 133615cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 133715cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 133815cfb094SRafael J. Wysocki * appropriate. 133915cfb094SRafael J. Wysocki * 1340515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 134115cfb094SRafael J. Wysocki */ 13429ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 13439ed98953SRafael J. Wysocki { 134415cfb094SRafael J. Wysocki struct device_link *link; 134515cfb094SRafael J. Wysocki 13469ed98953SRafael J. Wysocki device_links_write_lock(); 134715cfb094SRafael J. Wysocki 134815cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1349515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 135015cfb094SRafael J. Wysocki continue; 135115cfb094SRafael J. Wysocki 135215cfb094SRafael J. Wysocki /* 135315cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 135415cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 135515cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 135615cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 135715cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 135815cfb094SRafael J. Wysocki */ 135915cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 136015cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 136115cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 136215cfb094SRafael J. Wysocki } 136315cfb094SRafael J. Wysocki 13649ed98953SRafael J. Wysocki __device_links_no_driver(dev); 136515cfb094SRafael J. Wysocki 13669ed98953SRafael J. Wysocki device_links_write_unlock(); 13679ed98953SRafael J. Wysocki } 13689ed98953SRafael J. Wysocki 13699ed98953SRafael J. Wysocki /** 13709ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 13719ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 13729ed98953SRafael J. Wysocki * 13739ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 13749ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 13759ed98953SRafael J. Wysocki * appropriate. 13769ed98953SRafael J. Wysocki * 1377515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 13789ed98953SRafael J. Wysocki */ 13799ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 13809ed98953SRafael J. Wysocki { 1381c8d50986SRafael J. Wysocki struct device_link *link, *ln; 13829ed98953SRafael J. Wysocki 13839ed98953SRafael J. Wysocki device_links_write_lock(); 13849ed98953SRafael J. Wysocki 1385c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1386515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13879ed98953SRafael J. Wysocki continue; 13889ed98953SRafael J. Wysocki 1389e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 13909ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 13911689cac5SVivek Gautam 13921689cac5SVivek Gautam /* 13931689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 13941689cac5SVivek Gautam * devices that are not active, i.e. where the link state 13951689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 13961689cac5SVivek Gautam */ 13971689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 13981689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1399515db266SRafael J. Wysocki device_link_drop_managed(link); 14001689cac5SVivek Gautam 14019ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 14029ed98953SRafael J. Wysocki } 14039ed98953SRafael J. Wysocki 14043b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 14059ed98953SRafael J. Wysocki __device_links_no_driver(dev); 14069ed98953SRafael J. Wysocki 14079ed98953SRafael J. Wysocki device_links_write_unlock(); 14089ed98953SRafael J. Wysocki } 14099ed98953SRafael J. Wysocki 14109ed98953SRafael J. Wysocki /** 14119ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 14129ed98953SRafael J. Wysocki * @dev: Device to check. 14139ed98953SRafael J. Wysocki * 14149ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 14159ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 14169ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 14179ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 14189ed98953SRafael J. Wysocki * successfully going forward. 14199ed98953SRafael J. Wysocki * 14209ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 14219ed98953SRafael J. Wysocki * 1422515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14239ed98953SRafael J. Wysocki */ 14249ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 14259ed98953SRafael J. Wysocki { 14269ed98953SRafael J. Wysocki struct device_link *link; 14279ed98953SRafael J. Wysocki bool ret = false; 14289ed98953SRafael J. Wysocki 14299ed98953SRafael J. Wysocki device_links_write_lock(); 14309ed98953SRafael J. Wysocki 14319ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1432515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 14339ed98953SRafael J. Wysocki continue; 14349ed98953SRafael J. Wysocki 14359ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 14369ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 14379ed98953SRafael J. Wysocki ret = true; 14389ed98953SRafael J. Wysocki break; 14399ed98953SRafael J. Wysocki } 14409ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 14419ed98953SRafael J. Wysocki } 14429ed98953SRafael J. Wysocki 14439ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 14449ed98953SRafael J. Wysocki 14459ed98953SRafael J. Wysocki device_links_write_unlock(); 14469ed98953SRafael J. Wysocki return ret; 14479ed98953SRafael J. Wysocki } 14489ed98953SRafael J. Wysocki 14499ed98953SRafael J. Wysocki /** 14509ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 14519ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 14529ed98953SRafael J. Wysocki * 14539ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 14549ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 14559ed98953SRafael J. Wysocki * and start over. 14569ed98953SRafael J. Wysocki * 14579ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 14589ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 14599ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 14609ed98953SRafael J. Wysocki * changed the state of the link already). 14619ed98953SRafael J. Wysocki * 1462515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14639ed98953SRafael J. Wysocki */ 14649ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 14659ed98953SRafael J. Wysocki { 14669ed98953SRafael J. Wysocki struct device_link *link; 14679ed98953SRafael J. Wysocki 14689ed98953SRafael J. Wysocki start: 14699ed98953SRafael J. Wysocki device_links_write_lock(); 14709ed98953SRafael J. Wysocki 14719ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 14729ed98953SRafael J. Wysocki enum device_link_state status; 14739ed98953SRafael J. Wysocki 147405ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 147505ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 14769ed98953SRafael J. Wysocki continue; 14779ed98953SRafael J. Wysocki 14789ed98953SRafael J. Wysocki status = link->status; 14799ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 14809ed98953SRafael J. Wysocki device_links_write_unlock(); 14819ed98953SRafael J. Wysocki 14829ed98953SRafael J. Wysocki wait_for_device_probe(); 14839ed98953SRafael J. Wysocki goto start; 14849ed98953SRafael J. Wysocki } 14859ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 14869ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 14879ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 14889ed98953SRafael J. Wysocki 14899ed98953SRafael J. Wysocki get_device(consumer); 14909ed98953SRafael J. Wysocki 14919ed98953SRafael J. Wysocki device_links_write_unlock(); 14929ed98953SRafael J. Wysocki 14939ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 14949ed98953SRafael J. Wysocki consumer->parent); 14959ed98953SRafael J. Wysocki put_device(consumer); 14969ed98953SRafael J. Wysocki goto start; 14979ed98953SRafael J. Wysocki } 14989ed98953SRafael J. Wysocki } 14999ed98953SRafael J. Wysocki 15009ed98953SRafael J. Wysocki device_links_write_unlock(); 15019ed98953SRafael J. Wysocki } 15029ed98953SRafael J. Wysocki 15039ed98953SRafael J. Wysocki /** 15049ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 15059ed98953SRafael J. Wysocki * @dev: Target device. 15069ed98953SRafael J. Wysocki */ 15079ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 15089ed98953SRafael J. Wysocki { 15099ed98953SRafael J. Wysocki struct device_link *link, *ln; 15109ed98953SRafael J. Wysocki 1511287905e6SSaravana Kannan if (dev->class == &devlink_class) 1512287905e6SSaravana Kannan return; 1513287905e6SSaravana Kannan 15149ed98953SRafael J. Wysocki /* 15159ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 15169ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 15179ed98953SRafael J. Wysocki */ 15189ed98953SRafael J. Wysocki device_links_write_lock(); 15199ed98953SRafael J. Wysocki 15209ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 15219ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1522ead18c23SLukas Wunner __device_link_del(&link->kref); 15239ed98953SRafael J. Wysocki } 15249ed98953SRafael J. Wysocki 15259ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 15269ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 15279ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1528ead18c23SLukas Wunner __device_link_del(&link->kref); 15299ed98953SRafael J. Wysocki } 15309ed98953SRafael J. Wysocki 15319ed98953SRafael J. Wysocki device_links_write_unlock(); 15329ed98953SRafael J. Wysocki } 15339ed98953SRafael J. Wysocki 1534b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_PERMISSIVE (DL_FLAG_INFERRED | \ 1535b90fb8f6SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 1536b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_ON (DL_FLAG_INFERRED | \ 1537b90fb8f6SSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER) 1538b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_RPM (FW_DEVLINK_FLAGS_ON | \ 1539b90fb8f6SSaravana Kannan DL_FLAG_PM_RUNTIME) 1540b90fb8f6SSaravana Kannan 1541ea718c69SSaravana Kannan static u32 fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 154242926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 154342926ac3SSaravana Kannan { 154442926ac3SSaravana Kannan if (!arg) 154542926ac3SSaravana Kannan return -EINVAL; 154642926ac3SSaravana Kannan 154742926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 154842926ac3SSaravana Kannan fw_devlink_flags = 0; 154942926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 1550b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 155142926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 1552b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 155342926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 1554b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_RPM; 155542926ac3SSaravana Kannan } 155642926ac3SSaravana Kannan return 0; 155742926ac3SSaravana Kannan } 155842926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 155942926ac3SSaravana Kannan 156019d0f5f6SSaravana Kannan static bool fw_devlink_strict; 156119d0f5f6SSaravana Kannan static int __init fw_devlink_strict_setup(char *arg) 156219d0f5f6SSaravana Kannan { 156319d0f5f6SSaravana Kannan return strtobool(arg, &fw_devlink_strict); 156419d0f5f6SSaravana Kannan } 156519d0f5f6SSaravana Kannan early_param("fw_devlink.strict", fw_devlink_strict_setup); 156619d0f5f6SSaravana Kannan 156742926ac3SSaravana Kannan u32 fw_devlink_get_flags(void) 156842926ac3SSaravana Kannan { 156942926ac3SSaravana Kannan return fw_devlink_flags; 157042926ac3SSaravana Kannan } 157142926ac3SSaravana Kannan 157242926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 157342926ac3SSaravana Kannan { 1574b90fb8f6SSaravana Kannan return fw_devlink_flags == FW_DEVLINK_FLAGS_PERMISSIVE; 157542926ac3SSaravana Kannan } 157642926ac3SSaravana Kannan 157719d0f5f6SSaravana Kannan bool fw_devlink_is_strict(void) 157819d0f5f6SSaravana Kannan { 157919d0f5f6SSaravana Kannan return fw_devlink_strict && !fw_devlink_is_permissive(); 15809ed98953SRafael J. Wysocki } 15819ed98953SRafael J. Wysocki 1582c2c724c8SSaravana Kannan static void fw_devlink_parse_fwnode(struct fwnode_handle *fwnode) 1583c2c724c8SSaravana Kannan { 1584c2c724c8SSaravana Kannan if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) 1585c2c724c8SSaravana Kannan return; 1586c2c724c8SSaravana Kannan 15872d09e6ebSSaravana Kannan fwnode_call_int_op(fwnode, add_links); 1588c2c724c8SSaravana Kannan fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; 1589c2c724c8SSaravana Kannan } 1590c2c724c8SSaravana Kannan 1591c2c724c8SSaravana Kannan static void fw_devlink_parse_fwtree(struct fwnode_handle *fwnode) 1592c2c724c8SSaravana Kannan { 1593c2c724c8SSaravana Kannan struct fwnode_handle *child = NULL; 1594c2c724c8SSaravana Kannan 1595c2c724c8SSaravana Kannan fw_devlink_parse_fwnode(fwnode); 1596c2c724c8SSaravana Kannan 1597c2c724c8SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 1598c2c724c8SSaravana Kannan fw_devlink_parse_fwtree(child); 1599c2c724c8SSaravana Kannan } 1600c2c724c8SSaravana Kannan 1601f9aa4606SSaravana Kannan /** 1602b0e2fa4fSSaravana Kannan * fw_devlink_relax_cycle - Convert cyclic links to SYNC_STATE_ONLY links 1603b0e2fa4fSSaravana Kannan * @con: Device to check dependencies for. 1604b0e2fa4fSSaravana Kannan * @sup: Device to check against. 1605b0e2fa4fSSaravana Kannan * 1606b0e2fa4fSSaravana Kannan * Check if @sup depends on @con or any device dependent on it (its child or 1607b0e2fa4fSSaravana Kannan * its consumer etc). When such a cyclic dependency is found, convert all 1608b0e2fa4fSSaravana Kannan * device links created solely by fw_devlink into SYNC_STATE_ONLY device links. 1609b0e2fa4fSSaravana Kannan * This is the equivalent of doing fw_devlink=permissive just between the 1610b0e2fa4fSSaravana Kannan * devices in the cycle. We need to do this because, at this point, fw_devlink 1611b0e2fa4fSSaravana Kannan * can't tell which of these dependencies is not a real dependency. 1612b0e2fa4fSSaravana Kannan * 1613b0e2fa4fSSaravana Kannan * Return 1 if a cycle is found. Otherwise, return 0. 1614b0e2fa4fSSaravana Kannan */ 1615c13b8279Skernel test robot static int fw_devlink_relax_cycle(struct device *con, void *sup) 1616b0e2fa4fSSaravana Kannan { 1617b0e2fa4fSSaravana Kannan struct device_link *link; 1618b0e2fa4fSSaravana Kannan int ret; 1619b0e2fa4fSSaravana Kannan 1620b0e2fa4fSSaravana Kannan if (con == sup) 1621b0e2fa4fSSaravana Kannan return 1; 1622b0e2fa4fSSaravana Kannan 1623b0e2fa4fSSaravana Kannan ret = device_for_each_child(con, sup, fw_devlink_relax_cycle); 1624b0e2fa4fSSaravana Kannan if (ret) 1625b0e2fa4fSSaravana Kannan return ret; 1626b0e2fa4fSSaravana Kannan 1627b0e2fa4fSSaravana Kannan list_for_each_entry(link, &con->links.consumers, s_node) { 1628b0e2fa4fSSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 1629b0e2fa4fSSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 1630b0e2fa4fSSaravana Kannan continue; 1631b0e2fa4fSSaravana Kannan 1632b0e2fa4fSSaravana Kannan if (!fw_devlink_relax_cycle(link->consumer, sup)) 1633b0e2fa4fSSaravana Kannan continue; 1634b0e2fa4fSSaravana Kannan 1635b0e2fa4fSSaravana Kannan ret = 1; 1636b0e2fa4fSSaravana Kannan 1637b0e2fa4fSSaravana Kannan if (!(link->flags & DL_FLAG_INFERRED)) 1638b0e2fa4fSSaravana Kannan continue; 1639b0e2fa4fSSaravana Kannan 1640b0e2fa4fSSaravana Kannan pm_runtime_drop_link(link); 1641b0e2fa4fSSaravana Kannan link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; 1642b0e2fa4fSSaravana Kannan dev_dbg(link->consumer, "Relaxing link with %s\n", 1643b0e2fa4fSSaravana Kannan dev_name(link->supplier)); 1644b0e2fa4fSSaravana Kannan } 1645b0e2fa4fSSaravana Kannan return ret; 1646b0e2fa4fSSaravana Kannan } 1647b0e2fa4fSSaravana Kannan 1648b0e2fa4fSSaravana Kannan /** 1649f9aa4606SSaravana Kannan * fw_devlink_create_devlink - Create a device link from a consumer to fwnode 1650*37c52f74SPierre-Louis Bossart * @con: consumer device for the device link 1651*37c52f74SPierre-Louis Bossart * @sup_handle: fwnode handle of supplier 1652*37c52f74SPierre-Louis Bossart * @flags: devlink flags 1653f9aa4606SSaravana Kannan * 1654f9aa4606SSaravana Kannan * This function will try to create a device link between the consumer device 1655f9aa4606SSaravana Kannan * @con and the supplier device represented by @sup_handle. 1656f9aa4606SSaravana Kannan * 1657f9aa4606SSaravana Kannan * The supplier has to be provided as a fwnode because incorrect cycles in 1658f9aa4606SSaravana Kannan * fwnode links can sometimes cause the supplier device to never be created. 1659f9aa4606SSaravana Kannan * This function detects such cases and returns an error if it cannot create a 1660f9aa4606SSaravana Kannan * device link from the consumer to a missing supplier. 1661f9aa4606SSaravana Kannan * 1662f9aa4606SSaravana Kannan * Returns, 1663f9aa4606SSaravana Kannan * 0 on successfully creating a device link 1664f9aa4606SSaravana Kannan * -EINVAL if the device link cannot be created as expected 1665f9aa4606SSaravana Kannan * -EAGAIN if the device link cannot be created right now, but it may be 1666f9aa4606SSaravana Kannan * possible to do that in the future 1667f9aa4606SSaravana Kannan */ 1668f9aa4606SSaravana Kannan static int fw_devlink_create_devlink(struct device *con, 1669f9aa4606SSaravana Kannan struct fwnode_handle *sup_handle, u32 flags) 1670f9aa4606SSaravana Kannan { 1671f9aa4606SSaravana Kannan struct device *sup_dev; 1672f9aa4606SSaravana Kannan int ret = 0; 1673f9aa4606SSaravana Kannan 1674f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle); 1675f9aa4606SSaravana Kannan if (sup_dev) { 1676f9aa4606SSaravana Kannan /* 167774c782cfSSaravana Kannan * If it's one of those drivers that don't actually bind to 167874c782cfSSaravana Kannan * their device using driver core, then don't wait on this 167974c782cfSSaravana Kannan * supplier device indefinitely. 168074c782cfSSaravana Kannan */ 168174c782cfSSaravana Kannan if (sup_dev->links.status == DL_DEV_NO_DRIVER && 168274c782cfSSaravana Kannan sup_handle->flags & FWNODE_FLAG_INITIALIZED) { 168374c782cfSSaravana Kannan ret = -EINVAL; 168474c782cfSSaravana Kannan goto out; 168574c782cfSSaravana Kannan } 168674c782cfSSaravana Kannan 168774c782cfSSaravana Kannan /* 1688f9aa4606SSaravana Kannan * If this fails, it is due to cycles in device links. Just 1689f9aa4606SSaravana Kannan * give up on this link and treat it as invalid. 1690f9aa4606SSaravana Kannan */ 1691b0e2fa4fSSaravana Kannan if (!device_link_add(con, sup_dev, flags) && 1692b0e2fa4fSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 1693b0e2fa4fSSaravana Kannan dev_info(con, "Fixing up cyclic dependency with %s\n", 1694b0e2fa4fSSaravana Kannan dev_name(sup_dev)); 1695b0e2fa4fSSaravana Kannan device_links_write_lock(); 1696b0e2fa4fSSaravana Kannan fw_devlink_relax_cycle(con, sup_dev); 1697b0e2fa4fSSaravana Kannan device_links_write_unlock(); 1698b0e2fa4fSSaravana Kannan device_link_add(con, sup_dev, 1699b0e2fa4fSSaravana Kannan FW_DEVLINK_FLAGS_PERMISSIVE); 1700f9aa4606SSaravana Kannan ret = -EINVAL; 1701b0e2fa4fSSaravana Kannan } 1702f9aa4606SSaravana Kannan 1703f9aa4606SSaravana Kannan goto out; 1704f9aa4606SSaravana Kannan } 1705f9aa4606SSaravana Kannan 170674c782cfSSaravana Kannan /* Supplier that's already initialized without a struct device. */ 170774c782cfSSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_INITIALIZED) 170874c782cfSSaravana Kannan return -EINVAL; 170974c782cfSSaravana Kannan 1710f9aa4606SSaravana Kannan /* 1711f9aa4606SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY doesn't block probing and supports 1712f9aa4606SSaravana Kannan * cycles. So cycle detection isn't necessary and shouldn't be 1713f9aa4606SSaravana Kannan * done. 1714f9aa4606SSaravana Kannan */ 1715f9aa4606SSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) 1716f9aa4606SSaravana Kannan return -EAGAIN; 1717f9aa4606SSaravana Kannan 1718f9aa4606SSaravana Kannan /* 1719f9aa4606SSaravana Kannan * If we can't find the supplier device from its fwnode, it might be 1720f9aa4606SSaravana Kannan * due to a cyclic dependency between fwnodes. Some of these cycles can 1721f9aa4606SSaravana Kannan * be broken by applying logic. Check for these types of cycles and 1722f9aa4606SSaravana Kannan * break them so that devices in the cycle probe properly. 1723f9aa4606SSaravana Kannan * 1724f9aa4606SSaravana Kannan * If the supplier's parent is dependent on the consumer, then 1725f9aa4606SSaravana Kannan * the consumer-supplier dependency is a false dependency. So, 1726f9aa4606SSaravana Kannan * treat it as an invalid link. 1727f9aa4606SSaravana Kannan */ 1728f9aa4606SSaravana Kannan sup_dev = fwnode_get_next_parent_dev(sup_handle); 1729f9aa4606SSaravana Kannan if (sup_dev && device_is_dependent(con, sup_dev)) { 1730f9aa4606SSaravana Kannan dev_dbg(con, "Not linking to %pfwP - False link\n", 1731f9aa4606SSaravana Kannan sup_handle); 1732f9aa4606SSaravana Kannan ret = -EINVAL; 1733f9aa4606SSaravana Kannan } else { 1734f9aa4606SSaravana Kannan /* 1735f9aa4606SSaravana Kannan * Can't check for cycles or no cycles. So let's try 1736f9aa4606SSaravana Kannan * again later. 1737f9aa4606SSaravana Kannan */ 1738f9aa4606SSaravana Kannan ret = -EAGAIN; 1739f9aa4606SSaravana Kannan } 1740f9aa4606SSaravana Kannan 1741f9aa4606SSaravana Kannan out: 1742f9aa4606SSaravana Kannan put_device(sup_dev); 1743f9aa4606SSaravana Kannan return ret; 1744f9aa4606SSaravana Kannan } 1745f9aa4606SSaravana Kannan 1746f9aa4606SSaravana Kannan /** 1747f9aa4606SSaravana Kannan * __fw_devlink_link_to_consumers - Create device links to consumers of a device 1748*37c52f74SPierre-Louis Bossart * @dev: Device that needs to be linked to its consumers 1749f9aa4606SSaravana Kannan * 1750f9aa4606SSaravana Kannan * This function looks at all the consumer fwnodes of @dev and creates device 1751f9aa4606SSaravana Kannan * links between the consumer device and @dev (supplier). 1752f9aa4606SSaravana Kannan * 1753f9aa4606SSaravana Kannan * If the consumer device has not been added yet, then this function creates a 1754f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link between @dev (supplier) and the closest ancestor device 1755f9aa4606SSaravana Kannan * of the consumer fwnode. This is necessary to make sure @dev doesn't get a 1756f9aa4606SSaravana Kannan * sync_state() callback before the real consumer device gets to be added and 1757f9aa4606SSaravana Kannan * then probed. 1758f9aa4606SSaravana Kannan * 1759f9aa4606SSaravana Kannan * Once device links are created from the real consumer to @dev (supplier), the 1760f9aa4606SSaravana Kannan * fwnode links are deleted. 1761f9aa4606SSaravana Kannan */ 1762f9aa4606SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev) 1763f9aa4606SSaravana Kannan { 1764f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 1765f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 1766f9aa4606SSaravana Kannan 1767f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { 1768f9aa4606SSaravana Kannan u32 dl_flags = fw_devlink_get_flags(); 1769f9aa4606SSaravana Kannan struct device *con_dev; 1770f9aa4606SSaravana Kannan bool own_link = true; 1771f9aa4606SSaravana Kannan int ret; 1772f9aa4606SSaravana Kannan 1773f9aa4606SSaravana Kannan con_dev = get_dev_from_fwnode(link->consumer); 1774f9aa4606SSaravana Kannan /* 1775f9aa4606SSaravana Kannan * If consumer device is not available yet, make a "proxy" 1776f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link from the consumer's parent device to 1777f9aa4606SSaravana Kannan * the supplier device. This is necessary to make sure the 1778f9aa4606SSaravana Kannan * supplier doesn't get a sync_state() callback before the real 1779f9aa4606SSaravana Kannan * consumer can create a device link to the supplier. 1780f9aa4606SSaravana Kannan * 1781f9aa4606SSaravana Kannan * This proxy link step is needed to handle the case where the 1782f9aa4606SSaravana Kannan * consumer's parent device is added before the supplier. 1783f9aa4606SSaravana Kannan */ 1784f9aa4606SSaravana Kannan if (!con_dev) { 1785f9aa4606SSaravana Kannan con_dev = fwnode_get_next_parent_dev(link->consumer); 1786f9aa4606SSaravana Kannan /* 1787f9aa4606SSaravana Kannan * However, if the consumer's parent device is also the 1788f9aa4606SSaravana Kannan * parent of the supplier, don't create a 1789f9aa4606SSaravana Kannan * consumer-supplier link from the parent to its child 1790f9aa4606SSaravana Kannan * device. Such a dependency is impossible. 1791f9aa4606SSaravana Kannan */ 1792f9aa4606SSaravana Kannan if (con_dev && 1793f9aa4606SSaravana Kannan fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { 1794f9aa4606SSaravana Kannan put_device(con_dev); 1795f9aa4606SSaravana Kannan con_dev = NULL; 1796f9aa4606SSaravana Kannan } else { 1797f9aa4606SSaravana Kannan own_link = false; 1798b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 1799f9aa4606SSaravana Kannan } 1800f9aa4606SSaravana Kannan } 1801f9aa4606SSaravana Kannan 1802f9aa4606SSaravana Kannan if (!con_dev) 1803f9aa4606SSaravana Kannan continue; 1804f9aa4606SSaravana Kannan 1805f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(con_dev, fwnode, dl_flags); 1806f9aa4606SSaravana Kannan put_device(con_dev); 1807f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 1808f9aa4606SSaravana Kannan continue; 1809f9aa4606SSaravana Kannan 1810f9aa4606SSaravana Kannan list_del(&link->s_hook); 1811f9aa4606SSaravana Kannan list_del(&link->c_hook); 1812f9aa4606SSaravana Kannan kfree(link); 1813f9aa4606SSaravana Kannan } 1814f9aa4606SSaravana Kannan } 1815f9aa4606SSaravana Kannan 1816f9aa4606SSaravana Kannan /** 1817f9aa4606SSaravana Kannan * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device 1818*37c52f74SPierre-Louis Bossart * @dev: The consumer device that needs to be linked to its suppliers 1819*37c52f74SPierre-Louis Bossart * @fwnode: Root of the fwnode tree that is used to create device links 1820f9aa4606SSaravana Kannan * 1821f9aa4606SSaravana Kannan * This function looks at all the supplier fwnodes of fwnode tree rooted at 1822f9aa4606SSaravana Kannan * @fwnode and creates device links between @dev (consumer) and all the 1823f9aa4606SSaravana Kannan * supplier devices of the entire fwnode tree at @fwnode. 1824f9aa4606SSaravana Kannan * 1825f9aa4606SSaravana Kannan * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev 1826f9aa4606SSaravana Kannan * and the real suppliers of @dev. Once these device links are created, the 1827f9aa4606SSaravana Kannan * fwnode links are deleted. When such device links are successfully created, 1828f9aa4606SSaravana Kannan * this function is called recursively on those supplier devices. This is 1829f9aa4606SSaravana Kannan * needed to detect and break some invalid cycles in fwnode links. See 1830f9aa4606SSaravana Kannan * fw_devlink_create_devlink() for more details. 1831f9aa4606SSaravana Kannan * 1832f9aa4606SSaravana Kannan * In addition, it also looks at all the suppliers of the entire fwnode tree 1833f9aa4606SSaravana Kannan * because some of the child devices of @dev that have not been added yet 1834f9aa4606SSaravana Kannan * (because @dev hasn't probed) might already have their suppliers added to 1835f9aa4606SSaravana Kannan * driver core. So, this function creates SYNC_STATE_ONLY device links between 1836f9aa4606SSaravana Kannan * @dev (consumer) and these suppliers to make sure they don't execute their 1837f9aa4606SSaravana Kannan * sync_state() callbacks before these child devices have a chance to create 1838f9aa4606SSaravana Kannan * their device links. The fwnode links that correspond to the child devices 1839f9aa4606SSaravana Kannan * aren't delete because they are needed later to create the device links 1840f9aa4606SSaravana Kannan * between the real consumer and supplier devices. 1841f9aa4606SSaravana Kannan */ 1842f9aa4606SSaravana Kannan static void __fw_devlink_link_to_suppliers(struct device *dev, 1843f9aa4606SSaravana Kannan struct fwnode_handle *fwnode) 1844f9aa4606SSaravana Kannan { 1845f9aa4606SSaravana Kannan bool own_link = (dev->fwnode == fwnode); 1846f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 1847f9aa4606SSaravana Kannan struct fwnode_handle *child = NULL; 1848f9aa4606SSaravana Kannan u32 dl_flags; 1849f9aa4606SSaravana Kannan 1850f9aa4606SSaravana Kannan if (own_link) 1851f9aa4606SSaravana Kannan dl_flags = fw_devlink_get_flags(); 1852f9aa4606SSaravana Kannan else 1853b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 1854f9aa4606SSaravana Kannan 1855f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { 1856f9aa4606SSaravana Kannan int ret; 1857f9aa4606SSaravana Kannan struct device *sup_dev; 1858f9aa4606SSaravana Kannan struct fwnode_handle *sup = link->supplier; 1859f9aa4606SSaravana Kannan 1860f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(dev, sup, dl_flags); 1861f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 1862f9aa4606SSaravana Kannan continue; 1863f9aa4606SSaravana Kannan 1864f9aa4606SSaravana Kannan list_del(&link->s_hook); 1865f9aa4606SSaravana Kannan list_del(&link->c_hook); 1866f9aa4606SSaravana Kannan kfree(link); 1867f9aa4606SSaravana Kannan 1868f9aa4606SSaravana Kannan /* If no device link was created, nothing more to do. */ 1869f9aa4606SSaravana Kannan if (ret) 1870f9aa4606SSaravana Kannan continue; 1871f9aa4606SSaravana Kannan 1872f9aa4606SSaravana Kannan /* 1873f9aa4606SSaravana Kannan * If a device link was successfully created to a supplier, we 1874f9aa4606SSaravana Kannan * now need to try and link the supplier to all its suppliers. 1875f9aa4606SSaravana Kannan * 1876f9aa4606SSaravana Kannan * This is needed to detect and delete false dependencies in 1877f9aa4606SSaravana Kannan * fwnode links that haven't been converted to a device link 1878f9aa4606SSaravana Kannan * yet. See comments in fw_devlink_create_devlink() for more 1879f9aa4606SSaravana Kannan * details on the false dependency. 1880f9aa4606SSaravana Kannan * 1881f9aa4606SSaravana Kannan * Without deleting these false dependencies, some devices will 1882f9aa4606SSaravana Kannan * never probe because they'll keep waiting for their false 1883f9aa4606SSaravana Kannan * dependency fwnode links to be converted to device links. 1884f9aa4606SSaravana Kannan */ 1885f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup); 1886f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(sup_dev, sup_dev->fwnode); 1887f9aa4606SSaravana Kannan put_device(sup_dev); 1888f9aa4606SSaravana Kannan } 1889f9aa4606SSaravana Kannan 1890f9aa4606SSaravana Kannan /* 1891f9aa4606SSaravana Kannan * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of 1892f9aa4606SSaravana Kannan * all the descendants. This proxy link step is needed to handle the 1893f9aa4606SSaravana Kannan * case where the supplier is added before the consumer's parent device 1894f9aa4606SSaravana Kannan * (@dev). 1895f9aa4606SSaravana Kannan */ 1896f9aa4606SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 1897f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, child); 1898f9aa4606SSaravana Kannan } 1899f9aa4606SSaravana Kannan 19005f5377eaSSaravana Kannan static void fw_devlink_link_device(struct device *dev) 19015f5377eaSSaravana Kannan { 1902f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 19035f5377eaSSaravana Kannan 1904f9aa4606SSaravana Kannan if (!fw_devlink_flags) 1905f9aa4606SSaravana Kannan return; 19065f5377eaSSaravana Kannan 1907f9aa4606SSaravana Kannan fw_devlink_parse_fwtree(fwnode); 1908f9aa4606SSaravana Kannan 1909f9aa4606SSaravana Kannan mutex_lock(&fwnode_link_lock); 1910f9aa4606SSaravana Kannan __fw_devlink_link_to_consumers(dev); 1911f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, fwnode); 1912f9aa4606SSaravana Kannan mutex_unlock(&fwnode_link_lock); 19135f5377eaSSaravana Kannan } 19145f5377eaSSaravana Kannan 19159ed98953SRafael J. Wysocki /* Device links support end. */ 19169ed98953SRafael J. Wysocki 19171da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 19181da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 1919e105b8bfSDan Williams static struct kobject *dev_kobj; 1920e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 1921e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 19221da177e4SLinus Torvalds 19235e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 19245e33bc41SRafael J. Wysocki 19255e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 19265e33bc41SRafael J. Wysocki { 19275e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 19285e33bc41SRafael J. Wysocki } 19295e33bc41SRafael J. Wysocki 19305e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 19315e33bc41SRafael J. Wysocki { 19325e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 19335e33bc41SRafael J. Wysocki } 19345e33bc41SRafael J. Wysocki 19355e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 19365e33bc41SRafael J. Wysocki { 19375e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 19385e33bc41SRafael J. Wysocki return 0; 19395e33bc41SRafael J. Wysocki 19405e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 19415e33bc41SRafael J. Wysocki msleep(5); 19425e33bc41SRafael J. Wysocki return restart_syscall(); 19435e33bc41SRafael J. Wysocki } 19445e33bc41SRafael J. Wysocki 19454e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 19464e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 19474e886c29SGreg Kroah-Hartman { 19484e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 19494e886c29SGreg Kroah-Hartman } 19504e886c29SGreg Kroah-Hartman #else 19514e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 19524e886c29SGreg Kroah-Hartman { 19534e886c29SGreg Kroah-Hartman return 1; 19544e886c29SGreg Kroah-Hartman } 19554e886c29SGreg Kroah-Hartman #endif 19561da177e4SLinus Torvalds 195707de0e86SHeikki Krogerus static int 195807de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 195907de0e86SHeikki Krogerus { 19607847a145SHeikki Krogerus int ret; 19617847a145SHeikki Krogerus 19627847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 19637847a145SHeikki Krogerus if (ret) 19647847a145SHeikki Krogerus return ret; 19657847a145SHeikki Krogerus 196659abd836SHeikki Krogerus ret = software_node_notify(dev, action); 196759abd836SHeikki Krogerus if (ret) 196859abd836SHeikki Krogerus return ret; 196959abd836SHeikki Krogerus 197007de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 197107de0e86SHeikki Krogerus platform_notify(dev); 197207de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 197307de0e86SHeikki Krogerus platform_notify_remove(dev); 197407de0e86SHeikki Krogerus return 0; 197507de0e86SHeikki Krogerus } 197607de0e86SHeikki Krogerus 19773e95637aSAlan Stern /** 19783e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 19793e95637aSAlan Stern * @dev: struct device to get the name of 19803e95637aSAlan Stern * 19813e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 19829169c012Syan * the device is not bound to a driver, it will return the name of the bus 19833e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 19843e95637aSAlan Stern * string will be returned. 19853e95637aSAlan Stern */ 1986bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 19873e95637aSAlan Stern { 19883589972eSAlan Stern struct device_driver *drv; 19893589972eSAlan Stern 19903589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 19913589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 19923589972eSAlan Stern * never change once they are set, so they don't need special care. 19933589972eSAlan Stern */ 19946aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 1995e020ff61SSaravana Kannan return drv ? drv->name : dev_bus_name(dev); 19963e95637aSAlan Stern } 1997310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 19983e95637aSAlan Stern 19991da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 20001da177e4SLinus Torvalds 20014a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 20024a3ad20cSGreg Kroah-Hartman char *buf) 20031da177e4SLinus Torvalds { 20041da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2005b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 20064a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 20071da177e4SLinus Torvalds 20081da177e4SLinus Torvalds if (dev_attr->show) 200954b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 2010815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 2011a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 2012a52668c6SSergey Senozhatsky dev_attr->show); 2013815d2d50SAndrew Morton } 20141da177e4SLinus Torvalds return ret; 20151da177e4SLinus Torvalds } 20161da177e4SLinus Torvalds 20174a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 20181da177e4SLinus Torvalds const char *buf, size_t count) 20191da177e4SLinus Torvalds { 20201da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2021b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 20224a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds if (dev_attr->store) 202554b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 20261da177e4SLinus Torvalds return ret; 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds 202952cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 20301da177e4SLinus Torvalds .show = dev_attr_show, 20311da177e4SLinus Torvalds .store = dev_attr_store, 20321da177e4SLinus Torvalds }; 20331da177e4SLinus Torvalds 2034ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 2035ca22e56dSKay Sievers 2036ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 2037ca22e56dSKay Sievers struct device_attribute *attr, 2038ca22e56dSKay Sievers const char *buf, size_t size) 2039ca22e56dSKay Sievers { 2040ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2041f88184bfSKaitao cheng int ret; 2042f88184bfSKaitao cheng unsigned long new; 2043f88184bfSKaitao cheng 2044f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 2045f88184bfSKaitao cheng if (ret) 2046f88184bfSKaitao cheng return ret; 2047ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 2048ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2049ca22e56dSKay Sievers return size; 2050ca22e56dSKay Sievers } 2051ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 2052ca22e56dSKay Sievers 2053ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 2054ca22e56dSKay Sievers struct device_attribute *attr, 2055ca22e56dSKay Sievers char *buf) 2056ca22e56dSKay Sievers { 2057ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2058aa838896SJoe Perches return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); 2059ca22e56dSKay Sievers } 2060ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 2061ca22e56dSKay Sievers 2062ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 2063ca22e56dSKay Sievers struct device_attribute *attr, 2064ca22e56dSKay Sievers const char *buf, size_t size) 2065ca22e56dSKay Sievers { 2066ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2067f88184bfSKaitao cheng int ret; 2068f88184bfSKaitao cheng long new; 2069f88184bfSKaitao cheng 2070f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 2071f88184bfSKaitao cheng if (ret) 2072f88184bfSKaitao cheng return ret; 2073f88184bfSKaitao cheng 2074f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 2075ca22e56dSKay Sievers return -EINVAL; 2076ca22e56dSKay Sievers *(int *)(ea->var) = new; 2077ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2078ca22e56dSKay Sievers return size; 2079ca22e56dSKay Sievers } 2080ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 2081ca22e56dSKay Sievers 2082ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 2083ca22e56dSKay Sievers struct device_attribute *attr, 2084ca22e56dSKay Sievers char *buf) 2085ca22e56dSKay Sievers { 2086ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2087ca22e56dSKay Sievers 2088aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); 2089ca22e56dSKay Sievers } 2090ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 20911da177e4SLinus Torvalds 209291872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 209391872392SBorislav Petkov const char *buf, size_t size) 209491872392SBorislav Petkov { 209591872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 209691872392SBorislav Petkov 209791872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 209891872392SBorislav Petkov return -EINVAL; 209991872392SBorislav Petkov 210091872392SBorislav Petkov return size; 210191872392SBorislav Petkov } 210291872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 210391872392SBorislav Petkov 210491872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 210591872392SBorislav Petkov char *buf) 210691872392SBorislav Petkov { 210791872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 210891872392SBorislav Petkov 2109aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); 211091872392SBorislav Petkov } 211191872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 211291872392SBorislav Petkov 21131da177e4SLinus Torvalds /** 21141da177e4SLinus Torvalds * device_release - free device structure. 21151da177e4SLinus Torvalds * @kobj: device's kobject. 21161da177e4SLinus Torvalds * 21171da177e4SLinus Torvalds * This is called once the reference count for the object 21181da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 21191da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 21201da177e4SLinus Torvalds */ 21211da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 21221da177e4SLinus Torvalds { 2123b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2124fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 21251da177e4SLinus Torvalds 2126a525a3ddSMing Lei /* 2127a525a3ddSMing Lei * Some platform devices are driven without driver attached 2128a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 2129a525a3ddSMing Lei * all resources are released. 2130a525a3ddSMing Lei * 2131a525a3ddSMing Lei * Drivers still can add resources into device after device 2132a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 2133a525a3ddSMing Lei * possible memory leak. 2134a525a3ddSMing Lei */ 2135a525a3ddSMing Lei devres_release_all(dev); 2136a525a3ddSMing Lei 2137e0d07278SJim Quinlan kfree(dev->dma_range_map); 2138e0d07278SJim Quinlan 21391da177e4SLinus Torvalds if (dev->release) 21401da177e4SLinus Torvalds dev->release(dev); 2141f9f852dfSKay Sievers else if (dev->type && dev->type->release) 2142f9f852dfSKay Sievers dev->type->release(dev); 21432620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 21442620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 2145f810a5cfSArjan van de Ven else 21460c1bc6b8SMauro 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", 21471e0b2cf9SKay Sievers dev_name(dev)); 2148fb069a5dSGreg Kroah-Hartman kfree(p); 21491da177e4SLinus Torvalds } 21501da177e4SLinus Torvalds 2151bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 2152bc451f20SEric W. Biederman { 2153b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2154bc451f20SEric W. Biederman const void *ns = NULL; 2155bc451f20SEric W. Biederman 2156bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 2157bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 2158bc451f20SEric W. Biederman 2159bc451f20SEric W. Biederman return ns; 2160bc451f20SEric W. Biederman } 2161bc451f20SEric W. Biederman 21629944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 21639944e894SDmitry Torokhov { 21649944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 21659944e894SDmitry Torokhov 21669944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 21679944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 21689944e894SDmitry Torokhov } 21699944e894SDmitry Torokhov 21708f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 21711da177e4SLinus Torvalds .release = device_release, 21721da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 2173bc451f20SEric W. Biederman .namespace = device_namespace, 21749944e894SDmitry Torokhov .get_ownership = device_get_ownership, 21751da177e4SLinus Torvalds }; 21761da177e4SLinus Torvalds 21771da177e4SLinus Torvalds 2178312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 21791da177e4SLinus Torvalds { 21801da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 21811da177e4SLinus Torvalds 21828f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 2183b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 21841da177e4SLinus Torvalds if (dev->bus) 21851da177e4SLinus Torvalds return 1; 218623681e47SGreg Kroah-Hartman if (dev->class) 218723681e47SGreg Kroah-Hartman return 1; 21881da177e4SLinus Torvalds } 21891da177e4SLinus Torvalds return 0; 21901da177e4SLinus Torvalds } 21911da177e4SLinus Torvalds 2192312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 21931da177e4SLinus Torvalds { 2194b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 21951da177e4SLinus Torvalds 219623681e47SGreg Kroah-Hartman if (dev->bus) 21971da177e4SLinus Torvalds return dev->bus->name; 219823681e47SGreg Kroah-Hartman if (dev->class) 219923681e47SGreg Kroah-Hartman return dev->class->name; 220023681e47SGreg Kroah-Hartman return NULL; 22011da177e4SLinus Torvalds } 22021da177e4SLinus Torvalds 22037eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 22047eff2e7aSKay Sievers struct kobj_uevent_env *env) 22051da177e4SLinus Torvalds { 2206b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 22071da177e4SLinus Torvalds int retval = 0; 22081da177e4SLinus Torvalds 22096fcf53acSKay Sievers /* add device node properties if present */ 221023681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 22116fcf53acSKay Sievers const char *tmp; 22126fcf53acSKay Sievers const char *name; 22132c9ede55SAl Viro umode_t mode = 0; 22144e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 22154e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 22166fcf53acSKay Sievers 22177eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 22187eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 22193c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 22206fcf53acSKay Sievers if (name) { 22216fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 2222e454cea2SKay Sievers if (mode) 2223e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 22244e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 22254e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 22264e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 22274e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 22283c2670e6SKay Sievers kfree(tmp); 22296fcf53acSKay Sievers } 223023681e47SGreg Kroah-Hartman } 223123681e47SGreg Kroah-Hartman 2232414264f9SKay Sievers if (dev->type && dev->type->name) 22337eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 2234414264f9SKay Sievers 2235239378f1SKay Sievers if (dev->driver) 22367eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 2237239378f1SKay Sievers 223807d57a32SGrant Likely /* Add common DT information about the device */ 223907d57a32SGrant Likely of_device_uevent(dev, env); 224007d57a32SGrant Likely 22411da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 22427eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 22437eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 2244f9f852dfSKay Sievers if (retval) 22457dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 22461e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 22471da177e4SLinus Torvalds } 22481da177e4SLinus Torvalds 22492620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 22507eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 22517eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 2252f9f852dfSKay Sievers if (retval) 22537dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 22541e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 22552b3a302aSHarvey Harrison __func__, retval); 22562620efefSGreg Kroah-Hartman } 2257f9f852dfSKay Sievers 2258eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 22597eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 22607eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 2261f9f852dfSKay Sievers if (retval) 22627dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 22631e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 22642b3a302aSHarvey Harrison __func__, retval); 22652620efefSGreg Kroah-Hartman } 22662620efefSGreg Kroah-Hartman 22671da177e4SLinus Torvalds return retval; 22681da177e4SLinus Torvalds } 22691da177e4SLinus Torvalds 22709cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 2271312c004dSKay Sievers .filter = dev_uevent_filter, 2272312c004dSKay Sievers .name = dev_uevent_name, 2273312c004dSKay Sievers .uevent = dev_uevent, 22741da177e4SLinus Torvalds }; 22751da177e4SLinus Torvalds 2276c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 227716574dccSKay Sievers char *buf) 227816574dccSKay Sievers { 227916574dccSKay Sievers struct kobject *top_kobj; 228016574dccSKay Sievers struct kset *kset; 22817eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 228216574dccSKay Sievers int i; 2283948b3edbSJoe Perches int len = 0; 228416574dccSKay Sievers int retval; 228516574dccSKay Sievers 228616574dccSKay Sievers /* search the kset, the device belongs to */ 228716574dccSKay Sievers top_kobj = &dev->kobj; 22885c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 228916574dccSKay Sievers top_kobj = top_kobj->parent; 229016574dccSKay Sievers if (!top_kobj->kset) 229116574dccSKay Sievers goto out; 22925c5daf65SKay Sievers 229316574dccSKay Sievers kset = top_kobj->kset; 229416574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 229516574dccSKay Sievers goto out; 229616574dccSKay Sievers 229716574dccSKay Sievers /* respect filter */ 229816574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 229916574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 230016574dccSKay Sievers goto out; 230116574dccSKay Sievers 23027eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 23037eff2e7aSKay Sievers if (!env) 2304c7308c81SGreg Kroah-Hartman return -ENOMEM; 2305c7308c81SGreg Kroah-Hartman 230616574dccSKay Sievers /* let the kset specific function add its keys */ 23077eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 230816574dccSKay Sievers if (retval) 230916574dccSKay Sievers goto out; 231016574dccSKay Sievers 231116574dccSKay Sievers /* copy keys to file */ 23127eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 2313948b3edbSJoe Perches len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); 231416574dccSKay Sievers out: 23157eff2e7aSKay Sievers kfree(env); 2316948b3edbSJoe Perches return len; 231716574dccSKay Sievers } 231816574dccSKay Sievers 2319c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 2320a7fd6706SKay Sievers const char *buf, size_t count) 2321a7fd6706SKay Sievers { 2322df44b479SPeter Rajnoha int rc; 2323df44b479SPeter Rajnoha 2324df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 2325df44b479SPeter Rajnoha 2326df44b479SPeter Rajnoha if (rc) { 2327f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 2328df44b479SPeter Rajnoha return rc; 2329df44b479SPeter Rajnoha } 233060a96a59SKay Sievers 2331a7fd6706SKay Sievers return count; 2332a7fd6706SKay Sievers } 2333c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 2334a7fd6706SKay Sievers 2335c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 23364f3549d7SRafael J. Wysocki char *buf) 23374f3549d7SRafael J. Wysocki { 23384f3549d7SRafael J. Wysocki bool val; 23394f3549d7SRafael J. Wysocki 23405e33bc41SRafael J. Wysocki device_lock(dev); 23414f3549d7SRafael J. Wysocki val = !dev->offline; 23425e33bc41SRafael J. Wysocki device_unlock(dev); 2343aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 23444f3549d7SRafael J. Wysocki } 23454f3549d7SRafael J. Wysocki 2346c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 23474f3549d7SRafael J. Wysocki const char *buf, size_t count) 23484f3549d7SRafael J. Wysocki { 23494f3549d7SRafael J. Wysocki bool val; 23504f3549d7SRafael J. Wysocki int ret; 23514f3549d7SRafael J. Wysocki 23524f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 23534f3549d7SRafael J. Wysocki if (ret < 0) 23544f3549d7SRafael J. Wysocki return ret; 23554f3549d7SRafael J. Wysocki 23565e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 23575e33bc41SRafael J. Wysocki if (ret) 23585e33bc41SRafael J. Wysocki return ret; 23595e33bc41SRafael J. Wysocki 23604f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 23614f3549d7SRafael J. Wysocki unlock_device_hotplug(); 23624f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 23634f3549d7SRafael J. Wysocki } 2364c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 23654f3549d7SRafael J. Wysocki 2366fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 2367621a1672SDmitry Torokhov { 23683e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 2369621a1672SDmitry Torokhov } 2370a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 2371621a1672SDmitry Torokhov 2372fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 2373a4dbd674SDavid Brownell const struct attribute_group **groups) 2374621a1672SDmitry Torokhov { 23753e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 2376621a1672SDmitry Torokhov } 2377a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 2378de0ff00dSGreg Kroah-Hartman 237957b8ff07SDmitry Torokhov union device_attr_group_devres { 238057b8ff07SDmitry Torokhov const struct attribute_group *group; 238157b8ff07SDmitry Torokhov const struct attribute_group **groups; 238257b8ff07SDmitry Torokhov }; 238357b8ff07SDmitry Torokhov 238457b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 238557b8ff07SDmitry Torokhov { 238657b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 238757b8ff07SDmitry Torokhov } 238857b8ff07SDmitry Torokhov 238957b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 239057b8ff07SDmitry Torokhov { 239157b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 239257b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 239357b8ff07SDmitry Torokhov 239457b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 239557b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 239657b8ff07SDmitry Torokhov } 239757b8ff07SDmitry Torokhov 239857b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 239957b8ff07SDmitry Torokhov { 240057b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 240157b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 240257b8ff07SDmitry Torokhov 240357b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 240457b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 240557b8ff07SDmitry Torokhov } 240657b8ff07SDmitry Torokhov 240757b8ff07SDmitry Torokhov /** 240857b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 240957b8ff07SDmitry Torokhov * @dev: The device to create the group for 241057b8ff07SDmitry Torokhov * @grp: The attribute group to create 241157b8ff07SDmitry Torokhov * 241257b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 241357b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 241457b8ff07SDmitry Torokhov * 241557b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 241657b8ff07SDmitry Torokhov */ 241757b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 241857b8ff07SDmitry Torokhov { 241957b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 242057b8ff07SDmitry Torokhov int error; 242157b8ff07SDmitry Torokhov 242257b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 242357b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 242457b8ff07SDmitry Torokhov if (!devres) 242557b8ff07SDmitry Torokhov return -ENOMEM; 242657b8ff07SDmitry Torokhov 242757b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 242857b8ff07SDmitry Torokhov if (error) { 242957b8ff07SDmitry Torokhov devres_free(devres); 243057b8ff07SDmitry Torokhov return error; 243157b8ff07SDmitry Torokhov } 243257b8ff07SDmitry Torokhov 243357b8ff07SDmitry Torokhov devres->group = grp; 243457b8ff07SDmitry Torokhov devres_add(dev, devres); 243557b8ff07SDmitry Torokhov return 0; 243657b8ff07SDmitry Torokhov } 243757b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 243857b8ff07SDmitry Torokhov 243957b8ff07SDmitry Torokhov /** 244057b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 244157b8ff07SDmitry Torokhov * @dev: device to remove the group from 244257b8ff07SDmitry Torokhov * @grp: group to remove 244357b8ff07SDmitry Torokhov * 244457b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 244557b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 244657b8ff07SDmitry Torokhov */ 244757b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 244857b8ff07SDmitry Torokhov const struct attribute_group *grp) 244957b8ff07SDmitry Torokhov { 245057b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 245157b8ff07SDmitry Torokhov devm_attr_group_match, 245257b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 245357b8ff07SDmitry Torokhov } 245457b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 245557b8ff07SDmitry Torokhov 245657b8ff07SDmitry Torokhov /** 245757b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 245857b8ff07SDmitry Torokhov * @dev: The device to create the group for 245957b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 246057b8ff07SDmitry Torokhov * 246157b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 246257b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 246357b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 246457b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 246557b8ff07SDmitry Torokhov * attribute files being created already exist. 246657b8ff07SDmitry Torokhov * 246757b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 246857b8ff07SDmitry Torokhov */ 246957b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 247057b8ff07SDmitry Torokhov const struct attribute_group **groups) 247157b8ff07SDmitry Torokhov { 247257b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 247357b8ff07SDmitry Torokhov int error; 247457b8ff07SDmitry Torokhov 247557b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 247657b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 247757b8ff07SDmitry Torokhov if (!devres) 247857b8ff07SDmitry Torokhov return -ENOMEM; 247957b8ff07SDmitry Torokhov 248057b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 248157b8ff07SDmitry Torokhov if (error) { 248257b8ff07SDmitry Torokhov devres_free(devres); 248357b8ff07SDmitry Torokhov return error; 248457b8ff07SDmitry Torokhov } 248557b8ff07SDmitry Torokhov 248657b8ff07SDmitry Torokhov devres->groups = groups; 248757b8ff07SDmitry Torokhov devres_add(dev, devres); 248857b8ff07SDmitry Torokhov return 0; 248957b8ff07SDmitry Torokhov } 249057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 249157b8ff07SDmitry Torokhov 249257b8ff07SDmitry Torokhov /** 249357b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 249457b8ff07SDmitry Torokhov * 249557b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 249657b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 249757b8ff07SDmitry Torokhov * 249857b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 249957b8ff07SDmitry Torokhov */ 250057b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 250157b8ff07SDmitry Torokhov const struct attribute_group **groups) 250257b8ff07SDmitry Torokhov { 250357b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 250457b8ff07SDmitry Torokhov devm_attr_group_match, 250557b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 250657b8ff07SDmitry Torokhov } 250757b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 25081da177e4SLinus Torvalds 25092620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 25102620efefSGreg Kroah-Hartman { 25112620efefSGreg Kroah-Hartman struct class *class = dev->class; 2512aed65af1SStephen Hemminger const struct device_type *type = dev->type; 2513621a1672SDmitry Torokhov int error; 25142620efefSGreg Kroah-Hartman 2515621a1672SDmitry Torokhov if (class) { 2516d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 25172620efefSGreg Kroah-Hartman if (error) 2518621a1672SDmitry Torokhov return error; 2519f9f852dfSKay Sievers } 2520f9f852dfSKay Sievers 2521621a1672SDmitry Torokhov if (type) { 2522621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 2523f9f852dfSKay Sievers if (error) 2524a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 2525f9f852dfSKay Sievers } 2526621a1672SDmitry Torokhov 2527621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 2528f9f852dfSKay Sievers if (error) 2529621a1672SDmitry Torokhov goto err_remove_type_groups; 2530621a1672SDmitry Torokhov 25314f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 2532c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 25334f3549d7SRafael J. Wysocki if (error) 2534ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 25354f3549d7SRafael J. Wysocki } 25364f3549d7SRafael J. Wysocki 253725ac86c6SSaravana Kannan if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { 2538da6d6475SSaravana Kannan error = device_create_file(dev, &dev_attr_waiting_for_supplier); 2539da6d6475SSaravana Kannan if (error) 2540da6d6475SSaravana Kannan goto err_remove_dev_online; 2541da6d6475SSaravana Kannan } 2542da6d6475SSaravana Kannan 2543621a1672SDmitry Torokhov return 0; 2544621a1672SDmitry Torokhov 2545da6d6475SSaravana Kannan err_remove_dev_online: 2546da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_online); 2547ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 2548ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 2549621a1672SDmitry Torokhov err_remove_type_groups: 2550621a1672SDmitry Torokhov if (type) 2551621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2552d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 2553d05a6f96SGreg Kroah-Hartman if (class) 2554d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2555f9f852dfSKay Sievers 25562620efefSGreg Kroah-Hartman return error; 25572620efefSGreg Kroah-Hartman } 25582620efefSGreg Kroah-Hartman 25592620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 25602620efefSGreg Kroah-Hartman { 25612620efefSGreg Kroah-Hartman struct class *class = dev->class; 2562aed65af1SStephen Hemminger const struct device_type *type = dev->type; 25632620efefSGreg Kroah-Hartman 2564da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 2565c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 2566621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 2567f9f852dfSKay Sievers 2568621a1672SDmitry Torokhov if (type) 2569621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2570621a1672SDmitry Torokhov 2571a6b01dedSGreg Kroah-Hartman if (class) 2572d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2573c97415a7SStefan Achatz } 25742620efefSGreg Kroah-Hartman 2575c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 257623681e47SGreg Kroah-Hartman char *buf) 257723681e47SGreg Kroah-Hartman { 257823681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 257923681e47SGreg Kroah-Hartman } 2580c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 2581ad6a1e1cSTejun Heo 2582ca22e56dSKay Sievers /* /sys/devices/ */ 2583881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 25841da177e4SLinus Torvalds 25851da177e4SLinus Torvalds /** 258652cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 258752cdbdd4SGrygorii Strashko * @deva: Device to move. 258852cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 258952cdbdd4SGrygorii Strashko */ 259052cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 259152cdbdd4SGrygorii Strashko { 259252cdbdd4SGrygorii Strashko if (!devices_kset) 259352cdbdd4SGrygorii Strashko return; 259452cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 259552cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 259652cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 259752cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 259852cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 259952cdbdd4SGrygorii Strashko } 260052cdbdd4SGrygorii Strashko 260152cdbdd4SGrygorii Strashko /** 260252cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 260352cdbdd4SGrygorii Strashko * @deva: Device to move 260452cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 260552cdbdd4SGrygorii Strashko */ 260652cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 260752cdbdd4SGrygorii Strashko { 260852cdbdd4SGrygorii Strashko if (!devices_kset) 260952cdbdd4SGrygorii Strashko return; 261052cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 261152cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 261252cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 261352cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 261452cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 261552cdbdd4SGrygorii Strashko } 261652cdbdd4SGrygorii Strashko 261752cdbdd4SGrygorii Strashko /** 261852cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 261952cdbdd4SGrygorii Strashko * @dev: device to move 262052cdbdd4SGrygorii Strashko */ 262152cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 262252cdbdd4SGrygorii Strashko { 262352cdbdd4SGrygorii Strashko if (!devices_kset) 262452cdbdd4SGrygorii Strashko return; 262552cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 262652cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 262752cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 262852cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 262952cdbdd4SGrygorii Strashko } 263052cdbdd4SGrygorii Strashko 263152cdbdd4SGrygorii Strashko /** 26321da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 26331da177e4SLinus Torvalds * @dev: device. 26341da177e4SLinus Torvalds * @attr: device attribute descriptor. 26351da177e4SLinus Torvalds */ 263626579ab7SPhil Carmody int device_create_file(struct device *dev, 263726579ab7SPhil Carmody const struct device_attribute *attr) 26381da177e4SLinus Torvalds { 26391da177e4SLinus Torvalds int error = 0; 26408f46baaaSFelipe Balbi 26418f46baaaSFelipe Balbi if (dev) { 26428f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 264397521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 264497521978Sdyoung@redhat.com attr->attr.name); 26458f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 264697521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 264797521978Sdyoung@redhat.com attr->attr.name); 26481da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 26498f46baaaSFelipe Balbi } 26508f46baaaSFelipe Balbi 26511da177e4SLinus Torvalds return error; 26521da177e4SLinus Torvalds } 265386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 26541da177e4SLinus Torvalds 26551da177e4SLinus Torvalds /** 26561da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 26571da177e4SLinus Torvalds * @dev: device. 26581da177e4SLinus Torvalds * @attr: device attribute descriptor. 26591da177e4SLinus Torvalds */ 266026579ab7SPhil Carmody void device_remove_file(struct device *dev, 266126579ab7SPhil Carmody const struct device_attribute *attr) 26621da177e4SLinus Torvalds { 26630c98b19fSCornelia Huck if (dev) 26641da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 26651da177e4SLinus Torvalds } 266686df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 26671da177e4SLinus Torvalds 26682589f188SGreg Kroah-Hartman /** 26696b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 26706b0afc2aSTejun Heo * @dev: device. 26716b0afc2aSTejun Heo * @attr: device attribute descriptor. 26726b0afc2aSTejun Heo * 26736b0afc2aSTejun Heo * See kernfs_remove_self() for details. 26746b0afc2aSTejun Heo */ 26756b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 26766b0afc2aSTejun Heo const struct device_attribute *attr) 26776b0afc2aSTejun Heo { 26786b0afc2aSTejun Heo if (dev) 26796b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 26806b0afc2aSTejun Heo else 26816b0afc2aSTejun Heo return false; 26826b0afc2aSTejun Heo } 26836b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 26846b0afc2aSTejun Heo 26856b0afc2aSTejun Heo /** 26862589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 26872589f188SGreg Kroah-Hartman * @dev: device. 26882589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 26892589f188SGreg Kroah-Hartman */ 269066ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 269166ecb92bSPhil Carmody const struct bin_attribute *attr) 26922589f188SGreg Kroah-Hartman { 26932589f188SGreg Kroah-Hartman int error = -EINVAL; 26942589f188SGreg Kroah-Hartman if (dev) 26952589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 26962589f188SGreg Kroah-Hartman return error; 26972589f188SGreg Kroah-Hartman } 26982589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 26992589f188SGreg Kroah-Hartman 27002589f188SGreg Kroah-Hartman /** 27012589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 27022589f188SGreg Kroah-Hartman * @dev: device. 27032589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 27042589f188SGreg Kroah-Hartman */ 270566ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 270666ecb92bSPhil Carmody const struct bin_attribute *attr) 27072589f188SGreg Kroah-Hartman { 27082589f188SGreg Kroah-Hartman if (dev) 27092589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 27102589f188SGreg Kroah-Hartman } 27112589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 27122589f188SGreg Kroah-Hartman 271334bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 271434bb61f9SJames Bottomley { 2715f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2716f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 271734bb61f9SJames Bottomley 271834bb61f9SJames Bottomley get_device(dev); 271934bb61f9SJames Bottomley } 272034bb61f9SJames Bottomley 272134bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 272234bb61f9SJames Bottomley { 2723f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2724f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 272534bb61f9SJames Bottomley 272634bb61f9SJames Bottomley put_device(dev); 272734bb61f9SJames Bottomley } 272834bb61f9SJames Bottomley 27291da177e4SLinus Torvalds /** 27301da177e4SLinus Torvalds * device_initialize - init device structure. 27311da177e4SLinus Torvalds * @dev: device. 27321da177e4SLinus Torvalds * 27335739411aSCornelia Huck * This prepares the device for use by other layers by initializing 27345739411aSCornelia Huck * its fields. 27351da177e4SLinus Torvalds * It is the first half of device_register(), if called by 27365739411aSCornelia Huck * that function, though it can also be called separately, so one 27375739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 27385739411aSCornelia Huck * may be used for reference counting of @dev after calling this 27395739411aSCornelia Huck * function. 27405739411aSCornelia Huck * 2741b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 2742b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 2743b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 2744b10d5efdSAlan Stern * @dev. 2745b10d5efdSAlan Stern * 27465739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 27475739411aSCornelia Huck * @dev directly once you have called this function. 27481da177e4SLinus Torvalds */ 27491da177e4SLinus Torvalds void device_initialize(struct device *dev) 27501da177e4SLinus Torvalds { 2751881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 2752f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 27531da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 27543142788bSThomas Gleixner mutex_init(&dev->mutex); 275587a30e1fSDan Williams #ifdef CONFIG_PROVE_LOCKING 275687a30e1fSDan Williams mutex_init(&dev->lockdep_mutex); 275787a30e1fSDan Williams #endif 27581704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 27599ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 27609ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 27613b98aeafSAlan Stern device_pm_init(dev); 276287348136SChristoph Hellwig set_dev_node(dev, -1); 27634a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 27644a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 27654a7cc831SJiang Liu #endif 27669ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 27679ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 27683b052a3eSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 27699ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 27706d4e9a8eSChristoph Hellwig #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \ 27716d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \ 27726d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) 27736d4e9a8eSChristoph Hellwig dev->dma_coherent = dma_default_coherent; 27746d4e9a8eSChristoph Hellwig #endif 27751da177e4SLinus Torvalds } 277686df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 27771da177e4SLinus Torvalds 2778d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 2779f0ee61a6SGreg Kroah-Hartman { 2780f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 2781f0ee61a6SGreg Kroah-Hartman 2782f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 27834ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 2784881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 2785f0ee61a6SGreg Kroah-Hartman 278686406245SKay Sievers return virtual_dir; 2787f0ee61a6SGreg Kroah-Hartman } 2788f0ee61a6SGreg Kroah-Hartman 2789bc451f20SEric W. Biederman struct class_dir { 2790bc451f20SEric W. Biederman struct kobject kobj; 2791bc451f20SEric W. Biederman struct class *class; 2792bc451f20SEric W. Biederman }; 2793bc451f20SEric W. Biederman 2794bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 2795bc451f20SEric W. Biederman 2796bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 2797bc451f20SEric W. Biederman { 2798bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2799bc451f20SEric W. Biederman kfree(dir); 2800bc451f20SEric W. Biederman } 2801bc451f20SEric W. Biederman 2802bc451f20SEric W. Biederman static const 2803bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 2804bc451f20SEric W. Biederman { 2805bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2806bc451f20SEric W. Biederman return dir->class->ns_type; 2807bc451f20SEric W. Biederman } 2808bc451f20SEric W. Biederman 2809bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 2810bc451f20SEric W. Biederman .release = class_dir_release, 2811bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 2812bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 2813bc451f20SEric W. Biederman }; 2814bc451f20SEric W. Biederman 2815bc451f20SEric W. Biederman static struct kobject * 2816bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 2817bc451f20SEric W. Biederman { 2818bc451f20SEric W. Biederman struct class_dir *dir; 2819bc451f20SEric W. Biederman int retval; 2820bc451f20SEric W. Biederman 2821bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 2822bc451f20SEric W. Biederman if (!dir) 282384d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 2824bc451f20SEric W. Biederman 2825bc451f20SEric W. Biederman dir->class = class; 2826bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 2827bc451f20SEric W. Biederman 28286b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 2829bc451f20SEric W. Biederman 2830bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 2831bc451f20SEric W. Biederman if (retval < 0) { 2832bc451f20SEric W. Biederman kobject_put(&dir->kobj); 283384d0c27dSTetsuo Handa return ERR_PTR(retval); 2834bc451f20SEric W. Biederman } 2835bc451f20SEric W. Biederman return &dir->kobj; 2836bc451f20SEric W. Biederman } 2837bc451f20SEric W. Biederman 2838e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 2839bc451f20SEric W. Biederman 2840c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 2841c744aeaeSCornelia Huck struct device *parent) 284240fa5422SGreg Kroah-Hartman { 284386406245SKay Sievers if (dev->class) { 284486406245SKay Sievers struct kobject *kobj = NULL; 284586406245SKay Sievers struct kobject *parent_kobj; 284686406245SKay Sievers struct kobject *k; 284786406245SKay Sievers 2848ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 284939aba963SKay Sievers /* block disks show up in /sys/block */ 2850e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 285139aba963SKay Sievers if (parent && parent->class == &block_class) 285239aba963SKay Sievers return &parent->kobj; 28536b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 285439aba963SKay Sievers } 2855ead454feSRandy Dunlap #endif 2856e52eec13SAndi Kleen 285786406245SKay Sievers /* 285886406245SKay Sievers * If we have no parent, we live in "virtual". 28590f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 28600f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 286186406245SKay Sievers */ 286286406245SKay Sievers if (parent == NULL) 286386406245SKay Sievers parent_kobj = virtual_device_parent(dev); 286424b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 286586406245SKay Sievers return &parent->kobj; 286686406245SKay Sievers else 286786406245SKay Sievers parent_kobj = &parent->kobj; 286886406245SKay Sievers 286977d3d7c1STejun Heo mutex_lock(&gdp_mutex); 287077d3d7c1STejun Heo 287186406245SKay Sievers /* find our class-directory at the parent and reference it */ 28726b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 28736b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 287486406245SKay Sievers if (k->parent == parent_kobj) { 287586406245SKay Sievers kobj = kobject_get(k); 287686406245SKay Sievers break; 287786406245SKay Sievers } 28786b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 287977d3d7c1STejun Heo if (kobj) { 288077d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 288186406245SKay Sievers return kobj; 288277d3d7c1STejun Heo } 288386406245SKay Sievers 288486406245SKay Sievers /* or create a new class-directory at the parent device */ 2885bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 28860f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 288777d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 288843968d2fSGreg Kroah-Hartman return k; 288986406245SKay Sievers } 289086406245SKay Sievers 2891ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 2892ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 2893ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 2894ca22e56dSKay Sievers 289586406245SKay Sievers if (parent) 2896c744aeaeSCornelia Huck return &parent->kobj; 2897c744aeaeSCornelia Huck return NULL; 2898c744aeaeSCornelia Huck } 2899da231fd5SKay Sievers 2900cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 2901cebf8fd1SMing Lei struct device *dev) 2902cebf8fd1SMing Lei { 2903cebf8fd1SMing Lei if (!kobj || !dev->class || 2904cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 2905cebf8fd1SMing Lei return false; 2906cebf8fd1SMing Lei return true; 2907cebf8fd1SMing Lei } 2908cebf8fd1SMing Lei 2909cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 2910cebf8fd1SMing Lei { 2911cebf8fd1SMing Lei return dev->kobj.parent; 2912cebf8fd1SMing Lei } 2913cebf8fd1SMing Lei 2914cebf8fd1SMing Lei /* 2915cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 2916cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 2917cebf8fd1SMing Lei * global lock 2918cebf8fd1SMing Lei */ 291963b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 2920da231fd5SKay Sievers { 2921ac43432cSMuchun Song unsigned int ref; 2922ac43432cSMuchun Song 29230f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 2924cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 2925da231fd5SKay Sievers return; 2926da231fd5SKay Sievers 2927e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 2928ac43432cSMuchun Song /** 2929ac43432cSMuchun Song * There is a race condition between removing glue directory 2930ac43432cSMuchun Song * and adding a new device under the glue directory. 2931ac43432cSMuchun Song * 2932ac43432cSMuchun Song * CPU1: CPU2: 2933ac43432cSMuchun Song * 2934ac43432cSMuchun Song * device_add() 2935ac43432cSMuchun Song * get_device_parent() 2936ac43432cSMuchun Song * class_dir_create_and_add() 2937ac43432cSMuchun Song * kobject_add_internal() 2938ac43432cSMuchun Song * create_dir() // create glue_dir 2939ac43432cSMuchun Song * 2940ac43432cSMuchun Song * device_add() 2941ac43432cSMuchun Song * get_device_parent() 2942ac43432cSMuchun Song * kobject_get() // get glue_dir 2943ac43432cSMuchun Song * 2944ac43432cSMuchun Song * device_del() 2945ac43432cSMuchun Song * cleanup_glue_dir() 2946ac43432cSMuchun Song * kobject_del(glue_dir) 2947ac43432cSMuchun Song * 2948ac43432cSMuchun Song * kobject_add() 2949ac43432cSMuchun Song * kobject_add_internal() 2950ac43432cSMuchun Song * create_dir() // in glue_dir 2951ac43432cSMuchun Song * sysfs_create_dir_ns() 2952ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 2953ac43432cSMuchun Song * 2954ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 2955ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 2956ac43432cSMuchun Song * 2957ac43432cSMuchun Song * // sd is freed 2958ac43432cSMuchun Song * kernfs_new_node(sd) 2959ac43432cSMuchun Song * kernfs_get(glue_dir) 2960ac43432cSMuchun Song * kernfs_add_one() 2961ac43432cSMuchun Song * kernfs_put() 2962ac43432cSMuchun Song * 2963ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 2964ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 2965ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 2966ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 2967ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 2968ac43432cSMuchun Song * 2969ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 2970ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 2971ac43432cSMuchun Song * 2972ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 2973ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 2974ac43432cSMuchun Song * for glue_dir kobj is 1. 2975ac43432cSMuchun Song */ 2976ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 2977ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 2978726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 29790f4dafc0SKay Sievers kobject_put(glue_dir); 2980e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 2981da231fd5SKay Sievers } 298263b6971aSCornelia Huck 29832ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 29842ee97cafSCornelia Huck { 29855590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 29862ee97cafSCornelia Huck int error; 29872ee97cafSCornelia Huck 29885590f319SBenjamin Herrenschmidt if (of_node) { 29890c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 29905590f319SBenjamin Herrenschmidt if (error) 29915590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 29925590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 29935590f319SBenjamin Herrenschmidt } 29945590f319SBenjamin Herrenschmidt 29952ee97cafSCornelia Huck if (!dev->class) 29962ee97cafSCornelia Huck return 0; 2997da231fd5SKay Sievers 29981fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 29996b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 30002ee97cafSCornelia Huck "subsystem"); 30012ee97cafSCornelia Huck if (error) 30025590f319SBenjamin Herrenschmidt goto out_devnode; 3003da231fd5SKay Sievers 30044e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 30054f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 30064f01a757SDmitry Torokhov "device"); 30074f01a757SDmitry Torokhov if (error) 300839aba963SKay Sievers goto out_subsys; 30092ee97cafSCornelia Huck } 301039aba963SKay Sievers 3011ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 301239aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 3013e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 301439aba963SKay Sievers return 0; 3015ead454feSRandy Dunlap #endif 301639aba963SKay Sievers 301739aba963SKay Sievers /* link in the class directory pointing to the device */ 30186b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 301939aba963SKay Sievers &dev->kobj, dev_name(dev)); 302039aba963SKay Sievers if (error) 302139aba963SKay Sievers goto out_device; 302239aba963SKay Sievers 30232ee97cafSCornelia Huck return 0; 30242ee97cafSCornelia Huck 302539aba963SKay Sievers out_device: 302639aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 3027da231fd5SKay Sievers 30282ee97cafSCornelia Huck out_subsys: 30292ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 30305590f319SBenjamin Herrenschmidt out_devnode: 30315590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 30322ee97cafSCornelia Huck return error; 30332ee97cafSCornelia Huck } 30342ee97cafSCornelia Huck 30352ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 30362ee97cafSCornelia Huck { 30375590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 30385590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 30395590f319SBenjamin Herrenschmidt 30402ee97cafSCornelia Huck if (!dev->class) 30412ee97cafSCornelia Huck return; 3042da231fd5SKay Sievers 30434e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 3044da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 30452ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 3046ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 3047e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 304839aba963SKay Sievers return; 3049ead454feSRandy Dunlap #endif 30506b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 30512ee97cafSCornelia Huck } 30522ee97cafSCornelia Huck 30531da177e4SLinus Torvalds /** 3054413c239fSStephen Rothwell * dev_set_name - set a device name 3055413c239fSStephen Rothwell * @dev: device 305646232366SRandy Dunlap * @fmt: format string for the device's name 3057413c239fSStephen Rothwell */ 3058413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 3059413c239fSStephen Rothwell { 3060413c239fSStephen Rothwell va_list vargs; 30611fa5ae85SKay Sievers int err; 3062413c239fSStephen Rothwell 3063413c239fSStephen Rothwell va_start(vargs, fmt); 30641fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 3065413c239fSStephen Rothwell va_end(vargs); 30661fa5ae85SKay Sievers return err; 3067413c239fSStephen Rothwell } 3068413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 3069413c239fSStephen Rothwell 3070413c239fSStephen Rothwell /** 3071e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 3072e105b8bfSDan Williams * @dev: device 3073e105b8bfSDan Williams * 3074e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 3075e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 3076e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 3077e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 30780d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 30790d4e293cSPeter Korsgaard * the link. 3080e105b8bfSDan Williams */ 3081e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 3082e105b8bfSDan Williams { 3083e105b8bfSDan Williams struct kobject *kobj; 3084e105b8bfSDan Williams 3085e105b8bfSDan Williams if (dev->class) 3086e105b8bfSDan Williams kobj = dev->class->dev_kobj; 3087e105b8bfSDan Williams else 3088e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 3089e105b8bfSDan Williams 3090e105b8bfSDan Williams return kobj; 3091e105b8bfSDan Williams } 3092e105b8bfSDan Williams 3093e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 3094e105b8bfSDan Williams { 3095e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3096e105b8bfSDan Williams int error = 0; 3097e105b8bfSDan Williams char devt_str[15]; 3098e105b8bfSDan Williams 3099e105b8bfSDan Williams if (kobj) { 3100e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3101e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 3102e105b8bfSDan Williams } 3103e105b8bfSDan Williams 3104e105b8bfSDan Williams return error; 3105e105b8bfSDan Williams } 3106e105b8bfSDan Williams 3107e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 3108e105b8bfSDan Williams { 3109e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3110e105b8bfSDan Williams char devt_str[15]; 3111e105b8bfSDan Williams 3112e105b8bfSDan Williams if (kobj) { 3113e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3114e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 3115e105b8bfSDan Williams } 3116e105b8bfSDan Williams } 3117e105b8bfSDan Williams 311846d3a037SShaokun Zhang static int device_private_init(struct device *dev) 3119b4028437SGreg Kroah-Hartman { 3120b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 3121b4028437SGreg Kroah-Hartman if (!dev->p) 3122b4028437SGreg Kroah-Hartman return -ENOMEM; 3123b4028437SGreg Kroah-Hartman dev->p->device = dev; 3124b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 3125b4028437SGreg Kroah-Hartman klist_children_put); 3126ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 3127b4028437SGreg Kroah-Hartman return 0; 3128b4028437SGreg Kroah-Hartman } 3129b4028437SGreg Kroah-Hartman 3130e105b8bfSDan Williams /** 31311da177e4SLinus Torvalds * device_add - add device to device hierarchy. 31321da177e4SLinus Torvalds * @dev: device. 31331da177e4SLinus Torvalds * 31341da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 31351da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 31361da177e4SLinus Torvalds * 31375739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 31381da177e4SLinus Torvalds * to the global and sibling lists for the device, then 31391da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 31405739411aSCornelia Huck * 3141b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 3142b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 3143b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 3144b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 3145b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 3146b10d5efdSAlan Stern * and register a fresh new struct device instead. 3147b10d5efdSAlan Stern * 31485739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 31495739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 31505739411aSCornelia Huck * reference instead. 3151affada72SBorislav Petkov * 3152affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 3153affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 3154affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 3155affada72SBorislav Petkov * count. 31561da177e4SLinus Torvalds */ 31571da177e4SLinus Torvalds int device_add(struct device *dev) 31581da177e4SLinus Torvalds { 315935dbf4efSViresh Kumar struct device *parent; 3160ca22e56dSKay Sievers struct kobject *kobj; 3161c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 31625f5377eaSSaravana Kannan int error = -EINVAL; 3163cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3164775b64d2SRafael J. Wysocki 31651da177e4SLinus Torvalds dev = get_device(dev); 3166c906a48aSGreg Kroah-Hartman if (!dev) 3167c906a48aSGreg Kroah-Hartman goto done; 3168c906a48aSGreg Kroah-Hartman 3169fb069a5dSGreg Kroah-Hartman if (!dev->p) { 3170b4028437SGreg Kroah-Hartman error = device_private_init(dev); 3171b4028437SGreg Kroah-Hartman if (error) 3172fb069a5dSGreg Kroah-Hartman goto done; 3173fb069a5dSGreg Kroah-Hartman } 3174fb069a5dSGreg Kroah-Hartman 31751fa5ae85SKay Sievers /* 31761fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 31771fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 31781fa5ae85SKay Sievers * the name, and force the use of dev_name() 31791fa5ae85SKay Sievers */ 31801fa5ae85SKay Sievers if (dev->init_name) { 3181acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 31821fa5ae85SKay Sievers dev->init_name = NULL; 31831fa5ae85SKay Sievers } 3184c906a48aSGreg Kroah-Hartman 3185ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 3186ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 3187ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 3188ca22e56dSKay Sievers 3189e6309e75SThomas Gleixner if (!dev_name(dev)) { 3190e6309e75SThomas Gleixner error = -EINVAL; 31915c8563d7SKay Sievers goto name_error; 3192e6309e75SThomas Gleixner } 31931da177e4SLinus Torvalds 31941e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 3195c205ef48SGreg Kroah-Hartman 31961da177e4SLinus Torvalds parent = get_device(dev->parent); 3197ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 319884d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 319984d0c27dSTetsuo Handa error = PTR_ERR(kobj); 320084d0c27dSTetsuo Handa goto parent_error; 320184d0c27dSTetsuo Handa } 3202ca22e56dSKay Sievers if (kobj) 3203ca22e56dSKay Sievers dev->kobj.parent = kobj; 32041da177e4SLinus Torvalds 32050d358f22SYinghai Lu /* use parent numa_node */ 320656f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 32070d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 32080d358f22SYinghai Lu 32091da177e4SLinus Torvalds /* first, register with generic layer. */ 32108a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 32118a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 3212cebf8fd1SMing Lei if (error) { 3213cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 32141da177e4SLinus Torvalds goto Error; 3215cebf8fd1SMing Lei } 3216a7fd6706SKay Sievers 321737022644SBrian Walsh /* notify platform of device entry */ 321807de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 321907de0e86SHeikki Krogerus if (error) 322007de0e86SHeikki Krogerus goto platform_error; 322137022644SBrian Walsh 3222c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 3223a306eea4SCornelia Huck if (error) 3224a306eea4SCornelia Huck goto attrError; 3225a7fd6706SKay Sievers 32262ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 32272ee97cafSCornelia Huck if (error) 32282ee97cafSCornelia Huck goto SymlinkError; 3229dc0afa83SCornelia Huck error = device_add_attrs(dev); 3230dc0afa83SCornelia Huck if (error) 32312620efefSGreg Kroah-Hartman goto AttrsError; 3232dc0afa83SCornelia Huck error = bus_add_device(dev); 3233dc0afa83SCornelia Huck if (error) 32341da177e4SLinus Torvalds goto BusError; 32353b98aeafSAlan Stern error = dpm_sysfs_add(dev); 323657eee3d2SRafael J. Wysocki if (error) 32373b98aeafSAlan Stern goto DPMError; 32383b98aeafSAlan Stern device_pm_add(dev); 3239ec0676eeSAlan Stern 32400cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 32410cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 32420cd75047SSergey Klyaus if (error) 32430cd75047SSergey Klyaus goto DevAttrError; 32440cd75047SSergey Klyaus 32450cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 32460cd75047SSergey Klyaus if (error) 32470cd75047SSergey Klyaus goto SysEntryError; 32480cd75047SSergey Klyaus 32490cd75047SSergey Klyaus devtmpfs_create_node(dev); 32500cd75047SSergey Klyaus } 32510cd75047SSergey Klyaus 3252ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 3253268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 3254ec0676eeSAlan Stern */ 3255ec0676eeSAlan Stern if (dev->bus) 3256ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3257ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 3258ec0676eeSAlan Stern 325953877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 3260372a67c0SSaravana Kannan 3261e2ae9bccSSaravana Kannan /* 3262e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 3263e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 3264e2ae9bccSSaravana Kannan * link to it. 3265e2ae9bccSSaravana Kannan * 3266e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 3267e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 3268e2ae9bccSSaravana Kannan * 32692cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure 3270e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 3271e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 3272e2ae9bccSSaravana Kannan */ 32732cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 32742cd38fd1SSaravana Kannan dev->fwnode->dev = dev; 32755f5377eaSSaravana Kannan fw_devlink_link_device(dev); 327603324507SSaravana Kannan } 3277e2ae9bccSSaravana Kannan 32782023c610SAlan Stern bus_probe_device(dev); 32791da177e4SLinus Torvalds if (parent) 3280f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3281f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 32821da177e4SLinus Torvalds 32835d9fd169SGreg Kroah-Hartman if (dev->class) { 3284ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3285c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 3286570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 32876b6e39a6SKay Sievers &dev->class->p->klist_devices); 3288c47ed219SGreg Kroah-Hartman 3289c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 3290184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3291ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3292c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 3293c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 3294ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 32955d9fd169SGreg Kroah-Hartman } 3296c906a48aSGreg Kroah-Hartman done: 32971da177e4SLinus Torvalds put_device(dev); 32981da177e4SLinus Torvalds return error; 32990cd75047SSergey Klyaus SysEntryError: 33000cd75047SSergey Klyaus if (MAJOR(dev->devt)) 33010cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 33020cd75047SSergey Klyaus DevAttrError: 33030cd75047SSergey Klyaus device_pm_remove(dev); 33040cd75047SSergey Klyaus dpm_sysfs_remove(dev); 33053b98aeafSAlan Stern DPMError: 330657eee3d2SRafael J. Wysocki bus_remove_device(dev); 330757eee3d2SRafael J. Wysocki BusError: 33082620efefSGreg Kroah-Hartman device_remove_attrs(dev); 33092620efefSGreg Kroah-Hartman AttrsError: 33102ee97cafSCornelia Huck device_remove_class_symlinks(dev); 33112ee97cafSCornelia Huck SymlinkError: 3312c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 331323681e47SGreg Kroah-Hartman attrError: 331407de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 331507de0e86SHeikki Krogerus platform_error: 3316312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3317cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 33181da177e4SLinus Torvalds kobject_del(&dev->kobj); 33191da177e4SLinus Torvalds Error: 3320cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 332184d0c27dSTetsuo Handa parent_error: 33221da177e4SLinus Torvalds put_device(parent); 33235c8563d7SKay Sievers name_error: 33245c8563d7SKay Sievers kfree(dev->p); 33255c8563d7SKay Sievers dev->p = NULL; 3326c906a48aSGreg Kroah-Hartman goto done; 33271da177e4SLinus Torvalds } 332886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 33291da177e4SLinus Torvalds 33301da177e4SLinus Torvalds /** 33311da177e4SLinus Torvalds * device_register - register a device with the system. 33321da177e4SLinus Torvalds * @dev: pointer to the device structure 33331da177e4SLinus Torvalds * 33341da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 33351da177e4SLinus Torvalds * and add it to the system. The two steps can be called 33361da177e4SLinus Torvalds * separately, but this is the easiest and most common. 33371da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 33381da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 33391da177e4SLinus Torvalds * before it is added to the hierarchy. 33405739411aSCornelia Huck * 3341b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 3342b10d5efdSAlan Stern * and device_add(). 3343b10d5efdSAlan Stern * 33445739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 33455739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 33465739411aSCornelia Huck * reference initialized in this function instead. 33471da177e4SLinus Torvalds */ 33481da177e4SLinus Torvalds int device_register(struct device *dev) 33491da177e4SLinus Torvalds { 33501da177e4SLinus Torvalds device_initialize(dev); 33511da177e4SLinus Torvalds return device_add(dev); 33521da177e4SLinus Torvalds } 335386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 33541da177e4SLinus Torvalds 33551da177e4SLinus Torvalds /** 33561da177e4SLinus Torvalds * get_device - increment reference count for device. 33571da177e4SLinus Torvalds * @dev: device. 33581da177e4SLinus Torvalds * 33591da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 33601da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 33611da177e4SLinus Torvalds * pointer passed in. 33621da177e4SLinus Torvalds */ 33631da177e4SLinus Torvalds struct device *get_device(struct device *dev) 33641da177e4SLinus Torvalds { 3365b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 33661da177e4SLinus Torvalds } 336786df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 33681da177e4SLinus Torvalds 33691da177e4SLinus Torvalds /** 33701da177e4SLinus Torvalds * put_device - decrement reference count. 33711da177e4SLinus Torvalds * @dev: device in question. 33721da177e4SLinus Torvalds */ 33731da177e4SLinus Torvalds void put_device(struct device *dev) 33741da177e4SLinus Torvalds { 3375edfaa7c3SKay Sievers /* might_sleep(); */ 33761da177e4SLinus Torvalds if (dev) 33771da177e4SLinus Torvalds kobject_put(&dev->kobj); 33781da177e4SLinus Torvalds } 337986df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 33801da177e4SLinus Torvalds 338100289cd8SDan Williams bool kill_device(struct device *dev) 338200289cd8SDan Williams { 338300289cd8SDan Williams /* 338400289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 338500289cd8SDan Williams * the update behavior is consistent with the other bitfields near 338600289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 338700289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 338800289cd8SDan Williams * underneath the device. 338900289cd8SDan Williams */ 339000289cd8SDan Williams lockdep_assert_held(&dev->mutex); 339100289cd8SDan Williams 339200289cd8SDan Williams if (dev->p->dead) 339300289cd8SDan Williams return false; 339400289cd8SDan Williams dev->p->dead = true; 339500289cd8SDan Williams return true; 339600289cd8SDan Williams } 339700289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 339800289cd8SDan Williams 33991da177e4SLinus Torvalds /** 34001da177e4SLinus Torvalds * device_del - delete device from system. 34011da177e4SLinus Torvalds * @dev: device. 34021da177e4SLinus Torvalds * 34031da177e4SLinus Torvalds * This is the first part of the device unregistration 34041da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 34051da177e4SLinus Torvalds * from here, has it removed from the other driver model 34061da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 34071da177e4SLinus Torvalds * from the kobject hierarchy. 34081da177e4SLinus Torvalds * 34091da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 34101da177e4SLinus Torvalds * also called manually. 34111da177e4SLinus Torvalds */ 34121da177e4SLinus Torvalds void device_del(struct device *dev) 34131da177e4SLinus Torvalds { 34141da177e4SLinus Torvalds struct device *parent = dev->parent; 3415cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3416c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 3417b8530017SOliver Neukum unsigned int noio_flag; 34181da177e4SLinus Torvalds 34193451a495SAlexander Duyck device_lock(dev); 342000289cd8SDan Williams kill_device(dev); 34213451a495SAlexander Duyck device_unlock(dev); 34223451a495SAlexander Duyck 3423372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 3424372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 3425372a67c0SSaravana Kannan 3426ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 3427ec0676eeSAlan Stern * before dpm_sysfs_remove(). 3428ec0676eeSAlan Stern */ 3429b8530017SOliver Neukum noio_flag = memalloc_noio_save(); 3430ec0676eeSAlan Stern if (dev->bus) 3431ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3432ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 34339ed98953SRafael J. Wysocki 34343b98aeafSAlan Stern dpm_sysfs_remove(dev); 34351da177e4SLinus Torvalds if (parent) 3436f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 3437e105b8bfSDan Williams if (MAJOR(dev->devt)) { 34382b2af54aSKay Sievers devtmpfs_delete_node(dev); 3439e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 3440c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 3441e105b8bfSDan Williams } 3442b9d9c82bSKay Sievers if (dev->class) { 3443da231fd5SKay Sievers device_remove_class_symlinks(dev); 344499ef3ef8SKay Sievers 3445ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3446c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 3447184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3448ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3449c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 3450c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 3451c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 3452570d0200SWei Yang klist_del(&dev->p->knode_class); 3453ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 3454b9d9c82bSKay Sievers } 3455c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 34562620efefSGreg Kroah-Hartman device_remove_attrs(dev); 345728953533SBenjamin Herrenschmidt bus_remove_device(dev); 34584b6d1f12SLongX Zhang device_pm_remove(dev); 3459d1c3414cSGrant Likely driver_deferred_probe_del(dev); 346007de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 3461478573c9SLukas Wunner device_remove_properties(dev); 34622ec16150SJeffy Chen device_links_purge(dev); 34631da177e4SLinus Torvalds 3464599bad38SJoerg Roedel if (dev->bus) 3465599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3466599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 3467312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3468cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 34691da177e4SLinus Torvalds kobject_del(&dev->kobj); 3470cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 3471b8530017SOliver Neukum memalloc_noio_restore(noio_flag); 34721da177e4SLinus Torvalds put_device(parent); 34731da177e4SLinus Torvalds } 347486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 34751da177e4SLinus Torvalds 34761da177e4SLinus Torvalds /** 34771da177e4SLinus Torvalds * device_unregister - unregister device from system. 34781da177e4SLinus Torvalds * @dev: device going away. 34791da177e4SLinus Torvalds * 34801da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 34811da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 34821da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 34831da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 34841da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 34851da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 34861da177e4SLinus Torvalds */ 34871da177e4SLinus Torvalds void device_unregister(struct device *dev) 34881da177e4SLinus Torvalds { 34891e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 34901da177e4SLinus Torvalds device_del(dev); 34911da177e4SLinus Torvalds put_device(dev); 34921da177e4SLinus Torvalds } 349386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 34941da177e4SLinus Torvalds 34953d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 34963d060aebSAndy Shevchenko { 34973d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 34983d060aebSAndy Shevchenko struct device *dev = NULL; 34993d060aebSAndy Shevchenko struct device_private *p; 35003d060aebSAndy Shevchenko 35013d060aebSAndy Shevchenko if (n) { 35023d060aebSAndy Shevchenko p = to_device_private_parent(n); 35033d060aebSAndy Shevchenko dev = p->device; 35043d060aebSAndy Shevchenko } 35053d060aebSAndy Shevchenko return dev; 35063d060aebSAndy Shevchenko } 35073d060aebSAndy Shevchenko 350836239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 350936239577Smochel@digitalimplant.org { 351036239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 3511f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 3512f791b8c8SGreg Kroah-Hartman struct device_private *p; 3513f791b8c8SGreg Kroah-Hartman 3514f791b8c8SGreg Kroah-Hartman if (n) { 3515f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 3516f791b8c8SGreg Kroah-Hartman dev = p->device; 3517f791b8c8SGreg Kroah-Hartman } 3518f791b8c8SGreg Kroah-Hartman return dev; 351936239577Smochel@digitalimplant.org } 352036239577Smochel@digitalimplant.org 35211da177e4SLinus Torvalds /** 3522e454cea2SKay Sievers * device_get_devnode - path of device node file 35236fcf53acSKay Sievers * @dev: device 3524e454cea2SKay Sievers * @mode: returned file access mode 35253c2670e6SKay Sievers * @uid: returned file owner 35263c2670e6SKay Sievers * @gid: returned file group 35276fcf53acSKay Sievers * @tmp: possibly allocated string 35286fcf53acSKay Sievers * 35296fcf53acSKay Sievers * Return the relative path of a possible device node. 35306fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 35316fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 35326fcf53acSKay Sievers * freed by the caller. 35336fcf53acSKay Sievers */ 3534e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 35354e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 35363c2670e6SKay Sievers const char **tmp) 35376fcf53acSKay Sievers { 35386fcf53acSKay Sievers char *s; 35396fcf53acSKay Sievers 35406fcf53acSKay Sievers *tmp = NULL; 35416fcf53acSKay Sievers 35426fcf53acSKay Sievers /* the device type may provide a specific name */ 3543e454cea2SKay Sievers if (dev->type && dev->type->devnode) 35443c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 35456fcf53acSKay Sievers if (*tmp) 35466fcf53acSKay Sievers return *tmp; 35476fcf53acSKay Sievers 35486fcf53acSKay Sievers /* the class may provide a specific name */ 3549e454cea2SKay Sievers if (dev->class && dev->class->devnode) 3550e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 35516fcf53acSKay Sievers if (*tmp) 35526fcf53acSKay Sievers return *tmp; 35536fcf53acSKay Sievers 35546fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 35556fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 35566fcf53acSKay Sievers return dev_name(dev); 35576fcf53acSKay Sievers 35586fcf53acSKay Sievers /* replace '!' in the name with '/' */ 3559a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 3560a29fd614SRasmus Villemoes if (!s) 35616fcf53acSKay Sievers return NULL; 3562a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 3563a29fd614SRasmus Villemoes return *tmp = s; 35646fcf53acSKay Sievers } 35656fcf53acSKay Sievers 35666fcf53acSKay Sievers /** 35671da177e4SLinus Torvalds * device_for_each_child - device child iterator. 3568c41455fbSRandy Dunlap * @parent: parent struct device. 35691da177e4SLinus Torvalds * @fn: function to be called for each device. 3570f8878dcbSRobert P. J. Day * @data: data for the callback. 35711da177e4SLinus Torvalds * 3572c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 35731da177e4SLinus Torvalds * passing it @data. 35741da177e4SLinus Torvalds * 35751da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 35761da177e4SLinus Torvalds * other than 0, we break out and return that value. 35771da177e4SLinus Torvalds */ 357836239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 35794a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 35801da177e4SLinus Torvalds { 358136239577Smochel@digitalimplant.org struct klist_iter i; 35821da177e4SLinus Torvalds struct device *child; 35831da177e4SLinus Torvalds int error = 0; 35841da177e4SLinus Torvalds 3585014c90dbSGreg Kroah-Hartman if (!parent->p) 3586014c90dbSGreg Kroah-Hartman return 0; 3587014c90dbSGreg Kroah-Hartman 3588f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 358993ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 359036239577Smochel@digitalimplant.org error = fn(child, data); 359136239577Smochel@digitalimplant.org klist_iter_exit(&i); 35921da177e4SLinus Torvalds return error; 35931da177e4SLinus Torvalds } 359486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 35951da177e4SLinus Torvalds 35965ab69981SCornelia Huck /** 35973d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 35983d060aebSAndy Shevchenko * @parent: parent struct device. 35993d060aebSAndy Shevchenko * @fn: function to be called for each device. 36003d060aebSAndy Shevchenko * @data: data for the callback. 36013d060aebSAndy Shevchenko * 36023d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 36033d060aebSAndy Shevchenko * passing it @data. 36043d060aebSAndy Shevchenko * 36053d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 36063d060aebSAndy Shevchenko * other than 0, we break out and return that value. 36073d060aebSAndy Shevchenko */ 36083d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 36093d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 36103d060aebSAndy Shevchenko { 36113d060aebSAndy Shevchenko struct klist_iter i; 36123d060aebSAndy Shevchenko struct device *child; 36133d060aebSAndy Shevchenko int error = 0; 36143d060aebSAndy Shevchenko 36153d060aebSAndy Shevchenko if (!parent->p) 36163d060aebSAndy Shevchenko return 0; 36173d060aebSAndy Shevchenko 36183d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 36193d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 36203d060aebSAndy Shevchenko error = fn(child, data); 36213d060aebSAndy Shevchenko klist_iter_exit(&i); 36223d060aebSAndy Shevchenko return error; 36233d060aebSAndy Shevchenko } 36243d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 36253d060aebSAndy Shevchenko 36263d060aebSAndy Shevchenko /** 36275ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 36285ab69981SCornelia Huck * @parent: parent struct device 36295ab69981SCornelia Huck * @match: Callback function to check device 3630f8878dcbSRobert P. J. Day * @data: Data to pass to match function 36315ab69981SCornelia Huck * 36325ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 36335ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 36345ab69981SCornelia Huck * determined by the @match callback. 36355ab69981SCornelia Huck * 36365ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 36375ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 36385ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 36395ab69981SCornelia Huck * and not iterate over any more devices. 3640a4e2400aSFederico Vaga * 3641a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 36425ab69981SCornelia Huck */ 36435ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 36444a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 36455ab69981SCornelia Huck { 36465ab69981SCornelia Huck struct klist_iter i; 36475ab69981SCornelia Huck struct device *child; 36485ab69981SCornelia Huck 36495ab69981SCornelia Huck if (!parent) 36505ab69981SCornelia Huck return NULL; 36515ab69981SCornelia Huck 3652f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 36535ab69981SCornelia Huck while ((child = next_device(&i))) 36545ab69981SCornelia Huck if (match(child, data) && get_device(child)) 36555ab69981SCornelia Huck break; 36565ab69981SCornelia Huck klist_iter_exit(&i); 36575ab69981SCornelia Huck return child; 36585ab69981SCornelia Huck } 365986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 36605ab69981SCornelia Huck 3661dad9bb01SHeikki Krogerus /** 3662dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 3663dad9bb01SHeikki Krogerus * @parent: parent struct device 3664dad9bb01SHeikki Krogerus * @name: name of the child device 3665dad9bb01SHeikki Krogerus * 3666dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 3667dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 3668dad9bb01SHeikki Krogerus * 3669dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 3670dad9bb01SHeikki Krogerus */ 3671dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 3672dad9bb01SHeikki Krogerus const char *name) 3673dad9bb01SHeikki Krogerus { 3674dad9bb01SHeikki Krogerus struct klist_iter i; 3675dad9bb01SHeikki Krogerus struct device *child; 3676dad9bb01SHeikki Krogerus 3677dad9bb01SHeikki Krogerus if (!parent) 3678dad9bb01SHeikki Krogerus return NULL; 3679dad9bb01SHeikki Krogerus 3680dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 3681dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 3682c77f520dSDan Williams if (sysfs_streq(dev_name(child), name) && get_device(child)) 3683dad9bb01SHeikki Krogerus break; 3684dad9bb01SHeikki Krogerus klist_iter_exit(&i); 3685dad9bb01SHeikki Krogerus return child; 3686dad9bb01SHeikki Krogerus } 3687dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 3688dad9bb01SHeikki Krogerus 36891da177e4SLinus Torvalds int __init devices_init(void) 36901da177e4SLinus Torvalds { 3691881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 3692881c6cfdSGreg Kroah-Hartman if (!devices_kset) 3693881c6cfdSGreg Kroah-Hartman return -ENOMEM; 3694e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 3695e105b8bfSDan Williams if (!dev_kobj) 3696e105b8bfSDan Williams goto dev_kobj_err; 3697e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 3698e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 3699e105b8bfSDan Williams goto block_kobj_err; 3700e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 3701e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 3702e105b8bfSDan Williams goto char_kobj_err; 3703e105b8bfSDan Williams 3704881c6cfdSGreg Kroah-Hartman return 0; 3705e105b8bfSDan Williams 3706e105b8bfSDan Williams char_kobj_err: 3707e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 3708e105b8bfSDan Williams block_kobj_err: 3709e105b8bfSDan Williams kobject_put(dev_kobj); 3710e105b8bfSDan Williams dev_kobj_err: 3711e105b8bfSDan Williams kset_unregister(devices_kset); 3712e105b8bfSDan Williams return -ENOMEM; 37131da177e4SLinus Torvalds } 37141da177e4SLinus Torvalds 37154f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 37164f3549d7SRafael J. Wysocki { 37174f3549d7SRafael J. Wysocki int ret; 37184f3549d7SRafael J. Wysocki 37194f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 37204f3549d7SRafael J. Wysocki if (ret) 37214f3549d7SRafael J. Wysocki return ret; 37224f3549d7SRafael J. Wysocki 37234f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 37244f3549d7SRafael J. Wysocki } 37254f3549d7SRafael J. Wysocki 37264f3549d7SRafael J. Wysocki /** 37274f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 37284f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 37294f3549d7SRafael J. Wysocki * 37304f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 37314f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 37324f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 37334f3549d7SRafael J. Wysocki * is executed. 37344f3549d7SRafael J. Wysocki * 37354f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 37364f3549d7SRafael J. Wysocki */ 37374f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 37384f3549d7SRafael J. Wysocki { 37394f3549d7SRafael J. Wysocki int ret; 37404f3549d7SRafael J. Wysocki 37414f3549d7SRafael J. Wysocki if (dev->offline_disabled) 37424f3549d7SRafael J. Wysocki return -EPERM; 37434f3549d7SRafael J. Wysocki 37444f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 37454f3549d7SRafael J. Wysocki if (ret) 37464f3549d7SRafael J. Wysocki return ret; 37474f3549d7SRafael J. Wysocki 37484f3549d7SRafael J. Wysocki device_lock(dev); 37494f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 37504f3549d7SRafael J. Wysocki if (dev->offline) { 37514f3549d7SRafael J. Wysocki ret = 1; 37524f3549d7SRafael J. Wysocki } else { 37534f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 37544f3549d7SRafael J. Wysocki if (!ret) { 37554f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 37564f3549d7SRafael J. Wysocki dev->offline = true; 37574f3549d7SRafael J. Wysocki } 37584f3549d7SRafael J. Wysocki } 37594f3549d7SRafael J. Wysocki } 37604f3549d7SRafael J. Wysocki device_unlock(dev); 37614f3549d7SRafael J. Wysocki 37624f3549d7SRafael J. Wysocki return ret; 37634f3549d7SRafael J. Wysocki } 37644f3549d7SRafael J. Wysocki 37654f3549d7SRafael J. Wysocki /** 37664f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 37674f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 37684f3549d7SRafael J. Wysocki * 37694f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 37704f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 37714f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 37724f3549d7SRafael J. Wysocki * 37734f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 37744f3549d7SRafael J. Wysocki */ 37754f3549d7SRafael J. Wysocki int device_online(struct device *dev) 37764f3549d7SRafael J. Wysocki { 37774f3549d7SRafael J. Wysocki int ret = 0; 37784f3549d7SRafael J. Wysocki 37794f3549d7SRafael J. Wysocki device_lock(dev); 37804f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 37814f3549d7SRafael J. Wysocki if (dev->offline) { 37824f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 37834f3549d7SRafael J. Wysocki if (!ret) { 37844f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 37854f3549d7SRafael J. Wysocki dev->offline = false; 37864f3549d7SRafael J. Wysocki } 37874f3549d7SRafael J. Wysocki } else { 37884f3549d7SRafael J. Wysocki ret = 1; 37894f3549d7SRafael J. Wysocki } 37904f3549d7SRafael J. Wysocki } 37914f3549d7SRafael J. Wysocki device_unlock(dev); 37924f3549d7SRafael J. Wysocki 37934f3549d7SRafael J. Wysocki return ret; 37944f3549d7SRafael J. Wysocki } 37954f3549d7SRafael J. Wysocki 37967f100d15SKarthigan Srinivasan struct root_device { 37970aa0dc41SMark McLoughlin struct device dev; 37980aa0dc41SMark McLoughlin struct module *owner; 37990aa0dc41SMark McLoughlin }; 38000aa0dc41SMark McLoughlin 380193058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 3802481e2079SFerenc Wagner { 3803481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 3804481e2079SFerenc Wagner } 38050aa0dc41SMark McLoughlin 38060aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 38070aa0dc41SMark McLoughlin { 38080aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 38090aa0dc41SMark McLoughlin } 38100aa0dc41SMark McLoughlin 38110aa0dc41SMark McLoughlin /** 38120aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 38130aa0dc41SMark McLoughlin * @name: root device name 38140aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 38150aa0dc41SMark McLoughlin * 38160aa0dc41SMark McLoughlin * This function allocates a root device and registers it 38170aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 38180aa0dc41SMark McLoughlin * device, use root_device_unregister(). 38190aa0dc41SMark McLoughlin * 38200aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 38210aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 38220aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 38230aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 38240aa0dc41SMark McLoughlin * 38250aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 38260aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 38270aa0dc41SMark McLoughlin * in sysfs. 38280aa0dc41SMark McLoughlin * 3829f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3830f0eae0edSJani Nikula * 38310aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 38320aa0dc41SMark McLoughlin */ 38330aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 38340aa0dc41SMark McLoughlin { 38350aa0dc41SMark McLoughlin struct root_device *root; 38360aa0dc41SMark McLoughlin int err = -ENOMEM; 38370aa0dc41SMark McLoughlin 38380aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 38390aa0dc41SMark McLoughlin if (!root) 38400aa0dc41SMark McLoughlin return ERR_PTR(err); 38410aa0dc41SMark McLoughlin 3842acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 38430aa0dc41SMark McLoughlin if (err) { 38440aa0dc41SMark McLoughlin kfree(root); 38450aa0dc41SMark McLoughlin return ERR_PTR(err); 38460aa0dc41SMark McLoughlin } 38470aa0dc41SMark McLoughlin 38480aa0dc41SMark McLoughlin root->dev.release = root_device_release; 38490aa0dc41SMark McLoughlin 38500aa0dc41SMark McLoughlin err = device_register(&root->dev); 38510aa0dc41SMark McLoughlin if (err) { 38520aa0dc41SMark McLoughlin put_device(&root->dev); 38530aa0dc41SMark McLoughlin return ERR_PTR(err); 38540aa0dc41SMark McLoughlin } 38550aa0dc41SMark McLoughlin 38561d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 38570aa0dc41SMark McLoughlin if (owner) { 38580aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 38590aa0dc41SMark McLoughlin 38600aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 38610aa0dc41SMark McLoughlin if (err) { 38620aa0dc41SMark McLoughlin device_unregister(&root->dev); 38630aa0dc41SMark McLoughlin return ERR_PTR(err); 38640aa0dc41SMark McLoughlin } 38650aa0dc41SMark McLoughlin root->owner = owner; 38660aa0dc41SMark McLoughlin } 38670aa0dc41SMark McLoughlin #endif 38680aa0dc41SMark McLoughlin 38690aa0dc41SMark McLoughlin return &root->dev; 38700aa0dc41SMark McLoughlin } 38710aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 38720aa0dc41SMark McLoughlin 38730aa0dc41SMark McLoughlin /** 38740aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 38757cbcf225SRandy Dunlap * @dev: device going away 38760aa0dc41SMark McLoughlin * 38770aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 38780aa0dc41SMark McLoughlin * root_device_register(). 38790aa0dc41SMark McLoughlin */ 38800aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 38810aa0dc41SMark McLoughlin { 38820aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 38830aa0dc41SMark McLoughlin 38840aa0dc41SMark McLoughlin if (root->owner) 38850aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 38860aa0dc41SMark McLoughlin 38870aa0dc41SMark McLoughlin device_unregister(dev); 38880aa0dc41SMark McLoughlin } 38890aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 38900aa0dc41SMark McLoughlin 389123681e47SGreg Kroah-Hartman 389223681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 389323681e47SGreg Kroah-Hartman { 38941e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 389523681e47SGreg Kroah-Hartman kfree(dev); 389623681e47SGreg Kroah-Hartman } 389723681e47SGreg Kroah-Hartman 38986a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 389939ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 390039ef3112SGuenter Roeck dev_t devt, void *drvdata, 390139ef3112SGuenter Roeck const struct attribute_group **groups, 390239ef3112SGuenter Roeck const char *fmt, va_list args) 390339ef3112SGuenter Roeck { 390439ef3112SGuenter Roeck struct device *dev = NULL; 390539ef3112SGuenter Roeck int retval = -ENODEV; 390639ef3112SGuenter Roeck 390739ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 390839ef3112SGuenter Roeck goto error; 390939ef3112SGuenter Roeck 391039ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 391139ef3112SGuenter Roeck if (!dev) { 391239ef3112SGuenter Roeck retval = -ENOMEM; 391339ef3112SGuenter Roeck goto error; 391439ef3112SGuenter Roeck } 391539ef3112SGuenter Roeck 3916bbc780f8SDavid Herrmann device_initialize(dev); 391739ef3112SGuenter Roeck dev->devt = devt; 391839ef3112SGuenter Roeck dev->class = class; 391939ef3112SGuenter Roeck dev->parent = parent; 392039ef3112SGuenter Roeck dev->groups = groups; 392139ef3112SGuenter Roeck dev->release = device_create_release; 392239ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 392339ef3112SGuenter Roeck 392439ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 392539ef3112SGuenter Roeck if (retval) 392639ef3112SGuenter Roeck goto error; 392739ef3112SGuenter Roeck 3928bbc780f8SDavid Herrmann retval = device_add(dev); 392939ef3112SGuenter Roeck if (retval) 393039ef3112SGuenter Roeck goto error; 393139ef3112SGuenter Roeck 393239ef3112SGuenter Roeck return dev; 393339ef3112SGuenter Roeck 393439ef3112SGuenter Roeck error: 393539ef3112SGuenter Roeck put_device(dev); 393639ef3112SGuenter Roeck return ERR_PTR(retval); 393739ef3112SGuenter Roeck } 393839ef3112SGuenter Roeck 393923681e47SGreg Kroah-Hartman /** 39404e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 39418882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 39428882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 39438882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 39448882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 39458882b394SGreg Kroah-Hartman * @fmt: string for the device's name 39468882b394SGreg Kroah-Hartman * 39478882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 39488882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 39498882b394SGreg Kroah-Hartman * 39508882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 39518882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 39528882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 39538882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 39548882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 39558882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 39568882b394SGreg Kroah-Hartman * pointer. 39578882b394SGreg Kroah-Hartman * 3958f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3959f0eae0edSJani Nikula * 39608882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 39618882b394SGreg Kroah-Hartman * been created with a call to class_create(). 39628882b394SGreg Kroah-Hartman */ 39634e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 39644e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 39658882b394SGreg Kroah-Hartman { 39668882b394SGreg Kroah-Hartman va_list vargs; 39678882b394SGreg Kroah-Hartman struct device *dev; 39688882b394SGreg Kroah-Hartman 39698882b394SGreg Kroah-Hartman va_start(vargs, fmt); 39704c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL, 39714c747466SChristoph Hellwig fmt, vargs); 39728882b394SGreg Kroah-Hartman va_end(vargs); 39738882b394SGreg Kroah-Hartman return dev; 39748882b394SGreg Kroah-Hartman } 39754e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 39768882b394SGreg Kroah-Hartman 397739ef3112SGuenter Roeck /** 397839ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 397939ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 398039ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 398139ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 398239ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 398339ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 398439ef3112SGuenter Roeck * @fmt: string for the device's name 398539ef3112SGuenter Roeck * 398639ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 398739ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 398839ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 398939ef3112SGuenter Roeck * be created automatically. 399039ef3112SGuenter Roeck * 399139ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 399239ef3112SGuenter Roeck * the dev_t is not 0,0. 399339ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 399439ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 399539ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 399639ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 399739ef3112SGuenter Roeck * pointer. 399839ef3112SGuenter Roeck * 399939ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 400039ef3112SGuenter Roeck * 400139ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 400239ef3112SGuenter Roeck * been created with a call to class_create(). 400339ef3112SGuenter Roeck */ 400439ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 400539ef3112SGuenter Roeck struct device *parent, dev_t devt, 400639ef3112SGuenter Roeck void *drvdata, 400739ef3112SGuenter Roeck const struct attribute_group **groups, 400839ef3112SGuenter Roeck const char *fmt, ...) 400939ef3112SGuenter Roeck { 401039ef3112SGuenter Roeck va_list vargs; 401139ef3112SGuenter Roeck struct device *dev; 401239ef3112SGuenter Roeck 401339ef3112SGuenter Roeck va_start(vargs, fmt); 401439ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 401539ef3112SGuenter Roeck fmt, vargs); 401639ef3112SGuenter Roeck va_end(vargs); 401739ef3112SGuenter Roeck return dev; 401839ef3112SGuenter Roeck } 401939ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 402039ef3112SGuenter Roeck 4021775b64d2SRafael J. Wysocki /** 4022775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 4023775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 4024775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 4025775b64d2SRafael J. Wysocki * 4026775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 4027775b64d2SRafael J. Wysocki * call to device_create(). 4028775b64d2SRafael J. Wysocki */ 4029775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 4030775b64d2SRafael J. Wysocki { 4031775b64d2SRafael J. Wysocki struct device *dev; 4032775b64d2SRafael J. Wysocki 40334495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 4034cd35449bSDave Young if (dev) { 4035cd35449bSDave Young put_device(dev); 403623681e47SGreg Kroah-Hartman device_unregister(dev); 403723681e47SGreg Kroah-Hartman } 4038cd35449bSDave Young } 403923681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 4040a2de48caSGreg Kroah-Hartman 4041a2de48caSGreg Kroah-Hartman /** 4042a2de48caSGreg Kroah-Hartman * device_rename - renames a device 4043a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 4044a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 4045030c1d2bSEric W. Biederman * 4046030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 4047030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 4048030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 4049030c1d2bSEric W. Biederman * won't conflict with other devices. 4050c6c0ac66SMichael Ellerman * 4051a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 4052a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 4053a5462516STimur Tabi * some insight: 4054a5462516STimur Tabi * 4055a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 4056a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 4057a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 4058a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 4059a5462516STimur Tabi * 4060a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 4061a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 4062a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 4063a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 4064a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 4065a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 4066a5462516STimur Tabi * 4067a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 4068a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 4069a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 4070a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 4071a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 4072a5462516STimur Tabi * reasons. 4073a5462516STimur Tabi * 4074a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 4075a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 4076a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 4077a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 4078a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 4079a2de48caSGreg Kroah-Hartman */ 40806937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 4081a2de48caSGreg Kroah-Hartman { 40824b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 40832ee97cafSCornelia Huck char *old_device_name = NULL; 4084a2de48caSGreg Kroah-Hartman int error; 4085a2de48caSGreg Kroah-Hartman 4086a2de48caSGreg Kroah-Hartman dev = get_device(dev); 4087a2de48caSGreg Kroah-Hartman if (!dev) 4088a2de48caSGreg Kroah-Hartman return -EINVAL; 4089a2de48caSGreg Kroah-Hartman 409069df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 4091a2de48caSGreg Kroah-Hartman 40921fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 40932ee97cafSCornelia Huck if (!old_device_name) { 4094952ab431SJesper Juhl error = -ENOMEM; 40952ee97cafSCornelia Huck goto out; 4096952ab431SJesper Juhl } 4097a2de48caSGreg Kroah-Hartman 4098f349cf34SEric W. Biederman if (dev->class) { 40994b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 41004b30ee58STejun Heo kobj, old_device_name, 41014b30ee58STejun Heo new_name, kobject_namespace(kobj)); 4102f349cf34SEric W. Biederman if (error) 4103f349cf34SEric W. Biederman goto out; 4104f349cf34SEric W. Biederman } 410539aba963SKay Sievers 41064b30ee58STejun Heo error = kobject_rename(kobj, new_name); 41071fa5ae85SKay Sievers if (error) 41082ee97cafSCornelia Huck goto out; 4109a2de48caSGreg Kroah-Hartman 41102ee97cafSCornelia Huck out: 4111a2de48caSGreg Kroah-Hartman put_device(dev); 4112a2de48caSGreg Kroah-Hartman 41132ee97cafSCornelia Huck kfree(old_device_name); 4114a2de48caSGreg Kroah-Hartman 4115a2de48caSGreg Kroah-Hartman return error; 4116a2de48caSGreg Kroah-Hartman } 4117a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 41188a82472fSCornelia Huck 41198a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 41208a82472fSCornelia Huck struct device *old_parent, 41218a82472fSCornelia Huck struct device *new_parent) 41228a82472fSCornelia Huck { 4123f7f3461dSGreg Kroah-Hartman int error = 0; 41248a82472fSCornelia Huck 4125f7f3461dSGreg Kroah-Hartman if (old_parent) 4126f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 4127f7f3461dSGreg Kroah-Hartman if (new_parent) 4128f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 4129f7f3461dSGreg Kroah-Hartman "device"); 4130f7f3461dSGreg Kroah-Hartman return error; 41318a82472fSCornelia Huck } 41328a82472fSCornelia Huck 41338a82472fSCornelia Huck /** 41348a82472fSCornelia Huck * device_move - moves a device to a new parent 41358a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 413613509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 4137ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 41388a82472fSCornelia Huck */ 4139ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 4140ffa6a705SCornelia Huck enum dpm_order dpm_order) 41418a82472fSCornelia Huck { 41428a82472fSCornelia Huck int error; 41438a82472fSCornelia Huck struct device *old_parent; 4144c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 41458a82472fSCornelia Huck 41468a82472fSCornelia Huck dev = get_device(dev); 41478a82472fSCornelia Huck if (!dev) 41488a82472fSCornelia Huck return -EINVAL; 41498a82472fSCornelia Huck 4150ffa6a705SCornelia Huck device_pm_lock(); 41518a82472fSCornelia Huck new_parent = get_device(new_parent); 4152c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 415384d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 415484d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 415584d0c27dSTetsuo Handa put_device(new_parent); 415684d0c27dSTetsuo Handa goto out; 415784d0c27dSTetsuo Handa } 415863b6971aSCornelia Huck 41591e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 41601e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 4161c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 41628a82472fSCornelia Huck if (error) { 416363b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 41648a82472fSCornelia Huck put_device(new_parent); 41658a82472fSCornelia Huck goto out; 41668a82472fSCornelia Huck } 41678a82472fSCornelia Huck old_parent = dev->parent; 41688a82472fSCornelia Huck dev->parent = new_parent; 41698a82472fSCornelia Huck if (old_parent) 4170f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 41710d358f22SYinghai Lu if (new_parent) { 4172f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4173f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 41740d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 41750d358f22SYinghai Lu } 41760d358f22SYinghai Lu 4177bdd4034dSRabin Vincent if (dev->class) { 41788a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 41798a82472fSCornelia Huck if (error) { 41808a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 41818a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 41828a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 4183c744aeaeSCornelia Huck if (new_parent) 4184f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 41850d358f22SYinghai Lu dev->parent = old_parent; 41860d358f22SYinghai Lu if (old_parent) { 4187f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4188f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 41890d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 41900d358f22SYinghai Lu } 41918a82472fSCornelia Huck } 419263b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 41938a82472fSCornelia Huck put_device(new_parent); 41948a82472fSCornelia Huck goto out; 41958a82472fSCornelia Huck } 4196bdd4034dSRabin Vincent } 4197ffa6a705SCornelia Huck switch (dpm_order) { 4198ffa6a705SCornelia Huck case DPM_ORDER_NONE: 4199ffa6a705SCornelia Huck break; 4200ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 4201ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 420252cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 4203ffa6a705SCornelia Huck break; 4204ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 4205ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 420652cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 4207ffa6a705SCornelia Huck break; 4208ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 4209ffa6a705SCornelia Huck device_pm_move_last(dev); 421052cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 4211ffa6a705SCornelia Huck break; 4212ffa6a705SCornelia Huck } 4213bdd4034dSRabin Vincent 42148a82472fSCornelia Huck put_device(old_parent); 42158a82472fSCornelia Huck out: 4216ffa6a705SCornelia Huck device_pm_unlock(); 42178a82472fSCornelia Huck put_device(dev); 42188a82472fSCornelia Huck return error; 42198a82472fSCornelia Huck } 42208a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 422137b0c020SGreg Kroah-Hartman 4222b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 4223b8f33e5dSChristian Brauner kgid_t kgid) 4224b8f33e5dSChristian Brauner { 4225b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4226b8f33e5dSChristian Brauner struct class *class = dev->class; 4227b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 4228b8f33e5dSChristian Brauner int error; 4229b8f33e5dSChristian Brauner 4230b8f33e5dSChristian Brauner if (class) { 4231b8f33e5dSChristian Brauner /* 4232b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 4233b8f33e5dSChristian Brauner * @kuid/@kgid. 4234b8f33e5dSChristian Brauner */ 4235b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 4236b8f33e5dSChristian Brauner kgid); 4237b8f33e5dSChristian Brauner if (error) 4238b8f33e5dSChristian Brauner return error; 4239b8f33e5dSChristian Brauner } 4240b8f33e5dSChristian Brauner 4241b8f33e5dSChristian Brauner if (type) { 4242b8f33e5dSChristian Brauner /* 4243b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 4244b8f33e5dSChristian Brauner * @kuid/@kgid. 4245b8f33e5dSChristian Brauner */ 4246b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 4247b8f33e5dSChristian Brauner kgid); 4248b8f33e5dSChristian Brauner if (error) 4249b8f33e5dSChristian Brauner return error; 4250b8f33e5dSChristian Brauner } 4251b8f33e5dSChristian Brauner 4252b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 4253b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 4254b8f33e5dSChristian Brauner if (error) 4255b8f33e5dSChristian Brauner return error; 4256b8f33e5dSChristian Brauner 4257b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 4258b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 4259b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 4260b8f33e5dSChristian Brauner kuid, kgid); 4261b8f33e5dSChristian Brauner if (error) 4262b8f33e5dSChristian Brauner return error; 4263b8f33e5dSChristian Brauner } 4264b8f33e5dSChristian Brauner 4265b8f33e5dSChristian Brauner return 0; 4266b8f33e5dSChristian Brauner } 4267b8f33e5dSChristian Brauner 4268b8f33e5dSChristian Brauner /** 4269b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 4270b8f33e5dSChristian Brauner * @dev: device. 4271b8f33e5dSChristian Brauner * @kuid: new owner's kuid 4272b8f33e5dSChristian Brauner * @kgid: new owner's kgid 4273b8f33e5dSChristian Brauner * 4274b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 4275b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 4276b8f33e5dSChristian Brauner * core. 4277b8f33e5dSChristian Brauner * 4278b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 4279b8f33e5dSChristian Brauner */ 4280b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 4281b8f33e5dSChristian Brauner { 4282b8f33e5dSChristian Brauner int error; 4283b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4284b8f33e5dSChristian Brauner 4285b8f33e5dSChristian Brauner dev = get_device(dev); 4286b8f33e5dSChristian Brauner if (!dev) 4287b8f33e5dSChristian Brauner return -EINVAL; 4288b8f33e5dSChristian Brauner 4289b8f33e5dSChristian Brauner /* 4290b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 4291b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 4292b8f33e5dSChristian Brauner */ 4293b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 4294b8f33e5dSChristian Brauner if (error) 4295b8f33e5dSChristian Brauner goto out; 4296b8f33e5dSChristian Brauner 4297b8f33e5dSChristian Brauner /* 4298b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 4299b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 4300b8f33e5dSChristian Brauner * that step here. 4301b8f33e5dSChristian Brauner */ 4302b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 4303b8f33e5dSChristian Brauner kgid); 4304b8f33e5dSChristian Brauner if (error) 4305b8f33e5dSChristian Brauner goto out; 4306b8f33e5dSChristian Brauner 4307b8f33e5dSChristian Brauner /* 4308b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 4309b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 4310b8f33e5dSChristian Brauner * to @kuid/@kgid. 4311b8f33e5dSChristian Brauner */ 4312b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 4313b8f33e5dSChristian Brauner if (error) 4314b8f33e5dSChristian Brauner goto out; 4315b8f33e5dSChristian Brauner 43163b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 43173b52fc5dSChristian Brauner if (error) 43183b52fc5dSChristian Brauner goto out; 43193b52fc5dSChristian Brauner 4320b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 4321b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 4322b8f33e5dSChristian Brauner goto out; 4323b8f33e5dSChristian Brauner #endif 4324b8f33e5dSChristian Brauner 4325b8f33e5dSChristian Brauner /* 4326b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 4327b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 4328b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 4329b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 4330b8f33e5dSChristian Brauner */ 4331b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 4332b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 4333b8f33e5dSChristian Brauner if (error) 4334b8f33e5dSChristian Brauner goto out; 4335b8f33e5dSChristian Brauner 4336b8f33e5dSChristian Brauner out: 4337b8f33e5dSChristian Brauner put_device(dev); 4338b8f33e5dSChristian Brauner return error; 4339b8f33e5dSChristian Brauner } 4340b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 4341b8f33e5dSChristian Brauner 434237b0c020SGreg Kroah-Hartman /** 434337b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 434437b0c020SGreg Kroah-Hartman */ 434537b0c020SGreg Kroah-Hartman void device_shutdown(void) 434637b0c020SGreg Kroah-Hartman { 4347f123db8eSBenson Leung struct device *dev, *parent; 434837b0c020SGreg Kroah-Hartman 43493297c8fcSPingfan Liu wait_for_device_probe(); 43503297c8fcSPingfan Liu device_block_probing(); 43513297c8fcSPingfan Liu 435265650b35SRafael J. Wysocki cpufreq_suspend(); 435365650b35SRafael J. Wysocki 43546245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 43556245838fSHugh Daschbach /* 43566245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 43576245838fSHugh Daschbach * Beware that device unplug events may also start pulling 43586245838fSHugh Daschbach * devices offline, even as the system is shutting down. 43596245838fSHugh Daschbach */ 43606245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 43616245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 43626245838fSHugh Daschbach kobj.entry); 4363d1c6c030SMing Lei 4364d1c6c030SMing Lei /* 4365d1c6c030SMing Lei * hold reference count of device's parent to 4366d1c6c030SMing Lei * prevent it from being freed because parent's 4367d1c6c030SMing Lei * lock is to be held 4368d1c6c030SMing Lei */ 4369f123db8eSBenson Leung parent = get_device(dev->parent); 43706245838fSHugh Daschbach get_device(dev); 43716245838fSHugh Daschbach /* 43726245838fSHugh Daschbach * Make sure the device is off the kset list, in the 43736245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 43746245838fSHugh Daschbach */ 43756245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 43766245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 4377fe6b91f4SAlan Stern 4378d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 4379f123db8eSBenson Leung if (parent) 4380f123db8eSBenson Leung device_lock(parent); 4381d1c6c030SMing Lei device_lock(dev); 4382d1c6c030SMing Lei 4383fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 4384fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 4385fe6b91f4SAlan Stern pm_runtime_barrier(dev); 43866245838fSHugh Daschbach 43877521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 4388f77af151SJosh Zimmerman if (initcall_debug) 43897521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 43907521621eSMichal Suchanek dev->class->shutdown_pre(dev); 43917521621eSMichal Suchanek } 43927521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 43930246c4faSShuoX Liu if (initcall_debug) 43940246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 439537b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 439637b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 43970246c4faSShuoX Liu if (initcall_debug) 43980246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 439937b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 440037b0c020SGreg Kroah-Hartman } 4401d1c6c030SMing Lei 4402d1c6c030SMing Lei device_unlock(dev); 4403f123db8eSBenson Leung if (parent) 4404f123db8eSBenson Leung device_unlock(parent); 4405d1c6c030SMing Lei 44066245838fSHugh Daschbach put_device(dev); 4407f123db8eSBenson Leung put_device(parent); 44086245838fSHugh Daschbach 44096245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 441037b0c020SGreg Kroah-Hartman } 44116245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 441237b0c020SGreg Kroah-Hartman } 441399bcf217SJoe Perches 441499bcf217SJoe Perches /* 441599bcf217SJoe Perches * Device logging functions 441699bcf217SJoe Perches */ 441799bcf217SJoe Perches 441899bcf217SJoe Perches #ifdef CONFIG_PRINTK 441974caba7fSJohn Ogness static void 442074caba7fSJohn Ogness set_dev_info(const struct device *dev, struct dev_printk_info *dev_info) 442199bcf217SJoe Perches { 4422c4e00daaSKay Sievers const char *subsys; 442374caba7fSJohn Ogness 442474caba7fSJohn Ogness memset(dev_info, 0, sizeof(*dev_info)); 442599bcf217SJoe Perches 4426c4e00daaSKay Sievers if (dev->class) 4427c4e00daaSKay Sievers subsys = dev->class->name; 4428c4e00daaSKay Sievers else if (dev->bus) 4429c4e00daaSKay Sievers subsys = dev->bus->name; 4430c4e00daaSKay Sievers else 443174caba7fSJohn Ogness return; 4432c4e00daaSKay Sievers 443374caba7fSJohn Ogness strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); 4434c4e00daaSKay Sievers 4435c4e00daaSKay Sievers /* 4436c4e00daaSKay Sievers * Add device identifier DEVICE=: 4437c4e00daaSKay Sievers * b12:8 block dev_t 4438c4e00daaSKay Sievers * c127:3 char dev_t 4439c4e00daaSKay Sievers * n8 netdev ifindex 4440c4e00daaSKay Sievers * +sound:card0 subsystem:devname 4441c4e00daaSKay Sievers */ 4442c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 4443c4e00daaSKay Sievers char c; 4444c4e00daaSKay Sievers 4445c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 4446c4e00daaSKay Sievers c = 'b'; 4447c4e00daaSKay Sievers else 4448c4e00daaSKay Sievers c = 'c'; 444974caba7fSJohn Ogness 445074caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 445174caba7fSJohn Ogness "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); 4452c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 4453c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 4454c4e00daaSKay Sievers 445574caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 445674caba7fSJohn Ogness "n%u", net->ifindex); 4457c4e00daaSKay Sievers } else { 445874caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 445974caba7fSJohn Ogness "+%s:%s", subsys, dev_name(dev)); 4460c4e00daaSKay Sievers } 446199bcf217SJoe Perches } 4462798efc60SJoe Perches 446305e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 446405e4e5b8SJoe Perches const char *fmt, va_list args) 446505e4e5b8SJoe Perches { 446674caba7fSJohn Ogness struct dev_printk_info dev_info; 446705e4e5b8SJoe Perches 446874caba7fSJohn Ogness set_dev_info(dev, &dev_info); 446905e4e5b8SJoe Perches 447074caba7fSJohn Ogness return vprintk_emit(0, level, &dev_info, fmt, args); 447105e4e5b8SJoe Perches } 447205e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 447305e4e5b8SJoe Perches 447405e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 447505e4e5b8SJoe Perches { 447605e4e5b8SJoe Perches va_list args; 447705e4e5b8SJoe Perches int r; 447805e4e5b8SJoe Perches 447905e4e5b8SJoe Perches va_start(args, fmt); 448005e4e5b8SJoe Perches 448105e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 448205e4e5b8SJoe Perches 448305e4e5b8SJoe Perches va_end(args); 448405e4e5b8SJoe Perches 448505e4e5b8SJoe Perches return r; 448605e4e5b8SJoe Perches } 448705e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 448805e4e5b8SJoe Perches 4489d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 4490798efc60SJoe Perches struct va_format *vaf) 4491798efc60SJoe Perches { 4492d1f1052cSJoe Perches if (dev) 4493d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 4494798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 4495d1f1052cSJoe Perches else 4496d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 4497798efc60SJoe Perches } 449899bcf217SJoe Perches 4499d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 450099bcf217SJoe Perches const char *fmt, ...) 450199bcf217SJoe Perches { 450299bcf217SJoe Perches struct va_format vaf; 450399bcf217SJoe Perches va_list args; 450499bcf217SJoe Perches 450599bcf217SJoe Perches va_start(args, fmt); 450699bcf217SJoe Perches 450799bcf217SJoe Perches vaf.fmt = fmt; 450899bcf217SJoe Perches vaf.va = &args; 450999bcf217SJoe Perches 4510d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 4511798efc60SJoe Perches 451299bcf217SJoe Perches va_end(args); 451399bcf217SJoe Perches } 451499bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 451599bcf217SJoe Perches 451699bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 4517d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 451899bcf217SJoe Perches { \ 451999bcf217SJoe Perches struct va_format vaf; \ 452099bcf217SJoe Perches va_list args; \ 452199bcf217SJoe Perches \ 452299bcf217SJoe Perches va_start(args, fmt); \ 452399bcf217SJoe Perches \ 452499bcf217SJoe Perches vaf.fmt = fmt; \ 452599bcf217SJoe Perches vaf.va = &args; \ 452699bcf217SJoe Perches \ 4527d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 4528798efc60SJoe Perches \ 452999bcf217SJoe Perches va_end(args); \ 453099bcf217SJoe Perches } \ 453199bcf217SJoe Perches EXPORT_SYMBOL(func); 453299bcf217SJoe Perches 4533663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 4534663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 4535663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 4536663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 4537663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 4538663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 453999bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 454099bcf217SJoe Perches 454199bcf217SJoe Perches #endif 454297badf87SRafael J. Wysocki 4543a787e540SAndrzej Hajda /** 4544a787e540SAndrzej Hajda * dev_err_probe - probe error check and log helper 4545a787e540SAndrzej Hajda * @dev: the pointer to the struct device 4546a787e540SAndrzej Hajda * @err: error value to test 4547a787e540SAndrzej Hajda * @fmt: printf-style format string 4548a787e540SAndrzej Hajda * @...: arguments as specified in the format string 4549a787e540SAndrzej Hajda * 4550a787e540SAndrzej Hajda * This helper implements common pattern present in probe functions for error 4551a787e540SAndrzej Hajda * checking: print debug or error message depending if the error value is 4552a787e540SAndrzej Hajda * -EPROBE_DEFER and propagate error upwards. 4553d090b70eSAndrzej Hajda * In case of -EPROBE_DEFER it sets also defer probe reason, which can be 4554d090b70eSAndrzej Hajda * checked later by reading devices_deferred debugfs attribute. 4555074b3aadSMauro Carvalho Chehab * It replaces code sequence:: 4556074b3aadSMauro Carvalho Chehab * 4557a787e540SAndrzej Hajda * if (err != -EPROBE_DEFER) 4558a787e540SAndrzej Hajda * dev_err(dev, ...); 4559a787e540SAndrzej Hajda * else 4560a787e540SAndrzej Hajda * dev_dbg(dev, ...); 4561a787e540SAndrzej Hajda * return err; 4562074b3aadSMauro Carvalho Chehab * 4563074b3aadSMauro Carvalho Chehab * with:: 4564074b3aadSMauro Carvalho Chehab * 4565a787e540SAndrzej Hajda * return dev_err_probe(dev, err, ...); 4566a787e540SAndrzej Hajda * 4567a787e540SAndrzej Hajda * Returns @err. 4568a787e540SAndrzej Hajda * 4569a787e540SAndrzej Hajda */ 4570a787e540SAndrzej Hajda int dev_err_probe(const struct device *dev, int err, const char *fmt, ...) 4571a787e540SAndrzej Hajda { 4572a787e540SAndrzej Hajda struct va_format vaf; 4573a787e540SAndrzej Hajda va_list args; 4574a787e540SAndrzej Hajda 4575a787e540SAndrzej Hajda va_start(args, fmt); 4576a787e540SAndrzej Hajda vaf.fmt = fmt; 4577a787e540SAndrzej Hajda vaf.va = &args; 4578a787e540SAndrzej Hajda 4579d090b70eSAndrzej Hajda if (err != -EPROBE_DEFER) { 4580693a8e93SMichał Mirosław dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4581d090b70eSAndrzej Hajda } else { 4582d090b70eSAndrzej Hajda device_set_deferred_probe_reason(dev, &vaf); 4583693a8e93SMichał Mirosław dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4584d090b70eSAndrzej Hajda } 4585a787e540SAndrzej Hajda 4586a787e540SAndrzej Hajda va_end(args); 4587a787e540SAndrzej Hajda 4588a787e540SAndrzej Hajda return err; 4589a787e540SAndrzej Hajda } 4590a787e540SAndrzej Hajda EXPORT_SYMBOL_GPL(dev_err_probe); 4591a787e540SAndrzej Hajda 459297badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 459397badf87SRafael J. Wysocki { 459497badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 459597badf87SRafael J. Wysocki } 459697badf87SRafael J. Wysocki 459797badf87SRafael J. Wysocki /** 459897badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 459997badf87SRafael J. Wysocki * @dev: Device to handle. 460097badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 460197badf87SRafael J. Wysocki * 460297badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 460397badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 46043f7bddafSBard Liao * 46053f7bddafSBard Liao * Valid fwnode cases are: 46063f7bddafSBard Liao * - primary --> secondary --> -ENODEV 46073f7bddafSBard Liao * - primary --> NULL 46083f7bddafSBard Liao * - secondary --> -ENODEV 46093f7bddafSBard Liao * - NULL 461097badf87SRafael J. Wysocki */ 461197badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 461297badf87SRafael J. Wysocki { 461399aed922SAndy Shevchenko struct device *parent = dev->parent; 461497badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 461597badf87SRafael J. Wysocki 4616c15e1bddSHeikki Krogerus if (fwnode) { 461797badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 461897badf87SRafael J. Wysocki fn = fn->secondary; 461997badf87SRafael J. Wysocki 462055f89a8aSMika Westerberg if (fn) { 462155f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 462297badf87SRafael J. Wysocki fwnode->secondary = fn; 462355f89a8aSMika Westerberg } 462497badf87SRafael J. Wysocki dev->fwnode = fwnode; 462597badf87SRafael J. Wysocki } else { 4626c15e1bddSHeikki Krogerus if (fwnode_is_primary(fn)) { 4627c15e1bddSHeikki Krogerus dev->fwnode = fn->secondary; 46283f7bddafSBard Liao /* Set fn->secondary = NULL, so fn remains the primary fwnode */ 462999aed922SAndy Shevchenko if (!(parent && fn == parent->fwnode)) 463047f44699SBard Liao fn->secondary = NULL; 4631c15e1bddSHeikki Krogerus } else { 4632c15e1bddSHeikki Krogerus dev->fwnode = NULL; 4633c15e1bddSHeikki Krogerus } 463497badf87SRafael J. Wysocki } 463597badf87SRafael J. Wysocki } 463697badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 463797badf87SRafael J. Wysocki 463897badf87SRafael J. Wysocki /** 463997badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 464097badf87SRafael J. Wysocki * @dev: Device to handle. 464197badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 464297badf87SRafael J. Wysocki * 464397badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 464497badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 464597badf87SRafael J. Wysocki * @fwnode. 464697badf87SRafael J. Wysocki */ 464797badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 464897badf87SRafael J. Wysocki { 464997badf87SRafael J. Wysocki if (fwnode) 465097badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 465197badf87SRafael J. Wysocki 465297badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 465397badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 465497badf87SRafael J. Wysocki else 465597badf87SRafael J. Wysocki dev->fwnode = fwnode; 465697badf87SRafael J. Wysocki } 465796489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 46584e75e1d7SJohan Hovold 46594e75e1d7SJohan Hovold /** 46604e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 46614e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 46624e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 46634e75e1d7SJohan Hovold * 46644e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 46654e75e1d7SJohan Hovold * any reference held to the old node. 46664e75e1d7SJohan Hovold */ 46674e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 46684e75e1d7SJohan Hovold { 46694e75e1d7SJohan Hovold of_node_put(dev->of_node); 46704e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 46714e75e1d7SJohan Hovold dev->of_node_reused = true; 46724e75e1d7SJohan Hovold } 46734e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 467465b66682SSuzuki K Poulose 46756cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 46766cda08a2SSuzuki K Poulose { 46776cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 46786cda08a2SSuzuki K Poulose } 46796cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 46806cda08a2SSuzuki K Poulose 468165b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 468265b66682SSuzuki K Poulose { 468365b66682SSuzuki K Poulose return dev->of_node == np; 468465b66682SSuzuki K Poulose } 468565b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 468667843bbaSSuzuki K Poulose 468767843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 468867843bbaSSuzuki K Poulose { 468967843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 469067843bbaSSuzuki K Poulose } 469167843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 46924495dfddSSuzuki K Poulose 46934495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 46944495dfddSSuzuki K Poulose { 46954495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 46964495dfddSSuzuki K Poulose } 46974495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 469800500147SSuzuki K Poulose 469900500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 470000500147SSuzuki K Poulose { 470100500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 470200500147SSuzuki K Poulose } 470300500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 47046bf85ba9SSuzuki K Poulose 47056bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 47066bf85ba9SSuzuki K Poulose { 47076bf85ba9SSuzuki K Poulose return 1; 47086bf85ba9SSuzuki K Poulose } 47096bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 4710