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> 24322cbb50SChristoph Hellwig #include <linux/blkdev.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> 3069031f50SClaire Chang #include <linux/swiotlb.h> 3163967685SGreg Kroah-Hartman #include <linux/sysfs.h> 326d4e9a8eSChristoph Hellwig #include <linux/dma-map-ops.h> /* for dma_default_coherent */ 331da177e4SLinus Torvalds 341da177e4SLinus Torvalds #include "base.h" 356423d295SWon Chung #include "physical_location.h" 361da177e4SLinus Torvalds #include "power/power.h" 371da177e4SLinus Torvalds 38e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 39e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 40e52eec13SAndi Kleen long sysfs_deprecated = 1; 41e52eec13SAndi Kleen #else 42e52eec13SAndi Kleen long sysfs_deprecated = 0; 43e52eec13SAndi Kleen #endif 443454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 45e52eec13SAndi Kleen { 4634da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 47e52eec13SAndi Kleen } 48e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 49e52eec13SAndi Kleen #endif 50e52eec13SAndi Kleen 519ed98953SRafael J. Wysocki /* Device links support. */ 52fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 53fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 547b337cb3SSaravana Kannan static DEFINE_MUTEX(fwnode_link_lock); 5525ac86c6SSaravana Kannan static bool fw_devlink_is_permissive(void); 56d46f3e3eSSaravana Kannan static bool fw_devlink_drv_reg_done; 572f8c3ae8SSaravana Kannan static bool fw_devlink_best_effort; 587b337cb3SSaravana Kannan 597b337cb3SSaravana Kannan /** 607b337cb3SSaravana Kannan * fwnode_link_add - Create a link between two fwnode_handles. 617b337cb3SSaravana Kannan * @con: Consumer end of the link. 627b337cb3SSaravana Kannan * @sup: Supplier end of the link. 637b337cb3SSaravana Kannan * 647b337cb3SSaravana Kannan * Create a fwnode link between fwnode handles @con and @sup. The fwnode link 657b337cb3SSaravana Kannan * represents the detail that the firmware lists @sup fwnode as supplying a 667b337cb3SSaravana Kannan * resource to @con. 677b337cb3SSaravana Kannan * 687b337cb3SSaravana Kannan * The driver core will use the fwnode link to create a device link between the 697b337cb3SSaravana Kannan * two device objects corresponding to @con and @sup when they are created. The 707b337cb3SSaravana Kannan * driver core will automatically delete the fwnode link between @con and @sup 717b337cb3SSaravana Kannan * after doing that. 727b337cb3SSaravana Kannan * 737b337cb3SSaravana Kannan * Attempts to create duplicate links between the same pair of fwnode handles 747b337cb3SSaravana Kannan * are ignored and there is no reference counting. 757b337cb3SSaravana Kannan */ 767b337cb3SSaravana Kannan int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup) 777b337cb3SSaravana Kannan { 787b337cb3SSaravana Kannan struct fwnode_link *link; 797b337cb3SSaravana Kannan int ret = 0; 807b337cb3SSaravana Kannan 817b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 827b337cb3SSaravana Kannan 837b337cb3SSaravana Kannan list_for_each_entry(link, &sup->consumers, s_hook) 847b337cb3SSaravana Kannan if (link->consumer == con) 857b337cb3SSaravana Kannan goto out; 867b337cb3SSaravana Kannan 877b337cb3SSaravana Kannan link = kzalloc(sizeof(*link), GFP_KERNEL); 887b337cb3SSaravana Kannan if (!link) { 897b337cb3SSaravana Kannan ret = -ENOMEM; 907b337cb3SSaravana Kannan goto out; 917b337cb3SSaravana Kannan } 927b337cb3SSaravana Kannan 937b337cb3SSaravana Kannan link->supplier = sup; 947b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->s_hook); 957b337cb3SSaravana Kannan link->consumer = con; 967b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->c_hook); 977b337cb3SSaravana Kannan 987b337cb3SSaravana Kannan list_add(&link->s_hook, &sup->consumers); 997b337cb3SSaravana Kannan list_add(&link->c_hook, &con->suppliers); 100ebd6823aSSaravana Kannan pr_debug("%pfwP Linked as a fwnode consumer to %pfwP\n", 101ebd6823aSSaravana Kannan con, sup); 1027b337cb3SSaravana Kannan out: 1037b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1047b337cb3SSaravana Kannan 1057b337cb3SSaravana Kannan return ret; 1067b337cb3SSaravana Kannan } 1077b337cb3SSaravana Kannan 1087b337cb3SSaravana Kannan /** 10976f13081SSaravana Kannan * __fwnode_link_del - Delete a link between two fwnode_handles. 11076f13081SSaravana Kannan * @link: the fwnode_link to be deleted 11176f13081SSaravana Kannan * 11276f13081SSaravana Kannan * The fwnode_link_lock needs to be held when this function is called. 11376f13081SSaravana Kannan */ 11476f13081SSaravana Kannan static void __fwnode_link_del(struct fwnode_link *link) 11576f13081SSaravana Kannan { 116ebd6823aSSaravana Kannan pr_debug("%pfwP Dropping the fwnode link to %pfwP\n", 117ebd6823aSSaravana Kannan link->consumer, link->supplier); 11876f13081SSaravana Kannan list_del(&link->s_hook); 11976f13081SSaravana Kannan list_del(&link->c_hook); 12076f13081SSaravana Kannan kfree(link); 12176f13081SSaravana Kannan } 12276f13081SSaravana Kannan 12376f13081SSaravana Kannan /** 1247b337cb3SSaravana Kannan * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle. 1257b337cb3SSaravana Kannan * @fwnode: fwnode whose supplier links need to be deleted 1267b337cb3SSaravana Kannan * 1277b337cb3SSaravana Kannan * Deletes all supplier links connecting directly to @fwnode. 1287b337cb3SSaravana Kannan */ 1297b337cb3SSaravana Kannan static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode) 1307b337cb3SSaravana Kannan { 1317b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1327b337cb3SSaravana Kannan 1337b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 13476f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) 13576f13081SSaravana Kannan __fwnode_link_del(link); 1367b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1377b337cb3SSaravana Kannan } 1387b337cb3SSaravana Kannan 1397b337cb3SSaravana Kannan /** 1407b337cb3SSaravana Kannan * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle. 1417b337cb3SSaravana Kannan * @fwnode: fwnode whose consumer links need to be deleted 1427b337cb3SSaravana Kannan * 1437b337cb3SSaravana Kannan * Deletes all consumer links connecting directly to @fwnode. 1447b337cb3SSaravana Kannan */ 1457b337cb3SSaravana Kannan static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode) 1467b337cb3SSaravana Kannan { 1477b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1487b337cb3SSaravana Kannan 1497b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 15076f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) 15176f13081SSaravana Kannan __fwnode_link_del(link); 1527b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1537b337cb3SSaravana Kannan } 1547b337cb3SSaravana Kannan 1557b337cb3SSaravana Kannan /** 1567b337cb3SSaravana Kannan * fwnode_links_purge - Delete all links connected to a fwnode_handle. 1577b337cb3SSaravana Kannan * @fwnode: fwnode whose links needs to be deleted 1587b337cb3SSaravana Kannan * 1597b337cb3SSaravana Kannan * Deletes all links connecting directly to a fwnode. 1607b337cb3SSaravana Kannan */ 1617b337cb3SSaravana Kannan void fwnode_links_purge(struct fwnode_handle *fwnode) 1627b337cb3SSaravana Kannan { 1637b337cb3SSaravana Kannan fwnode_links_purge_suppliers(fwnode); 1647b337cb3SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1657b337cb3SSaravana Kannan } 1669ed98953SRafael J. Wysocki 16728ec344bSSaravana Kannan void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode) 1689528e0d9SSaravana Kannan { 1699528e0d9SSaravana Kannan struct fwnode_handle *child; 1709528e0d9SSaravana Kannan 1719528e0d9SSaravana Kannan /* Don't purge consumer links of an added child */ 1729528e0d9SSaravana Kannan if (fwnode->dev) 1739528e0d9SSaravana Kannan return; 1749528e0d9SSaravana Kannan 1759528e0d9SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; 1769528e0d9SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1779528e0d9SSaravana Kannan 1789528e0d9SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child) 1799528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 1809528e0d9SSaravana Kannan } 18128ec344bSSaravana Kannan EXPORT_SYMBOL_GPL(fw_devlink_purge_absent_suppliers); 1829528e0d9SSaravana Kannan 1839ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 1849ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 1859ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 1869ed98953SRafael J. Wysocki 1879ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 1889ed98953SRafael J. Wysocki { 1899ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 1909ed98953SRafael J. Wysocki } 1919ed98953SRafael J. Wysocki 1929ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 1939ed98953SRafael J. Wysocki { 1949ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 1959ed98953SRafael J. Wysocki } 1969ed98953SRafael J. Wysocki 19768464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 1989ed98953SRafael J. Wysocki { 1999ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 2009ed98953SRafael J. Wysocki } 2019ed98953SRafael J. Wysocki 202ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 2039ed98953SRafael J. Wysocki { 2049ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 2059ed98953SRafael J. Wysocki } 206c2fa1e1bSJoel Fernandes (Google) 207c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 208c2fa1e1bSJoel Fernandes (Google) { 209c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 210c2fa1e1bSJoel Fernandes (Google) } 21180dd33cfSRafael J. Wysocki 21280dd33cfSRafael J. Wysocki static void device_link_synchronize_removal(void) 21380dd33cfSRafael J. Wysocki { 21480dd33cfSRafael J. Wysocki synchronize_srcu(&device_links_srcu); 21580dd33cfSRafael J. Wysocki } 2160c871315SRafael J. Wysocki 2170c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link) 2180c871315SRafael J. Wysocki { 2190c871315SRafael J. Wysocki list_del_rcu(&link->s_node); 2200c871315SRafael J. Wysocki list_del_rcu(&link->c_node); 2210c871315SRafael J. Wysocki } 2229ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 2239ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 2249ed98953SRafael J. Wysocki 2259ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 2269ed98953SRafael J. Wysocki { 2279ed98953SRafael J. Wysocki down_write(&device_links_lock); 2289ed98953SRafael J. Wysocki } 2299ed98953SRafael J. Wysocki 2309ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 2319ed98953SRafael J. Wysocki { 2329ed98953SRafael J. Wysocki up_write(&device_links_lock); 2339ed98953SRafael J. Wysocki } 2349ed98953SRafael J. Wysocki 2359ed98953SRafael J. Wysocki int device_links_read_lock(void) 2369ed98953SRafael J. Wysocki { 2379ed98953SRafael J. Wysocki down_read(&device_links_lock); 2389ed98953SRafael J. Wysocki return 0; 2399ed98953SRafael J. Wysocki } 2409ed98953SRafael J. Wysocki 2419ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 2429ed98953SRafael J. Wysocki { 2439ed98953SRafael J. Wysocki up_read(&device_links_lock); 2449ed98953SRafael J. Wysocki } 245c2fa1e1bSJoel Fernandes (Google) 246c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 247c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 248c2fa1e1bSJoel Fernandes (Google) { 249c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 250c2fa1e1bSJoel Fernandes (Google) } 251c2fa1e1bSJoel Fernandes (Google) #endif 25280dd33cfSRafael J. Wysocki 25380dd33cfSRafael J. Wysocki static inline void device_link_synchronize_removal(void) 25480dd33cfSRafael J. Wysocki { 25580dd33cfSRafael J. Wysocki } 2560c871315SRafael J. Wysocki 2570c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link) 2580c871315SRafael J. Wysocki { 2590c871315SRafael J. Wysocki list_del(&link->s_node); 2600c871315SRafael J. Wysocki list_del(&link->c_node); 2610c871315SRafael J. Wysocki } 2629ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 2639ed98953SRafael J. Wysocki 2643d1cf435SRafael J. Wysocki static bool device_is_ancestor(struct device *dev, struct device *target) 2653d1cf435SRafael J. Wysocki { 2663d1cf435SRafael J. Wysocki while (target->parent) { 2673d1cf435SRafael J. Wysocki target = target->parent; 2683d1cf435SRafael J. Wysocki if (dev == target) 2693d1cf435SRafael J. Wysocki return true; 2703d1cf435SRafael J. Wysocki } 2713d1cf435SRafael J. Wysocki return false; 2723d1cf435SRafael J. Wysocki } 2733d1cf435SRafael J. Wysocki 2749ed98953SRafael J. Wysocki /** 2759ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 2769ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 2779ed98953SRafael J. Wysocki * @target: Device to check against. 2789ed98953SRafael J. Wysocki * 2799ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 2809ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 2819ed98953SRafael J. Wysocki */ 2827d34ca38SSaravana Kannan int device_is_dependent(struct device *dev, void *target) 2839ed98953SRafael J. Wysocki { 2849ed98953SRafael J. Wysocki struct device_link *link; 2859ed98953SRafael J. Wysocki int ret; 2869ed98953SRafael J. Wysocki 2873d1cf435SRafael J. Wysocki /* 2883d1cf435SRafael J. Wysocki * The "ancestors" check is needed to catch the case when the target 2893d1cf435SRafael J. Wysocki * device has not been completely initialized yet and it is still 2903d1cf435SRafael J. Wysocki * missing from the list of children of its parent device. 2913d1cf435SRafael J. Wysocki */ 2923d1cf435SRafael J. Wysocki if (dev == target || device_is_ancestor(dev, target)) 2939ed98953SRafael J. Wysocki return 1; 2949ed98953SRafael J. Wysocki 2959ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 2969ed98953SRafael J. Wysocki if (ret) 2979ed98953SRafael J. Wysocki return ret; 2989ed98953SRafael J. Wysocki 2999ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 3004b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 3014b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 30205ef983eSSaravana Kannan continue; 30305ef983eSSaravana Kannan 304e16f4f3eSBenjamin Gaignard if (link->consumer == target) 3059ed98953SRafael J. Wysocki return 1; 3069ed98953SRafael J. Wysocki 3079ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 3089ed98953SRafael J. Wysocki if (ret) 3099ed98953SRafael J. Wysocki break; 3109ed98953SRafael J. Wysocki } 3119ed98953SRafael J. Wysocki return ret; 3129ed98953SRafael J. Wysocki } 3139ed98953SRafael J. Wysocki 314515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 315515db266SRafael J. Wysocki struct device *consumer, 316515db266SRafael J. Wysocki struct device *supplier) 317515db266SRafael J. Wysocki { 318515db266SRafael J. Wysocki switch (supplier->links.status) { 319515db266SRafael J. Wysocki case DL_DEV_PROBING: 320515db266SRafael J. Wysocki switch (consumer->links.status) { 321515db266SRafael J. Wysocki case DL_DEV_PROBING: 322515db266SRafael J. Wysocki /* 323515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 324515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 325515db266SRafael J. Wysocki * knows that the supplier is already functional (for 326515db266SRafael J. Wysocki * example, it has just acquired some resources from the 327515db266SRafael J. Wysocki * supplier). 328515db266SRafael J. Wysocki */ 329515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 330515db266SRafael J. Wysocki break; 331515db266SRafael J. Wysocki default: 332515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 333515db266SRafael J. Wysocki break; 334515db266SRafael J. Wysocki } 335515db266SRafael J. Wysocki break; 336515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 337515db266SRafael J. Wysocki switch (consumer->links.status) { 338515db266SRafael J. Wysocki case DL_DEV_PROBING: 339515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 340515db266SRafael J. Wysocki break; 341515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 342515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 343515db266SRafael J. Wysocki break; 344515db266SRafael J. Wysocki default: 345515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 346515db266SRafael J. Wysocki break; 347515db266SRafael J. Wysocki } 348515db266SRafael J. Wysocki break; 349515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 350515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 351515db266SRafael J. Wysocki break; 352515db266SRafael J. Wysocki default: 353515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 354515db266SRafael J. Wysocki break; 355515db266SRafael J. Wysocki } 356515db266SRafael J. Wysocki } 357515db266SRafael J. Wysocki 3589ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 3599ed98953SRafael J. Wysocki { 3609ed98953SRafael J. Wysocki struct device_link *link; 3619ed98953SRafael J. Wysocki 3629ed98953SRafael J. Wysocki /* 3639ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 3649ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 3659ed98953SRafael J. Wysocki */ 3669ed98953SRafael J. Wysocki if (device_is_registered(dev)) 3679ed98953SRafael J. Wysocki devices_kset_move_last(dev); 3689ed98953SRafael J. Wysocki 3699ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 3709ed98953SRafael J. Wysocki device_pm_move_last(dev); 3719ed98953SRafael J. Wysocki 3729ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 37305ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 3744b9bbb29SSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 3754b9bbb29SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 37605ef983eSSaravana Kannan continue; 3779ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 37805ef983eSSaravana Kannan } 3799ed98953SRafael J. Wysocki 3809ed98953SRafael J. Wysocki return 0; 3819ed98953SRafael J. Wysocki } 3829ed98953SRafael J. Wysocki 3839ed98953SRafael J. Wysocki /** 384494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 385494fd7b7SFeng Kan * @dev: Device to move 386494fd7b7SFeng Kan * 387494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 388494fd7b7SFeng Kan * 389494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 390494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 391494fd7b7SFeng Kan */ 392494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 393494fd7b7SFeng Kan { 394494fd7b7SFeng Kan int idx; 395494fd7b7SFeng Kan 396494fd7b7SFeng Kan idx = device_links_read_lock(); 397494fd7b7SFeng Kan device_pm_lock(); 398494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 399494fd7b7SFeng Kan device_pm_unlock(); 400494fd7b7SFeng Kan device_links_read_unlock(idx); 401494fd7b7SFeng Kan } 402494fd7b7SFeng Kan 403287905e6SSaravana Kannan #define to_devlink(dev) container_of((dev), struct device_link, link_dev) 404287905e6SSaravana Kannan 405287905e6SSaravana Kannan static ssize_t status_show(struct device *dev, 406287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 407287905e6SSaravana Kannan { 408948b3edbSJoe Perches const char *output; 409287905e6SSaravana Kannan 410287905e6SSaravana Kannan switch (to_devlink(dev)->status) { 411287905e6SSaravana Kannan case DL_STATE_NONE: 412948b3edbSJoe Perches output = "not tracked"; 413948b3edbSJoe Perches break; 414287905e6SSaravana Kannan case DL_STATE_DORMANT: 415948b3edbSJoe Perches output = "dormant"; 416948b3edbSJoe Perches break; 417287905e6SSaravana Kannan case DL_STATE_AVAILABLE: 418948b3edbSJoe Perches output = "available"; 419948b3edbSJoe Perches break; 420287905e6SSaravana Kannan case DL_STATE_CONSUMER_PROBE: 421948b3edbSJoe Perches output = "consumer probing"; 422948b3edbSJoe Perches break; 423287905e6SSaravana Kannan case DL_STATE_ACTIVE: 424948b3edbSJoe Perches output = "active"; 425948b3edbSJoe Perches break; 426287905e6SSaravana Kannan case DL_STATE_SUPPLIER_UNBIND: 427948b3edbSJoe Perches output = "supplier unbinding"; 428948b3edbSJoe Perches break; 429287905e6SSaravana Kannan default: 430948b3edbSJoe Perches output = "unknown"; 431948b3edbSJoe Perches break; 432287905e6SSaravana Kannan } 433948b3edbSJoe Perches 434948b3edbSJoe Perches return sysfs_emit(buf, "%s\n", output); 435287905e6SSaravana Kannan } 436287905e6SSaravana Kannan static DEVICE_ATTR_RO(status); 437287905e6SSaravana Kannan 438287905e6SSaravana Kannan static ssize_t auto_remove_on_show(struct device *dev, 439287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 440287905e6SSaravana Kannan { 441287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 442973c3911SJoe Perches const char *output; 443287905e6SSaravana Kannan 444287905e6SSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 445973c3911SJoe Perches output = "supplier unbind"; 446287905e6SSaravana Kannan else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 447973c3911SJoe Perches output = "consumer unbind"; 448287905e6SSaravana Kannan else 449973c3911SJoe Perches output = "never"; 450287905e6SSaravana Kannan 451973c3911SJoe Perches return sysfs_emit(buf, "%s\n", output); 452287905e6SSaravana Kannan } 453287905e6SSaravana Kannan static DEVICE_ATTR_RO(auto_remove_on); 454287905e6SSaravana Kannan 455287905e6SSaravana Kannan static ssize_t runtime_pm_show(struct device *dev, 456287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 457287905e6SSaravana Kannan { 458287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 459287905e6SSaravana Kannan 460aa838896SJoe Perches return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); 461287905e6SSaravana Kannan } 462287905e6SSaravana Kannan static DEVICE_ATTR_RO(runtime_pm); 463287905e6SSaravana Kannan 464287905e6SSaravana Kannan static ssize_t sync_state_only_show(struct device *dev, 465287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 466287905e6SSaravana Kannan { 467287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 468287905e6SSaravana Kannan 469aa838896SJoe Perches return sysfs_emit(buf, "%d\n", 470aa838896SJoe Perches !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 471287905e6SSaravana Kannan } 472287905e6SSaravana Kannan static DEVICE_ATTR_RO(sync_state_only); 473287905e6SSaravana Kannan 474287905e6SSaravana Kannan static struct attribute *devlink_attrs[] = { 475287905e6SSaravana Kannan &dev_attr_status.attr, 476287905e6SSaravana Kannan &dev_attr_auto_remove_on.attr, 477287905e6SSaravana Kannan &dev_attr_runtime_pm.attr, 478287905e6SSaravana Kannan &dev_attr_sync_state_only.attr, 479287905e6SSaravana Kannan NULL, 480287905e6SSaravana Kannan }; 481287905e6SSaravana Kannan ATTRIBUTE_GROUPS(devlink); 482287905e6SSaravana Kannan 48380dd33cfSRafael J. Wysocki static void device_link_release_fn(struct work_struct *work) 484843e600bSSaravana Kannan { 48580dd33cfSRafael J. Wysocki struct device_link *link = container_of(work, struct device_link, rm_work); 48680dd33cfSRafael J. Wysocki 48780dd33cfSRafael J. Wysocki /* Ensure that all references to the link object have been dropped. */ 48880dd33cfSRafael J. Wysocki device_link_synchronize_removal(); 48980dd33cfSRafael J. Wysocki 490d1579e61SRafael J. Wysocki pm_runtime_release_supplier(link, true); 491843e600bSSaravana Kannan 492843e600bSSaravana Kannan put_device(link->consumer); 493843e600bSSaravana Kannan put_device(link->supplier); 494843e600bSSaravana Kannan kfree(link); 495843e600bSSaravana Kannan } 496843e600bSSaravana Kannan 497287905e6SSaravana Kannan static void devlink_dev_release(struct device *dev) 498287905e6SSaravana Kannan { 499843e600bSSaravana Kannan struct device_link *link = to_devlink(dev); 500843e600bSSaravana Kannan 50180dd33cfSRafael J. Wysocki INIT_WORK(&link->rm_work, device_link_release_fn); 50280dd33cfSRafael J. Wysocki /* 50380dd33cfSRafael J. Wysocki * It may take a while to complete this work because of the SRCU 50480dd33cfSRafael J. Wysocki * synchronization in device_link_release_fn() and if the consumer or 50580dd33cfSRafael J. Wysocki * supplier devices get deleted when it runs, so put it into the "long" 50680dd33cfSRafael J. Wysocki * workqueue. 50780dd33cfSRafael J. Wysocki */ 50880dd33cfSRafael J. Wysocki queue_work(system_long_wq, &link->rm_work); 509287905e6SSaravana Kannan } 510287905e6SSaravana Kannan 511287905e6SSaravana Kannan static struct class devlink_class = { 512287905e6SSaravana Kannan .name = "devlink", 513287905e6SSaravana Kannan .owner = THIS_MODULE, 514287905e6SSaravana Kannan .dev_groups = devlink_groups, 515287905e6SSaravana Kannan .dev_release = devlink_dev_release, 516287905e6SSaravana Kannan }; 517287905e6SSaravana Kannan 518287905e6SSaravana Kannan static int devlink_add_symlinks(struct device *dev, 519287905e6SSaravana Kannan struct class_interface *class_intf) 520287905e6SSaravana Kannan { 521287905e6SSaravana Kannan int ret; 522287905e6SSaravana Kannan size_t len; 523287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 524287905e6SSaravana Kannan struct device *sup = link->supplier; 525287905e6SSaravana Kannan struct device *con = link->consumer; 526287905e6SSaravana Kannan char *buf; 527287905e6SSaravana Kannan 528e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 529e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 530e020ff61SSaravana Kannan len += strlen(":"); 531287905e6SSaravana Kannan len += strlen("supplier:") + 1; 532287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 533287905e6SSaravana Kannan if (!buf) 534287905e6SSaravana Kannan return -ENOMEM; 535287905e6SSaravana Kannan 536287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); 537287905e6SSaravana Kannan if (ret) 538287905e6SSaravana Kannan goto out; 539287905e6SSaravana Kannan 540287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); 541287905e6SSaravana Kannan if (ret) 542287905e6SSaravana Kannan goto err_con; 543287905e6SSaravana Kannan 544e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 545287905e6SSaravana Kannan ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); 546287905e6SSaravana Kannan if (ret) 547287905e6SSaravana Kannan goto err_con_dev; 548287905e6SSaravana Kannan 549e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 550287905e6SSaravana Kannan ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); 551287905e6SSaravana Kannan if (ret) 552287905e6SSaravana Kannan goto err_sup_dev; 553287905e6SSaravana Kannan 554287905e6SSaravana Kannan goto out; 555287905e6SSaravana Kannan 556287905e6SSaravana Kannan err_sup_dev: 557e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 558287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 559287905e6SSaravana Kannan err_con_dev: 560287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 561287905e6SSaravana Kannan err_con: 562287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 563287905e6SSaravana Kannan out: 564287905e6SSaravana Kannan kfree(buf); 565287905e6SSaravana Kannan return ret; 566287905e6SSaravana Kannan } 567287905e6SSaravana Kannan 568287905e6SSaravana Kannan static void devlink_remove_symlinks(struct device *dev, 569287905e6SSaravana Kannan struct class_interface *class_intf) 570287905e6SSaravana Kannan { 571287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 572287905e6SSaravana Kannan size_t len; 573287905e6SSaravana Kannan struct device *sup = link->supplier; 574287905e6SSaravana Kannan struct device *con = link->consumer; 575287905e6SSaravana Kannan char *buf; 576287905e6SSaravana Kannan 577287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 578287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 579287905e6SSaravana Kannan 580e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 581e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 582e020ff61SSaravana Kannan len += strlen(":"); 583287905e6SSaravana Kannan len += strlen("supplier:") + 1; 584287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 585287905e6SSaravana Kannan if (!buf) { 586287905e6SSaravana Kannan WARN(1, "Unable to properly free device link symlinks!\n"); 587287905e6SSaravana Kannan return; 588287905e6SSaravana Kannan } 589287905e6SSaravana Kannan 590e64daad6SAdrian Hunter if (device_is_registered(con)) { 591e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 592287905e6SSaravana Kannan sysfs_remove_link(&con->kobj, buf); 593e64daad6SAdrian Hunter } 594e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 595287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 596287905e6SSaravana Kannan kfree(buf); 597287905e6SSaravana Kannan } 598287905e6SSaravana Kannan 599287905e6SSaravana Kannan static struct class_interface devlink_class_intf = { 600287905e6SSaravana Kannan .class = &devlink_class, 601287905e6SSaravana Kannan .add_dev = devlink_add_symlinks, 602287905e6SSaravana Kannan .remove_dev = devlink_remove_symlinks, 603287905e6SSaravana Kannan }; 604287905e6SSaravana Kannan 605287905e6SSaravana Kannan static int __init devlink_class_init(void) 606287905e6SSaravana Kannan { 607287905e6SSaravana Kannan int ret; 608287905e6SSaravana Kannan 609287905e6SSaravana Kannan ret = class_register(&devlink_class); 610287905e6SSaravana Kannan if (ret) 611287905e6SSaravana Kannan return ret; 612287905e6SSaravana Kannan 613287905e6SSaravana Kannan ret = class_interface_register(&devlink_class_intf); 614287905e6SSaravana Kannan if (ret) 615287905e6SSaravana Kannan class_unregister(&devlink_class); 616287905e6SSaravana Kannan 617287905e6SSaravana Kannan return ret; 618287905e6SSaravana Kannan } 619287905e6SSaravana Kannan postcore_initcall(devlink_class_init); 620287905e6SSaravana Kannan 621515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 622515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 62305ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 6244b9bbb29SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY | \ 6254b9bbb29SSaravana Kannan DL_FLAG_INFERRED) 626515db266SRafael J. Wysocki 627fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 628fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 629fb583c8eSRafael J. Wysocki 630494fd7b7SFeng Kan /** 6319ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 6329ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 6339ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 6349ed98953SRafael J. Wysocki * @flags: Link flags. 6359ed98953SRafael J. Wysocki * 63621d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 63721d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 63821d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 63921d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 64021d5c57bSRafael J. Wysocki * be forced into the active meta state and reference-counted upon the creation 64121d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 64221d5c57bSRafael J. Wysocki * ignored. 64321d5c57bSRafael J. Wysocki * 644515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 645515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 646515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 64772175d4eSRafael J. Wysocki * 64872175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 64972175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 65072175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 65172175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 65272175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 65372175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 65472175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 65572175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 65672175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 65772175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 65872175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 659c8d50986SRafael J. Wysocki * 660e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 661e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 662e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 663d475f8eaSThierry Reding * be used to request the driver core to automatically probe for a consumer 664e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 665e7dd4010SRafael J. Wysocki * 666515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 667515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 668515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 669515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 670515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 671515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 672515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 673515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 674515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 675515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 6769ed98953SRafael J. Wysocki * 6779ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 6789ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 6799ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 6809ed98953SRafael J. Wysocki * not been registered when this function is called). 6819ed98953SRafael J. Wysocki * 6829ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 6839ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 68464df1148SLukas Wunner * not be registered, however. 6859ed98953SRafael J. Wysocki */ 6869ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 6879ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 6889ed98953SRafael J. Wysocki { 6899ed98953SRafael J. Wysocki struct device_link *link; 6909ed98953SRafael J. Wysocki 691f729a592SSaravana Kannan if (!consumer || !supplier || consumer == supplier || 692f729a592SSaravana Kannan flags & ~DL_ADD_VALID_FLAGS || 693515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 69405ef983eSSaravana Kannan (flags & DL_FLAG_SYNC_STATE_ONLY && 6954b9bbb29SSaravana Kannan (flags & ~DL_FLAG_INFERRED) != DL_FLAG_SYNC_STATE_ONLY) || 696e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 697e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 698e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 6999ed98953SRafael J. Wysocki return NULL; 7009ed98953SRafael J. Wysocki 7015db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 7025db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 7035db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 7045db25c9eSRafael J. Wysocki return NULL; 7055db25c9eSRafael J. Wysocki } 7065db25c9eSRafael J. Wysocki } 7075db25c9eSRafael J. Wysocki 708515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 709515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 710515db266SRafael J. Wysocki 7119ed98953SRafael J. Wysocki device_links_write_lock(); 7129ed98953SRafael J. Wysocki device_pm_lock(); 7139ed98953SRafael J. Wysocki 7149ed98953SRafael J. Wysocki /* 7159ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 71605ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 71705ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 71805ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 71905ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 7209ed98953SRafael J. Wysocki */ 7219ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 72205ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 72305ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 7249ed98953SRafael J. Wysocki link = NULL; 7259ed98953SRafael J. Wysocki goto out; 7269ed98953SRafael J. Wysocki } 7279ed98953SRafael J. Wysocki 72872175d4eSRafael J. Wysocki /* 729ac66c5bbSSaravana Kannan * SYNC_STATE_ONLY links are useless once a consumer device has probed. 730ac66c5bbSSaravana Kannan * So, only create it if the consumer hasn't probed yet. 731ac66c5bbSSaravana Kannan */ 732ac66c5bbSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY && 733ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_NO_DRIVER && 734ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_PROBING) { 735ac66c5bbSSaravana Kannan link = NULL; 736ac66c5bbSSaravana Kannan goto out; 737ac66c5bbSSaravana Kannan } 738ac66c5bbSSaravana Kannan 739ac66c5bbSSaravana Kannan /* 74072175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 74172175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 74272175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 74372175d4eSRafael J. Wysocki */ 74472175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 74572175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 74672175d4eSRafael J. Wysocki 747f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 748f265df55SRafael J. Wysocki if (link->consumer != consumer) 749f265df55SRafael J. Wysocki continue; 750f265df55SRafael J. Wysocki 7514b9bbb29SSaravana Kannan if (link->flags & DL_FLAG_INFERRED && 7524b9bbb29SSaravana Kannan !(flags & DL_FLAG_INFERRED)) 7534b9bbb29SSaravana Kannan link->flags &= ~DL_FLAG_INFERRED; 7544b9bbb29SSaravana Kannan 755e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 756e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 7574c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 758e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 759e2f3cd83SRafael J. Wysocki } 760e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 76136003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 762e2f3cd83SRafael J. Wysocki } 763e2f3cd83SRafael J. Wysocki 76472175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 765ead18c23SLukas Wunner kref_get(&link->kref); 76621c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 76744e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 76844e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 76905ef983eSSaravana Kannan goto reorder; 77044e96049SSaravana Kannan } else { 77144e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 7729ed98953SRafael J. Wysocki goto out; 773ead18c23SLukas Wunner } 77444e96049SSaravana Kannan } 7759ed98953SRafael J. Wysocki 77672175d4eSRafael J. Wysocki /* 77772175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 77872175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 77972175d4eSRafael J. Wysocki * update the existing link to stay around longer. 78072175d4eSRafael J. Wysocki */ 78172175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 78272175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 78372175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 78472175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 78572175d4eSRafael J. Wysocki } 78672175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 78772175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 78872175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 78972175d4eSRafael J. Wysocki } 790515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 791515db266SRafael J. Wysocki kref_get(&link->kref); 792515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 793515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 794515db266SRafael J. Wysocki } 79505ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 79605ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 79705ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 79805ef983eSSaravana Kannan goto reorder; 79905ef983eSSaravana Kannan } 80005ef983eSSaravana Kannan 80172175d4eSRafael J. Wysocki goto out; 80272175d4eSRafael J. Wysocki } 80372175d4eSRafael J. Wysocki 80421d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 8059ed98953SRafael J. Wysocki if (!link) 8069ed98953SRafael J. Wysocki goto out; 8079ed98953SRafael J. Wysocki 808e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 809e2f3cd83SRafael J. Wysocki 8109ed98953SRafael J. Wysocki get_device(supplier); 8119ed98953SRafael J. Wysocki link->supplier = supplier; 8129ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 8139ed98953SRafael J. Wysocki get_device(consumer); 8149ed98953SRafael J. Wysocki link->consumer = consumer; 8159ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 8169ed98953SRafael J. Wysocki link->flags = flags; 817ead18c23SLukas Wunner kref_init(&link->kref); 8189ed98953SRafael J. Wysocki 819287905e6SSaravana Kannan link->link_dev.class = &devlink_class; 820287905e6SSaravana Kannan device_set_pm_not_required(&link->link_dev); 821e020ff61SSaravana Kannan dev_set_name(&link->link_dev, "%s:%s--%s:%s", 822e020ff61SSaravana Kannan dev_bus_name(supplier), dev_name(supplier), 823e020ff61SSaravana Kannan dev_bus_name(consumer), dev_name(consumer)); 824287905e6SSaravana Kannan if (device_register(&link->link_dev)) { 825df0a1814SYang Yingliang put_device(&link->link_dev); 826287905e6SSaravana Kannan link = NULL; 827287905e6SSaravana Kannan goto out; 828287905e6SSaravana Kannan } 829287905e6SSaravana Kannan 830287905e6SSaravana Kannan if (flags & DL_FLAG_PM_RUNTIME) { 831287905e6SSaravana Kannan if (flags & DL_FLAG_RPM_ACTIVE) 832287905e6SSaravana Kannan refcount_inc(&link->rpm_active); 833287905e6SSaravana Kannan 834287905e6SSaravana Kannan pm_runtime_new_link(consumer); 835287905e6SSaravana Kannan } 836287905e6SSaravana Kannan 83764df1148SLukas Wunner /* Determine the initial link state. */ 838515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 8399ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 840515db266SRafael J. Wysocki else 841515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 8429ed98953SRafael J. Wysocki 8439ed98953SRafael J. Wysocki /* 84415cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 84515cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 84615cfb094SRafael J. Wysocki */ 84715cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 84815cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 84915cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 85015cfb094SRafael J. Wysocki 85121c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 85221c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 85321c27f06SSaravana Kannan 85405ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 85505ef983eSSaravana Kannan dev_dbg(consumer, 85605ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 85705ef983eSSaravana Kannan dev_name(supplier)); 85805ef983eSSaravana Kannan goto out; 85905ef983eSSaravana Kannan } 86021c27f06SSaravana Kannan 86105ef983eSSaravana Kannan reorder: 86215cfb094SRafael J. Wysocki /* 8639ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 8649ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 8659ed98953SRafael J. Wysocki * 8669ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 8679ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 8689ed98953SRafael J. Wysocki */ 8699ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 8709ed98953SRafael J. Wysocki 8718a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 8729ed98953SRafael J. Wysocki 8739ed98953SRafael J. Wysocki out: 8749ed98953SRafael J. Wysocki device_pm_unlock(); 8759ed98953SRafael J. Wysocki device_links_write_unlock(); 8765db25c9eSRafael J. Wysocki 877e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 8785db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 8795db25c9eSRafael J. Wysocki 8809ed98953SRafael J. Wysocki return link; 8819ed98953SRafael J. Wysocki } 8829ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 8839ed98953SRafael J. Wysocki 884ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 8859ed98953SRafael J. Wysocki { 886ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 887ead18c23SLukas Wunner 8888a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 8899ed98953SRafael J. Wysocki dev_name(link->supplier)); 8909ed98953SRafael J. Wysocki 891e0e398e2SRafael J. Wysocki pm_runtime_drop_link(link); 892baa8809fSRafael J. Wysocki 8930c871315SRafael J. Wysocki device_link_remove_from_lists(link); 894843e600bSSaravana Kannan device_unregister(&link->link_dev); 8959ed98953SRafael J. Wysocki } 8969ed98953SRafael J. Wysocki 89772175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 89872175d4eSRafael J. Wysocki { 89972175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 90072175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 901bf25967aSAdrian Hunter else if (!device_is_registered(link->consumer)) 902bf25967aSAdrian Hunter __device_link_del(&link->kref); 90372175d4eSRafael J. Wysocki else 90472175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 90572175d4eSRafael J. Wysocki } 90672175d4eSRafael J. Wysocki 9079ed98953SRafael J. Wysocki /** 90872175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 9099ed98953SRafael J. Wysocki * @link: Device link to delete. 9109ed98953SRafael J. Wysocki * 9119ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 912ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 913ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 914ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 9159ed98953SRafael J. Wysocki */ 9169ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 9179ed98953SRafael J. Wysocki { 9189ed98953SRafael J. Wysocki device_links_write_lock(); 91972175d4eSRafael J. Wysocki device_link_put_kref(link); 9209ed98953SRafael J. Wysocki device_links_write_unlock(); 9219ed98953SRafael J. Wysocki } 9229ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 9239ed98953SRafael J. Wysocki 924d8842211Spascal paillet /** 92572175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 926d8842211Spascal paillet * @consumer: Consumer end of the link. 927d8842211Spascal paillet * @supplier: Supplier end of the link. 928d8842211Spascal paillet * 929d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 930d8842211Spascal paillet * PM. 931d8842211Spascal paillet */ 932d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 933d8842211Spascal paillet { 934d8842211Spascal paillet struct device_link *link; 935d8842211Spascal paillet 936d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 937d8842211Spascal paillet return; 938d8842211Spascal paillet 939d8842211Spascal paillet device_links_write_lock(); 940d8842211Spascal paillet 941d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 942d8842211Spascal paillet if (link->consumer == consumer) { 94372175d4eSRafael J. Wysocki device_link_put_kref(link); 944d8842211Spascal paillet break; 945d8842211Spascal paillet } 946d8842211Spascal paillet } 947d8842211Spascal paillet 948d8842211Spascal paillet device_links_write_unlock(); 949d8842211Spascal paillet } 950d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 951d8842211Spascal paillet 9529ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 9539ed98953SRafael J. Wysocki { 9549ed98953SRafael J. Wysocki struct device_link *link; 9559ed98953SRafael J. Wysocki 9568c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) { 9578c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE) 9588c3e315dSSaravana Kannan continue; 9598c3e315dSSaravana Kannan 9608c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 9619ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 9628c3e315dSSaravana Kannan } else { 9638c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 9648c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 9658c3e315dSSaravana Kannan } 9668c3e315dSSaravana Kannan } 9679ed98953SRafael J. Wysocki } 9689ed98953SRafael J. Wysocki 9692f8c3ae8SSaravana Kannan static bool dev_is_best_effort(struct device *dev) 9702f8c3ae8SSaravana Kannan { 971*8f486cabSSaravana Kannan return (fw_devlink_best_effort && dev->can_match) || 972*8f486cabSSaravana Kannan (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT)); 9732f8c3ae8SSaravana Kannan } 9742f8c3ae8SSaravana Kannan 9759ed98953SRafael J. Wysocki /** 9769ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 9779ed98953SRafael J. Wysocki * @dev: Consumer device. 9789ed98953SRafael J. Wysocki * 9799ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 9809ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 9819ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 9829ed98953SRafael J. Wysocki * 9839ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 9849ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 9859ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 9869ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 9879ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 9889ed98953SRafael J. Wysocki * 989515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9909ed98953SRafael J. Wysocki */ 9919ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 9929ed98953SRafael J. Wysocki { 9939ed98953SRafael J. Wysocki struct device_link *link; 9942f8c3ae8SSaravana Kannan int ret = 0, fwnode_ret = 0; 99568223eeeSSaravana Kannan struct fwnode_handle *sup_fw; 9969ed98953SRafael J. Wysocki 997e2ae9bccSSaravana Kannan /* 998e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 999e2ae9bccSSaravana Kannan * probe. 1000e2ae9bccSSaravana Kannan */ 100125ac86c6SSaravana Kannan mutex_lock(&fwnode_link_lock); 100225ac86c6SSaravana Kannan if (dev->fwnode && !list_empty(&dev->fwnode->suppliers) && 100325ac86c6SSaravana Kannan !fw_devlink_is_permissive()) { 100468223eeeSSaravana Kannan sup_fw = list_first_entry(&dev->fwnode->suppliers, 10051f0dfa05SSaravana Kannan struct fwnode_link, 100668223eeeSSaravana Kannan c_hook)->supplier; 10072f8c3ae8SSaravana Kannan if (!dev_is_best_effort(dev)) { 10082f8c3ae8SSaravana Kannan fwnode_ret = -EPROBE_DEFER; 10092f8c3ae8SSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER, 10102f8c3ae8SSaravana Kannan "wait for supplier %pfwP\n", sup_fw); 10112f8c3ae8SSaravana Kannan } else { 10122f8c3ae8SSaravana Kannan fwnode_ret = -EAGAIN; 10132f8c3ae8SSaravana Kannan } 1014e2ae9bccSSaravana Kannan } 101525ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock); 10162f8c3ae8SSaravana Kannan if (fwnode_ret == -EPROBE_DEFER) 10172f8c3ae8SSaravana Kannan return fwnode_ret; 1018e2ae9bccSSaravana Kannan 10199ed98953SRafael J. Wysocki device_links_write_lock(); 10209ed98953SRafael J. Wysocki 10219ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 10228c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 10239ed98953SRafael J. Wysocki continue; 10249ed98953SRafael J. Wysocki 10258c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE && 10268c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { 10272f8c3ae8SSaravana Kannan 10282f8c3ae8SSaravana Kannan if (dev_is_best_effort(dev) && 10292f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED && 10302f8c3ae8SSaravana Kannan !link->supplier->can_match) { 10312f8c3ae8SSaravana Kannan ret = -EAGAIN; 10322f8c3ae8SSaravana Kannan continue; 10332f8c3ae8SSaravana Kannan } 10342f8c3ae8SSaravana Kannan 10359ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 103668223eeeSSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER, 103768223eeeSSaravana Kannan "supplier %s not ready\n", 10381f0dfa05SSaravana Kannan dev_name(link->supplier)); 10399ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 10409ed98953SRafael J. Wysocki break; 10419ed98953SRafael J. Wysocki } 10429ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 10439ed98953SRafael J. Wysocki } 10449ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 10459ed98953SRafael J. Wysocki 10469ed98953SRafael J. Wysocki device_links_write_unlock(); 10472f8c3ae8SSaravana Kannan 10482f8c3ae8SSaravana Kannan return ret ? ret : fwnode_ret; 10499ed98953SRafael J. Wysocki } 10509ed98953SRafael J. Wysocki 105126e77708SSaravana Kannan /** 105226e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 105326e77708SSaravana Kannan * @dev: Device to call sync_state() on 105426e77708SSaravana Kannan * @list: List head to queue the @dev on 105526e77708SSaravana Kannan * 105626e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 105726e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 105826e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 105926e77708SSaravana Kannan * device_links_write_lock() held. 106026e77708SSaravana Kannan * 106126e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 106226e77708SSaravana Kannan * on this list. 106326e77708SSaravana Kannan * 106426e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 106526e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 106626e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 106726e77708SSaravana Kannan * put_device() is called on this device. 106826e77708SSaravana Kannan */ 106926e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 107026e77708SSaravana Kannan struct list_head *list) 1071fc5a251dSSaravana Kannan { 1072fc5a251dSSaravana Kannan struct device_link *link; 1073fc5a251dSSaravana Kannan 107477036165SSaravana Kannan if (!dev_has_sync_state(dev)) 107577036165SSaravana Kannan return; 1076fc5a251dSSaravana Kannan if (dev->state_synced) 1077fc5a251dSSaravana Kannan return; 1078fc5a251dSSaravana Kannan 1079fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 1080fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1081fc5a251dSSaravana Kannan continue; 1082fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 1083fc5a251dSSaravana Kannan return; 1084fc5a251dSSaravana Kannan } 1085fc5a251dSSaravana Kannan 108626e77708SSaravana Kannan /* 108726e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 108826e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 108926e77708SSaravana Kannan * and probed before the list is flushed. 109026e77708SSaravana Kannan */ 109126e77708SSaravana Kannan dev->state_synced = true; 109226e77708SSaravana Kannan 10933b052a3eSSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 109426e77708SSaravana Kannan return; 109526e77708SSaravana Kannan 109626e77708SSaravana Kannan get_device(dev); 10973b052a3eSSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 109826e77708SSaravana Kannan } 109926e77708SSaravana Kannan 110026e77708SSaravana Kannan /** 110126e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 110226e77708SSaravana Kannan * @list: List of devices to call sync_state() on 110321eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 110426e77708SSaravana Kannan * 110526e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 110621eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 110721eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 110821eb93f4SSaravana Kannan * context where a device lock is already held. 110926e77708SSaravana Kannan */ 111021eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 111121eb93f4SSaravana Kannan struct device *dont_lock_dev) 111226e77708SSaravana Kannan { 111326e77708SSaravana Kannan struct device *dev, *tmp; 111426e77708SSaravana Kannan 11153b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 11163b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 111726e77708SSaravana Kannan 111821eb93f4SSaravana Kannan if (dev != dont_lock_dev) 111926e77708SSaravana Kannan device_lock(dev); 112026e77708SSaravana Kannan 1121fc5a251dSSaravana Kannan if (dev->bus->sync_state) 1122fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 1123fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 1124fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 1125fc5a251dSSaravana Kannan 112621eb93f4SSaravana Kannan if (dev != dont_lock_dev) 112726e77708SSaravana Kannan device_unlock(dev); 112826e77708SSaravana Kannan 112926e77708SSaravana Kannan put_device(dev); 113026e77708SSaravana Kannan } 1131fc5a251dSSaravana Kannan } 1132fc5a251dSSaravana Kannan 1133fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 1134fc5a251dSSaravana Kannan { 1135fc5a251dSSaravana Kannan device_links_write_lock(); 1136fc5a251dSSaravana Kannan defer_sync_state_count++; 1137fc5a251dSSaravana Kannan device_links_write_unlock(); 1138fc5a251dSSaravana Kannan } 1139fc5a251dSSaravana Kannan 1140fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 1141fc5a251dSSaravana Kannan { 1142fc5a251dSSaravana Kannan struct device *dev, *tmp; 114326e77708SSaravana Kannan LIST_HEAD(sync_list); 1144fc5a251dSSaravana Kannan 1145fc5a251dSSaravana Kannan device_links_write_lock(); 1146fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 1147fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 1148fc5a251dSSaravana Kannan goto out; 1149fc5a251dSSaravana Kannan } 1150fc5a251dSSaravana Kannan defer_sync_state_count--; 1151fc5a251dSSaravana Kannan if (defer_sync_state_count) 1152fc5a251dSSaravana Kannan goto out; 1153fc5a251dSSaravana Kannan 11543b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 115526e77708SSaravana Kannan /* 115626e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 11573b052a3eSSaravana Kannan * sync_list because defer_sync is used for both lists. 115826e77708SSaravana Kannan */ 11593b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 116026e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 1161fc5a251dSSaravana Kannan } 1162fc5a251dSSaravana Kannan out: 1163fc5a251dSSaravana Kannan device_links_write_unlock(); 116426e77708SSaravana Kannan 116521eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 1166fc5a251dSSaravana Kannan } 1167fc5a251dSSaravana Kannan 1168fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 1169fc5a251dSSaravana Kannan { 1170fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 1171fc5a251dSSaravana Kannan return 0; 1172fc5a251dSSaravana Kannan } 1173fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 1174fc5a251dSSaravana Kannan 1175fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 1176fc5a251dSSaravana Kannan { 11773b052a3eSSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 11783b052a3eSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 1179fc5a251dSSaravana Kannan } 1180fc5a251dSSaravana Kannan 118121c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link) 118221c27f06SSaravana Kannan { 118321c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED; 118421c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE); 118521c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del); 118621c27f06SSaravana Kannan } 118721c27f06SSaravana Kannan 1188da6d6475SSaravana Kannan static ssize_t waiting_for_supplier_show(struct device *dev, 1189da6d6475SSaravana Kannan struct device_attribute *attr, 1190da6d6475SSaravana Kannan char *buf) 1191da6d6475SSaravana Kannan { 1192da6d6475SSaravana Kannan bool val; 1193da6d6475SSaravana Kannan 1194da6d6475SSaravana Kannan device_lock(dev); 119525ac86c6SSaravana Kannan val = !list_empty(&dev->fwnode->suppliers); 1196da6d6475SSaravana Kannan device_unlock(dev); 1197aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 1198da6d6475SSaravana Kannan } 1199da6d6475SSaravana Kannan static DEVICE_ATTR_RO(waiting_for_supplier); 1200da6d6475SSaravana Kannan 12019ed98953SRafael J. Wysocki /** 1202b6f617dfSSaravana Kannan * device_links_force_bind - Prepares device to be force bound 1203b6f617dfSSaravana Kannan * @dev: Consumer device. 1204b6f617dfSSaravana Kannan * 1205b6f617dfSSaravana Kannan * device_bind_driver() force binds a device to a driver without calling any 1206b6f617dfSSaravana Kannan * driver probe functions. So the consumer really isn't going to wait for any 1207b6f617dfSSaravana Kannan * supplier before it's bound to the driver. We still want the device link 1208b6f617dfSSaravana Kannan * states to be sensible when this happens. 1209b6f617dfSSaravana Kannan * 1210b6f617dfSSaravana Kannan * In preparation for device_bind_driver(), this function goes through each 1211b6f617dfSSaravana Kannan * supplier device links and checks if the supplier is bound. If it is, then 1212b6f617dfSSaravana Kannan * the device link status is set to CONSUMER_PROBE. Otherwise, the device link 1213b6f617dfSSaravana Kannan * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored. 1214b6f617dfSSaravana Kannan */ 1215b6f617dfSSaravana Kannan void device_links_force_bind(struct device *dev) 1216b6f617dfSSaravana Kannan { 1217b6f617dfSSaravana Kannan struct device_link *link, *ln; 1218b6f617dfSSaravana Kannan 1219b6f617dfSSaravana Kannan device_links_write_lock(); 1220b6f617dfSSaravana Kannan 1221b6f617dfSSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 1222b6f617dfSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1223b6f617dfSSaravana Kannan continue; 1224b6f617dfSSaravana Kannan 1225b6f617dfSSaravana Kannan if (link->status != DL_STATE_AVAILABLE) { 1226b6f617dfSSaravana Kannan device_link_drop_managed(link); 1227b6f617dfSSaravana Kannan continue; 1228b6f617dfSSaravana Kannan } 1229b6f617dfSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 1230b6f617dfSSaravana Kannan } 1231b6f617dfSSaravana Kannan dev->links.status = DL_DEV_PROBING; 1232b6f617dfSSaravana Kannan 1233b6f617dfSSaravana Kannan device_links_write_unlock(); 1234b6f617dfSSaravana Kannan } 1235b6f617dfSSaravana Kannan 1236b6f617dfSSaravana Kannan /** 12379ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 12389ed98953SRafael J. Wysocki * @dev: Device to update the links for. 12399ed98953SRafael J. Wysocki * 12409ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 12419ed98953SRafael J. Wysocki * consumers by changing their status to "available". 12429ed98953SRafael J. Wysocki * 12439ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 12449ed98953SRafael J. Wysocki * 1245515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 12469ed98953SRafael J. Wysocki */ 12479ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 12489ed98953SRafael J. Wysocki { 124921c27f06SSaravana Kannan struct device_link *link, *ln; 125026e77708SSaravana Kannan LIST_HEAD(sync_list); 12519ed98953SRafael J. Wysocki 1252bcbbcfd5SSaravana Kannan /* 12539528e0d9SSaravana Kannan * If a device binds successfully, it's expected to have created all 1254bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 12559528e0d9SSaravana Kannan * them. So, fw_devlink no longer needs to create device links to any 12569528e0d9SSaravana Kannan * of the device's suppliers. 12579528e0d9SSaravana Kannan * 12589528e0d9SSaravana Kannan * Also, if a child firmware node of this bound device is not added as 12599528e0d9SSaravana Kannan * a device by now, assume it is never going to be added and make sure 12609528e0d9SSaravana Kannan * other devices don't defer probe indefinitely by waiting for such a 12619528e0d9SSaravana Kannan * child device. 1262bcbbcfd5SSaravana Kannan */ 12639528e0d9SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) { 12649528e0d9SSaravana Kannan struct fwnode_handle *child; 1265f9aa4606SSaravana Kannan fwnode_links_purge_suppliers(dev->fwnode); 12669528e0d9SSaravana Kannan fwnode_for_each_available_child_node(dev->fwnode, child) 12679528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 12689528e0d9SSaravana Kannan } 1269da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 1270bcbbcfd5SSaravana Kannan 12719ed98953SRafael J. Wysocki device_links_write_lock(); 12729ed98953SRafael J. Wysocki 12739ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1274515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 12759ed98953SRafael J. Wysocki continue; 12769ed98953SRafael J. Wysocki 127715cfb094SRafael J. Wysocki /* 127815cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 127915cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 128015cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 128115cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 128215cfb094SRafael J. Wysocki */ 128315cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 128415cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 128515cfb094SRafael J. Wysocki continue; 128615cfb094SRafael J. Wysocki 12879ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 12889ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 1289e7dd4010SRafael J. Wysocki 1290e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 1291e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 12929ed98953SRafael J. Wysocki } 12939ed98953SRafael J. Wysocki 129421eb93f4SSaravana Kannan if (defer_sync_state_count) 129521eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 129621eb93f4SSaravana Kannan else 129721eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 129821eb93f4SSaravana Kannan 129921c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 130021c27f06SSaravana Kannan struct device *supplier; 130121c27f06SSaravana Kannan 1302515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13039ed98953SRafael J. Wysocki continue; 13049ed98953SRafael J. Wysocki 130521c27f06SSaravana Kannan supplier = link->supplier; 130621c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { 130721c27f06SSaravana Kannan /* 130821c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no 130921c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's 131021c27f06SSaravana Kannan * save to drop the managed link completely. 131121c27f06SSaravana Kannan */ 131221c27f06SSaravana Kannan device_link_drop_managed(link); 13132f8c3ae8SSaravana Kannan } else if (dev_is_best_effort(dev) && 13142f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED && 13152f8c3ae8SSaravana Kannan link->status != DL_STATE_CONSUMER_PROBE && 13162f8c3ae8SSaravana Kannan !link->supplier->can_match) { 13172f8c3ae8SSaravana Kannan /* 13182f8c3ae8SSaravana Kannan * When dev_is_best_effort() is true, we ignore device 13192f8c3ae8SSaravana Kannan * links to suppliers that don't have a driver. If the 13202f8c3ae8SSaravana Kannan * consumer device still managed to probe, there's no 13212f8c3ae8SSaravana Kannan * point in maintaining a device link in a weird state 13222f8c3ae8SSaravana Kannan * (consumer probed before supplier). So delete it. 13232f8c3ae8SSaravana Kannan */ 13242f8c3ae8SSaravana Kannan device_link_drop_managed(link); 132521c27f06SSaravana Kannan } else { 13269ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 13279ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 132821c27f06SSaravana Kannan } 1329fc5a251dSSaravana Kannan 133021c27f06SSaravana Kannan /* 133121c27f06SSaravana Kannan * This needs to be done even for the deleted 133221c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last 133321c27f06SSaravana Kannan * device link that was preventing the supplier from getting a 133421c27f06SSaravana Kannan * sync_state() call. 133521c27f06SSaravana Kannan */ 1336fc5a251dSSaravana Kannan if (defer_sync_state_count) 133721c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier); 1338fc5a251dSSaravana Kannan else 133921c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list); 13409ed98953SRafael J. Wysocki } 13419ed98953SRafael J. Wysocki 13429ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 13439ed98953SRafael J. Wysocki 13449ed98953SRafael J. Wysocki device_links_write_unlock(); 134526e77708SSaravana Kannan 134621eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 13479ed98953SRafael J. Wysocki } 13489ed98953SRafael J. Wysocki 13499ed98953SRafael J. Wysocki /** 13509ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 13519ed98953SRafael J. Wysocki * @dev: Device without a drvier. 13529ed98953SRafael J. Wysocki * 13539ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 13549ed98953SRafael J. Wysocki * 13559ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 13569ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 13579ed98953SRafael J. Wysocki * case they need not be updated. 13589ed98953SRafael J. Wysocki * 1359515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 13609ed98953SRafael J. Wysocki */ 13619ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 13629ed98953SRafael J. Wysocki { 13639ed98953SRafael J. Wysocki struct device_link *link, *ln; 13649ed98953SRafael J. Wysocki 13659ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 1366515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13679ed98953SRafael J. Wysocki continue; 13689ed98953SRafael J. Wysocki 13698c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 1370515db266SRafael J. Wysocki device_link_drop_managed(link); 13718c3e315dSSaravana Kannan continue; 13728c3e315dSSaravana Kannan } 13738c3e315dSSaravana Kannan 13748c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE && 13758c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE) 13768c3e315dSSaravana Kannan continue; 13778c3e315dSSaravana Kannan 13788c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 13799ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 13808c3e315dSSaravana Kannan } else { 13818c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 13828c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 13838c3e315dSSaravana Kannan } 13849ed98953SRafael J. Wysocki } 13859ed98953SRafael J. Wysocki 13869ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 13879ed98953SRafael J. Wysocki } 13889ed98953SRafael J. Wysocki 138915cfb094SRafael J. Wysocki /** 139015cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 139115cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 139215cfb094SRafael J. Wysocki * 139315cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 139415cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 139515cfb094SRafael J. Wysocki * appropriate. 139615cfb094SRafael J. Wysocki * 1397515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 139815cfb094SRafael J. Wysocki */ 13999ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 14009ed98953SRafael J. Wysocki { 140115cfb094SRafael J. Wysocki struct device_link *link; 140215cfb094SRafael J. Wysocki 14039ed98953SRafael J. Wysocki device_links_write_lock(); 140415cfb094SRafael J. Wysocki 140515cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1406515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 140715cfb094SRafael J. Wysocki continue; 140815cfb094SRafael J. Wysocki 140915cfb094SRafael J. Wysocki /* 141015cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 141115cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 141215cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 141315cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 141415cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 141515cfb094SRafael J. Wysocki */ 141615cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 141715cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 141815cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 141915cfb094SRafael J. Wysocki } 142015cfb094SRafael J. Wysocki 14219ed98953SRafael J. Wysocki __device_links_no_driver(dev); 142215cfb094SRafael J. Wysocki 14239ed98953SRafael J. Wysocki device_links_write_unlock(); 14249ed98953SRafael J. Wysocki } 14259ed98953SRafael J. Wysocki 14269ed98953SRafael J. Wysocki /** 14279ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 14289ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 14299ed98953SRafael J. Wysocki * 14309ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 14319ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 14329ed98953SRafael J. Wysocki * appropriate. 14339ed98953SRafael J. Wysocki * 1434515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14359ed98953SRafael J. Wysocki */ 14369ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 14379ed98953SRafael J. Wysocki { 1438c8d50986SRafael J. Wysocki struct device_link *link, *ln; 14399ed98953SRafael J. Wysocki 14409ed98953SRafael J. Wysocki device_links_write_lock(); 14419ed98953SRafael J. Wysocki 1442c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1443515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 14449ed98953SRafael J. Wysocki continue; 14459ed98953SRafael J. Wysocki 1446e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 14479ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 14481689cac5SVivek Gautam 14491689cac5SVivek Gautam /* 14501689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 14511689cac5SVivek Gautam * devices that are not active, i.e. where the link state 14521689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 14531689cac5SVivek Gautam */ 14541689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 14551689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1456515db266SRafael J. Wysocki device_link_drop_managed(link); 14571689cac5SVivek Gautam 14589ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 14599ed98953SRafael J. Wysocki } 14609ed98953SRafael J. Wysocki 14613b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 14629ed98953SRafael J. Wysocki __device_links_no_driver(dev); 14639ed98953SRafael J. Wysocki 14649ed98953SRafael J. Wysocki device_links_write_unlock(); 14659ed98953SRafael J. Wysocki } 14669ed98953SRafael J. Wysocki 14679ed98953SRafael J. Wysocki /** 14689ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 14699ed98953SRafael J. Wysocki * @dev: Device to check. 14709ed98953SRafael J. Wysocki * 14719ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 14729ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 14739ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 14749ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 14759ed98953SRafael J. Wysocki * successfully going forward. 14769ed98953SRafael J. Wysocki * 14779ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 14789ed98953SRafael J. Wysocki * 1479515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14809ed98953SRafael J. Wysocki */ 14819ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 14829ed98953SRafael J. Wysocki { 14839ed98953SRafael J. Wysocki struct device_link *link; 14849ed98953SRafael J. Wysocki bool ret = false; 14859ed98953SRafael J. Wysocki 14869ed98953SRafael J. Wysocki device_links_write_lock(); 14879ed98953SRafael J. Wysocki 14889ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1489515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 14909ed98953SRafael J. Wysocki continue; 14919ed98953SRafael J. Wysocki 14929ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 14939ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 14949ed98953SRafael J. Wysocki ret = true; 14959ed98953SRafael J. Wysocki break; 14969ed98953SRafael J. Wysocki } 14979ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 14989ed98953SRafael J. Wysocki } 14999ed98953SRafael J. Wysocki 15009ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 15019ed98953SRafael J. Wysocki 15029ed98953SRafael J. Wysocki device_links_write_unlock(); 15039ed98953SRafael J. Wysocki return ret; 15049ed98953SRafael J. Wysocki } 15059ed98953SRafael J. Wysocki 15069ed98953SRafael J. Wysocki /** 15079ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 15089ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 15099ed98953SRafael J. Wysocki * 15109ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 15119ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 15129ed98953SRafael J. Wysocki * and start over. 15139ed98953SRafael J. Wysocki * 15149ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 15159ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 15169ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 15179ed98953SRafael J. Wysocki * changed the state of the link already). 15189ed98953SRafael J. Wysocki * 1519515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 15209ed98953SRafael J. Wysocki */ 15219ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 15229ed98953SRafael J. Wysocki { 15239ed98953SRafael J. Wysocki struct device_link *link; 15249ed98953SRafael J. Wysocki 15259ed98953SRafael J. Wysocki start: 15269ed98953SRafael J. Wysocki device_links_write_lock(); 15279ed98953SRafael J. Wysocki 15289ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 15299ed98953SRafael J. Wysocki enum device_link_state status; 15309ed98953SRafael J. Wysocki 153105ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 153205ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 15339ed98953SRafael J. Wysocki continue; 15349ed98953SRafael J. Wysocki 15359ed98953SRafael J. Wysocki status = link->status; 15369ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 15379ed98953SRafael J. Wysocki device_links_write_unlock(); 15389ed98953SRafael J. Wysocki 15399ed98953SRafael J. Wysocki wait_for_device_probe(); 15409ed98953SRafael J. Wysocki goto start; 15419ed98953SRafael J. Wysocki } 15429ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 15439ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 15449ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 15459ed98953SRafael J. Wysocki 15469ed98953SRafael J. Wysocki get_device(consumer); 15479ed98953SRafael J. Wysocki 15489ed98953SRafael J. Wysocki device_links_write_unlock(); 15499ed98953SRafael J. Wysocki 15509ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 15519ed98953SRafael J. Wysocki consumer->parent); 15529ed98953SRafael J. Wysocki put_device(consumer); 15539ed98953SRafael J. Wysocki goto start; 15549ed98953SRafael J. Wysocki } 15559ed98953SRafael J. Wysocki } 15569ed98953SRafael J. Wysocki 15579ed98953SRafael J. Wysocki device_links_write_unlock(); 15589ed98953SRafael J. Wysocki } 15599ed98953SRafael J. Wysocki 15609ed98953SRafael J. Wysocki /** 15619ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 15629ed98953SRafael J. Wysocki * @dev: Target device. 15639ed98953SRafael J. Wysocki */ 15649ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 15659ed98953SRafael J. Wysocki { 15669ed98953SRafael J. Wysocki struct device_link *link, *ln; 15679ed98953SRafael J. Wysocki 1568287905e6SSaravana Kannan if (dev->class == &devlink_class) 1569287905e6SSaravana Kannan return; 1570287905e6SSaravana Kannan 15719ed98953SRafael J. Wysocki /* 15729ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 15739ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 15749ed98953SRafael J. Wysocki */ 15759ed98953SRafael J. Wysocki device_links_write_lock(); 15769ed98953SRafael J. Wysocki 15779ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 15789ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1579ead18c23SLukas Wunner __device_link_del(&link->kref); 15809ed98953SRafael J. Wysocki } 15819ed98953SRafael J. Wysocki 15829ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 15839ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 15849ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1585ead18c23SLukas Wunner __device_link_del(&link->kref); 15869ed98953SRafael J. Wysocki } 15879ed98953SRafael J. Wysocki 15889ed98953SRafael J. Wysocki device_links_write_unlock(); 15899ed98953SRafael J. Wysocki } 15909ed98953SRafael J. Wysocki 1591b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_PERMISSIVE (DL_FLAG_INFERRED | \ 1592b90fb8f6SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 1593b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_ON (DL_FLAG_INFERRED | \ 1594b90fb8f6SSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER) 1595b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_RPM (FW_DEVLINK_FLAGS_ON | \ 1596b90fb8f6SSaravana Kannan DL_FLAG_PM_RUNTIME) 1597b90fb8f6SSaravana Kannan 1598ea718c69SSaravana Kannan static u32 fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 159942926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 160042926ac3SSaravana Kannan { 160142926ac3SSaravana Kannan if (!arg) 160242926ac3SSaravana Kannan return -EINVAL; 160342926ac3SSaravana Kannan 160442926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 160542926ac3SSaravana Kannan fw_devlink_flags = 0; 160642926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 1607b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 160842926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 1609b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 161042926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 1611b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_RPM; 161242926ac3SSaravana Kannan } 161342926ac3SSaravana Kannan return 0; 161442926ac3SSaravana Kannan } 161542926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 161642926ac3SSaravana Kannan 161771066545SSaravana Kannan static bool fw_devlink_strict = true; 161819d0f5f6SSaravana Kannan static int __init fw_devlink_strict_setup(char *arg) 161919d0f5f6SSaravana Kannan { 162019d0f5f6SSaravana Kannan return strtobool(arg, &fw_devlink_strict); 162119d0f5f6SSaravana Kannan } 162219d0f5f6SSaravana Kannan early_param("fw_devlink.strict", fw_devlink_strict_setup); 162319d0f5f6SSaravana Kannan 162442926ac3SSaravana Kannan u32 fw_devlink_get_flags(void) 162542926ac3SSaravana Kannan { 162642926ac3SSaravana Kannan return fw_devlink_flags; 162742926ac3SSaravana Kannan } 162842926ac3SSaravana Kannan 162942926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 163042926ac3SSaravana Kannan { 1631b90fb8f6SSaravana Kannan return fw_devlink_flags == FW_DEVLINK_FLAGS_PERMISSIVE; 163242926ac3SSaravana Kannan } 163342926ac3SSaravana Kannan 163419d0f5f6SSaravana Kannan bool fw_devlink_is_strict(void) 163519d0f5f6SSaravana Kannan { 163619d0f5f6SSaravana Kannan return fw_devlink_strict && !fw_devlink_is_permissive(); 16379ed98953SRafael J. Wysocki } 16389ed98953SRafael J. Wysocki 1639c2c724c8SSaravana Kannan static void fw_devlink_parse_fwnode(struct fwnode_handle *fwnode) 1640c2c724c8SSaravana Kannan { 1641c2c724c8SSaravana Kannan if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) 1642c2c724c8SSaravana Kannan return; 1643c2c724c8SSaravana Kannan 16442d09e6ebSSaravana Kannan fwnode_call_int_op(fwnode, add_links); 1645c2c724c8SSaravana Kannan fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; 1646c2c724c8SSaravana Kannan } 1647c2c724c8SSaravana Kannan 1648c2c724c8SSaravana Kannan static void fw_devlink_parse_fwtree(struct fwnode_handle *fwnode) 1649c2c724c8SSaravana Kannan { 1650c2c724c8SSaravana Kannan struct fwnode_handle *child = NULL; 1651c2c724c8SSaravana Kannan 1652c2c724c8SSaravana Kannan fw_devlink_parse_fwnode(fwnode); 1653c2c724c8SSaravana Kannan 1654c2c724c8SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 1655c2c724c8SSaravana Kannan fw_devlink_parse_fwtree(child); 1656c2c724c8SSaravana Kannan } 1657c2c724c8SSaravana Kannan 1658d46f3e3eSSaravana Kannan static void fw_devlink_relax_link(struct device_link *link) 1659d46f3e3eSSaravana Kannan { 1660d46f3e3eSSaravana Kannan if (!(link->flags & DL_FLAG_INFERRED)) 1661d46f3e3eSSaravana Kannan return; 1662d46f3e3eSSaravana Kannan 1663d46f3e3eSSaravana Kannan if (link->flags == (DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE)) 1664d46f3e3eSSaravana Kannan return; 1665d46f3e3eSSaravana Kannan 1666d46f3e3eSSaravana Kannan pm_runtime_drop_link(link); 1667d46f3e3eSSaravana Kannan link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; 1668d46f3e3eSSaravana Kannan dev_dbg(link->consumer, "Relaxing link with %s\n", 1669d46f3e3eSSaravana Kannan dev_name(link->supplier)); 1670d46f3e3eSSaravana Kannan } 1671d46f3e3eSSaravana Kannan 1672d46f3e3eSSaravana Kannan static int fw_devlink_no_driver(struct device *dev, void *data) 1673d46f3e3eSSaravana Kannan { 1674d46f3e3eSSaravana Kannan struct device_link *link = to_devlink(dev); 1675d46f3e3eSSaravana Kannan 1676d46f3e3eSSaravana Kannan if (!link->supplier->can_match) 1677d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1678d46f3e3eSSaravana Kannan 1679d46f3e3eSSaravana Kannan return 0; 1680d46f3e3eSSaravana Kannan } 1681d46f3e3eSSaravana Kannan 1682d46f3e3eSSaravana Kannan void fw_devlink_drivers_done(void) 1683d46f3e3eSSaravana Kannan { 1684d46f3e3eSSaravana Kannan fw_devlink_drv_reg_done = true; 1685d46f3e3eSSaravana Kannan device_links_write_lock(); 1686d46f3e3eSSaravana Kannan class_for_each_device(&devlink_class, NULL, NULL, 1687d46f3e3eSSaravana Kannan fw_devlink_no_driver); 1688d46f3e3eSSaravana Kannan device_links_write_unlock(); 1689d46f3e3eSSaravana Kannan } 1690d46f3e3eSSaravana Kannan 16912f8c3ae8SSaravana Kannan /** 16922f8c3ae8SSaravana Kannan * wait_for_init_devices_probe - Try to probe any device needed for init 16932f8c3ae8SSaravana Kannan * 16942f8c3ae8SSaravana Kannan * Some devices might need to be probed and bound successfully before the kernel 16952f8c3ae8SSaravana Kannan * boot sequence can finish and move on to init/userspace. For example, a 16962f8c3ae8SSaravana Kannan * network interface might need to be bound to be able to mount a NFS rootfs. 16972f8c3ae8SSaravana Kannan * 16982f8c3ae8SSaravana Kannan * With fw_devlink=on by default, some of these devices might be blocked from 16992f8c3ae8SSaravana Kannan * probing because they are waiting on a optional supplier that doesn't have a 17002f8c3ae8SSaravana Kannan * driver. While fw_devlink will eventually identify such devices and unblock 17012f8c3ae8SSaravana Kannan * the probing automatically, it might be too late by the time it unblocks the 17022f8c3ae8SSaravana Kannan * probing of devices. For example, the IP4 autoconfig might timeout before 17032f8c3ae8SSaravana Kannan * fw_devlink unblocks probing of the network interface. 17042f8c3ae8SSaravana Kannan * 17052f8c3ae8SSaravana Kannan * This function is available to temporarily try and probe all devices that have 17062f8c3ae8SSaravana Kannan * a driver even if some of their suppliers haven't been added or don't have 17072f8c3ae8SSaravana Kannan * drivers. 17082f8c3ae8SSaravana Kannan * 17092f8c3ae8SSaravana Kannan * The drivers can then decide which of the suppliers are optional vs mandatory 17102f8c3ae8SSaravana Kannan * and probe the device if possible. By the time this function returns, all such 17112f8c3ae8SSaravana Kannan * "best effort" probes are guaranteed to be completed. If a device successfully 17122f8c3ae8SSaravana Kannan * probes in this mode, we delete all fw_devlink discovered dependencies of that 17132f8c3ae8SSaravana Kannan * device where the supplier hasn't yet probed successfully because they have to 17142f8c3ae8SSaravana Kannan * be optional dependencies. 17152f8c3ae8SSaravana Kannan * 17162f8c3ae8SSaravana Kannan * Any devices that didn't successfully probe go back to being treated as if 17172f8c3ae8SSaravana Kannan * this function was never called. 17182f8c3ae8SSaravana Kannan * 17192f8c3ae8SSaravana Kannan * This also means that some devices that aren't needed for init and could have 17202f8c3ae8SSaravana Kannan * waited for their optional supplier to probe (when the supplier's module is 17212f8c3ae8SSaravana Kannan * loaded later on) would end up probing prematurely with limited functionality. 17222f8c3ae8SSaravana Kannan * So call this function only when boot would fail without it. 17232f8c3ae8SSaravana Kannan */ 17242f8c3ae8SSaravana Kannan void __init wait_for_init_devices_probe(void) 17252f8c3ae8SSaravana Kannan { 17262f8c3ae8SSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive()) 17272f8c3ae8SSaravana Kannan return; 17282f8c3ae8SSaravana Kannan 17292f8c3ae8SSaravana Kannan /* 17302f8c3ae8SSaravana Kannan * Wait for all ongoing probes to finish so that the "best effort" is 17312f8c3ae8SSaravana Kannan * only applied to devices that can't probe otherwise. 17322f8c3ae8SSaravana Kannan */ 17332f8c3ae8SSaravana Kannan wait_for_device_probe(); 17342f8c3ae8SSaravana Kannan 17352f8c3ae8SSaravana Kannan pr_info("Trying to probe devices needed for running init ...\n"); 17362f8c3ae8SSaravana Kannan fw_devlink_best_effort = true; 17372f8c3ae8SSaravana Kannan driver_deferred_probe_trigger(); 17382f8c3ae8SSaravana Kannan 17392f8c3ae8SSaravana Kannan /* 17402f8c3ae8SSaravana Kannan * Wait for all "best effort" probes to finish before going back to 17412f8c3ae8SSaravana Kannan * normal enforcement. 17422f8c3ae8SSaravana Kannan */ 17432f8c3ae8SSaravana Kannan wait_for_device_probe(); 17442f8c3ae8SSaravana Kannan fw_devlink_best_effort = false; 17452f8c3ae8SSaravana Kannan } 17462f8c3ae8SSaravana Kannan 1747d46f3e3eSSaravana Kannan static void fw_devlink_unblock_consumers(struct device *dev) 1748d46f3e3eSSaravana Kannan { 1749d46f3e3eSSaravana Kannan struct device_link *link; 1750d46f3e3eSSaravana Kannan 1751d46f3e3eSSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive()) 1752d46f3e3eSSaravana Kannan return; 1753d46f3e3eSSaravana Kannan 1754d46f3e3eSSaravana Kannan device_links_write_lock(); 1755d46f3e3eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) 1756d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1757d46f3e3eSSaravana Kannan device_links_write_unlock(); 1758d46f3e3eSSaravana Kannan } 1759d46f3e3eSSaravana Kannan 1760f9aa4606SSaravana Kannan /** 1761b0e2fa4fSSaravana Kannan * fw_devlink_relax_cycle - Convert cyclic links to SYNC_STATE_ONLY links 1762b0e2fa4fSSaravana Kannan * @con: Device to check dependencies for. 1763b0e2fa4fSSaravana Kannan * @sup: Device to check against. 1764b0e2fa4fSSaravana Kannan * 1765b0e2fa4fSSaravana Kannan * Check if @sup depends on @con or any device dependent on it (its child or 1766b0e2fa4fSSaravana Kannan * its consumer etc). When such a cyclic dependency is found, convert all 1767b0e2fa4fSSaravana Kannan * device links created solely by fw_devlink into SYNC_STATE_ONLY device links. 1768b0e2fa4fSSaravana Kannan * This is the equivalent of doing fw_devlink=permissive just between the 1769b0e2fa4fSSaravana Kannan * devices in the cycle. We need to do this because, at this point, fw_devlink 1770b0e2fa4fSSaravana Kannan * can't tell which of these dependencies is not a real dependency. 1771b0e2fa4fSSaravana Kannan * 1772b0e2fa4fSSaravana Kannan * Return 1 if a cycle is found. Otherwise, return 0. 1773b0e2fa4fSSaravana Kannan */ 1774c13b8279Skernel test robot static int fw_devlink_relax_cycle(struct device *con, void *sup) 1775b0e2fa4fSSaravana Kannan { 1776b0e2fa4fSSaravana Kannan struct device_link *link; 1777b0e2fa4fSSaravana Kannan int ret; 1778b0e2fa4fSSaravana Kannan 1779b0e2fa4fSSaravana Kannan if (con == sup) 1780b0e2fa4fSSaravana Kannan return 1; 1781b0e2fa4fSSaravana Kannan 1782b0e2fa4fSSaravana Kannan ret = device_for_each_child(con, sup, fw_devlink_relax_cycle); 1783b0e2fa4fSSaravana Kannan if (ret) 1784b0e2fa4fSSaravana Kannan return ret; 1785b0e2fa4fSSaravana Kannan 1786b0e2fa4fSSaravana Kannan list_for_each_entry(link, &con->links.consumers, s_node) { 1787b0e2fa4fSSaravana Kannan if ((link->flags & ~DL_FLAG_INFERRED) == 1788b0e2fa4fSSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 1789b0e2fa4fSSaravana Kannan continue; 1790b0e2fa4fSSaravana Kannan 1791b0e2fa4fSSaravana Kannan if (!fw_devlink_relax_cycle(link->consumer, sup)) 1792b0e2fa4fSSaravana Kannan continue; 1793b0e2fa4fSSaravana Kannan 1794b0e2fa4fSSaravana Kannan ret = 1; 1795b0e2fa4fSSaravana Kannan 1796d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1797b0e2fa4fSSaravana Kannan } 1798b0e2fa4fSSaravana Kannan return ret; 1799b0e2fa4fSSaravana Kannan } 1800b0e2fa4fSSaravana Kannan 1801b0e2fa4fSSaravana Kannan /** 1802f9aa4606SSaravana Kannan * fw_devlink_create_devlink - Create a device link from a consumer to fwnode 180337c52f74SPierre-Louis Bossart * @con: consumer device for the device link 180437c52f74SPierre-Louis Bossart * @sup_handle: fwnode handle of supplier 180537c52f74SPierre-Louis Bossart * @flags: devlink flags 1806f9aa4606SSaravana Kannan * 1807f9aa4606SSaravana Kannan * This function will try to create a device link between the consumer device 1808f9aa4606SSaravana Kannan * @con and the supplier device represented by @sup_handle. 1809f9aa4606SSaravana Kannan * 1810f9aa4606SSaravana Kannan * The supplier has to be provided as a fwnode because incorrect cycles in 1811f9aa4606SSaravana Kannan * fwnode links can sometimes cause the supplier device to never be created. 1812f9aa4606SSaravana Kannan * This function detects such cases and returns an error if it cannot create a 1813f9aa4606SSaravana Kannan * device link from the consumer to a missing supplier. 1814f9aa4606SSaravana Kannan * 1815f9aa4606SSaravana Kannan * Returns, 1816f9aa4606SSaravana Kannan * 0 on successfully creating a device link 1817f9aa4606SSaravana Kannan * -EINVAL if the device link cannot be created as expected 1818f9aa4606SSaravana Kannan * -EAGAIN if the device link cannot be created right now, but it may be 1819f9aa4606SSaravana Kannan * possible to do that in the future 1820f9aa4606SSaravana Kannan */ 1821f9aa4606SSaravana Kannan static int fw_devlink_create_devlink(struct device *con, 1822f9aa4606SSaravana Kannan struct fwnode_handle *sup_handle, u32 flags) 1823f9aa4606SSaravana Kannan { 1824f9aa4606SSaravana Kannan struct device *sup_dev; 1825f9aa4606SSaravana Kannan int ret = 0; 1826f9aa4606SSaravana Kannan 18275501765aSSaravana Kannan /* 18285501765aSSaravana Kannan * In some cases, a device P might also be a supplier to its child node 18295501765aSSaravana Kannan * C. However, this would defer the probe of C until the probe of P 18305501765aSSaravana Kannan * completes successfully. This is perfectly fine in the device driver 18315501765aSSaravana Kannan * model. device_add() doesn't guarantee probe completion of the device 18325501765aSSaravana Kannan * by the time it returns. 18335501765aSSaravana Kannan * 18345501765aSSaravana Kannan * However, there are a few drivers that assume C will finish probing 18355501765aSSaravana Kannan * as soon as it's added and before P finishes probing. So, we provide 18365501765aSSaravana Kannan * a flag to let fw_devlink know not to delay the probe of C until the 18375501765aSSaravana Kannan * probe of P completes successfully. 18385501765aSSaravana Kannan * 18395501765aSSaravana Kannan * When such a flag is set, we can't create device links where P is the 18405501765aSSaravana Kannan * supplier of C as that would delay the probe of C. 18415501765aSSaravana Kannan */ 18425501765aSSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD && 18435501765aSSaravana Kannan fwnode_is_ancestor_of(sup_handle, con->fwnode)) 18445501765aSSaravana Kannan return -EINVAL; 18455501765aSSaravana Kannan 1846f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle); 1847f9aa4606SSaravana Kannan if (sup_dev) { 1848f9aa4606SSaravana Kannan /* 184974c782cfSSaravana Kannan * If it's one of those drivers that don't actually bind to 185074c782cfSSaravana Kannan * their device using driver core, then don't wait on this 185174c782cfSSaravana Kannan * supplier device indefinitely. 185274c782cfSSaravana Kannan */ 185374c782cfSSaravana Kannan if (sup_dev->links.status == DL_DEV_NO_DRIVER && 185474c782cfSSaravana Kannan sup_handle->flags & FWNODE_FLAG_INITIALIZED) { 185574c782cfSSaravana Kannan ret = -EINVAL; 185674c782cfSSaravana Kannan goto out; 185774c782cfSSaravana Kannan } 185874c782cfSSaravana Kannan 185974c782cfSSaravana Kannan /* 1860f9aa4606SSaravana Kannan * If this fails, it is due to cycles in device links. Just 1861f9aa4606SSaravana Kannan * give up on this link and treat it as invalid. 1862f9aa4606SSaravana Kannan */ 1863b0e2fa4fSSaravana Kannan if (!device_link_add(con, sup_dev, flags) && 1864b0e2fa4fSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 1865b0e2fa4fSSaravana Kannan dev_info(con, "Fixing up cyclic dependency with %s\n", 1866b0e2fa4fSSaravana Kannan dev_name(sup_dev)); 1867b0e2fa4fSSaravana Kannan device_links_write_lock(); 1868b0e2fa4fSSaravana Kannan fw_devlink_relax_cycle(con, sup_dev); 1869b0e2fa4fSSaravana Kannan device_links_write_unlock(); 1870b0e2fa4fSSaravana Kannan device_link_add(con, sup_dev, 1871b0e2fa4fSSaravana Kannan FW_DEVLINK_FLAGS_PERMISSIVE); 1872f9aa4606SSaravana Kannan ret = -EINVAL; 1873b0e2fa4fSSaravana Kannan } 1874f9aa4606SSaravana Kannan 1875f9aa4606SSaravana Kannan goto out; 1876f9aa4606SSaravana Kannan } 1877f9aa4606SSaravana Kannan 187874c782cfSSaravana Kannan /* Supplier that's already initialized without a struct device. */ 187974c782cfSSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_INITIALIZED) 188074c782cfSSaravana Kannan return -EINVAL; 188174c782cfSSaravana Kannan 1882f9aa4606SSaravana Kannan /* 1883f9aa4606SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY doesn't block probing and supports 1884f9aa4606SSaravana Kannan * cycles. So cycle detection isn't necessary and shouldn't be 1885f9aa4606SSaravana Kannan * done. 1886f9aa4606SSaravana Kannan */ 1887f9aa4606SSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) 1888f9aa4606SSaravana Kannan return -EAGAIN; 1889f9aa4606SSaravana Kannan 1890f9aa4606SSaravana Kannan /* 1891f9aa4606SSaravana Kannan * If we can't find the supplier device from its fwnode, it might be 1892f9aa4606SSaravana Kannan * due to a cyclic dependency between fwnodes. Some of these cycles can 1893f9aa4606SSaravana Kannan * be broken by applying logic. Check for these types of cycles and 1894f9aa4606SSaravana Kannan * break them so that devices in the cycle probe properly. 1895f9aa4606SSaravana Kannan * 18962de9d8e0SSaravana Kannan * If the supplier's parent is dependent on the consumer, then the 18972de9d8e0SSaravana Kannan * consumer and supplier have a cyclic dependency. Since fw_devlink 18982de9d8e0SSaravana Kannan * can't tell which of the inferred dependencies are incorrect, don't 18992de9d8e0SSaravana Kannan * enforce probe ordering between any of the devices in this cyclic 19002de9d8e0SSaravana Kannan * dependency. Do this by relaxing all the fw_devlink device links in 19012de9d8e0SSaravana Kannan * this cycle and by treating the fwnode link between the consumer and 19022de9d8e0SSaravana Kannan * the supplier as an invalid dependency. 1903f9aa4606SSaravana Kannan */ 1904f9aa4606SSaravana Kannan sup_dev = fwnode_get_next_parent_dev(sup_handle); 1905f9aa4606SSaravana Kannan if (sup_dev && device_is_dependent(con, sup_dev)) { 19062de9d8e0SSaravana Kannan dev_info(con, "Fixing up cyclic dependency with %pfwP (%s)\n", 19072de9d8e0SSaravana Kannan sup_handle, dev_name(sup_dev)); 19082de9d8e0SSaravana Kannan device_links_write_lock(); 19092de9d8e0SSaravana Kannan fw_devlink_relax_cycle(con, sup_dev); 19102de9d8e0SSaravana Kannan device_links_write_unlock(); 1911f9aa4606SSaravana Kannan ret = -EINVAL; 1912f9aa4606SSaravana Kannan } else { 1913f9aa4606SSaravana Kannan /* 1914f9aa4606SSaravana Kannan * Can't check for cycles or no cycles. So let's try 1915f9aa4606SSaravana Kannan * again later. 1916f9aa4606SSaravana Kannan */ 1917f9aa4606SSaravana Kannan ret = -EAGAIN; 1918f9aa4606SSaravana Kannan } 1919f9aa4606SSaravana Kannan 1920f9aa4606SSaravana Kannan out: 1921f9aa4606SSaravana Kannan put_device(sup_dev); 1922f9aa4606SSaravana Kannan return ret; 1923f9aa4606SSaravana Kannan } 1924f9aa4606SSaravana Kannan 1925f9aa4606SSaravana Kannan /** 1926f9aa4606SSaravana Kannan * __fw_devlink_link_to_consumers - Create device links to consumers of a device 192737c52f74SPierre-Louis Bossart * @dev: Device that needs to be linked to its consumers 1928f9aa4606SSaravana Kannan * 1929f9aa4606SSaravana Kannan * This function looks at all the consumer fwnodes of @dev and creates device 1930f9aa4606SSaravana Kannan * links between the consumer device and @dev (supplier). 1931f9aa4606SSaravana Kannan * 1932f9aa4606SSaravana Kannan * If the consumer device has not been added yet, then this function creates a 1933f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link between @dev (supplier) and the closest ancestor device 1934f9aa4606SSaravana Kannan * of the consumer fwnode. This is necessary to make sure @dev doesn't get a 1935f9aa4606SSaravana Kannan * sync_state() callback before the real consumer device gets to be added and 1936f9aa4606SSaravana Kannan * then probed. 1937f9aa4606SSaravana Kannan * 1938f9aa4606SSaravana Kannan * Once device links are created from the real consumer to @dev (supplier), the 1939f9aa4606SSaravana Kannan * fwnode links are deleted. 1940f9aa4606SSaravana Kannan */ 1941f9aa4606SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev) 1942f9aa4606SSaravana Kannan { 1943f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 1944f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 1945f9aa4606SSaravana Kannan 1946f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { 1947f9aa4606SSaravana Kannan u32 dl_flags = fw_devlink_get_flags(); 1948f9aa4606SSaravana Kannan struct device *con_dev; 1949f9aa4606SSaravana Kannan bool own_link = true; 1950f9aa4606SSaravana Kannan int ret; 1951f9aa4606SSaravana Kannan 1952f9aa4606SSaravana Kannan con_dev = get_dev_from_fwnode(link->consumer); 1953f9aa4606SSaravana Kannan /* 1954f9aa4606SSaravana Kannan * If consumer device is not available yet, make a "proxy" 1955f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link from the consumer's parent device to 1956f9aa4606SSaravana Kannan * the supplier device. This is necessary to make sure the 1957f9aa4606SSaravana Kannan * supplier doesn't get a sync_state() callback before the real 1958f9aa4606SSaravana Kannan * consumer can create a device link to the supplier. 1959f9aa4606SSaravana Kannan * 1960f9aa4606SSaravana Kannan * This proxy link step is needed to handle the case where the 1961f9aa4606SSaravana Kannan * consumer's parent device is added before the supplier. 1962f9aa4606SSaravana Kannan */ 1963f9aa4606SSaravana Kannan if (!con_dev) { 1964f9aa4606SSaravana Kannan con_dev = fwnode_get_next_parent_dev(link->consumer); 1965f9aa4606SSaravana Kannan /* 1966f9aa4606SSaravana Kannan * However, if the consumer's parent device is also the 1967f9aa4606SSaravana Kannan * parent of the supplier, don't create a 1968f9aa4606SSaravana Kannan * consumer-supplier link from the parent to its child 1969f9aa4606SSaravana Kannan * device. Such a dependency is impossible. 1970f9aa4606SSaravana Kannan */ 1971f9aa4606SSaravana Kannan if (con_dev && 1972f9aa4606SSaravana Kannan fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { 1973f9aa4606SSaravana Kannan put_device(con_dev); 1974f9aa4606SSaravana Kannan con_dev = NULL; 1975f9aa4606SSaravana Kannan } else { 1976f9aa4606SSaravana Kannan own_link = false; 1977b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 1978f9aa4606SSaravana Kannan } 1979f9aa4606SSaravana Kannan } 1980f9aa4606SSaravana Kannan 1981f9aa4606SSaravana Kannan if (!con_dev) 1982f9aa4606SSaravana Kannan continue; 1983f9aa4606SSaravana Kannan 1984f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(con_dev, fwnode, dl_flags); 1985f9aa4606SSaravana Kannan put_device(con_dev); 1986f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 1987f9aa4606SSaravana Kannan continue; 1988f9aa4606SSaravana Kannan 198976f13081SSaravana Kannan __fwnode_link_del(link); 1990f9aa4606SSaravana Kannan } 1991f9aa4606SSaravana Kannan } 1992f9aa4606SSaravana Kannan 1993f9aa4606SSaravana Kannan /** 1994f9aa4606SSaravana Kannan * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device 199537c52f74SPierre-Louis Bossart * @dev: The consumer device that needs to be linked to its suppliers 199637c52f74SPierre-Louis Bossart * @fwnode: Root of the fwnode tree that is used to create device links 1997f9aa4606SSaravana Kannan * 1998f9aa4606SSaravana Kannan * This function looks at all the supplier fwnodes of fwnode tree rooted at 1999f9aa4606SSaravana Kannan * @fwnode and creates device links between @dev (consumer) and all the 2000f9aa4606SSaravana Kannan * supplier devices of the entire fwnode tree at @fwnode. 2001f9aa4606SSaravana Kannan * 2002f9aa4606SSaravana Kannan * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev 2003f9aa4606SSaravana Kannan * and the real suppliers of @dev. Once these device links are created, the 2004f9aa4606SSaravana Kannan * fwnode links are deleted. When such device links are successfully created, 2005f9aa4606SSaravana Kannan * this function is called recursively on those supplier devices. This is 2006f9aa4606SSaravana Kannan * needed to detect and break some invalid cycles in fwnode links. See 2007f9aa4606SSaravana Kannan * fw_devlink_create_devlink() for more details. 2008f9aa4606SSaravana Kannan * 2009f9aa4606SSaravana Kannan * In addition, it also looks at all the suppliers of the entire fwnode tree 2010f9aa4606SSaravana Kannan * because some of the child devices of @dev that have not been added yet 2011f9aa4606SSaravana Kannan * (because @dev hasn't probed) might already have their suppliers added to 2012f9aa4606SSaravana Kannan * driver core. So, this function creates SYNC_STATE_ONLY device links between 2013f9aa4606SSaravana Kannan * @dev (consumer) and these suppliers to make sure they don't execute their 2014f9aa4606SSaravana Kannan * sync_state() callbacks before these child devices have a chance to create 2015f9aa4606SSaravana Kannan * their device links. The fwnode links that correspond to the child devices 2016f9aa4606SSaravana Kannan * aren't delete because they are needed later to create the device links 2017f9aa4606SSaravana Kannan * between the real consumer and supplier devices. 2018f9aa4606SSaravana Kannan */ 2019f9aa4606SSaravana Kannan static void __fw_devlink_link_to_suppliers(struct device *dev, 2020f9aa4606SSaravana Kannan struct fwnode_handle *fwnode) 2021f9aa4606SSaravana Kannan { 2022f9aa4606SSaravana Kannan bool own_link = (dev->fwnode == fwnode); 2023f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 2024f9aa4606SSaravana Kannan struct fwnode_handle *child = NULL; 2025f9aa4606SSaravana Kannan u32 dl_flags; 2026f9aa4606SSaravana Kannan 2027f9aa4606SSaravana Kannan if (own_link) 2028f9aa4606SSaravana Kannan dl_flags = fw_devlink_get_flags(); 2029f9aa4606SSaravana Kannan else 2030b90fb8f6SSaravana Kannan dl_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 2031f9aa4606SSaravana Kannan 2032f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { 2033f9aa4606SSaravana Kannan int ret; 2034f9aa4606SSaravana Kannan struct device *sup_dev; 2035f9aa4606SSaravana Kannan struct fwnode_handle *sup = link->supplier; 2036f9aa4606SSaravana Kannan 2037f9aa4606SSaravana Kannan ret = fw_devlink_create_devlink(dev, sup, dl_flags); 2038f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 2039f9aa4606SSaravana Kannan continue; 2040f9aa4606SSaravana Kannan 204176f13081SSaravana Kannan __fwnode_link_del(link); 2042f9aa4606SSaravana Kannan 2043f9aa4606SSaravana Kannan /* If no device link was created, nothing more to do. */ 2044f9aa4606SSaravana Kannan if (ret) 2045f9aa4606SSaravana Kannan continue; 2046f9aa4606SSaravana Kannan 2047f9aa4606SSaravana Kannan /* 2048f9aa4606SSaravana Kannan * If a device link was successfully created to a supplier, we 2049f9aa4606SSaravana Kannan * now need to try and link the supplier to all its suppliers. 2050f9aa4606SSaravana Kannan * 2051f9aa4606SSaravana Kannan * This is needed to detect and delete false dependencies in 2052f9aa4606SSaravana Kannan * fwnode links that haven't been converted to a device link 2053f9aa4606SSaravana Kannan * yet. See comments in fw_devlink_create_devlink() for more 2054f9aa4606SSaravana Kannan * details on the false dependency. 2055f9aa4606SSaravana Kannan * 2056f9aa4606SSaravana Kannan * Without deleting these false dependencies, some devices will 2057f9aa4606SSaravana Kannan * never probe because they'll keep waiting for their false 2058f9aa4606SSaravana Kannan * dependency fwnode links to be converted to device links. 2059f9aa4606SSaravana Kannan */ 2060f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup); 2061f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(sup_dev, sup_dev->fwnode); 2062f9aa4606SSaravana Kannan put_device(sup_dev); 2063f9aa4606SSaravana Kannan } 2064f9aa4606SSaravana Kannan 2065f9aa4606SSaravana Kannan /* 2066f9aa4606SSaravana Kannan * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of 2067f9aa4606SSaravana Kannan * all the descendants. This proxy link step is needed to handle the 2068f9aa4606SSaravana Kannan * case where the supplier is added before the consumer's parent device 2069f9aa4606SSaravana Kannan * (@dev). 2070f9aa4606SSaravana Kannan */ 2071f9aa4606SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 2072f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, child); 2073f9aa4606SSaravana Kannan } 2074f9aa4606SSaravana Kannan 20755f5377eaSSaravana Kannan static void fw_devlink_link_device(struct device *dev) 20765f5377eaSSaravana Kannan { 2077f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 20785f5377eaSSaravana Kannan 2079f9aa4606SSaravana Kannan if (!fw_devlink_flags) 2080f9aa4606SSaravana Kannan return; 20815f5377eaSSaravana Kannan 2082f9aa4606SSaravana Kannan fw_devlink_parse_fwtree(fwnode); 2083f9aa4606SSaravana Kannan 2084f9aa4606SSaravana Kannan mutex_lock(&fwnode_link_lock); 2085f9aa4606SSaravana Kannan __fw_devlink_link_to_consumers(dev); 2086f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, fwnode); 2087f9aa4606SSaravana Kannan mutex_unlock(&fwnode_link_lock); 20885f5377eaSSaravana Kannan } 20895f5377eaSSaravana Kannan 20909ed98953SRafael J. Wysocki /* Device links support end. */ 20919ed98953SRafael J. Wysocki 20921da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 20931da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 2094e105b8bfSDan Williams static struct kobject *dev_kobj; 2095e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 2096e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 20971da177e4SLinus Torvalds 20985e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 20995e33bc41SRafael J. Wysocki 21005e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 21015e33bc41SRafael J. Wysocki { 21025e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 21035e33bc41SRafael J. Wysocki } 21045e33bc41SRafael J. Wysocki 21055e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 21065e33bc41SRafael J. Wysocki { 21075e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 21085e33bc41SRafael J. Wysocki } 21095e33bc41SRafael J. Wysocki 21105e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 21115e33bc41SRafael J. Wysocki { 21125e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 21135e33bc41SRafael J. Wysocki return 0; 21145e33bc41SRafael J. Wysocki 21155e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 21165e33bc41SRafael J. Wysocki msleep(5); 21175e33bc41SRafael J. Wysocki return restart_syscall(); 21185e33bc41SRafael J. Wysocki } 21195e33bc41SRafael J. Wysocki 21204e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 21214e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 21224e886c29SGreg Kroah-Hartman { 21234e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 21244e886c29SGreg Kroah-Hartman } 21254e886c29SGreg Kroah-Hartman #else 21264e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 21274e886c29SGreg Kroah-Hartman { 21284e886c29SGreg Kroah-Hartman return 1; 21294e886c29SGreg Kroah-Hartman } 21304e886c29SGreg Kroah-Hartman #endif 21311da177e4SLinus Torvalds 2132b2ebd9ddSRafael J. Wysocki static void device_platform_notify(struct device *dev) 213307de0e86SHeikki Krogerus { 2134d0b8e398SRafael J. Wysocki acpi_device_notify(dev); 21357847a145SHeikki Krogerus 2136b2ebd9ddSRafael J. Wysocki software_node_notify(dev); 21377847a145SHeikki Krogerus 2138b2ebd9ddSRafael J. Wysocki if (platform_notify) 213907de0e86SHeikki Krogerus platform_notify(dev); 2140b2ebd9ddSRafael J. Wysocki } 2141b2ebd9ddSRafael J. Wysocki 2142b2ebd9ddSRafael J. Wysocki static void device_platform_notify_remove(struct device *dev) 2143b2ebd9ddSRafael J. Wysocki { 2144d0b8e398SRafael J. Wysocki acpi_device_notify_remove(dev); 214507de0e86SHeikki Krogerus 2146384f5a85SRafael J. Wysocki software_node_notify_remove(dev); 21471da177e4SLinus Torvalds 2148b2ebd9ddSRafael J. Wysocki if (platform_notify_remove) 21491da177e4SLinus Torvalds platform_notify_remove(dev); 21501da177e4SLinus Torvalds } 21511da177e4SLinus Torvalds 21523e95637aSAlan Stern /** 21533e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 21543e95637aSAlan Stern * @dev: struct device to get the name of 21553e95637aSAlan Stern * 21563e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 21579169c012Syan * the device is not bound to a driver, it will return the name of the bus 21583e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 21593e95637aSAlan Stern * string will be returned. 21603e95637aSAlan Stern */ 2161bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 21623e95637aSAlan Stern { 21633589972eSAlan Stern struct device_driver *drv; 21643589972eSAlan Stern 21653589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 21663589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 21673589972eSAlan Stern * never change once they are set, so they don't need special care. 21683589972eSAlan Stern */ 21696aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 2170e020ff61SSaravana Kannan return drv ? drv->name : dev_bus_name(dev); 21713e95637aSAlan Stern } 2172310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 21733e95637aSAlan Stern 21741da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 21751da177e4SLinus Torvalds 21764a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 21774a3ad20cSGreg Kroah-Hartman char *buf) 21781da177e4SLinus Torvalds { 21791da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2180b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 21814a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 21821da177e4SLinus Torvalds 21831da177e4SLinus Torvalds if (dev_attr->show) 218454b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 2185815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 2186a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 2187a52668c6SSergey Senozhatsky dev_attr->show); 2188815d2d50SAndrew Morton } 21891da177e4SLinus Torvalds return ret; 21901da177e4SLinus Torvalds } 21911da177e4SLinus Torvalds 21924a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 21931da177e4SLinus Torvalds const char *buf, size_t count) 21941da177e4SLinus Torvalds { 21951da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2196b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 21974a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 21981da177e4SLinus Torvalds 21991da177e4SLinus Torvalds if (dev_attr->store) 220054b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 22011da177e4SLinus Torvalds return ret; 22021da177e4SLinus Torvalds } 22031da177e4SLinus Torvalds 220452cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 22051da177e4SLinus Torvalds .show = dev_attr_show, 22061da177e4SLinus Torvalds .store = dev_attr_store, 22071da177e4SLinus Torvalds }; 22081da177e4SLinus Torvalds 2209ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 2210ca22e56dSKay Sievers 2211ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 2212ca22e56dSKay Sievers struct device_attribute *attr, 2213ca22e56dSKay Sievers const char *buf, size_t size) 2214ca22e56dSKay Sievers { 2215ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2216f88184bfSKaitao cheng int ret; 2217f88184bfSKaitao cheng unsigned long new; 2218f88184bfSKaitao cheng 2219f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 2220f88184bfSKaitao cheng if (ret) 2221f88184bfSKaitao cheng return ret; 2222ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 2223ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2224ca22e56dSKay Sievers return size; 2225ca22e56dSKay Sievers } 2226ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 2227ca22e56dSKay Sievers 2228ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 2229ca22e56dSKay Sievers struct device_attribute *attr, 2230ca22e56dSKay Sievers char *buf) 2231ca22e56dSKay Sievers { 2232ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2233aa838896SJoe Perches return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); 2234ca22e56dSKay Sievers } 2235ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 2236ca22e56dSKay Sievers 2237ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 2238ca22e56dSKay Sievers struct device_attribute *attr, 2239ca22e56dSKay Sievers const char *buf, size_t size) 2240ca22e56dSKay Sievers { 2241ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2242f88184bfSKaitao cheng int ret; 2243f88184bfSKaitao cheng long new; 2244f88184bfSKaitao cheng 2245f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 2246f88184bfSKaitao cheng if (ret) 2247f88184bfSKaitao cheng return ret; 2248f88184bfSKaitao cheng 2249f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 2250ca22e56dSKay Sievers return -EINVAL; 2251ca22e56dSKay Sievers *(int *)(ea->var) = new; 2252ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2253ca22e56dSKay Sievers return size; 2254ca22e56dSKay Sievers } 2255ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 2256ca22e56dSKay Sievers 2257ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 2258ca22e56dSKay Sievers struct device_attribute *attr, 2259ca22e56dSKay Sievers char *buf) 2260ca22e56dSKay Sievers { 2261ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2262ca22e56dSKay Sievers 2263aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); 2264ca22e56dSKay Sievers } 2265ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 22661da177e4SLinus Torvalds 226791872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 226891872392SBorislav Petkov const char *buf, size_t size) 226991872392SBorislav Petkov { 227091872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 227191872392SBorislav Petkov 227291872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 227391872392SBorislav Petkov return -EINVAL; 227491872392SBorislav Petkov 227591872392SBorislav Petkov return size; 227691872392SBorislav Petkov } 227791872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 227891872392SBorislav Petkov 227991872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 228091872392SBorislav Petkov char *buf) 228191872392SBorislav Petkov { 228291872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 228391872392SBorislav Petkov 2284aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); 228591872392SBorislav Petkov } 228691872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 228791872392SBorislav Petkov 22881da177e4SLinus Torvalds /** 22891da177e4SLinus Torvalds * device_release - free device structure. 22901da177e4SLinus Torvalds * @kobj: device's kobject. 22911da177e4SLinus Torvalds * 22921da177e4SLinus Torvalds * This is called once the reference count for the object 22931da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 22941da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 22951da177e4SLinus Torvalds */ 22961da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 22971da177e4SLinus Torvalds { 2298b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2299fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 23001da177e4SLinus Torvalds 2301a525a3ddSMing Lei /* 2302a525a3ddSMing Lei * Some platform devices are driven without driver attached 2303a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 2304a525a3ddSMing Lei * all resources are released. 2305a525a3ddSMing Lei * 2306a525a3ddSMing Lei * Drivers still can add resources into device after device 2307a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 2308a525a3ddSMing Lei * possible memory leak. 2309a525a3ddSMing Lei */ 2310a525a3ddSMing Lei devres_release_all(dev); 2311a525a3ddSMing Lei 2312e0d07278SJim Quinlan kfree(dev->dma_range_map); 2313e0d07278SJim Quinlan 23141da177e4SLinus Torvalds if (dev->release) 23151da177e4SLinus Torvalds dev->release(dev); 2316f9f852dfSKay Sievers else if (dev->type && dev->type->release) 2317f9f852dfSKay Sievers dev->type->release(dev); 23182620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 23192620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 2320f810a5cfSArjan van de Ven else 23210c1bc6b8SMauro 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", 23221e0b2cf9SKay Sievers dev_name(dev)); 2323fb069a5dSGreg Kroah-Hartman kfree(p); 23241da177e4SLinus Torvalds } 23251da177e4SLinus Torvalds 2326bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 2327bc451f20SEric W. Biederman { 2328b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2329bc451f20SEric W. Biederman const void *ns = NULL; 2330bc451f20SEric W. Biederman 2331bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 2332bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 2333bc451f20SEric W. Biederman 2334bc451f20SEric W. Biederman return ns; 2335bc451f20SEric W. Biederman } 2336bc451f20SEric W. Biederman 23379944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 23389944e894SDmitry Torokhov { 23399944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 23409944e894SDmitry Torokhov 23419944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 23429944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 23439944e894SDmitry Torokhov } 23449944e894SDmitry Torokhov 23458f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 23461da177e4SLinus Torvalds .release = device_release, 23471da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 2348bc451f20SEric W. Biederman .namespace = device_namespace, 23499944e894SDmitry Torokhov .get_ownership = device_get_ownership, 23501da177e4SLinus Torvalds }; 23511da177e4SLinus Torvalds 23521da177e4SLinus Torvalds 2353cf6299b6SGreg Kroah-Hartman static int dev_uevent_filter(struct kobject *kobj) 23541da177e4SLinus Torvalds { 2355ee6d3dd4SWedson Almeida Filho const struct kobj_type *ktype = get_ktype(kobj); 23561da177e4SLinus Torvalds 23578f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 2358b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 23591da177e4SLinus Torvalds if (dev->bus) 23601da177e4SLinus Torvalds return 1; 236123681e47SGreg Kroah-Hartman if (dev->class) 236223681e47SGreg Kroah-Hartman return 1; 23631da177e4SLinus Torvalds } 23641da177e4SLinus Torvalds return 0; 23651da177e4SLinus Torvalds } 23661da177e4SLinus Torvalds 2367cf6299b6SGreg Kroah-Hartman static const char *dev_uevent_name(struct kobject *kobj) 23681da177e4SLinus Torvalds { 2369b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 23701da177e4SLinus Torvalds 237123681e47SGreg Kroah-Hartman if (dev->bus) 23721da177e4SLinus Torvalds return dev->bus->name; 237323681e47SGreg Kroah-Hartman if (dev->class) 237423681e47SGreg Kroah-Hartman return dev->class->name; 237523681e47SGreg Kroah-Hartman return NULL; 23761da177e4SLinus Torvalds } 23771da177e4SLinus Torvalds 2378cf6299b6SGreg Kroah-Hartman static int dev_uevent(struct kobject *kobj, struct kobj_uevent_env *env) 23791da177e4SLinus Torvalds { 2380b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 23811da177e4SLinus Torvalds int retval = 0; 23821da177e4SLinus Torvalds 23836fcf53acSKay Sievers /* add device node properties if present */ 238423681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 23856fcf53acSKay Sievers const char *tmp; 23866fcf53acSKay Sievers const char *name; 23872c9ede55SAl Viro umode_t mode = 0; 23884e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 23894e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 23906fcf53acSKay Sievers 23917eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 23927eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 23933c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 23946fcf53acSKay Sievers if (name) { 23956fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 2396e454cea2SKay Sievers if (mode) 2397e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 23984e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 23994e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 24004e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 24014e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 24023c2670e6SKay Sievers kfree(tmp); 24036fcf53acSKay Sievers } 240423681e47SGreg Kroah-Hartman } 240523681e47SGreg Kroah-Hartman 2406414264f9SKay Sievers if (dev->type && dev->type->name) 24077eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 2408414264f9SKay Sievers 2409239378f1SKay Sievers if (dev->driver) 24107eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 2411239378f1SKay Sievers 241207d57a32SGrant Likely /* Add common DT information about the device */ 241307d57a32SGrant Likely of_device_uevent(dev, env); 241407d57a32SGrant Likely 24151da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 24167eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 24177eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 2418f9f852dfSKay Sievers if (retval) 24197dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 24201e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 24211da177e4SLinus Torvalds } 24221da177e4SLinus Torvalds 24232620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 24247eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 24257eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 2426f9f852dfSKay Sievers if (retval) 24277dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 24281e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 24292b3a302aSHarvey Harrison __func__, retval); 24302620efefSGreg Kroah-Hartman } 2431f9f852dfSKay Sievers 2432eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 24337eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 24347eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 2435f9f852dfSKay Sievers if (retval) 24367dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 24371e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 24382b3a302aSHarvey Harrison __func__, retval); 24392620efefSGreg Kroah-Hartman } 24402620efefSGreg Kroah-Hartman 24411da177e4SLinus Torvalds return retval; 24421da177e4SLinus Torvalds } 24431da177e4SLinus Torvalds 24449cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 2445312c004dSKay Sievers .filter = dev_uevent_filter, 2446312c004dSKay Sievers .name = dev_uevent_name, 2447312c004dSKay Sievers .uevent = dev_uevent, 24481da177e4SLinus Torvalds }; 24491da177e4SLinus Torvalds 2450c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 245116574dccSKay Sievers char *buf) 245216574dccSKay Sievers { 245316574dccSKay Sievers struct kobject *top_kobj; 245416574dccSKay Sievers struct kset *kset; 24557eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 245616574dccSKay Sievers int i; 2457948b3edbSJoe Perches int len = 0; 245816574dccSKay Sievers int retval; 245916574dccSKay Sievers 246016574dccSKay Sievers /* search the kset, the device belongs to */ 246116574dccSKay Sievers top_kobj = &dev->kobj; 24625c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 246316574dccSKay Sievers top_kobj = top_kobj->parent; 246416574dccSKay Sievers if (!top_kobj->kset) 246516574dccSKay Sievers goto out; 24665c5daf65SKay Sievers 246716574dccSKay Sievers kset = top_kobj->kset; 246816574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 246916574dccSKay Sievers goto out; 247016574dccSKay Sievers 247116574dccSKay Sievers /* respect filter */ 247216574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 2473cf6299b6SGreg Kroah-Hartman if (!kset->uevent_ops->filter(&dev->kobj)) 247416574dccSKay Sievers goto out; 247516574dccSKay Sievers 24767eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 24777eff2e7aSKay Sievers if (!env) 2478c7308c81SGreg Kroah-Hartman return -ENOMEM; 2479c7308c81SGreg Kroah-Hartman 248016574dccSKay Sievers /* let the kset specific function add its keys */ 2481cf6299b6SGreg Kroah-Hartman retval = kset->uevent_ops->uevent(&dev->kobj, env); 248216574dccSKay Sievers if (retval) 248316574dccSKay Sievers goto out; 248416574dccSKay Sievers 248516574dccSKay Sievers /* copy keys to file */ 24867eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 2487948b3edbSJoe Perches len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); 248816574dccSKay Sievers out: 24897eff2e7aSKay Sievers kfree(env); 2490948b3edbSJoe Perches return len; 249116574dccSKay Sievers } 249216574dccSKay Sievers 2493c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 2494a7fd6706SKay Sievers const char *buf, size_t count) 2495a7fd6706SKay Sievers { 2496df44b479SPeter Rajnoha int rc; 2497df44b479SPeter Rajnoha 2498df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 2499df44b479SPeter Rajnoha 2500df44b479SPeter Rajnoha if (rc) { 2501f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 2502df44b479SPeter Rajnoha return rc; 2503df44b479SPeter Rajnoha } 250460a96a59SKay Sievers 2505a7fd6706SKay Sievers return count; 2506a7fd6706SKay Sievers } 2507c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 2508a7fd6706SKay Sievers 2509c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 25104f3549d7SRafael J. Wysocki char *buf) 25114f3549d7SRafael J. Wysocki { 25124f3549d7SRafael J. Wysocki bool val; 25134f3549d7SRafael J. Wysocki 25145e33bc41SRafael J. Wysocki device_lock(dev); 25154f3549d7SRafael J. Wysocki val = !dev->offline; 25165e33bc41SRafael J. Wysocki device_unlock(dev); 2517aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 25184f3549d7SRafael J. Wysocki } 25194f3549d7SRafael J. Wysocki 2520c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 25214f3549d7SRafael J. Wysocki const char *buf, size_t count) 25224f3549d7SRafael J. Wysocki { 25234f3549d7SRafael J. Wysocki bool val; 25244f3549d7SRafael J. Wysocki int ret; 25254f3549d7SRafael J. Wysocki 25264f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 25274f3549d7SRafael J. Wysocki if (ret < 0) 25284f3549d7SRafael J. Wysocki return ret; 25294f3549d7SRafael J. Wysocki 25305e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 25315e33bc41SRafael J. Wysocki if (ret) 25325e33bc41SRafael J. Wysocki return ret; 25335e33bc41SRafael J. Wysocki 25344f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 25354f3549d7SRafael J. Wysocki unlock_device_hotplug(); 25364f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 25374f3549d7SRafael J. Wysocki } 2538c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 25394f3549d7SRafael J. Wysocki 254070f400d4SRajat Jain static ssize_t removable_show(struct device *dev, struct device_attribute *attr, 254170f400d4SRajat Jain char *buf) 254270f400d4SRajat Jain { 254370f400d4SRajat Jain const char *loc; 254470f400d4SRajat Jain 254570f400d4SRajat Jain switch (dev->removable) { 254670f400d4SRajat Jain case DEVICE_REMOVABLE: 254770f400d4SRajat Jain loc = "removable"; 254870f400d4SRajat Jain break; 254970f400d4SRajat Jain case DEVICE_FIXED: 255070f400d4SRajat Jain loc = "fixed"; 255170f400d4SRajat Jain break; 255270f400d4SRajat Jain default: 255370f400d4SRajat Jain loc = "unknown"; 255470f400d4SRajat Jain } 255570f400d4SRajat Jain return sysfs_emit(buf, "%s\n", loc); 255670f400d4SRajat Jain } 255770f400d4SRajat Jain static DEVICE_ATTR_RO(removable); 255870f400d4SRajat Jain 2559fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 2560621a1672SDmitry Torokhov { 25613e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 2562621a1672SDmitry Torokhov } 2563a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 2564621a1672SDmitry Torokhov 2565fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 2566a4dbd674SDavid Brownell const struct attribute_group **groups) 2567621a1672SDmitry Torokhov { 25683e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 2569621a1672SDmitry Torokhov } 2570a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 2571de0ff00dSGreg Kroah-Hartman 257257b8ff07SDmitry Torokhov union device_attr_group_devres { 257357b8ff07SDmitry Torokhov const struct attribute_group *group; 257457b8ff07SDmitry Torokhov const struct attribute_group **groups; 257557b8ff07SDmitry Torokhov }; 257657b8ff07SDmitry Torokhov 257757b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 257857b8ff07SDmitry Torokhov { 257957b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 258057b8ff07SDmitry Torokhov } 258157b8ff07SDmitry Torokhov 258257b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 258357b8ff07SDmitry Torokhov { 258457b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 258557b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 258657b8ff07SDmitry Torokhov 258757b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 258857b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 258957b8ff07SDmitry Torokhov } 259057b8ff07SDmitry Torokhov 259157b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 259257b8ff07SDmitry Torokhov { 259357b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 259457b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 259557b8ff07SDmitry Torokhov 259657b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 259757b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 259857b8ff07SDmitry Torokhov } 259957b8ff07SDmitry Torokhov 260057b8ff07SDmitry Torokhov /** 260157b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 260257b8ff07SDmitry Torokhov * @dev: The device to create the group for 260357b8ff07SDmitry Torokhov * @grp: The attribute group to create 260457b8ff07SDmitry Torokhov * 260557b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 260657b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 260757b8ff07SDmitry Torokhov * 260857b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 260957b8ff07SDmitry Torokhov */ 261057b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 261157b8ff07SDmitry Torokhov { 261257b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 261357b8ff07SDmitry Torokhov int error; 261457b8ff07SDmitry Torokhov 261557b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 261657b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 261757b8ff07SDmitry Torokhov if (!devres) 261857b8ff07SDmitry Torokhov return -ENOMEM; 261957b8ff07SDmitry Torokhov 262057b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 262157b8ff07SDmitry Torokhov if (error) { 262257b8ff07SDmitry Torokhov devres_free(devres); 262357b8ff07SDmitry Torokhov return error; 262457b8ff07SDmitry Torokhov } 262557b8ff07SDmitry Torokhov 262657b8ff07SDmitry Torokhov devres->group = grp; 262757b8ff07SDmitry Torokhov devres_add(dev, devres); 262857b8ff07SDmitry Torokhov return 0; 262957b8ff07SDmitry Torokhov } 263057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 263157b8ff07SDmitry Torokhov 263257b8ff07SDmitry Torokhov /** 263357b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 263457b8ff07SDmitry Torokhov * @dev: device to remove the group from 263557b8ff07SDmitry Torokhov * @grp: group to remove 263657b8ff07SDmitry Torokhov * 263757b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 263857b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 263957b8ff07SDmitry Torokhov */ 264057b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 264157b8ff07SDmitry Torokhov const struct attribute_group *grp) 264257b8ff07SDmitry Torokhov { 264357b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 264457b8ff07SDmitry Torokhov devm_attr_group_match, 264557b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 264657b8ff07SDmitry Torokhov } 264757b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 264857b8ff07SDmitry Torokhov 264957b8ff07SDmitry Torokhov /** 265057b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 265157b8ff07SDmitry Torokhov * @dev: The device to create the group for 265257b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 265357b8ff07SDmitry Torokhov * 265457b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 265557b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 265657b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 265757b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 265857b8ff07SDmitry Torokhov * attribute files being created already exist. 265957b8ff07SDmitry Torokhov * 266057b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 266157b8ff07SDmitry Torokhov */ 266257b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 266357b8ff07SDmitry Torokhov const struct attribute_group **groups) 266457b8ff07SDmitry Torokhov { 266557b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 266657b8ff07SDmitry Torokhov int error; 266757b8ff07SDmitry Torokhov 266857b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 266957b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 267057b8ff07SDmitry Torokhov if (!devres) 267157b8ff07SDmitry Torokhov return -ENOMEM; 267257b8ff07SDmitry Torokhov 267357b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 267457b8ff07SDmitry Torokhov if (error) { 267557b8ff07SDmitry Torokhov devres_free(devres); 267657b8ff07SDmitry Torokhov return error; 267757b8ff07SDmitry Torokhov } 267857b8ff07SDmitry Torokhov 267957b8ff07SDmitry Torokhov devres->groups = groups; 268057b8ff07SDmitry Torokhov devres_add(dev, devres); 268157b8ff07SDmitry Torokhov return 0; 268257b8ff07SDmitry Torokhov } 268357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 268457b8ff07SDmitry Torokhov 268557b8ff07SDmitry Torokhov /** 268657b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 268757b8ff07SDmitry Torokhov * 268857b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 268957b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 269057b8ff07SDmitry Torokhov * 269157b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 269257b8ff07SDmitry Torokhov */ 269357b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 269457b8ff07SDmitry Torokhov const struct attribute_group **groups) 269557b8ff07SDmitry Torokhov { 269657b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 269757b8ff07SDmitry Torokhov devm_attr_group_match, 269857b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 269957b8ff07SDmitry Torokhov } 270057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 27011da177e4SLinus Torvalds 27022620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 27032620efefSGreg Kroah-Hartman { 27042620efefSGreg Kroah-Hartman struct class *class = dev->class; 2705aed65af1SStephen Hemminger const struct device_type *type = dev->type; 2706621a1672SDmitry Torokhov int error; 27072620efefSGreg Kroah-Hartman 2708621a1672SDmitry Torokhov if (class) { 2709d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 27102620efefSGreg Kroah-Hartman if (error) 2711621a1672SDmitry Torokhov return error; 2712f9f852dfSKay Sievers } 2713f9f852dfSKay Sievers 2714621a1672SDmitry Torokhov if (type) { 2715621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 2716f9f852dfSKay Sievers if (error) 2717a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 2718f9f852dfSKay Sievers } 2719621a1672SDmitry Torokhov 2720621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 2721f9f852dfSKay Sievers if (error) 2722621a1672SDmitry Torokhov goto err_remove_type_groups; 2723621a1672SDmitry Torokhov 27244f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 2725c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 27264f3549d7SRafael J. Wysocki if (error) 2727ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 27284f3549d7SRafael J. Wysocki } 27294f3549d7SRafael J. Wysocki 273025ac86c6SSaravana Kannan if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { 2731da6d6475SSaravana Kannan error = device_create_file(dev, &dev_attr_waiting_for_supplier); 2732da6d6475SSaravana Kannan if (error) 2733da6d6475SSaravana Kannan goto err_remove_dev_online; 2734da6d6475SSaravana Kannan } 2735da6d6475SSaravana Kannan 273670f400d4SRajat Jain if (dev_removable_is_valid(dev)) { 273770f400d4SRajat Jain error = device_create_file(dev, &dev_attr_removable); 273870f400d4SRajat Jain if (error) 273970f400d4SRajat Jain goto err_remove_dev_waiting_for_supplier; 274070f400d4SRajat Jain } 274170f400d4SRajat Jain 27426423d295SWon Chung if (dev_add_physical_location(dev)) { 27436423d295SWon Chung error = device_add_group(dev, 27446423d295SWon Chung &dev_attr_physical_location_group); 27456423d295SWon Chung if (error) 27466423d295SWon Chung goto err_remove_dev_removable; 27476423d295SWon Chung } 27486423d295SWon Chung 2749621a1672SDmitry Torokhov return 0; 2750621a1672SDmitry Torokhov 27516423d295SWon Chung err_remove_dev_removable: 27526423d295SWon Chung device_remove_file(dev, &dev_attr_removable); 275370f400d4SRajat Jain err_remove_dev_waiting_for_supplier: 275470f400d4SRajat Jain device_remove_file(dev, &dev_attr_waiting_for_supplier); 2755da6d6475SSaravana Kannan err_remove_dev_online: 2756da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_online); 2757ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 2758ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 2759621a1672SDmitry Torokhov err_remove_type_groups: 2760621a1672SDmitry Torokhov if (type) 2761621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2762d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 2763d05a6f96SGreg Kroah-Hartman if (class) 2764d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2765f9f852dfSKay Sievers 27662620efefSGreg Kroah-Hartman return error; 27672620efefSGreg Kroah-Hartman } 27682620efefSGreg Kroah-Hartman 27692620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 27702620efefSGreg Kroah-Hartman { 27712620efefSGreg Kroah-Hartman struct class *class = dev->class; 2772aed65af1SStephen Hemminger const struct device_type *type = dev->type; 27732620efefSGreg Kroah-Hartman 27746423d295SWon Chung if (dev->physical_location) { 27756423d295SWon Chung device_remove_group(dev, &dev_attr_physical_location_group); 27766423d295SWon Chung kfree(dev->physical_location); 27776423d295SWon Chung } 27786423d295SWon Chung 277970f400d4SRajat Jain device_remove_file(dev, &dev_attr_removable); 2780da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 2781c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 2782621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 2783f9f852dfSKay Sievers 2784621a1672SDmitry Torokhov if (type) 2785621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2786621a1672SDmitry Torokhov 2787a6b01dedSGreg Kroah-Hartman if (class) 2788d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2789c97415a7SStefan Achatz } 27902620efefSGreg Kroah-Hartman 2791c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 279223681e47SGreg Kroah-Hartman char *buf) 279323681e47SGreg Kroah-Hartman { 279423681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 279523681e47SGreg Kroah-Hartman } 2796c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 2797ad6a1e1cSTejun Heo 2798ca22e56dSKay Sievers /* /sys/devices/ */ 2799881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 28001da177e4SLinus Torvalds 28011da177e4SLinus Torvalds /** 280252cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 280352cdbdd4SGrygorii Strashko * @deva: Device to move. 280452cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 280552cdbdd4SGrygorii Strashko */ 280652cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 280752cdbdd4SGrygorii Strashko { 280852cdbdd4SGrygorii Strashko if (!devices_kset) 280952cdbdd4SGrygorii Strashko return; 281052cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 281152cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 281252cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 281352cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 281452cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 281552cdbdd4SGrygorii Strashko } 281652cdbdd4SGrygorii Strashko 281752cdbdd4SGrygorii Strashko /** 281852cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 281952cdbdd4SGrygorii Strashko * @deva: Device to move 282052cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 282152cdbdd4SGrygorii Strashko */ 282252cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 282352cdbdd4SGrygorii Strashko { 282452cdbdd4SGrygorii Strashko if (!devices_kset) 282552cdbdd4SGrygorii Strashko return; 282652cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 282752cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 282852cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 282952cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 283052cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 283152cdbdd4SGrygorii Strashko } 283252cdbdd4SGrygorii Strashko 283352cdbdd4SGrygorii Strashko /** 283452cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 283552cdbdd4SGrygorii Strashko * @dev: device to move 283652cdbdd4SGrygorii Strashko */ 283752cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 283852cdbdd4SGrygorii Strashko { 283952cdbdd4SGrygorii Strashko if (!devices_kset) 284052cdbdd4SGrygorii Strashko return; 284152cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 284252cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 284352cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 284452cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 284552cdbdd4SGrygorii Strashko } 284652cdbdd4SGrygorii Strashko 284752cdbdd4SGrygorii Strashko /** 28481da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 28491da177e4SLinus Torvalds * @dev: device. 28501da177e4SLinus Torvalds * @attr: device attribute descriptor. 28511da177e4SLinus Torvalds */ 285226579ab7SPhil Carmody int device_create_file(struct device *dev, 285326579ab7SPhil Carmody const struct device_attribute *attr) 28541da177e4SLinus Torvalds { 28551da177e4SLinus Torvalds int error = 0; 28568f46baaaSFelipe Balbi 28578f46baaaSFelipe Balbi if (dev) { 28588f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 285997521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 286097521978Sdyoung@redhat.com attr->attr.name); 28618f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 286297521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 286397521978Sdyoung@redhat.com attr->attr.name); 28641da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 28658f46baaaSFelipe Balbi } 28668f46baaaSFelipe Balbi 28671da177e4SLinus Torvalds return error; 28681da177e4SLinus Torvalds } 286986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 28701da177e4SLinus Torvalds 28711da177e4SLinus Torvalds /** 28721da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 28731da177e4SLinus Torvalds * @dev: device. 28741da177e4SLinus Torvalds * @attr: device attribute descriptor. 28751da177e4SLinus Torvalds */ 287626579ab7SPhil Carmody void device_remove_file(struct device *dev, 287726579ab7SPhil Carmody const struct device_attribute *attr) 28781da177e4SLinus Torvalds { 28790c98b19fSCornelia Huck if (dev) 28801da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 28811da177e4SLinus Torvalds } 288286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 28831da177e4SLinus Torvalds 28842589f188SGreg Kroah-Hartman /** 28856b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 28866b0afc2aSTejun Heo * @dev: device. 28876b0afc2aSTejun Heo * @attr: device attribute descriptor. 28886b0afc2aSTejun Heo * 28896b0afc2aSTejun Heo * See kernfs_remove_self() for details. 28906b0afc2aSTejun Heo */ 28916b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 28926b0afc2aSTejun Heo const struct device_attribute *attr) 28936b0afc2aSTejun Heo { 28946b0afc2aSTejun Heo if (dev) 28956b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 28966b0afc2aSTejun Heo else 28976b0afc2aSTejun Heo return false; 28986b0afc2aSTejun Heo } 28996b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 29006b0afc2aSTejun Heo 29016b0afc2aSTejun Heo /** 29022589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 29032589f188SGreg Kroah-Hartman * @dev: device. 29042589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 29052589f188SGreg Kroah-Hartman */ 290666ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 290766ecb92bSPhil Carmody const struct bin_attribute *attr) 29082589f188SGreg Kroah-Hartman { 29092589f188SGreg Kroah-Hartman int error = -EINVAL; 29102589f188SGreg Kroah-Hartman if (dev) 29112589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 29122589f188SGreg Kroah-Hartman return error; 29132589f188SGreg Kroah-Hartman } 29142589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 29152589f188SGreg Kroah-Hartman 29162589f188SGreg Kroah-Hartman /** 29172589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 29182589f188SGreg Kroah-Hartman * @dev: device. 29192589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 29202589f188SGreg Kroah-Hartman */ 292166ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 292266ecb92bSPhil Carmody const struct bin_attribute *attr) 29232589f188SGreg Kroah-Hartman { 29242589f188SGreg Kroah-Hartman if (dev) 29252589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 29262589f188SGreg Kroah-Hartman } 29272589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 29282589f188SGreg Kroah-Hartman 292934bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 293034bb61f9SJames Bottomley { 2931f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2932f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 293334bb61f9SJames Bottomley 293434bb61f9SJames Bottomley get_device(dev); 293534bb61f9SJames Bottomley } 293634bb61f9SJames Bottomley 293734bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 293834bb61f9SJames Bottomley { 2939f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2940f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 294134bb61f9SJames Bottomley 294234bb61f9SJames Bottomley put_device(dev); 294334bb61f9SJames Bottomley } 294434bb61f9SJames Bottomley 29451da177e4SLinus Torvalds /** 29461da177e4SLinus Torvalds * device_initialize - init device structure. 29471da177e4SLinus Torvalds * @dev: device. 29481da177e4SLinus Torvalds * 29495739411aSCornelia Huck * This prepares the device for use by other layers by initializing 29505739411aSCornelia Huck * its fields. 29511da177e4SLinus Torvalds * It is the first half of device_register(), if called by 29525739411aSCornelia Huck * that function, though it can also be called separately, so one 29535739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 29545739411aSCornelia Huck * may be used for reference counting of @dev after calling this 29555739411aSCornelia Huck * function. 29565739411aSCornelia Huck * 2957b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 2958b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 2959b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 2960b10d5efdSAlan Stern * @dev. 2961b10d5efdSAlan Stern * 29625739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 29635739411aSCornelia Huck * @dev directly once you have called this function. 29641da177e4SLinus Torvalds */ 29651da177e4SLinus Torvalds void device_initialize(struct device *dev) 29661da177e4SLinus Torvalds { 2967881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 2968f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 29691da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 29703142788bSThomas Gleixner mutex_init(&dev->mutex); 29711704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 29729ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 29739ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 29743b98aeafSAlan Stern device_pm_init(dev); 2975d460d7f7SMax Gurtovoy set_dev_node(dev, NUMA_NO_NODE); 29769ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 29779ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 29783b052a3eSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 29799ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 29806d4e9a8eSChristoph Hellwig #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \ 29816d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \ 29826d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) 29836d4e9a8eSChristoph Hellwig dev->dma_coherent = dma_default_coherent; 29846d4e9a8eSChristoph Hellwig #endif 298569031f50SClaire Chang #ifdef CONFIG_SWIOTLB 2986463e862aSWill Deacon dev->dma_io_tlb_mem = &io_tlb_default_mem; 298769031f50SClaire Chang #endif 29881da177e4SLinus Torvalds } 298986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 29901da177e4SLinus Torvalds 2991d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 2992f0ee61a6SGreg Kroah-Hartman { 2993f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 2994f0ee61a6SGreg Kroah-Hartman 2995f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 29964ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 2997881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 2998f0ee61a6SGreg Kroah-Hartman 299986406245SKay Sievers return virtual_dir; 3000f0ee61a6SGreg Kroah-Hartman } 3001f0ee61a6SGreg Kroah-Hartman 3002bc451f20SEric W. Biederman struct class_dir { 3003bc451f20SEric W. Biederman struct kobject kobj; 3004bc451f20SEric W. Biederman struct class *class; 3005bc451f20SEric W. Biederman }; 3006bc451f20SEric W. Biederman 3007bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 3008bc451f20SEric W. Biederman 3009bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 3010bc451f20SEric W. Biederman { 3011bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 3012bc451f20SEric W. Biederman kfree(dir); 3013bc451f20SEric W. Biederman } 3014bc451f20SEric W. Biederman 3015bc451f20SEric W. Biederman static const 3016bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 3017bc451f20SEric W. Biederman { 3018bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 3019bc451f20SEric W. Biederman return dir->class->ns_type; 3020bc451f20SEric W. Biederman } 3021bc451f20SEric W. Biederman 3022bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 3023bc451f20SEric W. Biederman .release = class_dir_release, 3024bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 3025bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 3026bc451f20SEric W. Biederman }; 3027bc451f20SEric W. Biederman 3028bc451f20SEric W. Biederman static struct kobject * 3029bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 3030bc451f20SEric W. Biederman { 3031bc451f20SEric W. Biederman struct class_dir *dir; 3032bc451f20SEric W. Biederman int retval; 3033bc451f20SEric W. Biederman 3034bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 3035bc451f20SEric W. Biederman if (!dir) 303684d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 3037bc451f20SEric W. Biederman 3038bc451f20SEric W. Biederman dir->class = class; 3039bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 3040bc451f20SEric W. Biederman 30416b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 3042bc451f20SEric W. Biederman 3043bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 3044bc451f20SEric W. Biederman if (retval < 0) { 3045bc451f20SEric W. Biederman kobject_put(&dir->kobj); 304684d0c27dSTetsuo Handa return ERR_PTR(retval); 3047bc451f20SEric W. Biederman } 3048bc451f20SEric W. Biederman return &dir->kobj; 3049bc451f20SEric W. Biederman } 3050bc451f20SEric W. Biederman 3051e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 3052bc451f20SEric W. Biederman 3053c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 3054c744aeaeSCornelia Huck struct device *parent) 305540fa5422SGreg Kroah-Hartman { 305686406245SKay Sievers if (dev->class) { 305786406245SKay Sievers struct kobject *kobj = NULL; 305886406245SKay Sievers struct kobject *parent_kobj; 305986406245SKay Sievers struct kobject *k; 306086406245SKay Sievers 3061ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 306239aba963SKay Sievers /* block disks show up in /sys/block */ 3063e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 306439aba963SKay Sievers if (parent && parent->class == &block_class) 306539aba963SKay Sievers return &parent->kobj; 30666b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 306739aba963SKay Sievers } 3068ead454feSRandy Dunlap #endif 3069e52eec13SAndi Kleen 307086406245SKay Sievers /* 307186406245SKay Sievers * If we have no parent, we live in "virtual". 30720f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 30730f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 307486406245SKay Sievers */ 307586406245SKay Sievers if (parent == NULL) 307686406245SKay Sievers parent_kobj = virtual_device_parent(dev); 307724b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 307886406245SKay Sievers return &parent->kobj; 307986406245SKay Sievers else 308086406245SKay Sievers parent_kobj = &parent->kobj; 308186406245SKay Sievers 308277d3d7c1STejun Heo mutex_lock(&gdp_mutex); 308377d3d7c1STejun Heo 308486406245SKay Sievers /* find our class-directory at the parent and reference it */ 30856b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 30866b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 308786406245SKay Sievers if (k->parent == parent_kobj) { 308886406245SKay Sievers kobj = kobject_get(k); 308986406245SKay Sievers break; 309086406245SKay Sievers } 30916b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 309277d3d7c1STejun Heo if (kobj) { 309377d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 309486406245SKay Sievers return kobj; 309577d3d7c1STejun Heo } 309686406245SKay Sievers 309786406245SKay Sievers /* or create a new class-directory at the parent device */ 3098bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 30990f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 310077d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 310143968d2fSGreg Kroah-Hartman return k; 310286406245SKay Sievers } 310386406245SKay Sievers 3104ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 3105ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 3106ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 3107ca22e56dSKay Sievers 310886406245SKay Sievers if (parent) 3109c744aeaeSCornelia Huck return &parent->kobj; 3110c744aeaeSCornelia Huck return NULL; 3111c744aeaeSCornelia Huck } 3112da231fd5SKay Sievers 3113cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 3114cebf8fd1SMing Lei struct device *dev) 3115cebf8fd1SMing Lei { 3116cebf8fd1SMing Lei if (!kobj || !dev->class || 3117cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 3118cebf8fd1SMing Lei return false; 3119cebf8fd1SMing Lei return true; 3120cebf8fd1SMing Lei } 3121cebf8fd1SMing Lei 3122cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 3123cebf8fd1SMing Lei { 3124cebf8fd1SMing Lei return dev->kobj.parent; 3125cebf8fd1SMing Lei } 3126cebf8fd1SMing Lei 3127f0832664SIngo Molnar /** 3128f0832664SIngo Molnar * kobject_has_children - Returns whether a kobject has children. 3129f0832664SIngo Molnar * @kobj: the object to test 3130f0832664SIngo Molnar * 3131f0832664SIngo Molnar * This will return whether a kobject has other kobjects as children. 3132f0832664SIngo Molnar * 3133f0832664SIngo Molnar * It does NOT account for the presence of attribute files, only sub 3134f0832664SIngo Molnar * directories. It also assumes there is no concurrent addition or 3135f0832664SIngo Molnar * removal of such children, and thus relies on external locking. 3136f0832664SIngo Molnar */ 3137f0832664SIngo Molnar static inline bool kobject_has_children(struct kobject *kobj) 3138f0832664SIngo Molnar { 3139f0832664SIngo Molnar WARN_ON_ONCE(kref_read(&kobj->kref) == 0); 3140f0832664SIngo Molnar 3141f0832664SIngo Molnar return kobj->sd && kobj->sd->dir.subdirs; 3142f0832664SIngo Molnar } 3143f0832664SIngo Molnar 3144cebf8fd1SMing Lei /* 3145cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 3146cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 3147cebf8fd1SMing Lei * global lock 3148cebf8fd1SMing Lei */ 314963b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 3150da231fd5SKay Sievers { 3151ac43432cSMuchun Song unsigned int ref; 3152ac43432cSMuchun Song 31530f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 3154cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 3155da231fd5SKay Sievers return; 3156da231fd5SKay Sievers 3157e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 3158ac43432cSMuchun Song /** 3159ac43432cSMuchun Song * There is a race condition between removing glue directory 3160ac43432cSMuchun Song * and adding a new device under the glue directory. 3161ac43432cSMuchun Song * 3162ac43432cSMuchun Song * CPU1: CPU2: 3163ac43432cSMuchun Song * 3164ac43432cSMuchun Song * device_add() 3165ac43432cSMuchun Song * get_device_parent() 3166ac43432cSMuchun Song * class_dir_create_and_add() 3167ac43432cSMuchun Song * kobject_add_internal() 3168ac43432cSMuchun Song * create_dir() // create glue_dir 3169ac43432cSMuchun Song * 3170ac43432cSMuchun Song * device_add() 3171ac43432cSMuchun Song * get_device_parent() 3172ac43432cSMuchun Song * kobject_get() // get glue_dir 3173ac43432cSMuchun Song * 3174ac43432cSMuchun Song * device_del() 3175ac43432cSMuchun Song * cleanup_glue_dir() 3176ac43432cSMuchun Song * kobject_del(glue_dir) 3177ac43432cSMuchun Song * 3178ac43432cSMuchun Song * kobject_add() 3179ac43432cSMuchun Song * kobject_add_internal() 3180ac43432cSMuchun Song * create_dir() // in glue_dir 3181ac43432cSMuchun Song * sysfs_create_dir_ns() 3182ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 3183ac43432cSMuchun Song * 3184ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 3185ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 3186ac43432cSMuchun Song * 3187ac43432cSMuchun Song * // sd is freed 3188ac43432cSMuchun Song * kernfs_new_node(sd) 3189ac43432cSMuchun Song * kernfs_get(glue_dir) 3190ac43432cSMuchun Song * kernfs_add_one() 3191ac43432cSMuchun Song * kernfs_put() 3192ac43432cSMuchun Song * 3193ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 3194ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 3195ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 3196ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 3197ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 3198ac43432cSMuchun Song * 3199ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 3200ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 3201ac43432cSMuchun Song * 3202ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 3203ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 3204ac43432cSMuchun Song * for glue_dir kobj is 1. 3205ac43432cSMuchun Song */ 3206ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 3207ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 3208726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 32090f4dafc0SKay Sievers kobject_put(glue_dir); 3210e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 3211da231fd5SKay Sievers } 321263b6971aSCornelia Huck 32132ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 32142ee97cafSCornelia Huck { 32155590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 32162ee97cafSCornelia Huck int error; 32172ee97cafSCornelia Huck 32185590f319SBenjamin Herrenschmidt if (of_node) { 32190c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 32205590f319SBenjamin Herrenschmidt if (error) 32215590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 32225590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 32235590f319SBenjamin Herrenschmidt } 32245590f319SBenjamin Herrenschmidt 32252ee97cafSCornelia Huck if (!dev->class) 32262ee97cafSCornelia Huck return 0; 3227da231fd5SKay Sievers 32281fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 32296b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 32302ee97cafSCornelia Huck "subsystem"); 32312ee97cafSCornelia Huck if (error) 32325590f319SBenjamin Herrenschmidt goto out_devnode; 3233da231fd5SKay Sievers 32344e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 32354f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 32364f01a757SDmitry Torokhov "device"); 32374f01a757SDmitry Torokhov if (error) 323839aba963SKay Sievers goto out_subsys; 32392ee97cafSCornelia Huck } 324039aba963SKay Sievers 3241ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 324239aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 3243e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 324439aba963SKay Sievers return 0; 3245ead454feSRandy Dunlap #endif 324639aba963SKay Sievers 324739aba963SKay Sievers /* link in the class directory pointing to the device */ 32486b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 324939aba963SKay Sievers &dev->kobj, dev_name(dev)); 325039aba963SKay Sievers if (error) 325139aba963SKay Sievers goto out_device; 325239aba963SKay Sievers 32532ee97cafSCornelia Huck return 0; 32542ee97cafSCornelia Huck 325539aba963SKay Sievers out_device: 325639aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 3257da231fd5SKay Sievers 32582ee97cafSCornelia Huck out_subsys: 32592ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 32605590f319SBenjamin Herrenschmidt out_devnode: 32615590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 32622ee97cafSCornelia Huck return error; 32632ee97cafSCornelia Huck } 32642ee97cafSCornelia Huck 32652ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 32662ee97cafSCornelia Huck { 32675590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 32685590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 32695590f319SBenjamin Herrenschmidt 32702ee97cafSCornelia Huck if (!dev->class) 32712ee97cafSCornelia Huck return; 3272da231fd5SKay Sievers 32734e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 3274da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 32752ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 3276ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 3277e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 327839aba963SKay Sievers return; 3279ead454feSRandy Dunlap #endif 32806b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 32812ee97cafSCornelia Huck } 32822ee97cafSCornelia Huck 32831da177e4SLinus Torvalds /** 3284413c239fSStephen Rothwell * dev_set_name - set a device name 3285413c239fSStephen Rothwell * @dev: device 328646232366SRandy Dunlap * @fmt: format string for the device's name 3287413c239fSStephen Rothwell */ 3288413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 3289413c239fSStephen Rothwell { 3290413c239fSStephen Rothwell va_list vargs; 32911fa5ae85SKay Sievers int err; 3292413c239fSStephen Rothwell 3293413c239fSStephen Rothwell va_start(vargs, fmt); 32941fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 3295413c239fSStephen Rothwell va_end(vargs); 32961fa5ae85SKay Sievers return err; 3297413c239fSStephen Rothwell } 3298413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 3299413c239fSStephen Rothwell 3300413c239fSStephen Rothwell /** 3301e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 3302e105b8bfSDan Williams * @dev: device 3303e105b8bfSDan Williams * 3304e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 3305e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 3306e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 3307e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 33080d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 33090d4e293cSPeter Korsgaard * the link. 3310e105b8bfSDan Williams */ 3311e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 3312e105b8bfSDan Williams { 3313e105b8bfSDan Williams struct kobject *kobj; 3314e105b8bfSDan Williams 3315e105b8bfSDan Williams if (dev->class) 3316e105b8bfSDan Williams kobj = dev->class->dev_kobj; 3317e105b8bfSDan Williams else 3318e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 3319e105b8bfSDan Williams 3320e105b8bfSDan Williams return kobj; 3321e105b8bfSDan Williams } 3322e105b8bfSDan Williams 3323e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 3324e105b8bfSDan Williams { 3325e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3326e105b8bfSDan Williams int error = 0; 3327e105b8bfSDan Williams char devt_str[15]; 3328e105b8bfSDan Williams 3329e105b8bfSDan Williams if (kobj) { 3330e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3331e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 3332e105b8bfSDan Williams } 3333e105b8bfSDan Williams 3334e105b8bfSDan Williams return error; 3335e105b8bfSDan Williams } 3336e105b8bfSDan Williams 3337e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 3338e105b8bfSDan Williams { 3339e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3340e105b8bfSDan Williams char devt_str[15]; 3341e105b8bfSDan Williams 3342e105b8bfSDan Williams if (kobj) { 3343e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3344e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 3345e105b8bfSDan Williams } 3346e105b8bfSDan Williams } 3347e105b8bfSDan Williams 334846d3a037SShaokun Zhang static int device_private_init(struct device *dev) 3349b4028437SGreg Kroah-Hartman { 3350b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 3351b4028437SGreg Kroah-Hartman if (!dev->p) 3352b4028437SGreg Kroah-Hartman return -ENOMEM; 3353b4028437SGreg Kroah-Hartman dev->p->device = dev; 3354b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 3355b4028437SGreg Kroah-Hartman klist_children_put); 3356ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 3357b4028437SGreg Kroah-Hartman return 0; 3358b4028437SGreg Kroah-Hartman } 3359b4028437SGreg Kroah-Hartman 3360e105b8bfSDan Williams /** 33611da177e4SLinus Torvalds * device_add - add device to device hierarchy. 33621da177e4SLinus Torvalds * @dev: device. 33631da177e4SLinus Torvalds * 33641da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 33651da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 33661da177e4SLinus Torvalds * 33675739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 33681da177e4SLinus Torvalds * to the global and sibling lists for the device, then 33691da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 33705739411aSCornelia Huck * 3371b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 3372b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 3373b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 3374b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 3375b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 3376b10d5efdSAlan Stern * and register a fresh new struct device instead. 3377b10d5efdSAlan Stern * 33785739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 33795739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 33805739411aSCornelia Huck * reference instead. 3381affada72SBorislav Petkov * 3382affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 3383affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 3384affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 3385affada72SBorislav Petkov * count. 33861da177e4SLinus Torvalds */ 33871da177e4SLinus Torvalds int device_add(struct device *dev) 33881da177e4SLinus Torvalds { 338935dbf4efSViresh Kumar struct device *parent; 3390ca22e56dSKay Sievers struct kobject *kobj; 3391c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 33925f5377eaSSaravana Kannan int error = -EINVAL; 3393cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3394775b64d2SRafael J. Wysocki 33951da177e4SLinus Torvalds dev = get_device(dev); 3396c906a48aSGreg Kroah-Hartman if (!dev) 3397c906a48aSGreg Kroah-Hartman goto done; 3398c906a48aSGreg Kroah-Hartman 3399fb069a5dSGreg Kroah-Hartman if (!dev->p) { 3400b4028437SGreg Kroah-Hartman error = device_private_init(dev); 3401b4028437SGreg Kroah-Hartman if (error) 3402fb069a5dSGreg Kroah-Hartman goto done; 3403fb069a5dSGreg Kroah-Hartman } 3404fb069a5dSGreg Kroah-Hartman 34051fa5ae85SKay Sievers /* 34061fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 34071fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 34081fa5ae85SKay Sievers * the name, and force the use of dev_name() 34091fa5ae85SKay Sievers */ 34101fa5ae85SKay Sievers if (dev->init_name) { 3411acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 34121fa5ae85SKay Sievers dev->init_name = NULL; 34131fa5ae85SKay Sievers } 3414c906a48aSGreg Kroah-Hartman 3415ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 3416ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 3417ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 3418ca22e56dSKay Sievers 3419e6309e75SThomas Gleixner if (!dev_name(dev)) { 3420e6309e75SThomas Gleixner error = -EINVAL; 34215c8563d7SKay Sievers goto name_error; 3422e6309e75SThomas Gleixner } 34231da177e4SLinus Torvalds 34241e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 3425c205ef48SGreg Kroah-Hartman 34261da177e4SLinus Torvalds parent = get_device(dev->parent); 3427ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 342884d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 342984d0c27dSTetsuo Handa error = PTR_ERR(kobj); 343084d0c27dSTetsuo Handa goto parent_error; 343184d0c27dSTetsuo Handa } 3432ca22e56dSKay Sievers if (kobj) 3433ca22e56dSKay Sievers dev->kobj.parent = kobj; 34341da177e4SLinus Torvalds 34350d358f22SYinghai Lu /* use parent numa_node */ 343656f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 34370d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 34380d358f22SYinghai Lu 34391da177e4SLinus Torvalds /* first, register with generic layer. */ 34408a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 34418a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 3442cebf8fd1SMing Lei if (error) { 3443cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 34441da177e4SLinus Torvalds goto Error; 3445cebf8fd1SMing Lei } 3446a7fd6706SKay Sievers 344737022644SBrian Walsh /* notify platform of device entry */ 3448b2ebd9ddSRafael J. Wysocki device_platform_notify(dev); 344937022644SBrian Walsh 3450c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 3451a306eea4SCornelia Huck if (error) 3452a306eea4SCornelia Huck goto attrError; 3453a7fd6706SKay Sievers 34542ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 34552ee97cafSCornelia Huck if (error) 34562ee97cafSCornelia Huck goto SymlinkError; 3457dc0afa83SCornelia Huck error = device_add_attrs(dev); 3458dc0afa83SCornelia Huck if (error) 34592620efefSGreg Kroah-Hartman goto AttrsError; 3460dc0afa83SCornelia Huck error = bus_add_device(dev); 3461dc0afa83SCornelia Huck if (error) 34621da177e4SLinus Torvalds goto BusError; 34633b98aeafSAlan Stern error = dpm_sysfs_add(dev); 346457eee3d2SRafael J. Wysocki if (error) 34653b98aeafSAlan Stern goto DPMError; 34663b98aeafSAlan Stern device_pm_add(dev); 3467ec0676eeSAlan Stern 34680cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 34690cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 34700cd75047SSergey Klyaus if (error) 34710cd75047SSergey Klyaus goto DevAttrError; 34720cd75047SSergey Klyaus 34730cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 34740cd75047SSergey Klyaus if (error) 34750cd75047SSergey Klyaus goto SysEntryError; 34760cd75047SSergey Klyaus 34770cd75047SSergey Klyaus devtmpfs_create_node(dev); 34780cd75047SSergey Klyaus } 34790cd75047SSergey Klyaus 3480ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 3481268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 3482ec0676eeSAlan Stern */ 3483ec0676eeSAlan Stern if (dev->bus) 3484ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3485ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 3486ec0676eeSAlan Stern 348753877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 3488372a67c0SSaravana Kannan 3489e2ae9bccSSaravana Kannan /* 3490e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 3491e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 3492e2ae9bccSSaravana Kannan * link to it. 3493e2ae9bccSSaravana Kannan * 3494e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 3495e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 3496e2ae9bccSSaravana Kannan * 34972cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure 3498e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 3499e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 3500e2ae9bccSSaravana Kannan */ 35012cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 35022cd38fd1SSaravana Kannan dev->fwnode->dev = dev; 35035f5377eaSSaravana Kannan fw_devlink_link_device(dev); 350403324507SSaravana Kannan } 3505e2ae9bccSSaravana Kannan 35062023c610SAlan Stern bus_probe_device(dev); 3507d46f3e3eSSaravana Kannan 3508d46f3e3eSSaravana Kannan /* 3509d46f3e3eSSaravana Kannan * If all driver registration is done and a newly added device doesn't 3510d46f3e3eSSaravana Kannan * match with any driver, don't block its consumers from probing in 3511d46f3e3eSSaravana Kannan * case the consumer device is able to operate without this supplier. 3512d46f3e3eSSaravana Kannan */ 3513d46f3e3eSSaravana Kannan if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) 3514d46f3e3eSSaravana Kannan fw_devlink_unblock_consumers(dev); 3515d46f3e3eSSaravana Kannan 35161da177e4SLinus Torvalds if (parent) 3517f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3518f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 35191da177e4SLinus Torvalds 35205d9fd169SGreg Kroah-Hartman if (dev->class) { 3521ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3522c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 3523570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 35246b6e39a6SKay Sievers &dev->class->p->klist_devices); 3525c47ed219SGreg Kroah-Hartman 3526c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 3527184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3528ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3529c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 3530c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 3531ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 35325d9fd169SGreg Kroah-Hartman } 3533c906a48aSGreg Kroah-Hartman done: 35341da177e4SLinus Torvalds put_device(dev); 35351da177e4SLinus Torvalds return error; 35360cd75047SSergey Klyaus SysEntryError: 35370cd75047SSergey Klyaus if (MAJOR(dev->devt)) 35380cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 35390cd75047SSergey Klyaus DevAttrError: 35400cd75047SSergey Klyaus device_pm_remove(dev); 35410cd75047SSergey Klyaus dpm_sysfs_remove(dev); 35423b98aeafSAlan Stern DPMError: 354357eee3d2SRafael J. Wysocki bus_remove_device(dev); 354457eee3d2SRafael J. Wysocki BusError: 35452620efefSGreg Kroah-Hartman device_remove_attrs(dev); 35462620efefSGreg Kroah-Hartman AttrsError: 35472ee97cafSCornelia Huck device_remove_class_symlinks(dev); 35482ee97cafSCornelia Huck SymlinkError: 3549c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 355023681e47SGreg Kroah-Hartman attrError: 3551b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev); 3552312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3553cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 35541da177e4SLinus Torvalds kobject_del(&dev->kobj); 35551da177e4SLinus Torvalds Error: 3556cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 355784d0c27dSTetsuo Handa parent_error: 35581da177e4SLinus Torvalds put_device(parent); 35595c8563d7SKay Sievers name_error: 35605c8563d7SKay Sievers kfree(dev->p); 35615c8563d7SKay Sievers dev->p = NULL; 3562c906a48aSGreg Kroah-Hartman goto done; 35631da177e4SLinus Torvalds } 356486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 35651da177e4SLinus Torvalds 35661da177e4SLinus Torvalds /** 35671da177e4SLinus Torvalds * device_register - register a device with the system. 35681da177e4SLinus Torvalds * @dev: pointer to the device structure 35691da177e4SLinus Torvalds * 35701da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 35711da177e4SLinus Torvalds * and add it to the system. The two steps can be called 35721da177e4SLinus Torvalds * separately, but this is the easiest and most common. 35731da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 35741da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 35751da177e4SLinus Torvalds * before it is added to the hierarchy. 35765739411aSCornelia Huck * 3577b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 3578b10d5efdSAlan Stern * and device_add(). 3579b10d5efdSAlan Stern * 35805739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 35815739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 35825739411aSCornelia Huck * reference initialized in this function instead. 35831da177e4SLinus Torvalds */ 35841da177e4SLinus Torvalds int device_register(struct device *dev) 35851da177e4SLinus Torvalds { 35861da177e4SLinus Torvalds device_initialize(dev); 35871da177e4SLinus Torvalds return device_add(dev); 35881da177e4SLinus Torvalds } 358986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 35901da177e4SLinus Torvalds 35911da177e4SLinus Torvalds /** 35921da177e4SLinus Torvalds * get_device - increment reference count for device. 35931da177e4SLinus Torvalds * @dev: device. 35941da177e4SLinus Torvalds * 35951da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 35961da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 35971da177e4SLinus Torvalds * pointer passed in. 35981da177e4SLinus Torvalds */ 35991da177e4SLinus Torvalds struct device *get_device(struct device *dev) 36001da177e4SLinus Torvalds { 3601b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 36021da177e4SLinus Torvalds } 360386df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 36041da177e4SLinus Torvalds 36051da177e4SLinus Torvalds /** 36061da177e4SLinus Torvalds * put_device - decrement reference count. 36071da177e4SLinus Torvalds * @dev: device in question. 36081da177e4SLinus Torvalds */ 36091da177e4SLinus Torvalds void put_device(struct device *dev) 36101da177e4SLinus Torvalds { 3611edfaa7c3SKay Sievers /* might_sleep(); */ 36121da177e4SLinus Torvalds if (dev) 36131da177e4SLinus Torvalds kobject_put(&dev->kobj); 36141da177e4SLinus Torvalds } 361586df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 36161da177e4SLinus Torvalds 361700289cd8SDan Williams bool kill_device(struct device *dev) 361800289cd8SDan Williams { 361900289cd8SDan Williams /* 362000289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 362100289cd8SDan Williams * the update behavior is consistent with the other bitfields near 362200289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 362300289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 362400289cd8SDan Williams * underneath the device. 362500289cd8SDan Williams */ 36268c60a141SJulian Wiedmann device_lock_assert(dev); 362700289cd8SDan Williams 362800289cd8SDan Williams if (dev->p->dead) 362900289cd8SDan Williams return false; 363000289cd8SDan Williams dev->p->dead = true; 363100289cd8SDan Williams return true; 363200289cd8SDan Williams } 363300289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 363400289cd8SDan Williams 36351da177e4SLinus Torvalds /** 36361da177e4SLinus Torvalds * device_del - delete device from system. 36371da177e4SLinus Torvalds * @dev: device. 36381da177e4SLinus Torvalds * 36391da177e4SLinus Torvalds * This is the first part of the device unregistration 36401da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 36411da177e4SLinus Torvalds * from here, has it removed from the other driver model 36421da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 36431da177e4SLinus Torvalds * from the kobject hierarchy. 36441da177e4SLinus Torvalds * 36451da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 36461da177e4SLinus Torvalds * also called manually. 36471da177e4SLinus Torvalds */ 36481da177e4SLinus Torvalds void device_del(struct device *dev) 36491da177e4SLinus Torvalds { 36501da177e4SLinus Torvalds struct device *parent = dev->parent; 3651cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3652c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 3653b8530017SOliver Neukum unsigned int noio_flag; 36541da177e4SLinus Torvalds 36553451a495SAlexander Duyck device_lock(dev); 365600289cd8SDan Williams kill_device(dev); 36573451a495SAlexander Duyck device_unlock(dev); 36583451a495SAlexander Duyck 3659372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 3660372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 3661372a67c0SSaravana Kannan 3662ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 3663ec0676eeSAlan Stern * before dpm_sysfs_remove(). 3664ec0676eeSAlan Stern */ 3665b8530017SOliver Neukum noio_flag = memalloc_noio_save(); 3666ec0676eeSAlan Stern if (dev->bus) 3667ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3668ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 36699ed98953SRafael J. Wysocki 36703b98aeafSAlan Stern dpm_sysfs_remove(dev); 36711da177e4SLinus Torvalds if (parent) 3672f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 3673e105b8bfSDan Williams if (MAJOR(dev->devt)) { 36742b2af54aSKay Sievers devtmpfs_delete_node(dev); 3675e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 3676c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 3677e105b8bfSDan Williams } 3678b9d9c82bSKay Sievers if (dev->class) { 3679da231fd5SKay Sievers device_remove_class_symlinks(dev); 368099ef3ef8SKay Sievers 3681ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3682c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 3683184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3684ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3685c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 3686c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 3687c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 3688570d0200SWei Yang klist_del(&dev->p->knode_class); 3689ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 3690b9d9c82bSKay Sievers } 3691c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 36922620efefSGreg Kroah-Hartman device_remove_attrs(dev); 369328953533SBenjamin Herrenschmidt bus_remove_device(dev); 36944b6d1f12SLongX Zhang device_pm_remove(dev); 3695d1c3414cSGrant Likely driver_deferred_probe_del(dev); 3696b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev); 36972ec16150SJeffy Chen device_links_purge(dev); 36981da177e4SLinus Torvalds 3699599bad38SJoerg Roedel if (dev->bus) 3700599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3701599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 3702312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3703cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 37041da177e4SLinus Torvalds kobject_del(&dev->kobj); 3705cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 3706b8530017SOliver Neukum memalloc_noio_restore(noio_flag); 37071da177e4SLinus Torvalds put_device(parent); 37081da177e4SLinus Torvalds } 370986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 37101da177e4SLinus Torvalds 37111da177e4SLinus Torvalds /** 37121da177e4SLinus Torvalds * device_unregister - unregister device from system. 37131da177e4SLinus Torvalds * @dev: device going away. 37141da177e4SLinus Torvalds * 37151da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 37161da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 37171da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 37181da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 37191da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 37201da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 37211da177e4SLinus Torvalds */ 37221da177e4SLinus Torvalds void device_unregister(struct device *dev) 37231da177e4SLinus Torvalds { 37241e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 37251da177e4SLinus Torvalds device_del(dev); 37261da177e4SLinus Torvalds put_device(dev); 37271da177e4SLinus Torvalds } 372886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 37291da177e4SLinus Torvalds 37303d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 37313d060aebSAndy Shevchenko { 37323d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 37333d060aebSAndy Shevchenko struct device *dev = NULL; 37343d060aebSAndy Shevchenko struct device_private *p; 37353d060aebSAndy Shevchenko 37363d060aebSAndy Shevchenko if (n) { 37373d060aebSAndy Shevchenko p = to_device_private_parent(n); 37383d060aebSAndy Shevchenko dev = p->device; 37393d060aebSAndy Shevchenko } 37403d060aebSAndy Shevchenko return dev; 37413d060aebSAndy Shevchenko } 37423d060aebSAndy Shevchenko 374336239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 374436239577Smochel@digitalimplant.org { 374536239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 3746f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 3747f791b8c8SGreg Kroah-Hartman struct device_private *p; 3748f791b8c8SGreg Kroah-Hartman 3749f791b8c8SGreg Kroah-Hartman if (n) { 3750f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 3751f791b8c8SGreg Kroah-Hartman dev = p->device; 3752f791b8c8SGreg Kroah-Hartman } 3753f791b8c8SGreg Kroah-Hartman return dev; 375436239577Smochel@digitalimplant.org } 375536239577Smochel@digitalimplant.org 37561da177e4SLinus Torvalds /** 3757e454cea2SKay Sievers * device_get_devnode - path of device node file 37586fcf53acSKay Sievers * @dev: device 3759e454cea2SKay Sievers * @mode: returned file access mode 37603c2670e6SKay Sievers * @uid: returned file owner 37613c2670e6SKay Sievers * @gid: returned file group 37626fcf53acSKay Sievers * @tmp: possibly allocated string 37636fcf53acSKay Sievers * 37646fcf53acSKay Sievers * Return the relative path of a possible device node. 37656fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 37666fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 37676fcf53acSKay Sievers * freed by the caller. 37686fcf53acSKay Sievers */ 3769e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 37704e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 37713c2670e6SKay Sievers const char **tmp) 37726fcf53acSKay Sievers { 37736fcf53acSKay Sievers char *s; 37746fcf53acSKay Sievers 37756fcf53acSKay Sievers *tmp = NULL; 37766fcf53acSKay Sievers 37776fcf53acSKay Sievers /* the device type may provide a specific name */ 3778e454cea2SKay Sievers if (dev->type && dev->type->devnode) 37793c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 37806fcf53acSKay Sievers if (*tmp) 37816fcf53acSKay Sievers return *tmp; 37826fcf53acSKay Sievers 37836fcf53acSKay Sievers /* the class may provide a specific name */ 3784e454cea2SKay Sievers if (dev->class && dev->class->devnode) 3785e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 37866fcf53acSKay Sievers if (*tmp) 37876fcf53acSKay Sievers return *tmp; 37886fcf53acSKay Sievers 37896fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 37906fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 37916fcf53acSKay Sievers return dev_name(dev); 37926fcf53acSKay Sievers 37936fcf53acSKay Sievers /* replace '!' in the name with '/' */ 3794a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 3795a29fd614SRasmus Villemoes if (!s) 37966fcf53acSKay Sievers return NULL; 3797a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 3798a29fd614SRasmus Villemoes return *tmp = s; 37996fcf53acSKay Sievers } 38006fcf53acSKay Sievers 38016fcf53acSKay Sievers /** 38021da177e4SLinus Torvalds * device_for_each_child - device child iterator. 3803c41455fbSRandy Dunlap * @parent: parent struct device. 38041da177e4SLinus Torvalds * @fn: function to be called for each device. 3805f8878dcbSRobert P. J. Day * @data: data for the callback. 38061da177e4SLinus Torvalds * 3807c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 38081da177e4SLinus Torvalds * passing it @data. 38091da177e4SLinus Torvalds * 38101da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 38111da177e4SLinus Torvalds * other than 0, we break out and return that value. 38121da177e4SLinus Torvalds */ 381336239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 38144a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 38151da177e4SLinus Torvalds { 381636239577Smochel@digitalimplant.org struct klist_iter i; 38171da177e4SLinus Torvalds struct device *child; 38181da177e4SLinus Torvalds int error = 0; 38191da177e4SLinus Torvalds 3820014c90dbSGreg Kroah-Hartman if (!parent->p) 3821014c90dbSGreg Kroah-Hartman return 0; 3822014c90dbSGreg Kroah-Hartman 3823f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 382493ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 382536239577Smochel@digitalimplant.org error = fn(child, data); 382636239577Smochel@digitalimplant.org klist_iter_exit(&i); 38271da177e4SLinus Torvalds return error; 38281da177e4SLinus Torvalds } 382986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 38301da177e4SLinus Torvalds 38315ab69981SCornelia Huck /** 38323d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 38333d060aebSAndy Shevchenko * @parent: parent struct device. 38343d060aebSAndy Shevchenko * @fn: function to be called for each device. 38353d060aebSAndy Shevchenko * @data: data for the callback. 38363d060aebSAndy Shevchenko * 38373d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 38383d060aebSAndy Shevchenko * passing it @data. 38393d060aebSAndy Shevchenko * 38403d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 38413d060aebSAndy Shevchenko * other than 0, we break out and return that value. 38423d060aebSAndy Shevchenko */ 38433d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 38443d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 38453d060aebSAndy Shevchenko { 38463d060aebSAndy Shevchenko struct klist_iter i; 38473d060aebSAndy Shevchenko struct device *child; 38483d060aebSAndy Shevchenko int error = 0; 38493d060aebSAndy Shevchenko 38503d060aebSAndy Shevchenko if (!parent->p) 38513d060aebSAndy Shevchenko return 0; 38523d060aebSAndy Shevchenko 38533d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 38543d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 38553d060aebSAndy Shevchenko error = fn(child, data); 38563d060aebSAndy Shevchenko klist_iter_exit(&i); 38573d060aebSAndy Shevchenko return error; 38583d060aebSAndy Shevchenko } 38593d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 38603d060aebSAndy Shevchenko 38613d060aebSAndy Shevchenko /** 38625ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 38635ab69981SCornelia Huck * @parent: parent struct device 38645ab69981SCornelia Huck * @match: Callback function to check device 3865f8878dcbSRobert P. J. Day * @data: Data to pass to match function 38665ab69981SCornelia Huck * 38675ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 38685ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 38695ab69981SCornelia Huck * determined by the @match callback. 38705ab69981SCornelia Huck * 38715ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 38725ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 38735ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 38745ab69981SCornelia Huck * and not iterate over any more devices. 3875a4e2400aSFederico Vaga * 3876a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 38775ab69981SCornelia Huck */ 38785ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 38794a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 38805ab69981SCornelia Huck { 38815ab69981SCornelia Huck struct klist_iter i; 38825ab69981SCornelia Huck struct device *child; 38835ab69981SCornelia Huck 38845ab69981SCornelia Huck if (!parent) 38855ab69981SCornelia Huck return NULL; 38865ab69981SCornelia Huck 3887f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 38885ab69981SCornelia Huck while ((child = next_device(&i))) 38895ab69981SCornelia Huck if (match(child, data) && get_device(child)) 38905ab69981SCornelia Huck break; 38915ab69981SCornelia Huck klist_iter_exit(&i); 38925ab69981SCornelia Huck return child; 38935ab69981SCornelia Huck } 389486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 38955ab69981SCornelia Huck 3896dad9bb01SHeikki Krogerus /** 3897dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 3898dad9bb01SHeikki Krogerus * @parent: parent struct device 3899dad9bb01SHeikki Krogerus * @name: name of the child device 3900dad9bb01SHeikki Krogerus * 3901dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 3902dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 3903dad9bb01SHeikki Krogerus * 3904dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 3905dad9bb01SHeikki Krogerus */ 3906dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 3907dad9bb01SHeikki Krogerus const char *name) 3908dad9bb01SHeikki Krogerus { 3909dad9bb01SHeikki Krogerus struct klist_iter i; 3910dad9bb01SHeikki Krogerus struct device *child; 3911dad9bb01SHeikki Krogerus 3912dad9bb01SHeikki Krogerus if (!parent) 3913dad9bb01SHeikki Krogerus return NULL; 3914dad9bb01SHeikki Krogerus 3915dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 3916dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 3917c77f520dSDan Williams if (sysfs_streq(dev_name(child), name) && get_device(child)) 3918dad9bb01SHeikki Krogerus break; 3919dad9bb01SHeikki Krogerus klist_iter_exit(&i); 3920dad9bb01SHeikki Krogerus return child; 3921dad9bb01SHeikki Krogerus } 3922dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 3923dad9bb01SHeikki Krogerus 392482b070beSAndy Shevchenko static int match_any(struct device *dev, void *unused) 392582b070beSAndy Shevchenko { 392682b070beSAndy Shevchenko return 1; 392782b070beSAndy Shevchenko } 392882b070beSAndy Shevchenko 392982b070beSAndy Shevchenko /** 393082b070beSAndy Shevchenko * device_find_any_child - device iterator for locating a child device, if any. 393182b070beSAndy Shevchenko * @parent: parent struct device 393282b070beSAndy Shevchenko * 393382b070beSAndy Shevchenko * This is similar to the device_find_child() function above, but it 393482b070beSAndy Shevchenko * returns a reference to a child device, if any. 393582b070beSAndy Shevchenko * 393682b070beSAndy Shevchenko * NOTE: you will need to drop the reference with put_device() after use. 393782b070beSAndy Shevchenko */ 393882b070beSAndy Shevchenko struct device *device_find_any_child(struct device *parent) 393982b070beSAndy Shevchenko { 394082b070beSAndy Shevchenko return device_find_child(parent, NULL, match_any); 394182b070beSAndy Shevchenko } 394282b070beSAndy Shevchenko EXPORT_SYMBOL_GPL(device_find_any_child); 394382b070beSAndy Shevchenko 39441da177e4SLinus Torvalds int __init devices_init(void) 39451da177e4SLinus Torvalds { 3946881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 3947881c6cfdSGreg Kroah-Hartman if (!devices_kset) 3948881c6cfdSGreg Kroah-Hartman return -ENOMEM; 3949e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 3950e105b8bfSDan Williams if (!dev_kobj) 3951e105b8bfSDan Williams goto dev_kobj_err; 3952e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 3953e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 3954e105b8bfSDan Williams goto block_kobj_err; 3955e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 3956e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 3957e105b8bfSDan Williams goto char_kobj_err; 3958e105b8bfSDan Williams 3959881c6cfdSGreg Kroah-Hartman return 0; 3960e105b8bfSDan Williams 3961e105b8bfSDan Williams char_kobj_err: 3962e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 3963e105b8bfSDan Williams block_kobj_err: 3964e105b8bfSDan Williams kobject_put(dev_kobj); 3965e105b8bfSDan Williams dev_kobj_err: 3966e105b8bfSDan Williams kset_unregister(devices_kset); 3967e105b8bfSDan Williams return -ENOMEM; 39681da177e4SLinus Torvalds } 39691da177e4SLinus Torvalds 39704f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 39714f3549d7SRafael J. Wysocki { 39724f3549d7SRafael J. Wysocki int ret; 39734f3549d7SRafael J. Wysocki 39744f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 39754f3549d7SRafael J. Wysocki if (ret) 39764f3549d7SRafael J. Wysocki return ret; 39774f3549d7SRafael J. Wysocki 39784f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 39794f3549d7SRafael J. Wysocki } 39804f3549d7SRafael J. Wysocki 39814f3549d7SRafael J. Wysocki /** 39824f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 39834f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 39844f3549d7SRafael J. Wysocki * 39854f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 39864f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 39874f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 39884f3549d7SRafael J. Wysocki * is executed. 39894f3549d7SRafael J. Wysocki * 39904f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 39914f3549d7SRafael J. Wysocki */ 39924f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 39934f3549d7SRafael J. Wysocki { 39944f3549d7SRafael J. Wysocki int ret; 39954f3549d7SRafael J. Wysocki 39964f3549d7SRafael J. Wysocki if (dev->offline_disabled) 39974f3549d7SRafael J. Wysocki return -EPERM; 39984f3549d7SRafael J. Wysocki 39994f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 40004f3549d7SRafael J. Wysocki if (ret) 40014f3549d7SRafael J. Wysocki return ret; 40024f3549d7SRafael J. Wysocki 40034f3549d7SRafael J. Wysocki device_lock(dev); 40044f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 40054f3549d7SRafael J. Wysocki if (dev->offline) { 40064f3549d7SRafael J. Wysocki ret = 1; 40074f3549d7SRafael J. Wysocki } else { 40084f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 40094f3549d7SRafael J. Wysocki if (!ret) { 40104f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 40114f3549d7SRafael J. Wysocki dev->offline = true; 40124f3549d7SRafael J. Wysocki } 40134f3549d7SRafael J. Wysocki } 40144f3549d7SRafael J. Wysocki } 40154f3549d7SRafael J. Wysocki device_unlock(dev); 40164f3549d7SRafael J. Wysocki 40174f3549d7SRafael J. Wysocki return ret; 40184f3549d7SRafael J. Wysocki } 40194f3549d7SRafael J. Wysocki 40204f3549d7SRafael J. Wysocki /** 40214f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 40224f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 40234f3549d7SRafael J. Wysocki * 40244f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 40254f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 40264f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 40274f3549d7SRafael J. Wysocki * 40284f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 40294f3549d7SRafael J. Wysocki */ 40304f3549d7SRafael J. Wysocki int device_online(struct device *dev) 40314f3549d7SRafael J. Wysocki { 40324f3549d7SRafael J. Wysocki int ret = 0; 40334f3549d7SRafael J. Wysocki 40344f3549d7SRafael J. Wysocki device_lock(dev); 40354f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 40364f3549d7SRafael J. Wysocki if (dev->offline) { 40374f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 40384f3549d7SRafael J. Wysocki if (!ret) { 40394f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 40404f3549d7SRafael J. Wysocki dev->offline = false; 40414f3549d7SRafael J. Wysocki } 40424f3549d7SRafael J. Wysocki } else { 40434f3549d7SRafael J. Wysocki ret = 1; 40444f3549d7SRafael J. Wysocki } 40454f3549d7SRafael J. Wysocki } 40464f3549d7SRafael J. Wysocki device_unlock(dev); 40474f3549d7SRafael J. Wysocki 40484f3549d7SRafael J. Wysocki return ret; 40494f3549d7SRafael J. Wysocki } 40504f3549d7SRafael J. Wysocki 40517f100d15SKarthigan Srinivasan struct root_device { 40520aa0dc41SMark McLoughlin struct device dev; 40530aa0dc41SMark McLoughlin struct module *owner; 40540aa0dc41SMark McLoughlin }; 40550aa0dc41SMark McLoughlin 405693058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 4057481e2079SFerenc Wagner { 4058481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 4059481e2079SFerenc Wagner } 40600aa0dc41SMark McLoughlin 40610aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 40620aa0dc41SMark McLoughlin { 40630aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 40640aa0dc41SMark McLoughlin } 40650aa0dc41SMark McLoughlin 40660aa0dc41SMark McLoughlin /** 40670aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 40680aa0dc41SMark McLoughlin * @name: root device name 40690aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 40700aa0dc41SMark McLoughlin * 40710aa0dc41SMark McLoughlin * This function allocates a root device and registers it 40720aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 40730aa0dc41SMark McLoughlin * device, use root_device_unregister(). 40740aa0dc41SMark McLoughlin * 40750aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 40760aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 40770aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 40780aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 40790aa0dc41SMark McLoughlin * 40800aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 40810aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 40820aa0dc41SMark McLoughlin * in sysfs. 40830aa0dc41SMark McLoughlin * 4084f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 4085f0eae0edSJani Nikula * 40860aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 40870aa0dc41SMark McLoughlin */ 40880aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 40890aa0dc41SMark McLoughlin { 40900aa0dc41SMark McLoughlin struct root_device *root; 40910aa0dc41SMark McLoughlin int err = -ENOMEM; 40920aa0dc41SMark McLoughlin 40930aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 40940aa0dc41SMark McLoughlin if (!root) 40950aa0dc41SMark McLoughlin return ERR_PTR(err); 40960aa0dc41SMark McLoughlin 4097acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 40980aa0dc41SMark McLoughlin if (err) { 40990aa0dc41SMark McLoughlin kfree(root); 41000aa0dc41SMark McLoughlin return ERR_PTR(err); 41010aa0dc41SMark McLoughlin } 41020aa0dc41SMark McLoughlin 41030aa0dc41SMark McLoughlin root->dev.release = root_device_release; 41040aa0dc41SMark McLoughlin 41050aa0dc41SMark McLoughlin err = device_register(&root->dev); 41060aa0dc41SMark McLoughlin if (err) { 41070aa0dc41SMark McLoughlin put_device(&root->dev); 41080aa0dc41SMark McLoughlin return ERR_PTR(err); 41090aa0dc41SMark McLoughlin } 41100aa0dc41SMark McLoughlin 41111d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 41120aa0dc41SMark McLoughlin if (owner) { 41130aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 41140aa0dc41SMark McLoughlin 41150aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 41160aa0dc41SMark McLoughlin if (err) { 41170aa0dc41SMark McLoughlin device_unregister(&root->dev); 41180aa0dc41SMark McLoughlin return ERR_PTR(err); 41190aa0dc41SMark McLoughlin } 41200aa0dc41SMark McLoughlin root->owner = owner; 41210aa0dc41SMark McLoughlin } 41220aa0dc41SMark McLoughlin #endif 41230aa0dc41SMark McLoughlin 41240aa0dc41SMark McLoughlin return &root->dev; 41250aa0dc41SMark McLoughlin } 41260aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 41270aa0dc41SMark McLoughlin 41280aa0dc41SMark McLoughlin /** 41290aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 41307cbcf225SRandy Dunlap * @dev: device going away 41310aa0dc41SMark McLoughlin * 41320aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 41330aa0dc41SMark McLoughlin * root_device_register(). 41340aa0dc41SMark McLoughlin */ 41350aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 41360aa0dc41SMark McLoughlin { 41370aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 41380aa0dc41SMark McLoughlin 41390aa0dc41SMark McLoughlin if (root->owner) 41400aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 41410aa0dc41SMark McLoughlin 41420aa0dc41SMark McLoughlin device_unregister(dev); 41430aa0dc41SMark McLoughlin } 41440aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 41450aa0dc41SMark McLoughlin 414623681e47SGreg Kroah-Hartman 414723681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 414823681e47SGreg Kroah-Hartman { 41491e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 415023681e47SGreg Kroah-Hartman kfree(dev); 415123681e47SGreg Kroah-Hartman } 415223681e47SGreg Kroah-Hartman 41536a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 415439ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 415539ef3112SGuenter Roeck dev_t devt, void *drvdata, 415639ef3112SGuenter Roeck const struct attribute_group **groups, 415739ef3112SGuenter Roeck const char *fmt, va_list args) 415839ef3112SGuenter Roeck { 415939ef3112SGuenter Roeck struct device *dev = NULL; 416039ef3112SGuenter Roeck int retval = -ENODEV; 416139ef3112SGuenter Roeck 416239ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 416339ef3112SGuenter Roeck goto error; 416439ef3112SGuenter Roeck 416539ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 416639ef3112SGuenter Roeck if (!dev) { 416739ef3112SGuenter Roeck retval = -ENOMEM; 416839ef3112SGuenter Roeck goto error; 416939ef3112SGuenter Roeck } 417039ef3112SGuenter Roeck 4171bbc780f8SDavid Herrmann device_initialize(dev); 417239ef3112SGuenter Roeck dev->devt = devt; 417339ef3112SGuenter Roeck dev->class = class; 417439ef3112SGuenter Roeck dev->parent = parent; 417539ef3112SGuenter Roeck dev->groups = groups; 417639ef3112SGuenter Roeck dev->release = device_create_release; 417739ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 417839ef3112SGuenter Roeck 417939ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 418039ef3112SGuenter Roeck if (retval) 418139ef3112SGuenter Roeck goto error; 418239ef3112SGuenter Roeck 4183bbc780f8SDavid Herrmann retval = device_add(dev); 418439ef3112SGuenter Roeck if (retval) 418539ef3112SGuenter Roeck goto error; 418639ef3112SGuenter Roeck 418739ef3112SGuenter Roeck return dev; 418839ef3112SGuenter Roeck 418939ef3112SGuenter Roeck error: 419039ef3112SGuenter Roeck put_device(dev); 419139ef3112SGuenter Roeck return ERR_PTR(retval); 419239ef3112SGuenter Roeck } 419339ef3112SGuenter Roeck 419423681e47SGreg Kroah-Hartman /** 41954e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 41968882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 41978882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 41988882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 41998882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 42008882b394SGreg Kroah-Hartman * @fmt: string for the device's name 42018882b394SGreg Kroah-Hartman * 42028882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 42038882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 42048882b394SGreg Kroah-Hartman * 42058882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 42068882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 42078882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 42088882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 42098882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 42108882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 42118882b394SGreg Kroah-Hartman * pointer. 42128882b394SGreg Kroah-Hartman * 4213f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 4214f0eae0edSJani Nikula * 42158882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 42168882b394SGreg Kroah-Hartman * been created with a call to class_create(). 42178882b394SGreg Kroah-Hartman */ 42184e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 42194e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 42208882b394SGreg Kroah-Hartman { 42218882b394SGreg Kroah-Hartman va_list vargs; 42228882b394SGreg Kroah-Hartman struct device *dev; 42238882b394SGreg Kroah-Hartman 42248882b394SGreg Kroah-Hartman va_start(vargs, fmt); 42254c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL, 42264c747466SChristoph Hellwig fmt, vargs); 42278882b394SGreg Kroah-Hartman va_end(vargs); 42288882b394SGreg Kroah-Hartman return dev; 42298882b394SGreg Kroah-Hartman } 42304e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 42318882b394SGreg Kroah-Hartman 423239ef3112SGuenter Roeck /** 423339ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 423439ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 423539ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 423639ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 423739ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 423839ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 423939ef3112SGuenter Roeck * @fmt: string for the device's name 424039ef3112SGuenter Roeck * 424139ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 424239ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 424339ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 424439ef3112SGuenter Roeck * be created automatically. 424539ef3112SGuenter Roeck * 424639ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 424739ef3112SGuenter Roeck * the dev_t is not 0,0. 424839ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 424939ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 425039ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 425139ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 425239ef3112SGuenter Roeck * pointer. 425339ef3112SGuenter Roeck * 425439ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 425539ef3112SGuenter Roeck * 425639ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 425739ef3112SGuenter Roeck * been created with a call to class_create(). 425839ef3112SGuenter Roeck */ 425939ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 426039ef3112SGuenter Roeck struct device *parent, dev_t devt, 426139ef3112SGuenter Roeck void *drvdata, 426239ef3112SGuenter Roeck const struct attribute_group **groups, 426339ef3112SGuenter Roeck const char *fmt, ...) 426439ef3112SGuenter Roeck { 426539ef3112SGuenter Roeck va_list vargs; 426639ef3112SGuenter Roeck struct device *dev; 426739ef3112SGuenter Roeck 426839ef3112SGuenter Roeck va_start(vargs, fmt); 426939ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 427039ef3112SGuenter Roeck fmt, vargs); 427139ef3112SGuenter Roeck va_end(vargs); 427239ef3112SGuenter Roeck return dev; 427339ef3112SGuenter Roeck } 427439ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 427539ef3112SGuenter Roeck 4276775b64d2SRafael J. Wysocki /** 4277775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 4278775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 4279775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 4280775b64d2SRafael J. Wysocki * 4281775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 4282775b64d2SRafael J. Wysocki * call to device_create(). 4283775b64d2SRafael J. Wysocki */ 4284775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 4285775b64d2SRafael J. Wysocki { 4286775b64d2SRafael J. Wysocki struct device *dev; 4287775b64d2SRafael J. Wysocki 42884495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 4289cd35449bSDave Young if (dev) { 4290cd35449bSDave Young put_device(dev); 429123681e47SGreg Kroah-Hartman device_unregister(dev); 429223681e47SGreg Kroah-Hartman } 4293cd35449bSDave Young } 429423681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 4295a2de48caSGreg Kroah-Hartman 4296a2de48caSGreg Kroah-Hartman /** 4297a2de48caSGreg Kroah-Hartman * device_rename - renames a device 4298a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 4299a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 4300030c1d2bSEric W. Biederman * 4301030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 4302030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 4303030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 4304030c1d2bSEric W. Biederman * won't conflict with other devices. 4305c6c0ac66SMichael Ellerman * 4306a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 4307a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 4308a5462516STimur Tabi * some insight: 4309a5462516STimur Tabi * 4310a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 4311a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 4312a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 4313a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 4314a5462516STimur Tabi * 4315a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 4316a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 4317a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 4318a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 4319a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 4320a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 4321a5462516STimur Tabi * 4322a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 4323a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 4324a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 4325a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 4326a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 4327a5462516STimur Tabi * reasons. 4328a5462516STimur Tabi * 4329a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 4330a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 4331a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 4332a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 4333a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 4334a2de48caSGreg Kroah-Hartman */ 43356937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 4336a2de48caSGreg Kroah-Hartman { 43374b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 43382ee97cafSCornelia Huck char *old_device_name = NULL; 4339a2de48caSGreg Kroah-Hartman int error; 4340a2de48caSGreg Kroah-Hartman 4341a2de48caSGreg Kroah-Hartman dev = get_device(dev); 4342a2de48caSGreg Kroah-Hartman if (!dev) 4343a2de48caSGreg Kroah-Hartman return -EINVAL; 4344a2de48caSGreg Kroah-Hartman 434569df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 4346a2de48caSGreg Kroah-Hartman 43471fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 43482ee97cafSCornelia Huck if (!old_device_name) { 4349952ab431SJesper Juhl error = -ENOMEM; 43502ee97cafSCornelia Huck goto out; 4351952ab431SJesper Juhl } 4352a2de48caSGreg Kroah-Hartman 4353f349cf34SEric W. Biederman if (dev->class) { 43544b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 43554b30ee58STejun Heo kobj, old_device_name, 43564b30ee58STejun Heo new_name, kobject_namespace(kobj)); 4357f349cf34SEric W. Biederman if (error) 4358f349cf34SEric W. Biederman goto out; 4359f349cf34SEric W. Biederman } 436039aba963SKay Sievers 43614b30ee58STejun Heo error = kobject_rename(kobj, new_name); 43621fa5ae85SKay Sievers if (error) 43632ee97cafSCornelia Huck goto out; 4364a2de48caSGreg Kroah-Hartman 43652ee97cafSCornelia Huck out: 4366a2de48caSGreg Kroah-Hartman put_device(dev); 4367a2de48caSGreg Kroah-Hartman 43682ee97cafSCornelia Huck kfree(old_device_name); 4369a2de48caSGreg Kroah-Hartman 4370a2de48caSGreg Kroah-Hartman return error; 4371a2de48caSGreg Kroah-Hartman } 4372a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 43738a82472fSCornelia Huck 43748a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 43758a82472fSCornelia Huck struct device *old_parent, 43768a82472fSCornelia Huck struct device *new_parent) 43778a82472fSCornelia Huck { 4378f7f3461dSGreg Kroah-Hartman int error = 0; 43798a82472fSCornelia Huck 4380f7f3461dSGreg Kroah-Hartman if (old_parent) 4381f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 4382f7f3461dSGreg Kroah-Hartman if (new_parent) 4383f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 4384f7f3461dSGreg Kroah-Hartman "device"); 4385f7f3461dSGreg Kroah-Hartman return error; 43868a82472fSCornelia Huck } 43878a82472fSCornelia Huck 43888a82472fSCornelia Huck /** 43898a82472fSCornelia Huck * device_move - moves a device to a new parent 43908a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 439113509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 4392ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 43938a82472fSCornelia Huck */ 4394ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 4395ffa6a705SCornelia Huck enum dpm_order dpm_order) 43968a82472fSCornelia Huck { 43978a82472fSCornelia Huck int error; 43988a82472fSCornelia Huck struct device *old_parent; 4399c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 44008a82472fSCornelia Huck 44018a82472fSCornelia Huck dev = get_device(dev); 44028a82472fSCornelia Huck if (!dev) 44038a82472fSCornelia Huck return -EINVAL; 44048a82472fSCornelia Huck 4405ffa6a705SCornelia Huck device_pm_lock(); 44068a82472fSCornelia Huck new_parent = get_device(new_parent); 4407c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 440884d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 440984d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 441084d0c27dSTetsuo Handa put_device(new_parent); 441184d0c27dSTetsuo Handa goto out; 441284d0c27dSTetsuo Handa } 441363b6971aSCornelia Huck 44141e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 44151e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 4416c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 44178a82472fSCornelia Huck if (error) { 441863b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 44198a82472fSCornelia Huck put_device(new_parent); 44208a82472fSCornelia Huck goto out; 44218a82472fSCornelia Huck } 44228a82472fSCornelia Huck old_parent = dev->parent; 44238a82472fSCornelia Huck dev->parent = new_parent; 44248a82472fSCornelia Huck if (old_parent) 4425f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 44260d358f22SYinghai Lu if (new_parent) { 4427f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4428f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 44290d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 44300d358f22SYinghai Lu } 44310d358f22SYinghai Lu 4432bdd4034dSRabin Vincent if (dev->class) { 44338a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 44348a82472fSCornelia Huck if (error) { 44358a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 44368a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 44378a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 4438c744aeaeSCornelia Huck if (new_parent) 4439f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 44400d358f22SYinghai Lu dev->parent = old_parent; 44410d358f22SYinghai Lu if (old_parent) { 4442f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4443f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 44440d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 44450d358f22SYinghai Lu } 44468a82472fSCornelia Huck } 444763b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 44488a82472fSCornelia Huck put_device(new_parent); 44498a82472fSCornelia Huck goto out; 44508a82472fSCornelia Huck } 4451bdd4034dSRabin Vincent } 4452ffa6a705SCornelia Huck switch (dpm_order) { 4453ffa6a705SCornelia Huck case DPM_ORDER_NONE: 4454ffa6a705SCornelia Huck break; 4455ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 4456ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 445752cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 4458ffa6a705SCornelia Huck break; 4459ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 4460ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 446152cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 4462ffa6a705SCornelia Huck break; 4463ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 4464ffa6a705SCornelia Huck device_pm_move_last(dev); 446552cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 4466ffa6a705SCornelia Huck break; 4467ffa6a705SCornelia Huck } 4468bdd4034dSRabin Vincent 44698a82472fSCornelia Huck put_device(old_parent); 44708a82472fSCornelia Huck out: 4471ffa6a705SCornelia Huck device_pm_unlock(); 44728a82472fSCornelia Huck put_device(dev); 44738a82472fSCornelia Huck return error; 44748a82472fSCornelia Huck } 44758a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 447637b0c020SGreg Kroah-Hartman 4477b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 4478b8f33e5dSChristian Brauner kgid_t kgid) 4479b8f33e5dSChristian Brauner { 4480b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4481b8f33e5dSChristian Brauner struct class *class = dev->class; 4482b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 4483b8f33e5dSChristian Brauner int error; 4484b8f33e5dSChristian Brauner 4485b8f33e5dSChristian Brauner if (class) { 4486b8f33e5dSChristian Brauner /* 4487b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 4488b8f33e5dSChristian Brauner * @kuid/@kgid. 4489b8f33e5dSChristian Brauner */ 4490b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 4491b8f33e5dSChristian Brauner kgid); 4492b8f33e5dSChristian Brauner if (error) 4493b8f33e5dSChristian Brauner return error; 4494b8f33e5dSChristian Brauner } 4495b8f33e5dSChristian Brauner 4496b8f33e5dSChristian Brauner if (type) { 4497b8f33e5dSChristian Brauner /* 4498b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 4499b8f33e5dSChristian Brauner * @kuid/@kgid. 4500b8f33e5dSChristian Brauner */ 4501b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 4502b8f33e5dSChristian Brauner kgid); 4503b8f33e5dSChristian Brauner if (error) 4504b8f33e5dSChristian Brauner return error; 4505b8f33e5dSChristian Brauner } 4506b8f33e5dSChristian Brauner 4507b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 4508b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 4509b8f33e5dSChristian Brauner if (error) 4510b8f33e5dSChristian Brauner return error; 4511b8f33e5dSChristian Brauner 4512b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 4513b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 4514b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 4515b8f33e5dSChristian Brauner kuid, kgid); 4516b8f33e5dSChristian Brauner if (error) 4517b8f33e5dSChristian Brauner return error; 4518b8f33e5dSChristian Brauner } 4519b8f33e5dSChristian Brauner 4520b8f33e5dSChristian Brauner return 0; 4521b8f33e5dSChristian Brauner } 4522b8f33e5dSChristian Brauner 4523b8f33e5dSChristian Brauner /** 4524b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 4525b8f33e5dSChristian Brauner * @dev: device. 4526b8f33e5dSChristian Brauner * @kuid: new owner's kuid 4527b8f33e5dSChristian Brauner * @kgid: new owner's kgid 4528b8f33e5dSChristian Brauner * 4529b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 4530b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 4531b8f33e5dSChristian Brauner * core. 4532b8f33e5dSChristian Brauner * 4533b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 4534b8f33e5dSChristian Brauner */ 4535b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 4536b8f33e5dSChristian Brauner { 4537b8f33e5dSChristian Brauner int error; 4538b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 4539b8f33e5dSChristian Brauner 4540b8f33e5dSChristian Brauner dev = get_device(dev); 4541b8f33e5dSChristian Brauner if (!dev) 4542b8f33e5dSChristian Brauner return -EINVAL; 4543b8f33e5dSChristian Brauner 4544b8f33e5dSChristian Brauner /* 4545b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 4546b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 4547b8f33e5dSChristian Brauner */ 4548b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 4549b8f33e5dSChristian Brauner if (error) 4550b8f33e5dSChristian Brauner goto out; 4551b8f33e5dSChristian Brauner 4552b8f33e5dSChristian Brauner /* 4553b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 4554b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 4555b8f33e5dSChristian Brauner * that step here. 4556b8f33e5dSChristian Brauner */ 4557b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 4558b8f33e5dSChristian Brauner kgid); 4559b8f33e5dSChristian Brauner if (error) 4560b8f33e5dSChristian Brauner goto out; 4561b8f33e5dSChristian Brauner 4562b8f33e5dSChristian Brauner /* 4563b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 4564b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 4565b8f33e5dSChristian Brauner * to @kuid/@kgid. 4566b8f33e5dSChristian Brauner */ 4567b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 4568b8f33e5dSChristian Brauner if (error) 4569b8f33e5dSChristian Brauner goto out; 4570b8f33e5dSChristian Brauner 45713b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 45723b52fc5dSChristian Brauner if (error) 45733b52fc5dSChristian Brauner goto out; 45743b52fc5dSChristian Brauner 4575b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 4576b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 4577b8f33e5dSChristian Brauner goto out; 4578b8f33e5dSChristian Brauner #endif 4579b8f33e5dSChristian Brauner 4580b8f33e5dSChristian Brauner /* 4581b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 4582b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 4583b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 4584b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 4585b8f33e5dSChristian Brauner */ 4586b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 4587b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 4588b8f33e5dSChristian Brauner if (error) 4589b8f33e5dSChristian Brauner goto out; 4590b8f33e5dSChristian Brauner 4591b8f33e5dSChristian Brauner out: 4592b8f33e5dSChristian Brauner put_device(dev); 4593b8f33e5dSChristian Brauner return error; 4594b8f33e5dSChristian Brauner } 4595b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 4596b8f33e5dSChristian Brauner 459737b0c020SGreg Kroah-Hartman /** 459837b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 459937b0c020SGreg Kroah-Hartman */ 460037b0c020SGreg Kroah-Hartman void device_shutdown(void) 460137b0c020SGreg Kroah-Hartman { 4602f123db8eSBenson Leung struct device *dev, *parent; 460337b0c020SGreg Kroah-Hartman 46043297c8fcSPingfan Liu wait_for_device_probe(); 46053297c8fcSPingfan Liu device_block_probing(); 46063297c8fcSPingfan Liu 460765650b35SRafael J. Wysocki cpufreq_suspend(); 460865650b35SRafael J. Wysocki 46096245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 46106245838fSHugh Daschbach /* 46116245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 46126245838fSHugh Daschbach * Beware that device unplug events may also start pulling 46136245838fSHugh Daschbach * devices offline, even as the system is shutting down. 46146245838fSHugh Daschbach */ 46156245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 46166245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 46176245838fSHugh Daschbach kobj.entry); 4618d1c6c030SMing Lei 4619d1c6c030SMing Lei /* 4620d1c6c030SMing Lei * hold reference count of device's parent to 4621d1c6c030SMing Lei * prevent it from being freed because parent's 4622d1c6c030SMing Lei * lock is to be held 4623d1c6c030SMing Lei */ 4624f123db8eSBenson Leung parent = get_device(dev->parent); 46256245838fSHugh Daschbach get_device(dev); 46266245838fSHugh Daschbach /* 46276245838fSHugh Daschbach * Make sure the device is off the kset list, in the 46286245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 46296245838fSHugh Daschbach */ 46306245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 46316245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 4632fe6b91f4SAlan Stern 4633d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 4634f123db8eSBenson Leung if (parent) 4635f123db8eSBenson Leung device_lock(parent); 4636d1c6c030SMing Lei device_lock(dev); 4637d1c6c030SMing Lei 4638fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 4639fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 4640fe6b91f4SAlan Stern pm_runtime_barrier(dev); 46416245838fSHugh Daschbach 46427521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 4643f77af151SJosh Zimmerman if (initcall_debug) 46447521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 46457521621eSMichal Suchanek dev->class->shutdown_pre(dev); 46467521621eSMichal Suchanek } 46477521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 46480246c4faSShuoX Liu if (initcall_debug) 46490246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 465037b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 465137b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 46520246c4faSShuoX Liu if (initcall_debug) 46530246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 465437b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 465537b0c020SGreg Kroah-Hartman } 4656d1c6c030SMing Lei 4657d1c6c030SMing Lei device_unlock(dev); 4658f123db8eSBenson Leung if (parent) 4659f123db8eSBenson Leung device_unlock(parent); 4660d1c6c030SMing Lei 46616245838fSHugh Daschbach put_device(dev); 4662f123db8eSBenson Leung put_device(parent); 46636245838fSHugh Daschbach 46646245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 466537b0c020SGreg Kroah-Hartman } 46666245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 466737b0c020SGreg Kroah-Hartman } 466899bcf217SJoe Perches 466999bcf217SJoe Perches /* 467099bcf217SJoe Perches * Device logging functions 467199bcf217SJoe Perches */ 467299bcf217SJoe Perches 467399bcf217SJoe Perches #ifdef CONFIG_PRINTK 467474caba7fSJohn Ogness static void 467574caba7fSJohn Ogness set_dev_info(const struct device *dev, struct dev_printk_info *dev_info) 467699bcf217SJoe Perches { 4677c4e00daaSKay Sievers const char *subsys; 467874caba7fSJohn Ogness 467974caba7fSJohn Ogness memset(dev_info, 0, sizeof(*dev_info)); 468099bcf217SJoe Perches 4681c4e00daaSKay Sievers if (dev->class) 4682c4e00daaSKay Sievers subsys = dev->class->name; 4683c4e00daaSKay Sievers else if (dev->bus) 4684c4e00daaSKay Sievers subsys = dev->bus->name; 4685c4e00daaSKay Sievers else 468674caba7fSJohn Ogness return; 4687c4e00daaSKay Sievers 468874caba7fSJohn Ogness strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); 4689c4e00daaSKay Sievers 4690c4e00daaSKay Sievers /* 4691c4e00daaSKay Sievers * Add device identifier DEVICE=: 4692c4e00daaSKay Sievers * b12:8 block dev_t 4693c4e00daaSKay Sievers * c127:3 char dev_t 4694c4e00daaSKay Sievers * n8 netdev ifindex 4695c4e00daaSKay Sievers * +sound:card0 subsystem:devname 4696c4e00daaSKay Sievers */ 4697c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 4698c4e00daaSKay Sievers char c; 4699c4e00daaSKay Sievers 4700c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 4701c4e00daaSKay Sievers c = 'b'; 4702c4e00daaSKay Sievers else 4703c4e00daaSKay Sievers c = 'c'; 470474caba7fSJohn Ogness 470574caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 470674caba7fSJohn Ogness "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); 4707c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 4708c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 4709c4e00daaSKay Sievers 471074caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 471174caba7fSJohn Ogness "n%u", net->ifindex); 4712c4e00daaSKay Sievers } else { 471374caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 471474caba7fSJohn Ogness "+%s:%s", subsys, dev_name(dev)); 4715c4e00daaSKay Sievers } 471699bcf217SJoe Perches } 4717798efc60SJoe Perches 471805e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 471905e4e5b8SJoe Perches const char *fmt, va_list args) 472005e4e5b8SJoe Perches { 472174caba7fSJohn Ogness struct dev_printk_info dev_info; 472205e4e5b8SJoe Perches 472374caba7fSJohn Ogness set_dev_info(dev, &dev_info); 472405e4e5b8SJoe Perches 472574caba7fSJohn Ogness return vprintk_emit(0, level, &dev_info, fmt, args); 472605e4e5b8SJoe Perches } 472705e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 472805e4e5b8SJoe Perches 472905e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 473005e4e5b8SJoe Perches { 473105e4e5b8SJoe Perches va_list args; 473205e4e5b8SJoe Perches int r; 473305e4e5b8SJoe Perches 473405e4e5b8SJoe Perches va_start(args, fmt); 473505e4e5b8SJoe Perches 473605e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 473705e4e5b8SJoe Perches 473805e4e5b8SJoe Perches va_end(args); 473905e4e5b8SJoe Perches 474005e4e5b8SJoe Perches return r; 474105e4e5b8SJoe Perches } 474205e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 474305e4e5b8SJoe Perches 4744d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 4745798efc60SJoe Perches struct va_format *vaf) 4746798efc60SJoe Perches { 4747d1f1052cSJoe Perches if (dev) 4748d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 4749798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 4750d1f1052cSJoe Perches else 4751d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 4752798efc60SJoe Perches } 475399bcf217SJoe Perches 4754ad7d61f1SChris Down void _dev_printk(const char *level, const struct device *dev, 475599bcf217SJoe Perches const char *fmt, ...) 475699bcf217SJoe Perches { 475799bcf217SJoe Perches struct va_format vaf; 475899bcf217SJoe Perches va_list args; 475999bcf217SJoe Perches 476099bcf217SJoe Perches va_start(args, fmt); 476199bcf217SJoe Perches 476299bcf217SJoe Perches vaf.fmt = fmt; 476399bcf217SJoe Perches vaf.va = &args; 476499bcf217SJoe Perches 4765d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 4766798efc60SJoe Perches 476799bcf217SJoe Perches va_end(args); 476899bcf217SJoe Perches } 4769ad7d61f1SChris Down EXPORT_SYMBOL(_dev_printk); 477099bcf217SJoe Perches 477199bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 4772d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 477399bcf217SJoe Perches { \ 477499bcf217SJoe Perches struct va_format vaf; \ 477599bcf217SJoe Perches va_list args; \ 477699bcf217SJoe Perches \ 477799bcf217SJoe Perches va_start(args, fmt); \ 477899bcf217SJoe Perches \ 477999bcf217SJoe Perches vaf.fmt = fmt; \ 478099bcf217SJoe Perches vaf.va = &args; \ 478199bcf217SJoe Perches \ 4782d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 4783798efc60SJoe Perches \ 478499bcf217SJoe Perches va_end(args); \ 478599bcf217SJoe Perches } \ 478699bcf217SJoe Perches EXPORT_SYMBOL(func); 478799bcf217SJoe Perches 4788663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 4789663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 4790663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 4791663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 4792663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 4793663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 479499bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 479599bcf217SJoe Perches 479699bcf217SJoe Perches #endif 479797badf87SRafael J. Wysocki 4798a787e540SAndrzej Hajda /** 4799a787e540SAndrzej Hajda * dev_err_probe - probe error check and log helper 4800a787e540SAndrzej Hajda * @dev: the pointer to the struct device 4801a787e540SAndrzej Hajda * @err: error value to test 4802a787e540SAndrzej Hajda * @fmt: printf-style format string 4803a787e540SAndrzej Hajda * @...: arguments as specified in the format string 4804a787e540SAndrzej Hajda * 4805a787e540SAndrzej Hajda * This helper implements common pattern present in probe functions for error 4806a787e540SAndrzej Hajda * checking: print debug or error message depending if the error value is 4807a787e540SAndrzej Hajda * -EPROBE_DEFER and propagate error upwards. 4808d090b70eSAndrzej Hajda * In case of -EPROBE_DEFER it sets also defer probe reason, which can be 4809d090b70eSAndrzej Hajda * checked later by reading devices_deferred debugfs attribute. 4810074b3aadSMauro Carvalho Chehab * It replaces code sequence:: 4811074b3aadSMauro Carvalho Chehab * 4812a787e540SAndrzej Hajda * if (err != -EPROBE_DEFER) 4813a787e540SAndrzej Hajda * dev_err(dev, ...); 4814a787e540SAndrzej Hajda * else 4815a787e540SAndrzej Hajda * dev_dbg(dev, ...); 4816a787e540SAndrzej Hajda * return err; 4817074b3aadSMauro Carvalho Chehab * 4818074b3aadSMauro Carvalho Chehab * with:: 4819074b3aadSMauro Carvalho Chehab * 4820a787e540SAndrzej Hajda * return dev_err_probe(dev, err, ...); 4821a787e540SAndrzej Hajda * 48227065f922SDouglas Anderson * Note that it is deemed acceptable to use this function for error 48237065f922SDouglas Anderson * prints during probe even if the @err is known to never be -EPROBE_DEFER. 48247065f922SDouglas Anderson * The benefit compared to a normal dev_err() is the standardized format 48257065f922SDouglas Anderson * of the error code and the fact that the error code is returned. 48267065f922SDouglas Anderson * 4827a787e540SAndrzej Hajda * Returns @err. 4828a787e540SAndrzej Hajda * 4829a787e540SAndrzej Hajda */ 4830a787e540SAndrzej Hajda int dev_err_probe(const struct device *dev, int err, const char *fmt, ...) 4831a787e540SAndrzej Hajda { 4832a787e540SAndrzej Hajda struct va_format vaf; 4833a787e540SAndrzej Hajda va_list args; 4834a787e540SAndrzej Hajda 4835a787e540SAndrzej Hajda va_start(args, fmt); 4836a787e540SAndrzej Hajda vaf.fmt = fmt; 4837a787e540SAndrzej Hajda vaf.va = &args; 4838a787e540SAndrzej Hajda 4839d090b70eSAndrzej Hajda if (err != -EPROBE_DEFER) { 4840693a8e93SMichał Mirosław dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4841d090b70eSAndrzej Hajda } else { 4842d090b70eSAndrzej Hajda device_set_deferred_probe_reason(dev, &vaf); 4843693a8e93SMichał Mirosław dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4844d090b70eSAndrzej Hajda } 4845a787e540SAndrzej Hajda 4846a787e540SAndrzej Hajda va_end(args); 4847a787e540SAndrzej Hajda 4848a787e540SAndrzej Hajda return err; 4849a787e540SAndrzej Hajda } 4850a787e540SAndrzej Hajda EXPORT_SYMBOL_GPL(dev_err_probe); 4851a787e540SAndrzej Hajda 485297badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 485397badf87SRafael J. Wysocki { 485497badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 485597badf87SRafael J. Wysocki } 485697badf87SRafael J. Wysocki 485797badf87SRafael J. Wysocki /** 485897badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 485997badf87SRafael J. Wysocki * @dev: Device to handle. 486097badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 486197badf87SRafael J. Wysocki * 486297badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 486397badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 48643f7bddafSBard Liao * 48653f7bddafSBard Liao * Valid fwnode cases are: 48663f7bddafSBard Liao * - primary --> secondary --> -ENODEV 48673f7bddafSBard Liao * - primary --> NULL 48683f7bddafSBard Liao * - secondary --> -ENODEV 48693f7bddafSBard Liao * - NULL 487097badf87SRafael J. Wysocki */ 487197badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 487297badf87SRafael J. Wysocki { 487399aed922SAndy Shevchenko struct device *parent = dev->parent; 487497badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 487597badf87SRafael J. Wysocki 4876c15e1bddSHeikki Krogerus if (fwnode) { 487797badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 487897badf87SRafael J. Wysocki fn = fn->secondary; 487997badf87SRafael J. Wysocki 488055f89a8aSMika Westerberg if (fn) { 488155f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 488297badf87SRafael J. Wysocki fwnode->secondary = fn; 488355f89a8aSMika Westerberg } 488497badf87SRafael J. Wysocki dev->fwnode = fwnode; 488597badf87SRafael J. Wysocki } else { 4886c15e1bddSHeikki Krogerus if (fwnode_is_primary(fn)) { 4887c15e1bddSHeikki Krogerus dev->fwnode = fn->secondary; 48883f7bddafSBard Liao /* Set fn->secondary = NULL, so fn remains the primary fwnode */ 488999aed922SAndy Shevchenko if (!(parent && fn == parent->fwnode)) 489047f44699SBard Liao fn->secondary = NULL; 4891c15e1bddSHeikki Krogerus } else { 4892c15e1bddSHeikki Krogerus dev->fwnode = NULL; 4893c15e1bddSHeikki Krogerus } 489497badf87SRafael J. Wysocki } 489597badf87SRafael J. Wysocki } 489697badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 489797badf87SRafael J. Wysocki 489897badf87SRafael J. Wysocki /** 489997badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 490097badf87SRafael J. Wysocki * @dev: Device to handle. 490197badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 490297badf87SRafael J. Wysocki * 490397badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 490497badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 490597badf87SRafael J. Wysocki * @fwnode. 490697badf87SRafael J. Wysocki */ 490797badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 490897badf87SRafael J. Wysocki { 490997badf87SRafael J. Wysocki if (fwnode) 491097badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 491197badf87SRafael J. Wysocki 491297badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 491397badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 491497badf87SRafael J. Wysocki else 491597badf87SRafael J. Wysocki dev->fwnode = fwnode; 491697badf87SRafael J. Wysocki } 491796489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 49184e75e1d7SJohan Hovold 49194e75e1d7SJohan Hovold /** 49204e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 49214e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 49224e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 49234e75e1d7SJohan Hovold * 49244e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 49254e75e1d7SJohan Hovold * any reference held to the old node. 49264e75e1d7SJohan Hovold */ 49274e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 49284e75e1d7SJohan Hovold { 49294e75e1d7SJohan Hovold of_node_put(dev->of_node); 49304e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 49314e75e1d7SJohan Hovold dev->of_node_reused = true; 49324e75e1d7SJohan Hovold } 49334e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 493465b66682SSuzuki K Poulose 493543e76d46SIoana Ciornei void device_set_node(struct device *dev, struct fwnode_handle *fwnode) 493643e76d46SIoana Ciornei { 493743e76d46SIoana Ciornei dev->fwnode = fwnode; 493843e76d46SIoana Ciornei dev->of_node = to_of_node(fwnode); 493943e76d46SIoana Ciornei } 494043e76d46SIoana Ciornei EXPORT_SYMBOL_GPL(device_set_node); 494143e76d46SIoana Ciornei 49426cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 49436cda08a2SSuzuki K Poulose { 49446cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 49456cda08a2SSuzuki K Poulose } 49466cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 49476cda08a2SSuzuki K Poulose 494865b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 494965b66682SSuzuki K Poulose { 495065b66682SSuzuki K Poulose return dev->of_node == np; 495165b66682SSuzuki K Poulose } 495265b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 495367843bbaSSuzuki K Poulose 495467843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 495567843bbaSSuzuki K Poulose { 495667843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 495767843bbaSSuzuki K Poulose } 495867843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 49594495dfddSSuzuki K Poulose 49604495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 49614495dfddSSuzuki K Poulose { 49624495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 49634495dfddSSuzuki K Poulose } 49644495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 496500500147SSuzuki K Poulose 496600500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 496700500147SSuzuki K Poulose { 496800500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 496900500147SSuzuki K Poulose } 497000500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 49716bf85ba9SSuzuki K Poulose 4972a164ff53SAndy Shevchenko int device_match_acpi_handle(struct device *dev, const void *handle) 4973a164ff53SAndy Shevchenko { 4974a164ff53SAndy Shevchenko return ACPI_HANDLE(dev) == handle; 4975a164ff53SAndy Shevchenko } 4976a164ff53SAndy Shevchenko EXPORT_SYMBOL(device_match_acpi_handle); 4977a164ff53SAndy Shevchenko 49786bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 49796bf85ba9SSuzuki K Poulose { 49806bf85ba9SSuzuki K Poulose return 1; 49816bf85ba9SSuzuki K Poulose } 49826bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 4983