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> 121da177e4SLinus Torvalds #include <linux/device.h> 131da177e4SLinus Torvalds #include <linux/err.h> 1497badf87SRafael J. Wysocki #include <linux/fwnode.h> 151da177e4SLinus Torvalds #include <linux/init.h> 161da177e4SLinus Torvalds #include <linux/module.h> 171da177e4SLinus Torvalds #include <linux/slab.h> 181da177e4SLinus Torvalds #include <linux/string.h> 1923681e47SGreg Kroah-Hartman #include <linux/kdev_t.h> 20116af378SBenjamin Herrenschmidt #include <linux/notifier.h> 2107d57a32SGrant Likely #include <linux/of.h> 2207d57a32SGrant Likely #include <linux/of_device.h> 23da231fd5SKay Sievers #include <linux/genhd.h> 24f75b1c60SDave Young #include <linux/mutex.h> 25af8db150SPeter Chen #include <linux/pm_runtime.h> 26c4e00daaSKay Sievers #include <linux/netdevice.h> 27174cd4b1SIngo Molnar #include <linux/sched/signal.h> 2863967685SGreg Kroah-Hartman #include <linux/sysfs.h> 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds #include "base.h" 311da177e4SLinus Torvalds #include "power/power.h" 321da177e4SLinus Torvalds 33e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 34e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 35e52eec13SAndi Kleen long sysfs_deprecated = 1; 36e52eec13SAndi Kleen #else 37e52eec13SAndi Kleen long sysfs_deprecated = 0; 38e52eec13SAndi Kleen #endif 393454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 40e52eec13SAndi Kleen { 4134da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 42e52eec13SAndi Kleen } 43e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 44e52eec13SAndi Kleen #endif 45e52eec13SAndi Kleen 469ed98953SRafael J. Wysocki /* Device links support. */ 47e2ae9bccSSaravana Kannan static LIST_HEAD(wait_for_suppliers); 48e2ae9bccSSaravana Kannan static DEFINE_MUTEX(wfs_lock); 49fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 50fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 519ed98953SRafael J. Wysocki 529ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 539ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 549ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 559ed98953SRafael J. Wysocki 569ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 579ed98953SRafael J. Wysocki { 589ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 599ed98953SRafael J. Wysocki } 609ed98953SRafael J. Wysocki 619ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 629ed98953SRafael J. Wysocki { 639ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 649ed98953SRafael J. Wysocki } 659ed98953SRafael J. Wysocki 669ed98953SRafael J. Wysocki int device_links_read_lock(void) 679ed98953SRafael J. Wysocki { 689ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 699ed98953SRafael J. Wysocki } 709ed98953SRafael J. Wysocki 719ed98953SRafael J. Wysocki void device_links_read_unlock(int idx) 729ed98953SRafael J. Wysocki { 739ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 749ed98953SRafael J. Wysocki } 75c2fa1e1bSJoel Fernandes (Google) 76c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 77c2fa1e1bSJoel Fernandes (Google) { 78c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 79c2fa1e1bSJoel Fernandes (Google) } 809ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 819ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 829ed98953SRafael J. Wysocki 839ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 849ed98953SRafael J. Wysocki { 859ed98953SRafael J. Wysocki down_write(&device_links_lock); 869ed98953SRafael J. Wysocki } 879ed98953SRafael J. Wysocki 889ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 899ed98953SRafael J. Wysocki { 909ed98953SRafael J. Wysocki up_write(&device_links_lock); 919ed98953SRafael J. Wysocki } 929ed98953SRafael J. Wysocki 939ed98953SRafael J. Wysocki int device_links_read_lock(void) 949ed98953SRafael J. Wysocki { 959ed98953SRafael J. Wysocki down_read(&device_links_lock); 969ed98953SRafael J. Wysocki return 0; 979ed98953SRafael J. Wysocki } 989ed98953SRafael J. Wysocki 999ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 1009ed98953SRafael J. Wysocki { 1019ed98953SRafael J. Wysocki up_read(&device_links_lock); 1029ed98953SRafael J. Wysocki } 103c2fa1e1bSJoel Fernandes (Google) 104c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 105c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 106c2fa1e1bSJoel Fernandes (Google) { 107c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 108c2fa1e1bSJoel Fernandes (Google) } 109c2fa1e1bSJoel Fernandes (Google) #endif 1109ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 1119ed98953SRafael J. Wysocki 1129ed98953SRafael J. Wysocki /** 1139ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 1149ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 1159ed98953SRafael J. Wysocki * @target: Device to check against. 1169ed98953SRafael J. Wysocki * 1179ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 1189ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 1199ed98953SRafael J. Wysocki */ 1209ed98953SRafael J. Wysocki static int device_is_dependent(struct device *dev, void *target) 1219ed98953SRafael J. Wysocki { 1229ed98953SRafael J. Wysocki struct device_link *link; 1239ed98953SRafael J. Wysocki int ret; 1249ed98953SRafael J. Wysocki 125e16f4f3eSBenjamin Gaignard if (dev == target) 1269ed98953SRafael J. Wysocki return 1; 1279ed98953SRafael J. Wysocki 1289ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 1299ed98953SRafael J. Wysocki if (ret) 1309ed98953SRafael J. Wysocki return ret; 1319ed98953SRafael J. Wysocki 1329ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 133e16f4f3eSBenjamin Gaignard if (link->consumer == target) 1349ed98953SRafael J. Wysocki return 1; 1359ed98953SRafael J. Wysocki 1369ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 1379ed98953SRafael J. Wysocki if (ret) 1389ed98953SRafael J. Wysocki break; 1399ed98953SRafael J. Wysocki } 1409ed98953SRafael J. Wysocki return ret; 1419ed98953SRafael J. Wysocki } 1429ed98953SRafael J. Wysocki 143515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 144515db266SRafael J. Wysocki struct device *consumer, 145515db266SRafael J. Wysocki struct device *supplier) 146515db266SRafael J. Wysocki { 147515db266SRafael J. Wysocki switch (supplier->links.status) { 148515db266SRafael J. Wysocki case DL_DEV_PROBING: 149515db266SRafael J. Wysocki switch (consumer->links.status) { 150515db266SRafael J. Wysocki case DL_DEV_PROBING: 151515db266SRafael J. Wysocki /* 152515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 153515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 154515db266SRafael J. Wysocki * knows that the supplier is already functional (for 155515db266SRafael J. Wysocki * example, it has just acquired some resources from the 156515db266SRafael J. Wysocki * supplier). 157515db266SRafael J. Wysocki */ 158515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 159515db266SRafael J. Wysocki break; 160515db266SRafael J. Wysocki default: 161515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 162515db266SRafael J. Wysocki break; 163515db266SRafael J. Wysocki } 164515db266SRafael J. Wysocki break; 165515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 166515db266SRafael J. Wysocki switch (consumer->links.status) { 167515db266SRafael J. Wysocki case DL_DEV_PROBING: 168515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 169515db266SRafael J. Wysocki break; 170515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 171515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 172515db266SRafael J. Wysocki break; 173515db266SRafael J. Wysocki default: 174515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 175515db266SRafael J. Wysocki break; 176515db266SRafael J. Wysocki } 177515db266SRafael J. Wysocki break; 178515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 179515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 180515db266SRafael J. Wysocki break; 181515db266SRafael J. Wysocki default: 182515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 183515db266SRafael J. Wysocki break; 184515db266SRafael J. Wysocki } 185515db266SRafael J. Wysocki } 186515db266SRafael J. Wysocki 1879ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 1889ed98953SRafael J. Wysocki { 1899ed98953SRafael J. Wysocki struct device_link *link; 1909ed98953SRafael J. Wysocki 1919ed98953SRafael J. Wysocki /* 1929ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 1939ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 1949ed98953SRafael J. Wysocki */ 1959ed98953SRafael J. Wysocki if (device_is_registered(dev)) 1969ed98953SRafael J. Wysocki devices_kset_move_last(dev); 1979ed98953SRafael J. Wysocki 1989ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 1999ed98953SRafael J. Wysocki device_pm_move_last(dev); 2009ed98953SRafael J. Wysocki 2019ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 2029ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) 2039ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 2049ed98953SRafael J. Wysocki 2059ed98953SRafael J. Wysocki return 0; 2069ed98953SRafael J. Wysocki } 2079ed98953SRafael J. Wysocki 2089ed98953SRafael J. Wysocki /** 209494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 210494fd7b7SFeng Kan * @dev: Device to move 211494fd7b7SFeng Kan * 212494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 213494fd7b7SFeng Kan * 214494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 215494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 216494fd7b7SFeng Kan */ 217494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 218494fd7b7SFeng Kan { 219494fd7b7SFeng Kan int idx; 220494fd7b7SFeng Kan 221494fd7b7SFeng Kan idx = device_links_read_lock(); 222494fd7b7SFeng Kan device_pm_lock(); 223494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 224494fd7b7SFeng Kan device_pm_unlock(); 225494fd7b7SFeng Kan device_links_read_unlock(idx); 226494fd7b7SFeng Kan } 227494fd7b7SFeng Kan 228515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 229515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 230515db266SRafael J. Wysocki DL_FLAG_AUTOPROBE_CONSUMER) 231515db266SRafael J. Wysocki 232fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 233fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 234fb583c8eSRafael J. Wysocki 235494fd7b7SFeng Kan /** 2369ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 2379ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 2389ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 2399ed98953SRafael J. Wysocki * @flags: Link flags. 2409ed98953SRafael J. Wysocki * 24121d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 24221d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 24321d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 24421d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 24521d5c57bSRafael J. Wysocki * be forced into the active metastate and reference-counted upon the creation 24621d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 24721d5c57bSRafael J. Wysocki * ignored. 24821d5c57bSRafael J. Wysocki * 249515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 250515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 251515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 25272175d4eSRafael J. Wysocki * 25372175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 25472175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 25572175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 25672175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 25772175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 25872175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 25972175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 26072175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 26172175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 26272175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 26372175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 264c8d50986SRafael J. Wysocki * 265e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 266e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 267e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 268e7dd4010SRafael J. Wysocki * be used to request the driver core to automaticall probe for a consmer 269e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 270e7dd4010SRafael J. Wysocki * 271515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 272515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 273515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 274515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 275515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 276515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 277515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 278515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 279515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 280515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 2819ed98953SRafael J. Wysocki * 2829ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 2839ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 2849ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 2859ed98953SRafael J. Wysocki * not been registered when this function is called). 2869ed98953SRafael J. Wysocki * 2879ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 2889ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 28964df1148SLukas Wunner * not be registered, however. 2909ed98953SRafael J. Wysocki */ 2919ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 2929ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 2939ed98953SRafael J. Wysocki { 2949ed98953SRafael J. Wysocki struct device_link *link; 2959ed98953SRafael J. Wysocki 296fb583c8eSRafael J. Wysocki if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || 297515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 298e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 299e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 300e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 3019ed98953SRafael J. Wysocki return NULL; 3029ed98953SRafael J. Wysocki 3035db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 3045db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 3055db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 3065db25c9eSRafael J. Wysocki return NULL; 3075db25c9eSRafael J. Wysocki } 3085db25c9eSRafael J. Wysocki } 3095db25c9eSRafael J. Wysocki 310515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 311515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 312515db266SRafael J. Wysocki 3139ed98953SRafael J. Wysocki device_links_write_lock(); 3149ed98953SRafael J. Wysocki device_pm_lock(); 3159ed98953SRafael J. Wysocki 3169ed98953SRafael J. Wysocki /* 3179ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 3189ed98953SRafael J. Wysocki * reverse dependency between the consumer and the supplier already in 3199ed98953SRafael J. Wysocki * the graph, return NULL. 3209ed98953SRafael J. Wysocki */ 3219ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 3229ed98953SRafael J. Wysocki || device_is_dependent(consumer, supplier)) { 3239ed98953SRafael J. Wysocki link = NULL; 3249ed98953SRafael J. Wysocki goto out; 3259ed98953SRafael J. Wysocki } 3269ed98953SRafael J. Wysocki 32772175d4eSRafael J. Wysocki /* 32872175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 32972175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 33072175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 33172175d4eSRafael J. Wysocki */ 33272175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 33372175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 33472175d4eSRafael J. Wysocki 335f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 336f265df55SRafael J. Wysocki if (link->consumer != consumer) 337f265df55SRafael J. Wysocki continue; 338f265df55SRafael J. Wysocki 339e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 340e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 3414c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 342e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 343e2f3cd83SRafael J. Wysocki } 344e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 34536003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 346e2f3cd83SRafael J. Wysocki } 347e2f3cd83SRafael J. Wysocki 34872175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 349515db266SRafael J. Wysocki link->flags |= DL_FLAG_STATELESS; 350ead18c23SLukas Wunner kref_get(&link->kref); 3519ed98953SRafael J. Wysocki goto out; 352ead18c23SLukas Wunner } 3539ed98953SRafael J. Wysocki 35472175d4eSRafael J. Wysocki /* 35572175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 35672175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 35772175d4eSRafael J. Wysocki * update the existing link to stay around longer. 35872175d4eSRafael J. Wysocki */ 35972175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 36072175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 36172175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 36272175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 36372175d4eSRafael J. Wysocki } 36472175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 36572175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 36672175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 36772175d4eSRafael J. Wysocki } 368515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 369515db266SRafael J. Wysocki kref_get(&link->kref); 370515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 371515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 372515db266SRafael J. Wysocki } 37372175d4eSRafael J. Wysocki goto out; 37472175d4eSRafael J. Wysocki } 37572175d4eSRafael J. Wysocki 37621d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 3779ed98953SRafael J. Wysocki if (!link) 3789ed98953SRafael J. Wysocki goto out; 3799ed98953SRafael J. Wysocki 380e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 381e2f3cd83SRafael J. Wysocki 382baa8809fSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 383e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 38436003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 385e2f3cd83SRafael J. Wysocki 3864c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 38721d5c57bSRafael J. Wysocki } 388e2f3cd83SRafael J. Wysocki 3899ed98953SRafael J. Wysocki get_device(supplier); 3909ed98953SRafael J. Wysocki link->supplier = supplier; 3919ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 3929ed98953SRafael J. Wysocki get_device(consumer); 3939ed98953SRafael J. Wysocki link->consumer = consumer; 3949ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 3959ed98953SRafael J. Wysocki link->flags = flags; 396ead18c23SLukas Wunner kref_init(&link->kref); 3979ed98953SRafael J. Wysocki 39864df1148SLukas Wunner /* Determine the initial link state. */ 399515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 4009ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 401515db266SRafael J. Wysocki else 402515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 4039ed98953SRafael J. Wysocki 4049ed98953SRafael J. Wysocki /* 40515cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 40615cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 40715cfb094SRafael J. Wysocki */ 40815cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 40915cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 41015cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 41115cfb094SRafael J. Wysocki 41215cfb094SRafael J. Wysocki /* 4139ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 4149ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 4159ed98953SRafael J. Wysocki * 4169ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 4179ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 4189ed98953SRafael J. Wysocki */ 4199ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 4209ed98953SRafael J. Wysocki 4219ed98953SRafael J. Wysocki list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 4229ed98953SRafael J. Wysocki list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 4239ed98953SRafael J. Wysocki 4248a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 4259ed98953SRafael J. Wysocki 4269ed98953SRafael J. Wysocki out: 4279ed98953SRafael J. Wysocki device_pm_unlock(); 4289ed98953SRafael J. Wysocki device_links_write_unlock(); 4295db25c9eSRafael J. Wysocki 430e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 4315db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 4325db25c9eSRafael J. Wysocki 4339ed98953SRafael J. Wysocki return link; 4349ed98953SRafael J. Wysocki } 4359ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 4369ed98953SRafael J. Wysocki 437e2ae9bccSSaravana Kannan /** 438e2ae9bccSSaravana Kannan * device_link_wait_for_supplier - Add device to wait_for_suppliers list 439e2ae9bccSSaravana Kannan * @consumer: Consumer device 440e2ae9bccSSaravana Kannan * 441e2ae9bccSSaravana Kannan * Marks the @consumer device as waiting for suppliers to become available by 442e2ae9bccSSaravana Kannan * adding it to the wait_for_suppliers list. The consumer device will never be 443e2ae9bccSSaravana Kannan * probed until it's removed from the wait_for_suppliers list. 444e2ae9bccSSaravana Kannan * 445e2ae9bccSSaravana Kannan * The caller is responsible for adding the links to the supplier devices once 446e2ae9bccSSaravana Kannan * they are available and removing the @consumer device from the 447e2ae9bccSSaravana Kannan * wait_for_suppliers list once links to all the suppliers have been created. 448e2ae9bccSSaravana Kannan * 449e2ae9bccSSaravana Kannan * This function is NOT meant to be called from the probe function of the 450e2ae9bccSSaravana Kannan * consumer but rather from code that creates/adds the consumer device. 451e2ae9bccSSaravana Kannan */ 452e2ae9bccSSaravana Kannan static void device_link_wait_for_supplier(struct device *consumer) 453e2ae9bccSSaravana Kannan { 454e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 455e2ae9bccSSaravana Kannan list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers); 456e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 457e2ae9bccSSaravana Kannan } 458e2ae9bccSSaravana Kannan 459e2ae9bccSSaravana Kannan /** 460e2ae9bccSSaravana Kannan * device_link_add_missing_supplier_links - Add links from consumer devices to 461e2ae9bccSSaravana Kannan * supplier devices, leaving any 462e2ae9bccSSaravana Kannan * consumer with inactive suppliers on 463e2ae9bccSSaravana Kannan * the wait_for_suppliers list 464e2ae9bccSSaravana Kannan * 465e2ae9bccSSaravana Kannan * Loops through all consumers waiting on suppliers and tries to add all their 466e2ae9bccSSaravana Kannan * supplier links. If that succeeds, the consumer device is removed from 467e2ae9bccSSaravana Kannan * wait_for_suppliers list. Otherwise, they are left in the wait_for_suppliers 468e2ae9bccSSaravana Kannan * list. Devices left on the wait_for_suppliers list will not be probed. 469e2ae9bccSSaravana Kannan * 470e2ae9bccSSaravana Kannan * The fwnode add_links callback is expected to return 0 if it has found and 471e2ae9bccSSaravana Kannan * added all the supplier links for the consumer device. It should return an 472e2ae9bccSSaravana Kannan * error if it isn't able to do so. 473e2ae9bccSSaravana Kannan * 474e2ae9bccSSaravana Kannan * The caller of device_link_wait_for_supplier() is expected to call this once 475e2ae9bccSSaravana Kannan * it's aware of potential suppliers becoming available. 476e2ae9bccSSaravana Kannan */ 477e2ae9bccSSaravana Kannan static void device_link_add_missing_supplier_links(void) 478e2ae9bccSSaravana Kannan { 479e2ae9bccSSaravana Kannan struct device *dev, *tmp; 480e2ae9bccSSaravana Kannan 481e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 482e2ae9bccSSaravana Kannan list_for_each_entry_safe(dev, tmp, &wait_for_suppliers, 483e2ae9bccSSaravana Kannan links.needs_suppliers) 484e2ae9bccSSaravana Kannan if (!fwnode_call_int_op(dev->fwnode, add_links, dev)) 485e2ae9bccSSaravana Kannan list_del_init(&dev->links.needs_suppliers); 486e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 487e2ae9bccSSaravana Kannan } 488e2ae9bccSSaravana Kannan 4899ed98953SRafael J. Wysocki static void device_link_free(struct device_link *link) 4909ed98953SRafael J. Wysocki { 491a1fdbfbbSRafael J. Wysocki while (refcount_dec_not_one(&link->rpm_active)) 492a1fdbfbbSRafael J. Wysocki pm_runtime_put(link->supplier); 493a1fdbfbbSRafael J. Wysocki 4949ed98953SRafael J. Wysocki put_device(link->consumer); 4959ed98953SRafael J. Wysocki put_device(link->supplier); 4969ed98953SRafael J. Wysocki kfree(link); 4979ed98953SRafael J. Wysocki } 4989ed98953SRafael J. Wysocki 4999ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 5009ed98953SRafael J. Wysocki static void __device_link_free_srcu(struct rcu_head *rhead) 5019ed98953SRafael J. Wysocki { 5029ed98953SRafael J. Wysocki device_link_free(container_of(rhead, struct device_link, rcu_head)); 5039ed98953SRafael J. Wysocki } 5049ed98953SRafael J. Wysocki 505ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5069ed98953SRafael J. Wysocki { 507ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 508ead18c23SLukas Wunner 5098a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 5109ed98953SRafael J. Wysocki dev_name(link->supplier)); 5119ed98953SRafael J. Wysocki 512baa8809fSRafael J. Wysocki if (link->flags & DL_FLAG_PM_RUNTIME) 513baa8809fSRafael J. Wysocki pm_runtime_drop_link(link->consumer); 514baa8809fSRafael J. Wysocki 5159ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 5169ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 5179ed98953SRafael J. Wysocki call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 5189ed98953SRafael J. Wysocki } 5199ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 520ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5219ed98953SRafael J. Wysocki { 522ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 523ead18c23SLukas Wunner 5249ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 5259ed98953SRafael J. Wysocki dev_name(link->supplier)); 5269ed98953SRafael J. Wysocki 527433986c2SLukas Wunner if (link->flags & DL_FLAG_PM_RUNTIME) 528433986c2SLukas Wunner pm_runtime_drop_link(link->consumer); 529433986c2SLukas Wunner 5309ed98953SRafael J. Wysocki list_del(&link->s_node); 5319ed98953SRafael J. Wysocki list_del(&link->c_node); 5329ed98953SRafael J. Wysocki device_link_free(link); 5339ed98953SRafael J. Wysocki } 5349ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 5359ed98953SRafael J. Wysocki 53672175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 53772175d4eSRafael J. Wysocki { 53872175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 53972175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 54072175d4eSRafael J. Wysocki else 54172175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 54272175d4eSRafael J. Wysocki } 54372175d4eSRafael J. Wysocki 5449ed98953SRafael J. Wysocki /** 54572175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 5469ed98953SRafael J. Wysocki * @link: Device link to delete. 5479ed98953SRafael J. Wysocki * 5489ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 549ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 550ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 551ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 5529ed98953SRafael J. Wysocki */ 5539ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 5549ed98953SRafael J. Wysocki { 5559ed98953SRafael J. Wysocki device_links_write_lock(); 5569ed98953SRafael J. Wysocki device_pm_lock(); 55772175d4eSRafael J. Wysocki device_link_put_kref(link); 5589ed98953SRafael J. Wysocki device_pm_unlock(); 5599ed98953SRafael J. Wysocki device_links_write_unlock(); 5609ed98953SRafael J. Wysocki } 5619ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 5629ed98953SRafael J. Wysocki 563d8842211Spascal paillet /** 56472175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 565d8842211Spascal paillet * @consumer: Consumer end of the link. 566d8842211Spascal paillet * @supplier: Supplier end of the link. 567d8842211Spascal paillet * 568d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 569d8842211Spascal paillet * PM. 570d8842211Spascal paillet */ 571d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 572d8842211Spascal paillet { 573d8842211Spascal paillet struct device_link *link; 574d8842211Spascal paillet 575d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 576d8842211Spascal paillet return; 577d8842211Spascal paillet 578d8842211Spascal paillet device_links_write_lock(); 579d8842211Spascal paillet device_pm_lock(); 580d8842211Spascal paillet 581d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 582d8842211Spascal paillet if (link->consumer == consumer) { 58372175d4eSRafael J. Wysocki device_link_put_kref(link); 584d8842211Spascal paillet break; 585d8842211Spascal paillet } 586d8842211Spascal paillet } 587d8842211Spascal paillet 588d8842211Spascal paillet device_pm_unlock(); 589d8842211Spascal paillet device_links_write_unlock(); 590d8842211Spascal paillet } 591d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 592d8842211Spascal paillet 5939ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 5949ed98953SRafael J. Wysocki { 5959ed98953SRafael J. Wysocki struct device_link *link; 5969ed98953SRafael J. Wysocki 5979ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) 5989ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE) 5999ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 6009ed98953SRafael J. Wysocki } 6019ed98953SRafael J. Wysocki 6029ed98953SRafael J. Wysocki /** 6039ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 6049ed98953SRafael J. Wysocki * @dev: Consumer device. 6059ed98953SRafael J. Wysocki * 6069ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 6079ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 6089ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 6099ed98953SRafael J. Wysocki * 6109ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 6119ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 6129ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 6139ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 6149ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 6159ed98953SRafael J. Wysocki * 616515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 6179ed98953SRafael J. Wysocki */ 6189ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 6199ed98953SRafael J. Wysocki { 6209ed98953SRafael J. Wysocki struct device_link *link; 6219ed98953SRafael J. Wysocki int ret = 0; 6229ed98953SRafael J. Wysocki 623e2ae9bccSSaravana Kannan /* 624e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 625e2ae9bccSSaravana Kannan * probe. 626e2ae9bccSSaravana Kannan */ 627e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 628e2ae9bccSSaravana Kannan if (!list_empty(&dev->links.needs_suppliers)) { 629e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 630e2ae9bccSSaravana Kannan return -EPROBE_DEFER; 631e2ae9bccSSaravana Kannan } 632e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 633e2ae9bccSSaravana Kannan 6349ed98953SRafael J. Wysocki device_links_write_lock(); 6359ed98953SRafael J. Wysocki 6369ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 637515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 6389ed98953SRafael J. Wysocki continue; 6399ed98953SRafael J. Wysocki 6409ed98953SRafael J. Wysocki if (link->status != DL_STATE_AVAILABLE) { 6419ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 6429ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 6439ed98953SRafael J. Wysocki break; 6449ed98953SRafael J. Wysocki } 6459ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 6469ed98953SRafael J. Wysocki } 6479ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 6489ed98953SRafael J. Wysocki 6499ed98953SRafael J. Wysocki device_links_write_unlock(); 6509ed98953SRafael J. Wysocki return ret; 6519ed98953SRafael J. Wysocki } 6529ed98953SRafael J. Wysocki 653fc5a251dSSaravana Kannan static void __device_links_supplier_sync_state(struct device *dev) 654fc5a251dSSaravana Kannan { 655fc5a251dSSaravana Kannan struct device_link *link; 656fc5a251dSSaravana Kannan 657fc5a251dSSaravana Kannan if (dev->state_synced) 658fc5a251dSSaravana Kannan return; 659fc5a251dSSaravana Kannan 660fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 661fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 662fc5a251dSSaravana Kannan continue; 663fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 664fc5a251dSSaravana Kannan return; 665fc5a251dSSaravana Kannan } 666fc5a251dSSaravana Kannan 667fc5a251dSSaravana Kannan if (dev->bus->sync_state) 668fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 669fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 670fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 671fc5a251dSSaravana Kannan 672fc5a251dSSaravana Kannan dev->state_synced = true; 673fc5a251dSSaravana Kannan } 674fc5a251dSSaravana Kannan 675fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 676fc5a251dSSaravana Kannan { 677fc5a251dSSaravana Kannan device_links_write_lock(); 678fc5a251dSSaravana Kannan defer_sync_state_count++; 679fc5a251dSSaravana Kannan device_links_write_unlock(); 680fc5a251dSSaravana Kannan } 681fc5a251dSSaravana Kannan 682fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 683fc5a251dSSaravana Kannan { 684fc5a251dSSaravana Kannan struct device *dev, *tmp; 685fc5a251dSSaravana Kannan 686fc5a251dSSaravana Kannan device_links_write_lock(); 687fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 688fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 689fc5a251dSSaravana Kannan goto out; 690fc5a251dSSaravana Kannan } 691fc5a251dSSaravana Kannan defer_sync_state_count--; 692fc5a251dSSaravana Kannan if (defer_sync_state_count) 693fc5a251dSSaravana Kannan goto out; 694fc5a251dSSaravana Kannan 695fc5a251dSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 696fc5a251dSSaravana Kannan __device_links_supplier_sync_state(dev); 697fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 698fc5a251dSSaravana Kannan } 699fc5a251dSSaravana Kannan out: 700fc5a251dSSaravana Kannan device_links_write_unlock(); 701fc5a251dSSaravana Kannan } 702fc5a251dSSaravana Kannan 703fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 704fc5a251dSSaravana Kannan { 705fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 706fc5a251dSSaravana Kannan return 0; 707fc5a251dSSaravana Kannan } 708fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 709fc5a251dSSaravana Kannan 710fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 711fc5a251dSSaravana Kannan { 712fc5a251dSSaravana Kannan if (list_empty(&sup->links.defer_sync)) 713fc5a251dSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 714fc5a251dSSaravana Kannan } 715fc5a251dSSaravana Kannan 7169ed98953SRafael J. Wysocki /** 7179ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 7189ed98953SRafael J. Wysocki * @dev: Device to update the links for. 7199ed98953SRafael J. Wysocki * 7209ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 7219ed98953SRafael J. Wysocki * consumers by changing their status to "available". 7229ed98953SRafael J. Wysocki * 7239ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 7249ed98953SRafael J. Wysocki * 725515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 7269ed98953SRafael J. Wysocki */ 7279ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 7289ed98953SRafael J. Wysocki { 7299ed98953SRafael J. Wysocki struct device_link *link; 7309ed98953SRafael J. Wysocki 7319ed98953SRafael J. Wysocki device_links_write_lock(); 7329ed98953SRafael J. Wysocki 7339ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 734515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 7359ed98953SRafael J. Wysocki continue; 7369ed98953SRafael J. Wysocki 73715cfb094SRafael J. Wysocki /* 73815cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 73915cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 74015cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 74115cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 74215cfb094SRafael J. Wysocki */ 74315cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 74415cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 74515cfb094SRafael J. Wysocki continue; 74615cfb094SRafael J. Wysocki 7479ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 7489ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 749e7dd4010SRafael J. Wysocki 750e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 751e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 7529ed98953SRafael J. Wysocki } 7539ed98953SRafael J. Wysocki 7549ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 755515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 7569ed98953SRafael J. Wysocki continue; 7579ed98953SRafael J. Wysocki 7589ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 7599ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 760fc5a251dSSaravana Kannan 761fc5a251dSSaravana Kannan if (defer_sync_state_count) 762fc5a251dSSaravana Kannan __device_links_supplier_defer_sync(link->supplier); 763fc5a251dSSaravana Kannan else 764fc5a251dSSaravana Kannan __device_links_supplier_sync_state(link->supplier); 7659ed98953SRafael J. Wysocki } 7669ed98953SRafael J. Wysocki 7679ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 7689ed98953SRafael J. Wysocki 7699ed98953SRafael J. Wysocki device_links_write_unlock(); 7709ed98953SRafael J. Wysocki } 7719ed98953SRafael J. Wysocki 772515db266SRafael J. Wysocki static void device_link_drop_managed(struct device_link *link) 773515db266SRafael J. Wysocki { 774515db266SRafael J. Wysocki link->flags &= ~DL_FLAG_MANAGED; 775515db266SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_NONE); 776515db266SRafael J. Wysocki kref_put(&link->kref, __device_link_del); 777515db266SRafael J. Wysocki } 778515db266SRafael J. Wysocki 7799ed98953SRafael J. Wysocki /** 7809ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 7819ed98953SRafael J. Wysocki * @dev: Device without a drvier. 7829ed98953SRafael J. Wysocki * 7839ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 7849ed98953SRafael J. Wysocki * 7859ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 7869ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 7879ed98953SRafael J. Wysocki * case they need not be updated. 7889ed98953SRafael J. Wysocki * 789515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 7909ed98953SRafael J. Wysocki */ 7919ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 7929ed98953SRafael J. Wysocki { 7939ed98953SRafael J. Wysocki struct device_link *link, *ln; 7949ed98953SRafael J. Wysocki 7959ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 796515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 7979ed98953SRafael J. Wysocki continue; 7989ed98953SRafael J. Wysocki 799e88728f4SVivek Gautam if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 800515db266SRafael J. Wysocki device_link_drop_managed(link); 80115cfb094SRafael J. Wysocki else if (link->status == DL_STATE_CONSUMER_PROBE || 80215cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 8039ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 8049ed98953SRafael J. Wysocki } 8059ed98953SRafael J. Wysocki 8069ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 8079ed98953SRafael J. Wysocki } 8089ed98953SRafael J. Wysocki 80915cfb094SRafael J. Wysocki /** 81015cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 81115cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 81215cfb094SRafael J. Wysocki * 81315cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 81415cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 81515cfb094SRafael J. Wysocki * appropriate. 81615cfb094SRafael J. Wysocki * 817515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 81815cfb094SRafael J. Wysocki */ 8199ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 8209ed98953SRafael J. Wysocki { 82115cfb094SRafael J. Wysocki struct device_link *link; 82215cfb094SRafael J. Wysocki 8239ed98953SRafael J. Wysocki device_links_write_lock(); 82415cfb094SRafael J. Wysocki 82515cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 826515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 82715cfb094SRafael J. Wysocki continue; 82815cfb094SRafael J. Wysocki 82915cfb094SRafael J. Wysocki /* 83015cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 83115cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 83215cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 83315cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 83415cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 83515cfb094SRafael J. Wysocki */ 83615cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 83715cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 83815cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 83915cfb094SRafael J. Wysocki } 84015cfb094SRafael J. Wysocki 8419ed98953SRafael J. Wysocki __device_links_no_driver(dev); 84215cfb094SRafael J. Wysocki 8439ed98953SRafael J. Wysocki device_links_write_unlock(); 8449ed98953SRafael J. Wysocki } 8459ed98953SRafael J. Wysocki 8469ed98953SRafael J. Wysocki /** 8479ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 8489ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 8499ed98953SRafael J. Wysocki * 8509ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 8519ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 8529ed98953SRafael J. Wysocki * appropriate. 8539ed98953SRafael J. Wysocki * 854515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 8559ed98953SRafael J. Wysocki */ 8569ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 8579ed98953SRafael J. Wysocki { 858c8d50986SRafael J. Wysocki struct device_link *link, *ln; 8599ed98953SRafael J. Wysocki 8609ed98953SRafael J. Wysocki device_links_write_lock(); 8619ed98953SRafael J. Wysocki 862c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 863515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 8649ed98953SRafael J. Wysocki continue; 8659ed98953SRafael J. Wysocki 866e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 8679ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 8681689cac5SVivek Gautam 8691689cac5SVivek Gautam /* 8701689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 8711689cac5SVivek Gautam * devices that are not active, i.e. where the link state 8721689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 8731689cac5SVivek Gautam */ 8741689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 8751689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 876515db266SRafael J. Wysocki device_link_drop_managed(link); 8771689cac5SVivek Gautam 8789ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 8799ed98953SRafael J. Wysocki } 8809ed98953SRafael J. Wysocki 881fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 8829ed98953SRafael J. Wysocki __device_links_no_driver(dev); 8839ed98953SRafael J. Wysocki 8849ed98953SRafael J. Wysocki device_links_write_unlock(); 8859ed98953SRafael J. Wysocki } 8869ed98953SRafael J. Wysocki 8879ed98953SRafael J. Wysocki /** 8889ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 8899ed98953SRafael J. Wysocki * @dev: Device to check. 8909ed98953SRafael J. Wysocki * 8919ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 8929ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 8939ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 8949ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 8959ed98953SRafael J. Wysocki * successfully going forward. 8969ed98953SRafael J. Wysocki * 8979ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 8989ed98953SRafael J. Wysocki * 899515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9009ed98953SRafael J. Wysocki */ 9019ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 9029ed98953SRafael J. Wysocki { 9039ed98953SRafael J. Wysocki struct device_link *link; 9049ed98953SRafael J. Wysocki bool ret = false; 9059ed98953SRafael J. Wysocki 9069ed98953SRafael J. Wysocki device_links_write_lock(); 9079ed98953SRafael J. Wysocki 9089ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 909515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 9109ed98953SRafael J. Wysocki continue; 9119ed98953SRafael J. Wysocki 9129ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 9139ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 9149ed98953SRafael J. Wysocki ret = true; 9159ed98953SRafael J. Wysocki break; 9169ed98953SRafael J. Wysocki } 9179ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 9189ed98953SRafael J. Wysocki } 9199ed98953SRafael J. Wysocki 9209ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 9219ed98953SRafael J. Wysocki 9229ed98953SRafael J. Wysocki device_links_write_unlock(); 9239ed98953SRafael J. Wysocki return ret; 9249ed98953SRafael J. Wysocki } 9259ed98953SRafael J. Wysocki 9269ed98953SRafael J. Wysocki /** 9279ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 9289ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 9299ed98953SRafael J. Wysocki * 9309ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 9319ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 9329ed98953SRafael J. Wysocki * and start over. 9339ed98953SRafael J. Wysocki * 9349ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 9359ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 9369ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 9379ed98953SRafael J. Wysocki * changed the state of the link already). 9389ed98953SRafael J. Wysocki * 939515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9409ed98953SRafael J. Wysocki */ 9419ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 9429ed98953SRafael J. Wysocki { 9439ed98953SRafael J. Wysocki struct device_link *link; 9449ed98953SRafael J. Wysocki 9459ed98953SRafael J. Wysocki start: 9469ed98953SRafael J. Wysocki device_links_write_lock(); 9479ed98953SRafael J. Wysocki 9489ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 9499ed98953SRafael J. Wysocki enum device_link_state status; 9509ed98953SRafael J. Wysocki 951515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 9529ed98953SRafael J. Wysocki continue; 9539ed98953SRafael J. Wysocki 9549ed98953SRafael J. Wysocki status = link->status; 9559ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 9569ed98953SRafael J. Wysocki device_links_write_unlock(); 9579ed98953SRafael J. Wysocki 9589ed98953SRafael J. Wysocki wait_for_device_probe(); 9599ed98953SRafael J. Wysocki goto start; 9609ed98953SRafael J. Wysocki } 9619ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 9629ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 9639ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 9649ed98953SRafael J. Wysocki 9659ed98953SRafael J. Wysocki get_device(consumer); 9669ed98953SRafael J. Wysocki 9679ed98953SRafael J. Wysocki device_links_write_unlock(); 9689ed98953SRafael J. Wysocki 9699ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 9709ed98953SRafael J. Wysocki consumer->parent); 9719ed98953SRafael J. Wysocki put_device(consumer); 9729ed98953SRafael J. Wysocki goto start; 9739ed98953SRafael J. Wysocki } 9749ed98953SRafael J. Wysocki } 9759ed98953SRafael J. Wysocki 9769ed98953SRafael J. Wysocki device_links_write_unlock(); 9779ed98953SRafael J. Wysocki } 9789ed98953SRafael J. Wysocki 9799ed98953SRafael J. Wysocki /** 9809ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 9819ed98953SRafael J. Wysocki * @dev: Target device. 9829ed98953SRafael J. Wysocki */ 9839ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 9849ed98953SRafael J. Wysocki { 9859ed98953SRafael J. Wysocki struct device_link *link, *ln; 9869ed98953SRafael J. Wysocki 987e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 988e2ae9bccSSaravana Kannan list_del(&dev->links.needs_suppliers); 989e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 990e2ae9bccSSaravana Kannan 9919ed98953SRafael J. Wysocki /* 9929ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 9939ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 9949ed98953SRafael J. Wysocki */ 9959ed98953SRafael J. Wysocki device_links_write_lock(); 9969ed98953SRafael J. Wysocki 9979ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 9989ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 999ead18c23SLukas Wunner __device_link_del(&link->kref); 10009ed98953SRafael J. Wysocki } 10019ed98953SRafael J. Wysocki 10029ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 10039ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 10049ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1005ead18c23SLukas Wunner __device_link_del(&link->kref); 10069ed98953SRafael J. Wysocki } 10079ed98953SRafael J. Wysocki 10089ed98953SRafael J. Wysocki device_links_write_unlock(); 10099ed98953SRafael J. Wysocki } 10109ed98953SRafael J. Wysocki 10119ed98953SRafael J. Wysocki /* Device links support end. */ 10129ed98953SRafael J. Wysocki 10131da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 10141da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 1015e105b8bfSDan Williams static struct kobject *dev_kobj; 1016e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 1017e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 10181da177e4SLinus Torvalds 10195e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 10205e33bc41SRafael J. Wysocki 10215e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 10225e33bc41SRafael J. Wysocki { 10235e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 10245e33bc41SRafael J. Wysocki } 10255e33bc41SRafael J. Wysocki 10265e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 10275e33bc41SRafael J. Wysocki { 10285e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 10295e33bc41SRafael J. Wysocki } 10305e33bc41SRafael J. Wysocki 10315e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 10325e33bc41SRafael J. Wysocki { 10335e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 10345e33bc41SRafael J. Wysocki return 0; 10355e33bc41SRafael J. Wysocki 10365e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 10375e33bc41SRafael J. Wysocki msleep(5); 10385e33bc41SRafael J. Wysocki return restart_syscall(); 10395e33bc41SRafael J. Wysocki } 10405e33bc41SRafael J. Wysocki 10414e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 10424e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 10434e886c29SGreg Kroah-Hartman { 10444e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 10454e886c29SGreg Kroah-Hartman } 10464e886c29SGreg Kroah-Hartman #else 10474e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 10484e886c29SGreg Kroah-Hartman { 10494e886c29SGreg Kroah-Hartman return 1; 10504e886c29SGreg Kroah-Hartman } 10514e886c29SGreg Kroah-Hartman #endif 10521da177e4SLinus Torvalds 105307de0e86SHeikki Krogerus static int 105407de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 105507de0e86SHeikki Krogerus { 10567847a145SHeikki Krogerus int ret; 10577847a145SHeikki Krogerus 10587847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 10597847a145SHeikki Krogerus if (ret) 10607847a145SHeikki Krogerus return ret; 10617847a145SHeikki Krogerus 106259abd836SHeikki Krogerus ret = software_node_notify(dev, action); 106359abd836SHeikki Krogerus if (ret) 106459abd836SHeikki Krogerus return ret; 106559abd836SHeikki Krogerus 106607de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 106707de0e86SHeikki Krogerus platform_notify(dev); 106807de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 106907de0e86SHeikki Krogerus platform_notify_remove(dev); 107007de0e86SHeikki Krogerus return 0; 107107de0e86SHeikki Krogerus } 107207de0e86SHeikki Krogerus 10733e95637aSAlan Stern /** 10743e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 10753e95637aSAlan Stern * @dev: struct device to get the name of 10763e95637aSAlan Stern * 10773e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 10789169c012Syan * the device is not bound to a driver, it will return the name of the bus 10793e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 10803e95637aSAlan Stern * string will be returned. 10813e95637aSAlan Stern */ 1082bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 10833e95637aSAlan Stern { 10843589972eSAlan Stern struct device_driver *drv; 10853589972eSAlan Stern 10863589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 10873589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 10883589972eSAlan Stern * never change once they are set, so they don't need special care. 10893589972eSAlan Stern */ 10906aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 10913589972eSAlan Stern return drv ? drv->name : 1092a456b702SJean Delvare (dev->bus ? dev->bus->name : 1093a456b702SJean Delvare (dev->class ? dev->class->name : "")); 10943e95637aSAlan Stern } 1095310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 10963e95637aSAlan Stern 10971da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 10981da177e4SLinus Torvalds 10994a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 11004a3ad20cSGreg Kroah-Hartman char *buf) 11011da177e4SLinus Torvalds { 11021da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1103b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 11044a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 11051da177e4SLinus Torvalds 11061da177e4SLinus Torvalds if (dev_attr->show) 110754b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 1108815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 1109a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 1110a52668c6SSergey Senozhatsky dev_attr->show); 1111815d2d50SAndrew Morton } 11121da177e4SLinus Torvalds return ret; 11131da177e4SLinus Torvalds } 11141da177e4SLinus Torvalds 11154a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 11161da177e4SLinus Torvalds const char *buf, size_t count) 11171da177e4SLinus Torvalds { 11181da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1119b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 11204a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds if (dev_attr->store) 112354b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 11241da177e4SLinus Torvalds return ret; 11251da177e4SLinus Torvalds } 11261da177e4SLinus Torvalds 112752cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 11281da177e4SLinus Torvalds .show = dev_attr_show, 11291da177e4SLinus Torvalds .store = dev_attr_store, 11301da177e4SLinus Torvalds }; 11311da177e4SLinus Torvalds 1132ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 1133ca22e56dSKay Sievers 1134ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 1135ca22e56dSKay Sievers struct device_attribute *attr, 1136ca22e56dSKay Sievers const char *buf, size_t size) 1137ca22e56dSKay Sievers { 1138ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1139f88184bfSKaitao cheng int ret; 1140f88184bfSKaitao cheng unsigned long new; 1141f88184bfSKaitao cheng 1142f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 1143f88184bfSKaitao cheng if (ret) 1144f88184bfSKaitao cheng return ret; 1145ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 1146ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1147ca22e56dSKay Sievers return size; 1148ca22e56dSKay Sievers } 1149ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 1150ca22e56dSKay Sievers 1151ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 1152ca22e56dSKay Sievers struct device_attribute *attr, 1153ca22e56dSKay Sievers char *buf) 1154ca22e56dSKay Sievers { 1155ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1156ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 1157ca22e56dSKay Sievers } 1158ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 1159ca22e56dSKay Sievers 1160ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 1161ca22e56dSKay Sievers struct device_attribute *attr, 1162ca22e56dSKay Sievers const char *buf, size_t size) 1163ca22e56dSKay Sievers { 1164ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1165f88184bfSKaitao cheng int ret; 1166f88184bfSKaitao cheng long new; 1167f88184bfSKaitao cheng 1168f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 1169f88184bfSKaitao cheng if (ret) 1170f88184bfSKaitao cheng return ret; 1171f88184bfSKaitao cheng 1172f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 1173ca22e56dSKay Sievers return -EINVAL; 1174ca22e56dSKay Sievers *(int *)(ea->var) = new; 1175ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1176ca22e56dSKay Sievers return size; 1177ca22e56dSKay Sievers } 1178ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 1179ca22e56dSKay Sievers 1180ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 1181ca22e56dSKay Sievers struct device_attribute *attr, 1182ca22e56dSKay Sievers char *buf) 1183ca22e56dSKay Sievers { 1184ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1185ca22e56dSKay Sievers 1186ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 1187ca22e56dSKay Sievers } 1188ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 11891da177e4SLinus Torvalds 119091872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 119191872392SBorislav Petkov const char *buf, size_t size) 119291872392SBorislav Petkov { 119391872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 119491872392SBorislav Petkov 119591872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 119691872392SBorislav Petkov return -EINVAL; 119791872392SBorislav Petkov 119891872392SBorislav Petkov return size; 119991872392SBorislav Petkov } 120091872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 120191872392SBorislav Petkov 120291872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 120391872392SBorislav Petkov char *buf) 120491872392SBorislav Petkov { 120591872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 120691872392SBorislav Petkov 120791872392SBorislav Petkov return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 120891872392SBorislav Petkov } 120991872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 121091872392SBorislav Petkov 12111da177e4SLinus Torvalds /** 12121da177e4SLinus Torvalds * device_release - free device structure. 12131da177e4SLinus Torvalds * @kobj: device's kobject. 12141da177e4SLinus Torvalds * 12151da177e4SLinus Torvalds * This is called once the reference count for the object 12161da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 12171da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 12181da177e4SLinus Torvalds */ 12191da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 12201da177e4SLinus Torvalds { 1221b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1222fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 12231da177e4SLinus Torvalds 1224a525a3ddSMing Lei /* 1225a525a3ddSMing Lei * Some platform devices are driven without driver attached 1226a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 1227a525a3ddSMing Lei * all resources are released. 1228a525a3ddSMing Lei * 1229a525a3ddSMing Lei * Drivers still can add resources into device after device 1230a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 1231a525a3ddSMing Lei * possible memory leak. 1232a525a3ddSMing Lei */ 1233a525a3ddSMing Lei devres_release_all(dev); 1234a525a3ddSMing Lei 12351da177e4SLinus Torvalds if (dev->release) 12361da177e4SLinus Torvalds dev->release(dev); 1237f9f852dfSKay Sievers else if (dev->type && dev->type->release) 1238f9f852dfSKay Sievers dev->type->release(dev); 12392620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 12402620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 1241f810a5cfSArjan van de Ven else 1242186bddb2SEzequiel Garcia WARN(1, KERN_ERR "Device '%s' does not have a release() function, it is broken and must be fixed. See Documentation/kobject.txt.\n", 12431e0b2cf9SKay Sievers dev_name(dev)); 1244fb069a5dSGreg Kroah-Hartman kfree(p); 12451da177e4SLinus Torvalds } 12461da177e4SLinus Torvalds 1247bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 1248bc451f20SEric W. Biederman { 1249b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1250bc451f20SEric W. Biederman const void *ns = NULL; 1251bc451f20SEric W. Biederman 1252bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 1253bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 1254bc451f20SEric W. Biederman 1255bc451f20SEric W. Biederman return ns; 1256bc451f20SEric W. Biederman } 1257bc451f20SEric W. Biederman 12589944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 12599944e894SDmitry Torokhov { 12609944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 12619944e894SDmitry Torokhov 12629944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 12639944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 12649944e894SDmitry Torokhov } 12659944e894SDmitry Torokhov 12668f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 12671da177e4SLinus Torvalds .release = device_release, 12681da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 1269bc451f20SEric W. Biederman .namespace = device_namespace, 12709944e894SDmitry Torokhov .get_ownership = device_get_ownership, 12711da177e4SLinus Torvalds }; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds 1274312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 12751da177e4SLinus Torvalds { 12761da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 12771da177e4SLinus Torvalds 12788f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 1279b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 12801da177e4SLinus Torvalds if (dev->bus) 12811da177e4SLinus Torvalds return 1; 128223681e47SGreg Kroah-Hartman if (dev->class) 128323681e47SGreg Kroah-Hartman return 1; 12841da177e4SLinus Torvalds } 12851da177e4SLinus Torvalds return 0; 12861da177e4SLinus Torvalds } 12871da177e4SLinus Torvalds 1288312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 12891da177e4SLinus Torvalds { 1290b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 12911da177e4SLinus Torvalds 129223681e47SGreg Kroah-Hartman if (dev->bus) 12931da177e4SLinus Torvalds return dev->bus->name; 129423681e47SGreg Kroah-Hartman if (dev->class) 129523681e47SGreg Kroah-Hartman return dev->class->name; 129623681e47SGreg Kroah-Hartman return NULL; 12971da177e4SLinus Torvalds } 12981da177e4SLinus Torvalds 12997eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 13007eff2e7aSKay Sievers struct kobj_uevent_env *env) 13011da177e4SLinus Torvalds { 1302b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 13031da177e4SLinus Torvalds int retval = 0; 13041da177e4SLinus Torvalds 13056fcf53acSKay Sievers /* add device node properties if present */ 130623681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 13076fcf53acSKay Sievers const char *tmp; 13086fcf53acSKay Sievers const char *name; 13092c9ede55SAl Viro umode_t mode = 0; 13104e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 13114e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 13126fcf53acSKay Sievers 13137eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 13147eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 13153c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 13166fcf53acSKay Sievers if (name) { 13176fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 1318e454cea2SKay Sievers if (mode) 1319e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 13204e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 13214e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 13224e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 13234e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 13243c2670e6SKay Sievers kfree(tmp); 13256fcf53acSKay Sievers } 132623681e47SGreg Kroah-Hartman } 132723681e47SGreg Kroah-Hartman 1328414264f9SKay Sievers if (dev->type && dev->type->name) 13297eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 1330414264f9SKay Sievers 1331239378f1SKay Sievers if (dev->driver) 13327eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 1333239378f1SKay Sievers 133407d57a32SGrant Likely /* Add common DT information about the device */ 133507d57a32SGrant Likely of_device_uevent(dev, env); 133607d57a32SGrant Likely 13371da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 13387eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 13397eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 1340f9f852dfSKay Sievers if (retval) 13417dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 13421e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 13431da177e4SLinus Torvalds } 13441da177e4SLinus Torvalds 13452620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 13467eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 13477eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 1348f9f852dfSKay Sievers if (retval) 13497dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 13501e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 13512b3a302aSHarvey Harrison __func__, retval); 13522620efefSGreg Kroah-Hartman } 1353f9f852dfSKay Sievers 1354eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 13557eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 13567eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 1357f9f852dfSKay Sievers if (retval) 13587dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 13591e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 13602b3a302aSHarvey Harrison __func__, retval); 13612620efefSGreg Kroah-Hartman } 13622620efefSGreg Kroah-Hartman 13631da177e4SLinus Torvalds return retval; 13641da177e4SLinus Torvalds } 13651da177e4SLinus Torvalds 13669cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 1367312c004dSKay Sievers .filter = dev_uevent_filter, 1368312c004dSKay Sievers .name = dev_uevent_name, 1369312c004dSKay Sievers .uevent = dev_uevent, 13701da177e4SLinus Torvalds }; 13711da177e4SLinus Torvalds 1372c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 137316574dccSKay Sievers char *buf) 137416574dccSKay Sievers { 137516574dccSKay Sievers struct kobject *top_kobj; 137616574dccSKay Sievers struct kset *kset; 13777eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 137816574dccSKay Sievers int i; 137916574dccSKay Sievers size_t count = 0; 138016574dccSKay Sievers int retval; 138116574dccSKay Sievers 138216574dccSKay Sievers /* search the kset, the device belongs to */ 138316574dccSKay Sievers top_kobj = &dev->kobj; 13845c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 138516574dccSKay Sievers top_kobj = top_kobj->parent; 138616574dccSKay Sievers if (!top_kobj->kset) 138716574dccSKay Sievers goto out; 13885c5daf65SKay Sievers 138916574dccSKay Sievers kset = top_kobj->kset; 139016574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 139116574dccSKay Sievers goto out; 139216574dccSKay Sievers 139316574dccSKay Sievers /* respect filter */ 139416574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 139516574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 139616574dccSKay Sievers goto out; 139716574dccSKay Sievers 13987eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 13997eff2e7aSKay Sievers if (!env) 1400c7308c81SGreg Kroah-Hartman return -ENOMEM; 1401c7308c81SGreg Kroah-Hartman 140216574dccSKay Sievers /* let the kset specific function add its keys */ 14037eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 140416574dccSKay Sievers if (retval) 140516574dccSKay Sievers goto out; 140616574dccSKay Sievers 140716574dccSKay Sievers /* copy keys to file */ 14087eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 14097eff2e7aSKay Sievers count += sprintf(&buf[count], "%s\n", env->envp[i]); 141016574dccSKay Sievers out: 14117eff2e7aSKay Sievers kfree(env); 141216574dccSKay Sievers return count; 141316574dccSKay Sievers } 141416574dccSKay Sievers 1415c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 1416a7fd6706SKay Sievers const char *buf, size_t count) 1417a7fd6706SKay Sievers { 1418df44b479SPeter Rajnoha int rc; 1419df44b479SPeter Rajnoha 1420df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 1421df44b479SPeter Rajnoha 1422df44b479SPeter Rajnoha if (rc) { 1423f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 1424df44b479SPeter Rajnoha return rc; 1425df44b479SPeter Rajnoha } 142660a96a59SKay Sievers 1427a7fd6706SKay Sievers return count; 1428a7fd6706SKay Sievers } 1429c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 1430a7fd6706SKay Sievers 1431c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 14324f3549d7SRafael J. Wysocki char *buf) 14334f3549d7SRafael J. Wysocki { 14344f3549d7SRafael J. Wysocki bool val; 14354f3549d7SRafael J. Wysocki 14365e33bc41SRafael J. Wysocki device_lock(dev); 14374f3549d7SRafael J. Wysocki val = !dev->offline; 14385e33bc41SRafael J. Wysocki device_unlock(dev); 14394f3549d7SRafael J. Wysocki return sprintf(buf, "%u\n", val); 14404f3549d7SRafael J. Wysocki } 14414f3549d7SRafael J. Wysocki 1442c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 14434f3549d7SRafael J. Wysocki const char *buf, size_t count) 14444f3549d7SRafael J. Wysocki { 14454f3549d7SRafael J. Wysocki bool val; 14464f3549d7SRafael J. Wysocki int ret; 14474f3549d7SRafael J. Wysocki 14484f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 14494f3549d7SRafael J. Wysocki if (ret < 0) 14504f3549d7SRafael J. Wysocki return ret; 14514f3549d7SRafael J. Wysocki 14525e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 14535e33bc41SRafael J. Wysocki if (ret) 14545e33bc41SRafael J. Wysocki return ret; 14555e33bc41SRafael J. Wysocki 14564f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 14574f3549d7SRafael J. Wysocki unlock_device_hotplug(); 14584f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 14594f3549d7SRafael J. Wysocki } 1460c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 14614f3549d7SRafael J. Wysocki 1462fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 1463621a1672SDmitry Torokhov { 14643e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 1465621a1672SDmitry Torokhov } 1466a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 1467621a1672SDmitry Torokhov 1468fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 1469a4dbd674SDavid Brownell const struct attribute_group **groups) 1470621a1672SDmitry Torokhov { 14713e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 1472621a1672SDmitry Torokhov } 1473a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 1474de0ff00dSGreg Kroah-Hartman 147557b8ff07SDmitry Torokhov union device_attr_group_devres { 147657b8ff07SDmitry Torokhov const struct attribute_group *group; 147757b8ff07SDmitry Torokhov const struct attribute_group **groups; 147857b8ff07SDmitry Torokhov }; 147957b8ff07SDmitry Torokhov 148057b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 148157b8ff07SDmitry Torokhov { 148257b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 148357b8ff07SDmitry Torokhov } 148457b8ff07SDmitry Torokhov 148557b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 148657b8ff07SDmitry Torokhov { 148757b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 148857b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 148957b8ff07SDmitry Torokhov 149057b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 149157b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 149257b8ff07SDmitry Torokhov } 149357b8ff07SDmitry Torokhov 149457b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 149557b8ff07SDmitry Torokhov { 149657b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 149757b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 149857b8ff07SDmitry Torokhov 149957b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 150057b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 150157b8ff07SDmitry Torokhov } 150257b8ff07SDmitry Torokhov 150357b8ff07SDmitry Torokhov /** 150457b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 150557b8ff07SDmitry Torokhov * @dev: The device to create the group for 150657b8ff07SDmitry Torokhov * @grp: The attribute group to create 150757b8ff07SDmitry Torokhov * 150857b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 150957b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 151057b8ff07SDmitry Torokhov * 151157b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 151257b8ff07SDmitry Torokhov */ 151357b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 151457b8ff07SDmitry Torokhov { 151557b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 151657b8ff07SDmitry Torokhov int error; 151757b8ff07SDmitry Torokhov 151857b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 151957b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 152057b8ff07SDmitry Torokhov if (!devres) 152157b8ff07SDmitry Torokhov return -ENOMEM; 152257b8ff07SDmitry Torokhov 152357b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 152457b8ff07SDmitry Torokhov if (error) { 152557b8ff07SDmitry Torokhov devres_free(devres); 152657b8ff07SDmitry Torokhov return error; 152757b8ff07SDmitry Torokhov } 152857b8ff07SDmitry Torokhov 152957b8ff07SDmitry Torokhov devres->group = grp; 153057b8ff07SDmitry Torokhov devres_add(dev, devres); 153157b8ff07SDmitry Torokhov return 0; 153257b8ff07SDmitry Torokhov } 153357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 153457b8ff07SDmitry Torokhov 153557b8ff07SDmitry Torokhov /** 153657b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 153757b8ff07SDmitry Torokhov * @dev: device to remove the group from 153857b8ff07SDmitry Torokhov * @grp: group to remove 153957b8ff07SDmitry Torokhov * 154057b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 154157b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 154257b8ff07SDmitry Torokhov */ 154357b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 154457b8ff07SDmitry Torokhov const struct attribute_group *grp) 154557b8ff07SDmitry Torokhov { 154657b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 154757b8ff07SDmitry Torokhov devm_attr_group_match, 154857b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 154957b8ff07SDmitry Torokhov } 155057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 155157b8ff07SDmitry Torokhov 155257b8ff07SDmitry Torokhov /** 155357b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 155457b8ff07SDmitry Torokhov * @dev: The device to create the group for 155557b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 155657b8ff07SDmitry Torokhov * 155757b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 155857b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 155957b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 156057b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 156157b8ff07SDmitry Torokhov * attribute files being created already exist. 156257b8ff07SDmitry Torokhov * 156357b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 156457b8ff07SDmitry Torokhov */ 156557b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 156657b8ff07SDmitry Torokhov const struct attribute_group **groups) 156757b8ff07SDmitry Torokhov { 156857b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 156957b8ff07SDmitry Torokhov int error; 157057b8ff07SDmitry Torokhov 157157b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 157257b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 157357b8ff07SDmitry Torokhov if (!devres) 157457b8ff07SDmitry Torokhov return -ENOMEM; 157557b8ff07SDmitry Torokhov 157657b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 157757b8ff07SDmitry Torokhov if (error) { 157857b8ff07SDmitry Torokhov devres_free(devres); 157957b8ff07SDmitry Torokhov return error; 158057b8ff07SDmitry Torokhov } 158157b8ff07SDmitry Torokhov 158257b8ff07SDmitry Torokhov devres->groups = groups; 158357b8ff07SDmitry Torokhov devres_add(dev, devres); 158457b8ff07SDmitry Torokhov return 0; 158557b8ff07SDmitry Torokhov } 158657b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 158757b8ff07SDmitry Torokhov 158857b8ff07SDmitry Torokhov /** 158957b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 159057b8ff07SDmitry Torokhov * 159157b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 159257b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 159357b8ff07SDmitry Torokhov * 159457b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 159557b8ff07SDmitry Torokhov */ 159657b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 159757b8ff07SDmitry Torokhov const struct attribute_group **groups) 159857b8ff07SDmitry Torokhov { 159957b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 160057b8ff07SDmitry Torokhov devm_attr_group_match, 160157b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 160257b8ff07SDmitry Torokhov } 160357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 16041da177e4SLinus Torvalds 16052620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 16062620efefSGreg Kroah-Hartman { 16072620efefSGreg Kroah-Hartman struct class *class = dev->class; 1608aed65af1SStephen Hemminger const struct device_type *type = dev->type; 1609621a1672SDmitry Torokhov int error; 16102620efefSGreg Kroah-Hartman 1611621a1672SDmitry Torokhov if (class) { 1612d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 16132620efefSGreg Kroah-Hartman if (error) 1614621a1672SDmitry Torokhov return error; 1615f9f852dfSKay Sievers } 1616f9f852dfSKay Sievers 1617621a1672SDmitry Torokhov if (type) { 1618621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 1619f9f852dfSKay Sievers if (error) 1620a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 1621f9f852dfSKay Sievers } 1622621a1672SDmitry Torokhov 1623621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 1624f9f852dfSKay Sievers if (error) 1625621a1672SDmitry Torokhov goto err_remove_type_groups; 1626621a1672SDmitry Torokhov 16274f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 1628c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 16294f3549d7SRafael J. Wysocki if (error) 1630ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 16314f3549d7SRafael J. Wysocki } 16324f3549d7SRafael J. Wysocki 1633621a1672SDmitry Torokhov return 0; 1634621a1672SDmitry Torokhov 1635ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 1636ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 1637621a1672SDmitry Torokhov err_remove_type_groups: 1638621a1672SDmitry Torokhov if (type) 1639621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1640d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 1641d05a6f96SGreg Kroah-Hartman if (class) 1642d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1643f9f852dfSKay Sievers 16442620efefSGreg Kroah-Hartman return error; 16452620efefSGreg Kroah-Hartman } 16462620efefSGreg Kroah-Hartman 16472620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 16482620efefSGreg Kroah-Hartman { 16492620efefSGreg Kroah-Hartman struct class *class = dev->class; 1650aed65af1SStephen Hemminger const struct device_type *type = dev->type; 16512620efefSGreg Kroah-Hartman 1652c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 1653621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 1654f9f852dfSKay Sievers 1655621a1672SDmitry Torokhov if (type) 1656621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1657621a1672SDmitry Torokhov 1658a6b01dedSGreg Kroah-Hartman if (class) 1659d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1660c97415a7SStefan Achatz } 16612620efefSGreg Kroah-Hartman 1662c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 166323681e47SGreg Kroah-Hartman char *buf) 166423681e47SGreg Kroah-Hartman { 166523681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 166623681e47SGreg Kroah-Hartman } 1667c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 1668ad6a1e1cSTejun Heo 1669ca22e56dSKay Sievers /* /sys/devices/ */ 1670881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 16711da177e4SLinus Torvalds 16721da177e4SLinus Torvalds /** 167352cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 167452cdbdd4SGrygorii Strashko * @deva: Device to move. 167552cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 167652cdbdd4SGrygorii Strashko */ 167752cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 167852cdbdd4SGrygorii Strashko { 167952cdbdd4SGrygorii Strashko if (!devices_kset) 168052cdbdd4SGrygorii Strashko return; 168152cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 168252cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 168352cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 168452cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 168552cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 168652cdbdd4SGrygorii Strashko } 168752cdbdd4SGrygorii Strashko 168852cdbdd4SGrygorii Strashko /** 168952cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 169052cdbdd4SGrygorii Strashko * @deva: Device to move 169152cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 169252cdbdd4SGrygorii Strashko */ 169352cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 169452cdbdd4SGrygorii Strashko { 169552cdbdd4SGrygorii Strashko if (!devices_kset) 169652cdbdd4SGrygorii Strashko return; 169752cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 169852cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 169952cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 170052cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 170152cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 170252cdbdd4SGrygorii Strashko } 170352cdbdd4SGrygorii Strashko 170452cdbdd4SGrygorii Strashko /** 170552cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 170652cdbdd4SGrygorii Strashko * @dev: device to move 170752cdbdd4SGrygorii Strashko */ 170852cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 170952cdbdd4SGrygorii Strashko { 171052cdbdd4SGrygorii Strashko if (!devices_kset) 171152cdbdd4SGrygorii Strashko return; 171252cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 171352cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 171452cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 171552cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 171652cdbdd4SGrygorii Strashko } 171752cdbdd4SGrygorii Strashko 171852cdbdd4SGrygorii Strashko /** 17191da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 17201da177e4SLinus Torvalds * @dev: device. 17211da177e4SLinus Torvalds * @attr: device attribute descriptor. 17221da177e4SLinus Torvalds */ 172326579ab7SPhil Carmody int device_create_file(struct device *dev, 172426579ab7SPhil Carmody const struct device_attribute *attr) 17251da177e4SLinus Torvalds { 17261da177e4SLinus Torvalds int error = 0; 17278f46baaaSFelipe Balbi 17288f46baaaSFelipe Balbi if (dev) { 17298f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 173097521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 173197521978Sdyoung@redhat.com attr->attr.name); 17328f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 173397521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 173497521978Sdyoung@redhat.com attr->attr.name); 17351da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 17368f46baaaSFelipe Balbi } 17378f46baaaSFelipe Balbi 17381da177e4SLinus Torvalds return error; 17391da177e4SLinus Torvalds } 174086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds /** 17431da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 17441da177e4SLinus Torvalds * @dev: device. 17451da177e4SLinus Torvalds * @attr: device attribute descriptor. 17461da177e4SLinus Torvalds */ 174726579ab7SPhil Carmody void device_remove_file(struct device *dev, 174826579ab7SPhil Carmody const struct device_attribute *attr) 17491da177e4SLinus Torvalds { 17500c98b19fSCornelia Huck if (dev) 17511da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 17521da177e4SLinus Torvalds } 175386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 17541da177e4SLinus Torvalds 17552589f188SGreg Kroah-Hartman /** 17566b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 17576b0afc2aSTejun Heo * @dev: device. 17586b0afc2aSTejun Heo * @attr: device attribute descriptor. 17596b0afc2aSTejun Heo * 17606b0afc2aSTejun Heo * See kernfs_remove_self() for details. 17616b0afc2aSTejun Heo */ 17626b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 17636b0afc2aSTejun Heo const struct device_attribute *attr) 17646b0afc2aSTejun Heo { 17656b0afc2aSTejun Heo if (dev) 17666b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 17676b0afc2aSTejun Heo else 17686b0afc2aSTejun Heo return false; 17696b0afc2aSTejun Heo } 17706b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 17716b0afc2aSTejun Heo 17726b0afc2aSTejun Heo /** 17732589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 17742589f188SGreg Kroah-Hartman * @dev: device. 17752589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 17762589f188SGreg Kroah-Hartman */ 177766ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 177866ecb92bSPhil Carmody const struct bin_attribute *attr) 17792589f188SGreg Kroah-Hartman { 17802589f188SGreg Kroah-Hartman int error = -EINVAL; 17812589f188SGreg Kroah-Hartman if (dev) 17822589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 17832589f188SGreg Kroah-Hartman return error; 17842589f188SGreg Kroah-Hartman } 17852589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 17862589f188SGreg Kroah-Hartman 17872589f188SGreg Kroah-Hartman /** 17882589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 17892589f188SGreg Kroah-Hartman * @dev: device. 17902589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 17912589f188SGreg Kroah-Hartman */ 179266ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 179366ecb92bSPhil Carmody const struct bin_attribute *attr) 17942589f188SGreg Kroah-Hartman { 17952589f188SGreg Kroah-Hartman if (dev) 17962589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 17972589f188SGreg Kroah-Hartman } 17982589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 17992589f188SGreg Kroah-Hartman 180034bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 180134bb61f9SJames Bottomley { 1802f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1803f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 180434bb61f9SJames Bottomley 180534bb61f9SJames Bottomley get_device(dev); 180634bb61f9SJames Bottomley } 180734bb61f9SJames Bottomley 180834bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 180934bb61f9SJames Bottomley { 1810f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1811f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 181234bb61f9SJames Bottomley 181334bb61f9SJames Bottomley put_device(dev); 181434bb61f9SJames Bottomley } 181534bb61f9SJames Bottomley 18161da177e4SLinus Torvalds /** 18171da177e4SLinus Torvalds * device_initialize - init device structure. 18181da177e4SLinus Torvalds * @dev: device. 18191da177e4SLinus Torvalds * 18205739411aSCornelia Huck * This prepares the device for use by other layers by initializing 18215739411aSCornelia Huck * its fields. 18221da177e4SLinus Torvalds * It is the first half of device_register(), if called by 18235739411aSCornelia Huck * that function, though it can also be called separately, so one 18245739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 18255739411aSCornelia Huck * may be used for reference counting of @dev after calling this 18265739411aSCornelia Huck * function. 18275739411aSCornelia Huck * 1828b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 1829b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 1830b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 1831b10d5efdSAlan Stern * @dev. 1832b10d5efdSAlan Stern * 18335739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 18345739411aSCornelia Huck * @dev directly once you have called this function. 18351da177e4SLinus Torvalds */ 18361da177e4SLinus Torvalds void device_initialize(struct device *dev) 18371da177e4SLinus Torvalds { 1838881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 1839f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 18401da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 18413142788bSThomas Gleixner mutex_init(&dev->mutex); 184287a30e1fSDan Williams #ifdef CONFIG_PROVE_LOCKING 184387a30e1fSDan Williams mutex_init(&dev->lockdep_mutex); 184487a30e1fSDan Williams #endif 18451704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 18469ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 18479ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 18483b98aeafSAlan Stern device_pm_init(dev); 184987348136SChristoph Hellwig set_dev_node(dev, -1); 18504a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 18514a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 18524a7cc831SJiang Liu #endif 18539ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 18549ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 1855e2ae9bccSSaravana Kannan INIT_LIST_HEAD(&dev->links.needs_suppliers); 1856fc5a251dSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 18579ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 18581da177e4SLinus Torvalds } 185986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 18601da177e4SLinus Torvalds 1861d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 1862f0ee61a6SGreg Kroah-Hartman { 1863f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 1864f0ee61a6SGreg Kroah-Hartman 1865f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 18664ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 1867881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 1868f0ee61a6SGreg Kroah-Hartman 186986406245SKay Sievers return virtual_dir; 1870f0ee61a6SGreg Kroah-Hartman } 1871f0ee61a6SGreg Kroah-Hartman 1872bc451f20SEric W. Biederman struct class_dir { 1873bc451f20SEric W. Biederman struct kobject kobj; 1874bc451f20SEric W. Biederman struct class *class; 1875bc451f20SEric W. Biederman }; 1876bc451f20SEric W. Biederman 1877bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 1878bc451f20SEric W. Biederman 1879bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 1880bc451f20SEric W. Biederman { 1881bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 1882bc451f20SEric W. Biederman kfree(dir); 1883bc451f20SEric W. Biederman } 1884bc451f20SEric W. Biederman 1885bc451f20SEric W. Biederman static const 1886bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 1887bc451f20SEric W. Biederman { 1888bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 1889bc451f20SEric W. Biederman return dir->class->ns_type; 1890bc451f20SEric W. Biederman } 1891bc451f20SEric W. Biederman 1892bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 1893bc451f20SEric W. Biederman .release = class_dir_release, 1894bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 1895bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 1896bc451f20SEric W. Biederman }; 1897bc451f20SEric W. Biederman 1898bc451f20SEric W. Biederman static struct kobject * 1899bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 1900bc451f20SEric W. Biederman { 1901bc451f20SEric W. Biederman struct class_dir *dir; 1902bc451f20SEric W. Biederman int retval; 1903bc451f20SEric W. Biederman 1904bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 1905bc451f20SEric W. Biederman if (!dir) 190684d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 1907bc451f20SEric W. Biederman 1908bc451f20SEric W. Biederman dir->class = class; 1909bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 1910bc451f20SEric W. Biederman 19116b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 1912bc451f20SEric W. Biederman 1913bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 1914bc451f20SEric W. Biederman if (retval < 0) { 1915bc451f20SEric W. Biederman kobject_put(&dir->kobj); 191684d0c27dSTetsuo Handa return ERR_PTR(retval); 1917bc451f20SEric W. Biederman } 1918bc451f20SEric W. Biederman return &dir->kobj; 1919bc451f20SEric W. Biederman } 1920bc451f20SEric W. Biederman 1921e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 1922bc451f20SEric W. Biederman 1923c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 1924c744aeaeSCornelia Huck struct device *parent) 192540fa5422SGreg Kroah-Hartman { 192686406245SKay Sievers if (dev->class) { 192786406245SKay Sievers struct kobject *kobj = NULL; 192886406245SKay Sievers struct kobject *parent_kobj; 192986406245SKay Sievers struct kobject *k; 193086406245SKay Sievers 1931ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 193239aba963SKay Sievers /* block disks show up in /sys/block */ 1933e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 193439aba963SKay Sievers if (parent && parent->class == &block_class) 193539aba963SKay Sievers return &parent->kobj; 19366b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 193739aba963SKay Sievers } 1938ead454feSRandy Dunlap #endif 1939e52eec13SAndi Kleen 194086406245SKay Sievers /* 194186406245SKay Sievers * If we have no parent, we live in "virtual". 19420f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 19430f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 194486406245SKay Sievers */ 194586406245SKay Sievers if (parent == NULL) 194686406245SKay Sievers parent_kobj = virtual_device_parent(dev); 194724b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 194886406245SKay Sievers return &parent->kobj; 194986406245SKay Sievers else 195086406245SKay Sievers parent_kobj = &parent->kobj; 195186406245SKay Sievers 195277d3d7c1STejun Heo mutex_lock(&gdp_mutex); 195377d3d7c1STejun Heo 195486406245SKay Sievers /* find our class-directory at the parent and reference it */ 19556b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 19566b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 195786406245SKay Sievers if (k->parent == parent_kobj) { 195886406245SKay Sievers kobj = kobject_get(k); 195986406245SKay Sievers break; 196086406245SKay Sievers } 19616b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 196277d3d7c1STejun Heo if (kobj) { 196377d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 196486406245SKay Sievers return kobj; 196577d3d7c1STejun Heo } 196686406245SKay Sievers 196786406245SKay Sievers /* or create a new class-directory at the parent device */ 1968bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 19690f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 197077d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 197143968d2fSGreg Kroah-Hartman return k; 197286406245SKay Sievers } 197386406245SKay Sievers 1974ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 1975ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 1976ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 1977ca22e56dSKay Sievers 197886406245SKay Sievers if (parent) 1979c744aeaeSCornelia Huck return &parent->kobj; 1980c744aeaeSCornelia Huck return NULL; 1981c744aeaeSCornelia Huck } 1982da231fd5SKay Sievers 1983cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 1984cebf8fd1SMing Lei struct device *dev) 1985cebf8fd1SMing Lei { 1986cebf8fd1SMing Lei if (!kobj || !dev->class || 1987cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 1988cebf8fd1SMing Lei return false; 1989cebf8fd1SMing Lei return true; 1990cebf8fd1SMing Lei } 1991cebf8fd1SMing Lei 1992cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 1993cebf8fd1SMing Lei { 1994cebf8fd1SMing Lei return dev->kobj.parent; 1995cebf8fd1SMing Lei } 1996cebf8fd1SMing Lei 1997cebf8fd1SMing Lei /* 1998cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 1999cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 2000cebf8fd1SMing Lei * global lock 2001cebf8fd1SMing Lei */ 200263b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 2003da231fd5SKay Sievers { 2004ac43432cSMuchun Song unsigned int ref; 2005ac43432cSMuchun Song 20060f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 2007cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 2008da231fd5SKay Sievers return; 2009da231fd5SKay Sievers 2010e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 2011ac43432cSMuchun Song /** 2012ac43432cSMuchun Song * There is a race condition between removing glue directory 2013ac43432cSMuchun Song * and adding a new device under the glue directory. 2014ac43432cSMuchun Song * 2015ac43432cSMuchun Song * CPU1: CPU2: 2016ac43432cSMuchun Song * 2017ac43432cSMuchun Song * device_add() 2018ac43432cSMuchun Song * get_device_parent() 2019ac43432cSMuchun Song * class_dir_create_and_add() 2020ac43432cSMuchun Song * kobject_add_internal() 2021ac43432cSMuchun Song * create_dir() // create glue_dir 2022ac43432cSMuchun Song * 2023ac43432cSMuchun Song * device_add() 2024ac43432cSMuchun Song * get_device_parent() 2025ac43432cSMuchun Song * kobject_get() // get glue_dir 2026ac43432cSMuchun Song * 2027ac43432cSMuchun Song * device_del() 2028ac43432cSMuchun Song * cleanup_glue_dir() 2029ac43432cSMuchun Song * kobject_del(glue_dir) 2030ac43432cSMuchun Song * 2031ac43432cSMuchun Song * kobject_add() 2032ac43432cSMuchun Song * kobject_add_internal() 2033ac43432cSMuchun Song * create_dir() // in glue_dir 2034ac43432cSMuchun Song * sysfs_create_dir_ns() 2035ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 2036ac43432cSMuchun Song * 2037ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 2038ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 2039ac43432cSMuchun Song * 2040ac43432cSMuchun Song * // sd is freed 2041ac43432cSMuchun Song * kernfs_new_node(sd) 2042ac43432cSMuchun Song * kernfs_get(glue_dir) 2043ac43432cSMuchun Song * kernfs_add_one() 2044ac43432cSMuchun Song * kernfs_put() 2045ac43432cSMuchun Song * 2046ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 2047ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 2048ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 2049ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 2050ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 2051ac43432cSMuchun Song * 2052ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 2053ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 2054ac43432cSMuchun Song * 2055ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 2056ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 2057ac43432cSMuchun Song * for glue_dir kobj is 1. 2058ac43432cSMuchun Song */ 2059ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 2060ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 2061726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 20620f4dafc0SKay Sievers kobject_put(glue_dir); 2063e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 2064da231fd5SKay Sievers } 206563b6971aSCornelia Huck 20662ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 20672ee97cafSCornelia Huck { 20685590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 20692ee97cafSCornelia Huck int error; 20702ee97cafSCornelia Huck 20715590f319SBenjamin Herrenschmidt if (of_node) { 20720c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 20735590f319SBenjamin Herrenschmidt if (error) 20745590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 20755590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 20765590f319SBenjamin Herrenschmidt } 20775590f319SBenjamin Herrenschmidt 20782ee97cafSCornelia Huck if (!dev->class) 20792ee97cafSCornelia Huck return 0; 2080da231fd5SKay Sievers 20811fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 20826b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 20832ee97cafSCornelia Huck "subsystem"); 20842ee97cafSCornelia Huck if (error) 20855590f319SBenjamin Herrenschmidt goto out_devnode; 2086da231fd5SKay Sievers 20874e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 20884f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 20894f01a757SDmitry Torokhov "device"); 20904f01a757SDmitry Torokhov if (error) 209139aba963SKay Sievers goto out_subsys; 20922ee97cafSCornelia Huck } 209339aba963SKay Sievers 2094ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 209539aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 2096e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 209739aba963SKay Sievers return 0; 2098ead454feSRandy Dunlap #endif 209939aba963SKay Sievers 210039aba963SKay Sievers /* link in the class directory pointing to the device */ 21016b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 210239aba963SKay Sievers &dev->kobj, dev_name(dev)); 210339aba963SKay Sievers if (error) 210439aba963SKay Sievers goto out_device; 210539aba963SKay Sievers 21062ee97cafSCornelia Huck return 0; 21072ee97cafSCornelia Huck 210839aba963SKay Sievers out_device: 210939aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 2110da231fd5SKay Sievers 21112ee97cafSCornelia Huck out_subsys: 21122ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 21135590f319SBenjamin Herrenschmidt out_devnode: 21145590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 21152ee97cafSCornelia Huck return error; 21162ee97cafSCornelia Huck } 21172ee97cafSCornelia Huck 21182ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 21192ee97cafSCornelia Huck { 21205590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 21215590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 21225590f319SBenjamin Herrenschmidt 21232ee97cafSCornelia Huck if (!dev->class) 21242ee97cafSCornelia Huck return; 2125da231fd5SKay Sievers 21264e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 2127da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 21282ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 2129ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 2130e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 213139aba963SKay Sievers return; 2132ead454feSRandy Dunlap #endif 21336b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 21342ee97cafSCornelia Huck } 21352ee97cafSCornelia Huck 21361da177e4SLinus Torvalds /** 2137413c239fSStephen Rothwell * dev_set_name - set a device name 2138413c239fSStephen Rothwell * @dev: device 213946232366SRandy Dunlap * @fmt: format string for the device's name 2140413c239fSStephen Rothwell */ 2141413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 2142413c239fSStephen Rothwell { 2143413c239fSStephen Rothwell va_list vargs; 21441fa5ae85SKay Sievers int err; 2145413c239fSStephen Rothwell 2146413c239fSStephen Rothwell va_start(vargs, fmt); 21471fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 2148413c239fSStephen Rothwell va_end(vargs); 21491fa5ae85SKay Sievers return err; 2150413c239fSStephen Rothwell } 2151413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 2152413c239fSStephen Rothwell 2153413c239fSStephen Rothwell /** 2154e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 2155e105b8bfSDan Williams * @dev: device 2156e105b8bfSDan Williams * 2157e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 2158e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 2159e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 2160e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 21610d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 21620d4e293cSPeter Korsgaard * the link. 2163e105b8bfSDan Williams */ 2164e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 2165e105b8bfSDan Williams { 2166e105b8bfSDan Williams struct kobject *kobj; 2167e105b8bfSDan Williams 2168e105b8bfSDan Williams if (dev->class) 2169e105b8bfSDan Williams kobj = dev->class->dev_kobj; 2170e105b8bfSDan Williams else 2171e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 2172e105b8bfSDan Williams 2173e105b8bfSDan Williams return kobj; 2174e105b8bfSDan Williams } 2175e105b8bfSDan Williams 2176e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 2177e105b8bfSDan Williams { 2178e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2179e105b8bfSDan Williams int error = 0; 2180e105b8bfSDan Williams char devt_str[15]; 2181e105b8bfSDan Williams 2182e105b8bfSDan Williams if (kobj) { 2183e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2184e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 2185e105b8bfSDan Williams } 2186e105b8bfSDan Williams 2187e105b8bfSDan Williams return error; 2188e105b8bfSDan Williams } 2189e105b8bfSDan Williams 2190e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 2191e105b8bfSDan Williams { 2192e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2193e105b8bfSDan Williams char devt_str[15]; 2194e105b8bfSDan Williams 2195e105b8bfSDan Williams if (kobj) { 2196e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2197e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 2198e105b8bfSDan Williams } 2199e105b8bfSDan Williams } 2200e105b8bfSDan Williams 220146d3a037SShaokun Zhang static int device_private_init(struct device *dev) 2202b4028437SGreg Kroah-Hartman { 2203b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 2204b4028437SGreg Kroah-Hartman if (!dev->p) 2205b4028437SGreg Kroah-Hartman return -ENOMEM; 2206b4028437SGreg Kroah-Hartman dev->p->device = dev; 2207b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 2208b4028437SGreg Kroah-Hartman klist_children_put); 2209ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 2210b4028437SGreg Kroah-Hartman return 0; 2211b4028437SGreg Kroah-Hartman } 2212b4028437SGreg Kroah-Hartman 2213e105b8bfSDan Williams /** 22141da177e4SLinus Torvalds * device_add - add device to device hierarchy. 22151da177e4SLinus Torvalds * @dev: device. 22161da177e4SLinus Torvalds * 22171da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 22181da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 22191da177e4SLinus Torvalds * 22205739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 22211da177e4SLinus Torvalds * to the global and sibling lists for the device, then 22221da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 22235739411aSCornelia Huck * 2224b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 2225b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 2226b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 2227b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 2228b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 2229b10d5efdSAlan Stern * and register a fresh new struct device instead. 2230b10d5efdSAlan Stern * 22315739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 22325739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 22335739411aSCornelia Huck * reference instead. 2234affada72SBorislav Petkov * 2235affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 2236affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 2237affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 2238affada72SBorislav Petkov * count. 22391da177e4SLinus Torvalds */ 22401da177e4SLinus Torvalds int device_add(struct device *dev) 22411da177e4SLinus Torvalds { 224235dbf4efSViresh Kumar struct device *parent; 2243ca22e56dSKay Sievers struct kobject *kobj; 2244c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 2245c906a48aSGreg Kroah-Hartman int error = -EINVAL; 2246cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2247775b64d2SRafael J. Wysocki 22481da177e4SLinus Torvalds dev = get_device(dev); 2249c906a48aSGreg Kroah-Hartman if (!dev) 2250c906a48aSGreg Kroah-Hartman goto done; 2251c906a48aSGreg Kroah-Hartman 2252fb069a5dSGreg Kroah-Hartman if (!dev->p) { 2253b4028437SGreg Kroah-Hartman error = device_private_init(dev); 2254b4028437SGreg Kroah-Hartman if (error) 2255fb069a5dSGreg Kroah-Hartman goto done; 2256fb069a5dSGreg Kroah-Hartman } 2257fb069a5dSGreg Kroah-Hartman 22581fa5ae85SKay Sievers /* 22591fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 22601fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 22611fa5ae85SKay Sievers * the name, and force the use of dev_name() 22621fa5ae85SKay Sievers */ 22631fa5ae85SKay Sievers if (dev->init_name) { 2264acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 22651fa5ae85SKay Sievers dev->init_name = NULL; 22661fa5ae85SKay Sievers } 2267c906a48aSGreg Kroah-Hartman 2268ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 2269ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 2270ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 2271ca22e56dSKay Sievers 2272e6309e75SThomas Gleixner if (!dev_name(dev)) { 2273e6309e75SThomas Gleixner error = -EINVAL; 22745c8563d7SKay Sievers goto name_error; 2275e6309e75SThomas Gleixner } 22761da177e4SLinus Torvalds 22771e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 2278c205ef48SGreg Kroah-Hartman 22791da177e4SLinus Torvalds parent = get_device(dev->parent); 2280ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 228184d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 228284d0c27dSTetsuo Handa error = PTR_ERR(kobj); 228384d0c27dSTetsuo Handa goto parent_error; 228484d0c27dSTetsuo Handa } 2285ca22e56dSKay Sievers if (kobj) 2286ca22e56dSKay Sievers dev->kobj.parent = kobj; 22871da177e4SLinus Torvalds 22880d358f22SYinghai Lu /* use parent numa_node */ 228956f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 22900d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 22910d358f22SYinghai Lu 22921da177e4SLinus Torvalds /* first, register with generic layer. */ 22938a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 22948a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 2295cebf8fd1SMing Lei if (error) { 2296cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 22971da177e4SLinus Torvalds goto Error; 2298cebf8fd1SMing Lei } 2299a7fd6706SKay Sievers 230037022644SBrian Walsh /* notify platform of device entry */ 230107de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 230207de0e86SHeikki Krogerus if (error) 230307de0e86SHeikki Krogerus goto platform_error; 230437022644SBrian Walsh 2305c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 2306a306eea4SCornelia Huck if (error) 2307a306eea4SCornelia Huck goto attrError; 2308a7fd6706SKay Sievers 23092ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 23102ee97cafSCornelia Huck if (error) 23112ee97cafSCornelia Huck goto SymlinkError; 2312dc0afa83SCornelia Huck error = device_add_attrs(dev); 2313dc0afa83SCornelia Huck if (error) 23142620efefSGreg Kroah-Hartman goto AttrsError; 2315dc0afa83SCornelia Huck error = bus_add_device(dev); 2316dc0afa83SCornelia Huck if (error) 23171da177e4SLinus Torvalds goto BusError; 23183b98aeafSAlan Stern error = dpm_sysfs_add(dev); 231957eee3d2SRafael J. Wysocki if (error) 23203b98aeafSAlan Stern goto DPMError; 23213b98aeafSAlan Stern device_pm_add(dev); 2322ec0676eeSAlan Stern 23230cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 23240cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 23250cd75047SSergey Klyaus if (error) 23260cd75047SSergey Klyaus goto DevAttrError; 23270cd75047SSergey Klyaus 23280cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 23290cd75047SSergey Klyaus if (error) 23300cd75047SSergey Klyaus goto SysEntryError; 23310cd75047SSergey Klyaus 23320cd75047SSergey Klyaus devtmpfs_create_node(dev); 23330cd75047SSergey Klyaus } 23340cd75047SSergey Klyaus 2335ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 2336268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 2337ec0676eeSAlan Stern */ 2338ec0676eeSAlan Stern if (dev->bus) 2339ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2340ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 2341ec0676eeSAlan Stern 234253877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 2343372a67c0SSaravana Kannan 2344372a67c0SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) 2345372a67c0SSaravana Kannan dev->fwnode->dev = dev; 2346372a67c0SSaravana Kannan 2347e2ae9bccSSaravana Kannan /* 2348e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 2349e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 2350e2ae9bccSSaravana Kannan * link to it. 2351e2ae9bccSSaravana Kannan * 2352e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 2353e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 2354e2ae9bccSSaravana Kannan * 2355e2ae9bccSSaravana Kannan * But this also needs to happe before bus_probe_device() to make sure 2356e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 2357e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 2358e2ae9bccSSaravana Kannan */ 2359e2ae9bccSSaravana Kannan device_link_add_missing_supplier_links(); 2360e2ae9bccSSaravana Kannan 2361e2ae9bccSSaravana Kannan if (fwnode_has_op(dev->fwnode, add_links) 2362e2ae9bccSSaravana Kannan && fwnode_call_int_op(dev->fwnode, add_links, dev)) 2363e2ae9bccSSaravana Kannan device_link_wait_for_supplier(dev); 2364e2ae9bccSSaravana Kannan 23652023c610SAlan Stern bus_probe_device(dev); 23661da177e4SLinus Torvalds if (parent) 2367f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2368f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 23691da177e4SLinus Torvalds 23705d9fd169SGreg Kroah-Hartman if (dev->class) { 2371ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2372c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 2373570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 23746b6e39a6SKay Sievers &dev->class->p->klist_devices); 2375c47ed219SGreg Kroah-Hartman 2376c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 2377184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2378ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2379c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 2380c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 2381ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 23825d9fd169SGreg Kroah-Hartman } 2383c906a48aSGreg Kroah-Hartman done: 23841da177e4SLinus Torvalds put_device(dev); 23851da177e4SLinus Torvalds return error; 23860cd75047SSergey Klyaus SysEntryError: 23870cd75047SSergey Klyaus if (MAJOR(dev->devt)) 23880cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 23890cd75047SSergey Klyaus DevAttrError: 23900cd75047SSergey Klyaus device_pm_remove(dev); 23910cd75047SSergey Klyaus dpm_sysfs_remove(dev); 23923b98aeafSAlan Stern DPMError: 239357eee3d2SRafael J. Wysocki bus_remove_device(dev); 239457eee3d2SRafael J. Wysocki BusError: 23952620efefSGreg Kroah-Hartman device_remove_attrs(dev); 23962620efefSGreg Kroah-Hartman AttrsError: 23972ee97cafSCornelia Huck device_remove_class_symlinks(dev); 23982ee97cafSCornelia Huck SymlinkError: 2399c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 240023681e47SGreg Kroah-Hartman attrError: 240107de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 240207de0e86SHeikki Krogerus platform_error: 2403312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2404cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 24051da177e4SLinus Torvalds kobject_del(&dev->kobj); 24061da177e4SLinus Torvalds Error: 2407cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 240884d0c27dSTetsuo Handa parent_error: 24091da177e4SLinus Torvalds put_device(parent); 24105c8563d7SKay Sievers name_error: 24115c8563d7SKay Sievers kfree(dev->p); 24125c8563d7SKay Sievers dev->p = NULL; 2413c906a48aSGreg Kroah-Hartman goto done; 24141da177e4SLinus Torvalds } 241586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 24161da177e4SLinus Torvalds 24171da177e4SLinus Torvalds /** 24181da177e4SLinus Torvalds * device_register - register a device with the system. 24191da177e4SLinus Torvalds * @dev: pointer to the device structure 24201da177e4SLinus Torvalds * 24211da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 24221da177e4SLinus Torvalds * and add it to the system. The two steps can be called 24231da177e4SLinus Torvalds * separately, but this is the easiest and most common. 24241da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 24251da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 24261da177e4SLinus Torvalds * before it is added to the hierarchy. 24275739411aSCornelia Huck * 2428b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 2429b10d5efdSAlan Stern * and device_add(). 2430b10d5efdSAlan Stern * 24315739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 24325739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 24335739411aSCornelia Huck * reference initialized in this function instead. 24341da177e4SLinus Torvalds */ 24351da177e4SLinus Torvalds int device_register(struct device *dev) 24361da177e4SLinus Torvalds { 24371da177e4SLinus Torvalds device_initialize(dev); 24381da177e4SLinus Torvalds return device_add(dev); 24391da177e4SLinus Torvalds } 244086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 24411da177e4SLinus Torvalds 24421da177e4SLinus Torvalds /** 24431da177e4SLinus Torvalds * get_device - increment reference count for device. 24441da177e4SLinus Torvalds * @dev: device. 24451da177e4SLinus Torvalds * 24461da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 24471da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 24481da177e4SLinus Torvalds * pointer passed in. 24491da177e4SLinus Torvalds */ 24501da177e4SLinus Torvalds struct device *get_device(struct device *dev) 24511da177e4SLinus Torvalds { 2452b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 24531da177e4SLinus Torvalds } 245486df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 24551da177e4SLinus Torvalds 24561da177e4SLinus Torvalds /** 24571da177e4SLinus Torvalds * put_device - decrement reference count. 24581da177e4SLinus Torvalds * @dev: device in question. 24591da177e4SLinus Torvalds */ 24601da177e4SLinus Torvalds void put_device(struct device *dev) 24611da177e4SLinus Torvalds { 2462edfaa7c3SKay Sievers /* might_sleep(); */ 24631da177e4SLinus Torvalds if (dev) 24641da177e4SLinus Torvalds kobject_put(&dev->kobj); 24651da177e4SLinus Torvalds } 246686df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 24671da177e4SLinus Torvalds 246800289cd8SDan Williams bool kill_device(struct device *dev) 246900289cd8SDan Williams { 247000289cd8SDan Williams /* 247100289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 247200289cd8SDan Williams * the update behavior is consistent with the other bitfields near 247300289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 247400289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 247500289cd8SDan Williams * underneath the device. 247600289cd8SDan Williams */ 247700289cd8SDan Williams lockdep_assert_held(&dev->mutex); 247800289cd8SDan Williams 247900289cd8SDan Williams if (dev->p->dead) 248000289cd8SDan Williams return false; 248100289cd8SDan Williams dev->p->dead = true; 248200289cd8SDan Williams return true; 248300289cd8SDan Williams } 248400289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 248500289cd8SDan Williams 24861da177e4SLinus Torvalds /** 24871da177e4SLinus Torvalds * device_del - delete device from system. 24881da177e4SLinus Torvalds * @dev: device. 24891da177e4SLinus Torvalds * 24901da177e4SLinus Torvalds * This is the first part of the device unregistration 24911da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 24921da177e4SLinus Torvalds * from here, has it removed from the other driver model 24931da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 24941da177e4SLinus Torvalds * from the kobject hierarchy. 24951da177e4SLinus Torvalds * 24961da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 24971da177e4SLinus Torvalds * also called manually. 24981da177e4SLinus Torvalds */ 24991da177e4SLinus Torvalds void device_del(struct device *dev) 25001da177e4SLinus Torvalds { 25011da177e4SLinus Torvalds struct device *parent = dev->parent; 2502cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2503c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 25041da177e4SLinus Torvalds 25053451a495SAlexander Duyck device_lock(dev); 250600289cd8SDan Williams kill_device(dev); 25073451a495SAlexander Duyck device_unlock(dev); 25083451a495SAlexander Duyck 2509372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 2510372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 2511372a67c0SSaravana Kannan 2512ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 2513ec0676eeSAlan Stern * before dpm_sysfs_remove(). 2514ec0676eeSAlan Stern */ 2515ec0676eeSAlan Stern if (dev->bus) 2516ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2517ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 25189ed98953SRafael J. Wysocki 25193b98aeafSAlan Stern dpm_sysfs_remove(dev); 25201da177e4SLinus Torvalds if (parent) 2521f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 2522e105b8bfSDan Williams if (MAJOR(dev->devt)) { 25232b2af54aSKay Sievers devtmpfs_delete_node(dev); 2524e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 2525c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 2526e105b8bfSDan Williams } 2527b9d9c82bSKay Sievers if (dev->class) { 2528da231fd5SKay Sievers device_remove_class_symlinks(dev); 252999ef3ef8SKay Sievers 2530ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2531c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 2532184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2533ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2534c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 2535c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 2536c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 2537570d0200SWei Yang klist_del(&dev->p->knode_class); 2538ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 2539b9d9c82bSKay Sievers } 2540c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 25412620efefSGreg Kroah-Hartman device_remove_attrs(dev); 254228953533SBenjamin Herrenschmidt bus_remove_device(dev); 25434b6d1f12SLongX Zhang device_pm_remove(dev); 2544d1c3414cSGrant Likely driver_deferred_probe_del(dev); 254507de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 2546478573c9SLukas Wunner device_remove_properties(dev); 25472ec16150SJeffy Chen device_links_purge(dev); 25481da177e4SLinus Torvalds 2549599bad38SJoerg Roedel if (dev->bus) 2550599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2551599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 2552312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2553cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 25541da177e4SLinus Torvalds kobject_del(&dev->kobj); 2555cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 25561da177e4SLinus Torvalds put_device(parent); 25571da177e4SLinus Torvalds } 255886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 25591da177e4SLinus Torvalds 25601da177e4SLinus Torvalds /** 25611da177e4SLinus Torvalds * device_unregister - unregister device from system. 25621da177e4SLinus Torvalds * @dev: device going away. 25631da177e4SLinus Torvalds * 25641da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 25651da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 25661da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 25671da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 25681da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 25691da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 25701da177e4SLinus Torvalds */ 25711da177e4SLinus Torvalds void device_unregister(struct device *dev) 25721da177e4SLinus Torvalds { 25731e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 25741da177e4SLinus Torvalds device_del(dev); 25751da177e4SLinus Torvalds put_device(dev); 25761da177e4SLinus Torvalds } 257786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 25781da177e4SLinus Torvalds 25793d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 25803d060aebSAndy Shevchenko { 25813d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 25823d060aebSAndy Shevchenko struct device *dev = NULL; 25833d060aebSAndy Shevchenko struct device_private *p; 25843d060aebSAndy Shevchenko 25853d060aebSAndy Shevchenko if (n) { 25863d060aebSAndy Shevchenko p = to_device_private_parent(n); 25873d060aebSAndy Shevchenko dev = p->device; 25883d060aebSAndy Shevchenko } 25893d060aebSAndy Shevchenko return dev; 25903d060aebSAndy Shevchenko } 25913d060aebSAndy Shevchenko 259236239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 259336239577Smochel@digitalimplant.org { 259436239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 2595f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 2596f791b8c8SGreg Kroah-Hartman struct device_private *p; 2597f791b8c8SGreg Kroah-Hartman 2598f791b8c8SGreg Kroah-Hartman if (n) { 2599f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 2600f791b8c8SGreg Kroah-Hartman dev = p->device; 2601f791b8c8SGreg Kroah-Hartman } 2602f791b8c8SGreg Kroah-Hartman return dev; 260336239577Smochel@digitalimplant.org } 260436239577Smochel@digitalimplant.org 26051da177e4SLinus Torvalds /** 2606e454cea2SKay Sievers * device_get_devnode - path of device node file 26076fcf53acSKay Sievers * @dev: device 2608e454cea2SKay Sievers * @mode: returned file access mode 26093c2670e6SKay Sievers * @uid: returned file owner 26103c2670e6SKay Sievers * @gid: returned file group 26116fcf53acSKay Sievers * @tmp: possibly allocated string 26126fcf53acSKay Sievers * 26136fcf53acSKay Sievers * Return the relative path of a possible device node. 26146fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 26156fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 26166fcf53acSKay Sievers * freed by the caller. 26176fcf53acSKay Sievers */ 2618e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 26194e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 26203c2670e6SKay Sievers const char **tmp) 26216fcf53acSKay Sievers { 26226fcf53acSKay Sievers char *s; 26236fcf53acSKay Sievers 26246fcf53acSKay Sievers *tmp = NULL; 26256fcf53acSKay Sievers 26266fcf53acSKay Sievers /* the device type may provide a specific name */ 2627e454cea2SKay Sievers if (dev->type && dev->type->devnode) 26283c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 26296fcf53acSKay Sievers if (*tmp) 26306fcf53acSKay Sievers return *tmp; 26316fcf53acSKay Sievers 26326fcf53acSKay Sievers /* the class may provide a specific name */ 2633e454cea2SKay Sievers if (dev->class && dev->class->devnode) 2634e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 26356fcf53acSKay Sievers if (*tmp) 26366fcf53acSKay Sievers return *tmp; 26376fcf53acSKay Sievers 26386fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 26396fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 26406fcf53acSKay Sievers return dev_name(dev); 26416fcf53acSKay Sievers 26426fcf53acSKay Sievers /* replace '!' in the name with '/' */ 2643a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 2644a29fd614SRasmus Villemoes if (!s) 26456fcf53acSKay Sievers return NULL; 2646a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 2647a29fd614SRasmus Villemoes return *tmp = s; 26486fcf53acSKay Sievers } 26496fcf53acSKay Sievers 26506fcf53acSKay Sievers /** 26511da177e4SLinus Torvalds * device_for_each_child - device child iterator. 2652c41455fbSRandy Dunlap * @parent: parent struct device. 26531da177e4SLinus Torvalds * @fn: function to be called for each device. 2654f8878dcbSRobert P. J. Day * @data: data for the callback. 26551da177e4SLinus Torvalds * 2656c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 26571da177e4SLinus Torvalds * passing it @data. 26581da177e4SLinus Torvalds * 26591da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 26601da177e4SLinus Torvalds * other than 0, we break out and return that value. 26611da177e4SLinus Torvalds */ 266236239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 26634a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 26641da177e4SLinus Torvalds { 266536239577Smochel@digitalimplant.org struct klist_iter i; 26661da177e4SLinus Torvalds struct device *child; 26671da177e4SLinus Torvalds int error = 0; 26681da177e4SLinus Torvalds 2669014c90dbSGreg Kroah-Hartman if (!parent->p) 2670014c90dbSGreg Kroah-Hartman return 0; 2671014c90dbSGreg Kroah-Hartman 2672f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 267393ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 267436239577Smochel@digitalimplant.org error = fn(child, data); 267536239577Smochel@digitalimplant.org klist_iter_exit(&i); 26761da177e4SLinus Torvalds return error; 26771da177e4SLinus Torvalds } 267886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 26791da177e4SLinus Torvalds 26805ab69981SCornelia Huck /** 26813d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 26823d060aebSAndy Shevchenko * @parent: parent struct device. 26833d060aebSAndy Shevchenko * @fn: function to be called for each device. 26843d060aebSAndy Shevchenko * @data: data for the callback. 26853d060aebSAndy Shevchenko * 26863d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 26873d060aebSAndy Shevchenko * passing it @data. 26883d060aebSAndy Shevchenko * 26893d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 26903d060aebSAndy Shevchenko * other than 0, we break out and return that value. 26913d060aebSAndy Shevchenko */ 26923d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 26933d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 26943d060aebSAndy Shevchenko { 26953d060aebSAndy Shevchenko struct klist_iter i; 26963d060aebSAndy Shevchenko struct device *child; 26973d060aebSAndy Shevchenko int error = 0; 26983d060aebSAndy Shevchenko 26993d060aebSAndy Shevchenko if (!parent->p) 27003d060aebSAndy Shevchenko return 0; 27013d060aebSAndy Shevchenko 27023d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 27033d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 27043d060aebSAndy Shevchenko error = fn(child, data); 27053d060aebSAndy Shevchenko klist_iter_exit(&i); 27063d060aebSAndy Shevchenko return error; 27073d060aebSAndy Shevchenko } 27083d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 27093d060aebSAndy Shevchenko 27103d060aebSAndy Shevchenko /** 27115ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 27125ab69981SCornelia Huck * @parent: parent struct device 27135ab69981SCornelia Huck * @match: Callback function to check device 2714f8878dcbSRobert P. J. Day * @data: Data to pass to match function 27155ab69981SCornelia Huck * 27165ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 27175ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 27185ab69981SCornelia Huck * determined by the @match callback. 27195ab69981SCornelia Huck * 27205ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 27215ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 27225ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 27235ab69981SCornelia Huck * and not iterate over any more devices. 2724a4e2400aSFederico Vaga * 2725a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 27265ab69981SCornelia Huck */ 27275ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 27284a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 27295ab69981SCornelia Huck { 27305ab69981SCornelia Huck struct klist_iter i; 27315ab69981SCornelia Huck struct device *child; 27325ab69981SCornelia Huck 27335ab69981SCornelia Huck if (!parent) 27345ab69981SCornelia Huck return NULL; 27355ab69981SCornelia Huck 2736f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 27375ab69981SCornelia Huck while ((child = next_device(&i))) 27385ab69981SCornelia Huck if (match(child, data) && get_device(child)) 27395ab69981SCornelia Huck break; 27405ab69981SCornelia Huck klist_iter_exit(&i); 27415ab69981SCornelia Huck return child; 27425ab69981SCornelia Huck } 274386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 27445ab69981SCornelia Huck 2745dad9bb01SHeikki Krogerus /** 2746dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 2747dad9bb01SHeikki Krogerus * @parent: parent struct device 2748dad9bb01SHeikki Krogerus * @name: name of the child device 2749dad9bb01SHeikki Krogerus * 2750dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 2751dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 2752dad9bb01SHeikki Krogerus * 2753dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 2754dad9bb01SHeikki Krogerus */ 2755dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 2756dad9bb01SHeikki Krogerus const char *name) 2757dad9bb01SHeikki Krogerus { 2758dad9bb01SHeikki Krogerus struct klist_iter i; 2759dad9bb01SHeikki Krogerus struct device *child; 2760dad9bb01SHeikki Krogerus 2761dad9bb01SHeikki Krogerus if (!parent) 2762dad9bb01SHeikki Krogerus return NULL; 2763dad9bb01SHeikki Krogerus 2764dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 2765dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 2766dad9bb01SHeikki Krogerus if (!strcmp(dev_name(child), name) && get_device(child)) 2767dad9bb01SHeikki Krogerus break; 2768dad9bb01SHeikki Krogerus klist_iter_exit(&i); 2769dad9bb01SHeikki Krogerus return child; 2770dad9bb01SHeikki Krogerus } 2771dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 2772dad9bb01SHeikki Krogerus 27731da177e4SLinus Torvalds int __init devices_init(void) 27741da177e4SLinus Torvalds { 2775881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 2776881c6cfdSGreg Kroah-Hartman if (!devices_kset) 2777881c6cfdSGreg Kroah-Hartman return -ENOMEM; 2778e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 2779e105b8bfSDan Williams if (!dev_kobj) 2780e105b8bfSDan Williams goto dev_kobj_err; 2781e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 2782e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 2783e105b8bfSDan Williams goto block_kobj_err; 2784e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 2785e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 2786e105b8bfSDan Williams goto char_kobj_err; 2787e105b8bfSDan Williams 2788881c6cfdSGreg Kroah-Hartman return 0; 2789e105b8bfSDan Williams 2790e105b8bfSDan Williams char_kobj_err: 2791e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 2792e105b8bfSDan Williams block_kobj_err: 2793e105b8bfSDan Williams kobject_put(dev_kobj); 2794e105b8bfSDan Williams dev_kobj_err: 2795e105b8bfSDan Williams kset_unregister(devices_kset); 2796e105b8bfSDan Williams return -ENOMEM; 27971da177e4SLinus Torvalds } 27981da177e4SLinus Torvalds 27994f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 28004f3549d7SRafael J. Wysocki { 28014f3549d7SRafael J. Wysocki int ret; 28024f3549d7SRafael J. Wysocki 28034f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 28044f3549d7SRafael J. Wysocki if (ret) 28054f3549d7SRafael J. Wysocki return ret; 28064f3549d7SRafael J. Wysocki 28074f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 28084f3549d7SRafael J. Wysocki } 28094f3549d7SRafael J. Wysocki 28104f3549d7SRafael J. Wysocki /** 28114f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 28124f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 28134f3549d7SRafael J. Wysocki * 28144f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 28154f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 28164f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 28174f3549d7SRafael J. Wysocki * is executed. 28184f3549d7SRafael J. Wysocki * 28194f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 28204f3549d7SRafael J. Wysocki */ 28214f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 28224f3549d7SRafael J. Wysocki { 28234f3549d7SRafael J. Wysocki int ret; 28244f3549d7SRafael J. Wysocki 28254f3549d7SRafael J. Wysocki if (dev->offline_disabled) 28264f3549d7SRafael J. Wysocki return -EPERM; 28274f3549d7SRafael J. Wysocki 28284f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 28294f3549d7SRafael J. Wysocki if (ret) 28304f3549d7SRafael J. Wysocki return ret; 28314f3549d7SRafael J. Wysocki 28324f3549d7SRafael J. Wysocki device_lock(dev); 28334f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 28344f3549d7SRafael J. Wysocki if (dev->offline) { 28354f3549d7SRafael J. Wysocki ret = 1; 28364f3549d7SRafael J. Wysocki } else { 28374f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 28384f3549d7SRafael J. Wysocki if (!ret) { 28394f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 28404f3549d7SRafael J. Wysocki dev->offline = true; 28414f3549d7SRafael J. Wysocki } 28424f3549d7SRafael J. Wysocki } 28434f3549d7SRafael J. Wysocki } 28444f3549d7SRafael J. Wysocki device_unlock(dev); 28454f3549d7SRafael J. Wysocki 28464f3549d7SRafael J. Wysocki return ret; 28474f3549d7SRafael J. Wysocki } 28484f3549d7SRafael J. Wysocki 28494f3549d7SRafael J. Wysocki /** 28504f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 28514f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 28524f3549d7SRafael J. Wysocki * 28534f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 28544f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 28554f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 28564f3549d7SRafael J. Wysocki * 28574f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 28584f3549d7SRafael J. Wysocki */ 28594f3549d7SRafael J. Wysocki int device_online(struct device *dev) 28604f3549d7SRafael J. Wysocki { 28614f3549d7SRafael J. Wysocki int ret = 0; 28624f3549d7SRafael J. Wysocki 28634f3549d7SRafael J. Wysocki device_lock(dev); 28644f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 28654f3549d7SRafael J. Wysocki if (dev->offline) { 28664f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 28674f3549d7SRafael J. Wysocki if (!ret) { 28684f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 28694f3549d7SRafael J. Wysocki dev->offline = false; 28704f3549d7SRafael J. Wysocki } 28714f3549d7SRafael J. Wysocki } else { 28724f3549d7SRafael J. Wysocki ret = 1; 28734f3549d7SRafael J. Wysocki } 28744f3549d7SRafael J. Wysocki } 28754f3549d7SRafael J. Wysocki device_unlock(dev); 28764f3549d7SRafael J. Wysocki 28774f3549d7SRafael J. Wysocki return ret; 28784f3549d7SRafael J. Wysocki } 28794f3549d7SRafael J. Wysocki 28807f100d15SKarthigan Srinivasan struct root_device { 28810aa0dc41SMark McLoughlin struct device dev; 28820aa0dc41SMark McLoughlin struct module *owner; 28830aa0dc41SMark McLoughlin }; 28840aa0dc41SMark McLoughlin 288593058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 2886481e2079SFerenc Wagner { 2887481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 2888481e2079SFerenc Wagner } 28890aa0dc41SMark McLoughlin 28900aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 28910aa0dc41SMark McLoughlin { 28920aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 28930aa0dc41SMark McLoughlin } 28940aa0dc41SMark McLoughlin 28950aa0dc41SMark McLoughlin /** 28960aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 28970aa0dc41SMark McLoughlin * @name: root device name 28980aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 28990aa0dc41SMark McLoughlin * 29000aa0dc41SMark McLoughlin * This function allocates a root device and registers it 29010aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 29020aa0dc41SMark McLoughlin * device, use root_device_unregister(). 29030aa0dc41SMark McLoughlin * 29040aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 29050aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 29060aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 29070aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 29080aa0dc41SMark McLoughlin * 29090aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 29100aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 29110aa0dc41SMark McLoughlin * in sysfs. 29120aa0dc41SMark McLoughlin * 2913f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 2914f0eae0edSJani Nikula * 29150aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 29160aa0dc41SMark McLoughlin */ 29170aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 29180aa0dc41SMark McLoughlin { 29190aa0dc41SMark McLoughlin struct root_device *root; 29200aa0dc41SMark McLoughlin int err = -ENOMEM; 29210aa0dc41SMark McLoughlin 29220aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 29230aa0dc41SMark McLoughlin if (!root) 29240aa0dc41SMark McLoughlin return ERR_PTR(err); 29250aa0dc41SMark McLoughlin 2926acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 29270aa0dc41SMark McLoughlin if (err) { 29280aa0dc41SMark McLoughlin kfree(root); 29290aa0dc41SMark McLoughlin return ERR_PTR(err); 29300aa0dc41SMark McLoughlin } 29310aa0dc41SMark McLoughlin 29320aa0dc41SMark McLoughlin root->dev.release = root_device_release; 29330aa0dc41SMark McLoughlin 29340aa0dc41SMark McLoughlin err = device_register(&root->dev); 29350aa0dc41SMark McLoughlin if (err) { 29360aa0dc41SMark McLoughlin put_device(&root->dev); 29370aa0dc41SMark McLoughlin return ERR_PTR(err); 29380aa0dc41SMark McLoughlin } 29390aa0dc41SMark McLoughlin 29401d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 29410aa0dc41SMark McLoughlin if (owner) { 29420aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 29430aa0dc41SMark McLoughlin 29440aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 29450aa0dc41SMark McLoughlin if (err) { 29460aa0dc41SMark McLoughlin device_unregister(&root->dev); 29470aa0dc41SMark McLoughlin return ERR_PTR(err); 29480aa0dc41SMark McLoughlin } 29490aa0dc41SMark McLoughlin root->owner = owner; 29500aa0dc41SMark McLoughlin } 29510aa0dc41SMark McLoughlin #endif 29520aa0dc41SMark McLoughlin 29530aa0dc41SMark McLoughlin return &root->dev; 29540aa0dc41SMark McLoughlin } 29550aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 29560aa0dc41SMark McLoughlin 29570aa0dc41SMark McLoughlin /** 29580aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 29597cbcf225SRandy Dunlap * @dev: device going away 29600aa0dc41SMark McLoughlin * 29610aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 29620aa0dc41SMark McLoughlin * root_device_register(). 29630aa0dc41SMark McLoughlin */ 29640aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 29650aa0dc41SMark McLoughlin { 29660aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 29670aa0dc41SMark McLoughlin 29680aa0dc41SMark McLoughlin if (root->owner) 29690aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 29700aa0dc41SMark McLoughlin 29710aa0dc41SMark McLoughlin device_unregister(dev); 29720aa0dc41SMark McLoughlin } 29730aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 29740aa0dc41SMark McLoughlin 297523681e47SGreg Kroah-Hartman 297623681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 297723681e47SGreg Kroah-Hartman { 29781e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 297923681e47SGreg Kroah-Hartman kfree(dev); 298023681e47SGreg Kroah-Hartman } 298123681e47SGreg Kroah-Hartman 29826a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 298339ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 298439ef3112SGuenter Roeck dev_t devt, void *drvdata, 298539ef3112SGuenter Roeck const struct attribute_group **groups, 298639ef3112SGuenter Roeck const char *fmt, va_list args) 298739ef3112SGuenter Roeck { 298839ef3112SGuenter Roeck struct device *dev = NULL; 298939ef3112SGuenter Roeck int retval = -ENODEV; 299039ef3112SGuenter Roeck 299139ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 299239ef3112SGuenter Roeck goto error; 299339ef3112SGuenter Roeck 299439ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 299539ef3112SGuenter Roeck if (!dev) { 299639ef3112SGuenter Roeck retval = -ENOMEM; 299739ef3112SGuenter Roeck goto error; 299839ef3112SGuenter Roeck } 299939ef3112SGuenter Roeck 3000bbc780f8SDavid Herrmann device_initialize(dev); 300139ef3112SGuenter Roeck dev->devt = devt; 300239ef3112SGuenter Roeck dev->class = class; 300339ef3112SGuenter Roeck dev->parent = parent; 300439ef3112SGuenter Roeck dev->groups = groups; 300539ef3112SGuenter Roeck dev->release = device_create_release; 300639ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 300739ef3112SGuenter Roeck 300839ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 300939ef3112SGuenter Roeck if (retval) 301039ef3112SGuenter Roeck goto error; 301139ef3112SGuenter Roeck 3012bbc780f8SDavid Herrmann retval = device_add(dev); 301339ef3112SGuenter Roeck if (retval) 301439ef3112SGuenter Roeck goto error; 301539ef3112SGuenter Roeck 301639ef3112SGuenter Roeck return dev; 301739ef3112SGuenter Roeck 301839ef3112SGuenter Roeck error: 301939ef3112SGuenter Roeck put_device(dev); 302039ef3112SGuenter Roeck return ERR_PTR(retval); 302139ef3112SGuenter Roeck } 302239ef3112SGuenter Roeck 302323681e47SGreg Kroah-Hartman /** 30248882b394SGreg Kroah-Hartman * device_create_vargs - creates a device and registers it with sysfs 30258882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 30268882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 30278882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 30288882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 30298882b394SGreg Kroah-Hartman * @fmt: string for the device's name 30308882b394SGreg Kroah-Hartman * @args: va_list for the device's name 30318882b394SGreg Kroah-Hartman * 30328882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 30338882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 30348882b394SGreg Kroah-Hartman * 30358882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 30368882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 30378882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 30388882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 30398882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 30408882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 30418882b394SGreg Kroah-Hartman * pointer. 30428882b394SGreg Kroah-Hartman * 3043f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3044f0eae0edSJani Nikula * 30458882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 30468882b394SGreg Kroah-Hartman * been created with a call to class_create(). 30478882b394SGreg Kroah-Hartman */ 30488882b394SGreg Kroah-Hartman struct device *device_create_vargs(struct class *class, struct device *parent, 30498882b394SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, 30508882b394SGreg Kroah-Hartman va_list args) 30518882b394SGreg Kroah-Hartman { 305239ef3112SGuenter Roeck return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 305339ef3112SGuenter Roeck fmt, args); 30548882b394SGreg Kroah-Hartman } 30558882b394SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_vargs); 30568882b394SGreg Kroah-Hartman 30578882b394SGreg Kroah-Hartman /** 30584e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 30598882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 30608882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 30618882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 30628882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 30638882b394SGreg Kroah-Hartman * @fmt: string for the device's name 30648882b394SGreg Kroah-Hartman * 30658882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 30668882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 30678882b394SGreg Kroah-Hartman * 30688882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 30698882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 30708882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 30718882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 30728882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 30738882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 30748882b394SGreg Kroah-Hartman * pointer. 30758882b394SGreg Kroah-Hartman * 3076f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3077f0eae0edSJani Nikula * 30788882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 30798882b394SGreg Kroah-Hartman * been created with a call to class_create(). 30808882b394SGreg Kroah-Hartman */ 30814e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 30824e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 30838882b394SGreg Kroah-Hartman { 30848882b394SGreg Kroah-Hartman va_list vargs; 30858882b394SGreg Kroah-Hartman struct device *dev; 30868882b394SGreg Kroah-Hartman 30878882b394SGreg Kroah-Hartman va_start(vargs, fmt); 30888882b394SGreg Kroah-Hartman dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 30898882b394SGreg Kroah-Hartman va_end(vargs); 30908882b394SGreg Kroah-Hartman return dev; 30918882b394SGreg Kroah-Hartman } 30924e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 30938882b394SGreg Kroah-Hartman 309439ef3112SGuenter Roeck /** 309539ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 309639ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 309739ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 309839ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 309939ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 310039ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 310139ef3112SGuenter Roeck * @fmt: string for the device's name 310239ef3112SGuenter Roeck * 310339ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 310439ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 310539ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 310639ef3112SGuenter Roeck * be created automatically. 310739ef3112SGuenter Roeck * 310839ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 310939ef3112SGuenter Roeck * the dev_t is not 0,0. 311039ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 311139ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 311239ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 311339ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 311439ef3112SGuenter Roeck * pointer. 311539ef3112SGuenter Roeck * 311639ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 311739ef3112SGuenter Roeck * 311839ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 311939ef3112SGuenter Roeck * been created with a call to class_create(). 312039ef3112SGuenter Roeck */ 312139ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 312239ef3112SGuenter Roeck struct device *parent, dev_t devt, 312339ef3112SGuenter Roeck void *drvdata, 312439ef3112SGuenter Roeck const struct attribute_group **groups, 312539ef3112SGuenter Roeck const char *fmt, ...) 312639ef3112SGuenter Roeck { 312739ef3112SGuenter Roeck va_list vargs; 312839ef3112SGuenter Roeck struct device *dev; 312939ef3112SGuenter Roeck 313039ef3112SGuenter Roeck va_start(vargs, fmt); 313139ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 313239ef3112SGuenter Roeck fmt, vargs); 313339ef3112SGuenter Roeck va_end(vargs); 313439ef3112SGuenter Roeck return dev; 313539ef3112SGuenter Roeck } 313639ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 313739ef3112SGuenter Roeck 3138775b64d2SRafael J. Wysocki /** 3139775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 3140775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 3141775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 3142775b64d2SRafael J. Wysocki * 3143775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 3144775b64d2SRafael J. Wysocki * call to device_create(). 3145775b64d2SRafael J. Wysocki */ 3146775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 3147775b64d2SRafael J. Wysocki { 3148775b64d2SRafael J. Wysocki struct device *dev; 3149775b64d2SRafael J. Wysocki 31504495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 3151cd35449bSDave Young if (dev) { 3152cd35449bSDave Young put_device(dev); 315323681e47SGreg Kroah-Hartman device_unregister(dev); 315423681e47SGreg Kroah-Hartman } 3155cd35449bSDave Young } 315623681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 3157a2de48caSGreg Kroah-Hartman 3158a2de48caSGreg Kroah-Hartman /** 3159a2de48caSGreg Kroah-Hartman * device_rename - renames a device 3160a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 3161a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 3162030c1d2bSEric W. Biederman * 3163030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 3164030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 3165030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 3166030c1d2bSEric W. Biederman * won't conflict with other devices. 3167c6c0ac66SMichael Ellerman * 3168a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 3169a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 3170a5462516STimur Tabi * some insight: 3171a5462516STimur Tabi * 3172a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 3173a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 3174a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 3175a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 3176a5462516STimur Tabi * 3177a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 3178a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 3179a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 3180a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 3181a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 3182a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 3183a5462516STimur Tabi * 3184a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 3185a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 3186a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 3187a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 3188a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 3189a5462516STimur Tabi * reasons. 3190a5462516STimur Tabi * 3191a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 3192a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 3193a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 3194a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 3195a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 3196a2de48caSGreg Kroah-Hartman */ 31976937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 3198a2de48caSGreg Kroah-Hartman { 31994b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 32002ee97cafSCornelia Huck char *old_device_name = NULL; 3201a2de48caSGreg Kroah-Hartman int error; 3202a2de48caSGreg Kroah-Hartman 3203a2de48caSGreg Kroah-Hartman dev = get_device(dev); 3204a2de48caSGreg Kroah-Hartman if (!dev) 3205a2de48caSGreg Kroah-Hartman return -EINVAL; 3206a2de48caSGreg Kroah-Hartman 320769df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 3208a2de48caSGreg Kroah-Hartman 32091fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 32102ee97cafSCornelia Huck if (!old_device_name) { 3211952ab431SJesper Juhl error = -ENOMEM; 32122ee97cafSCornelia Huck goto out; 3213952ab431SJesper Juhl } 3214a2de48caSGreg Kroah-Hartman 3215f349cf34SEric W. Biederman if (dev->class) { 32164b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 32174b30ee58STejun Heo kobj, old_device_name, 32184b30ee58STejun Heo new_name, kobject_namespace(kobj)); 3219f349cf34SEric W. Biederman if (error) 3220f349cf34SEric W. Biederman goto out; 3221f349cf34SEric W. Biederman } 322239aba963SKay Sievers 32234b30ee58STejun Heo error = kobject_rename(kobj, new_name); 32241fa5ae85SKay Sievers if (error) 32252ee97cafSCornelia Huck goto out; 3226a2de48caSGreg Kroah-Hartman 32272ee97cafSCornelia Huck out: 3228a2de48caSGreg Kroah-Hartman put_device(dev); 3229a2de48caSGreg Kroah-Hartman 32302ee97cafSCornelia Huck kfree(old_device_name); 3231a2de48caSGreg Kroah-Hartman 3232a2de48caSGreg Kroah-Hartman return error; 3233a2de48caSGreg Kroah-Hartman } 3234a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 32358a82472fSCornelia Huck 32368a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 32378a82472fSCornelia Huck struct device *old_parent, 32388a82472fSCornelia Huck struct device *new_parent) 32398a82472fSCornelia Huck { 3240f7f3461dSGreg Kroah-Hartman int error = 0; 32418a82472fSCornelia Huck 3242f7f3461dSGreg Kroah-Hartman if (old_parent) 3243f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 3244f7f3461dSGreg Kroah-Hartman if (new_parent) 3245f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 3246f7f3461dSGreg Kroah-Hartman "device"); 3247f7f3461dSGreg Kroah-Hartman return error; 32488a82472fSCornelia Huck } 32498a82472fSCornelia Huck 32508a82472fSCornelia Huck /** 32518a82472fSCornelia Huck * device_move - moves a device to a new parent 32528a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 325313509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 3254ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 32558a82472fSCornelia Huck */ 3256ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 3257ffa6a705SCornelia Huck enum dpm_order dpm_order) 32588a82472fSCornelia Huck { 32598a82472fSCornelia Huck int error; 32608a82472fSCornelia Huck struct device *old_parent; 3261c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 32628a82472fSCornelia Huck 32638a82472fSCornelia Huck dev = get_device(dev); 32648a82472fSCornelia Huck if (!dev) 32658a82472fSCornelia Huck return -EINVAL; 32668a82472fSCornelia Huck 3267ffa6a705SCornelia Huck device_pm_lock(); 32688a82472fSCornelia Huck new_parent = get_device(new_parent); 3269c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 327084d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 327184d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 327284d0c27dSTetsuo Handa put_device(new_parent); 327384d0c27dSTetsuo Handa goto out; 327484d0c27dSTetsuo Handa } 327563b6971aSCornelia Huck 32761e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 32771e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 3278c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 32798a82472fSCornelia Huck if (error) { 328063b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 32818a82472fSCornelia Huck put_device(new_parent); 32828a82472fSCornelia Huck goto out; 32838a82472fSCornelia Huck } 32848a82472fSCornelia Huck old_parent = dev->parent; 32858a82472fSCornelia Huck dev->parent = new_parent; 32868a82472fSCornelia Huck if (old_parent) 3287f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 32880d358f22SYinghai Lu if (new_parent) { 3289f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3290f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 32910d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 32920d358f22SYinghai Lu } 32930d358f22SYinghai Lu 3294bdd4034dSRabin Vincent if (dev->class) { 32958a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 32968a82472fSCornelia Huck if (error) { 32978a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 32988a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 32998a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 3300c744aeaeSCornelia Huck if (new_parent) 3301f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 33020d358f22SYinghai Lu dev->parent = old_parent; 33030d358f22SYinghai Lu if (old_parent) { 3304f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3305f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 33060d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 33070d358f22SYinghai Lu } 33088a82472fSCornelia Huck } 330963b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 33108a82472fSCornelia Huck put_device(new_parent); 33118a82472fSCornelia Huck goto out; 33128a82472fSCornelia Huck } 3313bdd4034dSRabin Vincent } 3314ffa6a705SCornelia Huck switch (dpm_order) { 3315ffa6a705SCornelia Huck case DPM_ORDER_NONE: 3316ffa6a705SCornelia Huck break; 3317ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 3318ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 331952cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 3320ffa6a705SCornelia Huck break; 3321ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 3322ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 332352cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 3324ffa6a705SCornelia Huck break; 3325ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 3326ffa6a705SCornelia Huck device_pm_move_last(dev); 332752cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 3328ffa6a705SCornelia Huck break; 3329ffa6a705SCornelia Huck } 3330bdd4034dSRabin Vincent 33318a82472fSCornelia Huck put_device(old_parent); 33328a82472fSCornelia Huck out: 3333ffa6a705SCornelia Huck device_pm_unlock(); 33348a82472fSCornelia Huck put_device(dev); 33358a82472fSCornelia Huck return error; 33368a82472fSCornelia Huck } 33378a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 333837b0c020SGreg Kroah-Hartman 333937b0c020SGreg Kroah-Hartman /** 334037b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 334137b0c020SGreg Kroah-Hartman */ 334237b0c020SGreg Kroah-Hartman void device_shutdown(void) 334337b0c020SGreg Kroah-Hartman { 3344f123db8eSBenson Leung struct device *dev, *parent; 334537b0c020SGreg Kroah-Hartman 33463297c8fcSPingfan Liu wait_for_device_probe(); 33473297c8fcSPingfan Liu device_block_probing(); 33483297c8fcSPingfan Liu 33496245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 33506245838fSHugh Daschbach /* 33516245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 33526245838fSHugh Daschbach * Beware that device unplug events may also start pulling 33536245838fSHugh Daschbach * devices offline, even as the system is shutting down. 33546245838fSHugh Daschbach */ 33556245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 33566245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 33576245838fSHugh Daschbach kobj.entry); 3358d1c6c030SMing Lei 3359d1c6c030SMing Lei /* 3360d1c6c030SMing Lei * hold reference count of device's parent to 3361d1c6c030SMing Lei * prevent it from being freed because parent's 3362d1c6c030SMing Lei * lock is to be held 3363d1c6c030SMing Lei */ 3364f123db8eSBenson Leung parent = get_device(dev->parent); 33656245838fSHugh Daschbach get_device(dev); 33666245838fSHugh Daschbach /* 33676245838fSHugh Daschbach * Make sure the device is off the kset list, in the 33686245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 33696245838fSHugh Daschbach */ 33706245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 33716245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 3372fe6b91f4SAlan Stern 3373d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 3374f123db8eSBenson Leung if (parent) 3375f123db8eSBenson Leung device_lock(parent); 3376d1c6c030SMing Lei device_lock(dev); 3377d1c6c030SMing Lei 3378fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 3379fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 3380fe6b91f4SAlan Stern pm_runtime_barrier(dev); 33816245838fSHugh Daschbach 33827521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 3383f77af151SJosh Zimmerman if (initcall_debug) 33847521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 33857521621eSMichal Suchanek dev->class->shutdown_pre(dev); 33867521621eSMichal Suchanek } 33877521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 33880246c4faSShuoX Liu if (initcall_debug) 33890246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 339037b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 339137b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 33920246c4faSShuoX Liu if (initcall_debug) 33930246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 339437b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 339537b0c020SGreg Kroah-Hartman } 3396d1c6c030SMing Lei 3397d1c6c030SMing Lei device_unlock(dev); 3398f123db8eSBenson Leung if (parent) 3399f123db8eSBenson Leung device_unlock(parent); 3400d1c6c030SMing Lei 34016245838fSHugh Daschbach put_device(dev); 3402f123db8eSBenson Leung put_device(parent); 34036245838fSHugh Daschbach 34046245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 340537b0c020SGreg Kroah-Hartman } 34066245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 340737b0c020SGreg Kroah-Hartman } 340899bcf217SJoe Perches 340999bcf217SJoe Perches /* 341099bcf217SJoe Perches * Device logging functions 341199bcf217SJoe Perches */ 341299bcf217SJoe Perches 341399bcf217SJoe Perches #ifdef CONFIG_PRINTK 3414666f355fSJoe Perches static int 3415666f355fSJoe Perches create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 341699bcf217SJoe Perches { 3417c4e00daaSKay Sievers const char *subsys; 3418798efc60SJoe Perches size_t pos = 0; 341999bcf217SJoe Perches 3420c4e00daaSKay Sievers if (dev->class) 3421c4e00daaSKay Sievers subsys = dev->class->name; 3422c4e00daaSKay Sievers else if (dev->bus) 3423c4e00daaSKay Sievers subsys = dev->bus->name; 3424c4e00daaSKay Sievers else 3425798efc60SJoe Perches return 0; 3426c4e00daaSKay Sievers 3427798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 3428655e5b7cSBen Hutchings if (pos >= hdrlen) 3429655e5b7cSBen Hutchings goto overflow; 3430c4e00daaSKay Sievers 3431c4e00daaSKay Sievers /* 3432c4e00daaSKay Sievers * Add device identifier DEVICE=: 3433c4e00daaSKay Sievers * b12:8 block dev_t 3434c4e00daaSKay Sievers * c127:3 char dev_t 3435c4e00daaSKay Sievers * n8 netdev ifindex 3436c4e00daaSKay Sievers * +sound:card0 subsystem:devname 3437c4e00daaSKay Sievers */ 3438c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 3439c4e00daaSKay Sievers char c; 3440c4e00daaSKay Sievers 3441c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 3442c4e00daaSKay Sievers c = 'b'; 3443c4e00daaSKay Sievers else 3444c4e00daaSKay Sievers c = 'c'; 3445798efc60SJoe Perches pos++; 3446798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3447c4e00daaSKay Sievers "DEVICE=%c%u:%u", 3448c4e00daaSKay Sievers c, MAJOR(dev->devt), MINOR(dev->devt)); 3449c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 3450c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 3451c4e00daaSKay Sievers 3452798efc60SJoe Perches pos++; 3453798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3454c4e00daaSKay Sievers "DEVICE=n%u", net->ifindex); 3455c4e00daaSKay Sievers } else { 3456798efc60SJoe Perches pos++; 3457798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3458c4e00daaSKay Sievers "DEVICE=+%s:%s", subsys, dev_name(dev)); 3459c4e00daaSKay Sievers } 3460af7f2158SJim Cromie 3461655e5b7cSBen Hutchings if (pos >= hdrlen) 3462655e5b7cSBen Hutchings goto overflow; 3463655e5b7cSBen Hutchings 3464798efc60SJoe Perches return pos; 3465655e5b7cSBen Hutchings 3466655e5b7cSBen Hutchings overflow: 3467655e5b7cSBen Hutchings dev_WARN(dev, "device/subsystem name too long"); 3468655e5b7cSBen Hutchings return 0; 346999bcf217SJoe Perches } 3470798efc60SJoe Perches 347105e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 347205e4e5b8SJoe Perches const char *fmt, va_list args) 347305e4e5b8SJoe Perches { 347405e4e5b8SJoe Perches char hdr[128]; 347505e4e5b8SJoe Perches size_t hdrlen; 347605e4e5b8SJoe Perches 347705e4e5b8SJoe Perches hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 347805e4e5b8SJoe Perches 347905e4e5b8SJoe Perches return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 348005e4e5b8SJoe Perches } 348105e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 348205e4e5b8SJoe Perches 348305e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 348405e4e5b8SJoe Perches { 348505e4e5b8SJoe Perches va_list args; 348605e4e5b8SJoe Perches int r; 348705e4e5b8SJoe Perches 348805e4e5b8SJoe Perches va_start(args, fmt); 348905e4e5b8SJoe Perches 349005e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 349105e4e5b8SJoe Perches 349205e4e5b8SJoe Perches va_end(args); 349305e4e5b8SJoe Perches 349405e4e5b8SJoe Perches return r; 349505e4e5b8SJoe Perches } 349605e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 349705e4e5b8SJoe Perches 3498d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 3499798efc60SJoe Perches struct va_format *vaf) 3500798efc60SJoe Perches { 3501d1f1052cSJoe Perches if (dev) 3502d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 3503798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 3504d1f1052cSJoe Perches else 3505d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 3506798efc60SJoe Perches } 350799bcf217SJoe Perches 3508d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 350999bcf217SJoe Perches const char *fmt, ...) 351099bcf217SJoe Perches { 351199bcf217SJoe Perches struct va_format vaf; 351299bcf217SJoe Perches va_list args; 351399bcf217SJoe Perches 351499bcf217SJoe Perches va_start(args, fmt); 351599bcf217SJoe Perches 351699bcf217SJoe Perches vaf.fmt = fmt; 351799bcf217SJoe Perches vaf.va = &args; 351899bcf217SJoe Perches 3519d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 3520798efc60SJoe Perches 352199bcf217SJoe Perches va_end(args); 352299bcf217SJoe Perches } 352399bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 352499bcf217SJoe Perches 352599bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 3526d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 352799bcf217SJoe Perches { \ 352899bcf217SJoe Perches struct va_format vaf; \ 352999bcf217SJoe Perches va_list args; \ 353099bcf217SJoe Perches \ 353199bcf217SJoe Perches va_start(args, fmt); \ 353299bcf217SJoe Perches \ 353399bcf217SJoe Perches vaf.fmt = fmt; \ 353499bcf217SJoe Perches vaf.va = &args; \ 353599bcf217SJoe Perches \ 3536d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 3537798efc60SJoe Perches \ 353899bcf217SJoe Perches va_end(args); \ 353999bcf217SJoe Perches } \ 354099bcf217SJoe Perches EXPORT_SYMBOL(func); 354199bcf217SJoe Perches 3542663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 3543663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 3544663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 3545663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 3546663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 3547663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 354899bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 354999bcf217SJoe Perches 355099bcf217SJoe Perches #endif 355197badf87SRafael J. Wysocki 355297badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 355397badf87SRafael J. Wysocki { 355497badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 355597badf87SRafael J. Wysocki } 355697badf87SRafael J. Wysocki 355797badf87SRafael J. Wysocki /** 355897badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 355997badf87SRafael J. Wysocki * @dev: Device to handle. 356097badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 356197badf87SRafael J. Wysocki * 356297badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 356397badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 356497badf87SRafael J. Wysocki */ 356597badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 356697badf87SRafael J. Wysocki { 356797badf87SRafael J. Wysocki if (fwnode) { 356897badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 356997badf87SRafael J. Wysocki 357097badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 357197badf87SRafael J. Wysocki fn = fn->secondary; 357297badf87SRafael J. Wysocki 357355f89a8aSMika Westerberg if (fn) { 357455f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 357597badf87SRafael J. Wysocki fwnode->secondary = fn; 357655f89a8aSMika Westerberg } 357797badf87SRafael J. Wysocki dev->fwnode = fwnode; 357897badf87SRafael J. Wysocki } else { 357997badf87SRafael J. Wysocki dev->fwnode = fwnode_is_primary(dev->fwnode) ? 358097badf87SRafael J. Wysocki dev->fwnode->secondary : NULL; 358197badf87SRafael J. Wysocki } 358297badf87SRafael J. Wysocki } 358397badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 358497badf87SRafael J. Wysocki 358597badf87SRafael J. Wysocki /** 358697badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 358797badf87SRafael J. Wysocki * @dev: Device to handle. 358897badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 358997badf87SRafael J. Wysocki * 359097badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 359197badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 359297badf87SRafael J. Wysocki * @fwnode. 359397badf87SRafael J. Wysocki */ 359497badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 359597badf87SRafael J. Wysocki { 359697badf87SRafael J. Wysocki if (fwnode) 359797badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 359897badf87SRafael J. Wysocki 359997badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 360097badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 360197badf87SRafael J. Wysocki else 360297badf87SRafael J. Wysocki dev->fwnode = fwnode; 360397badf87SRafael J. Wysocki } 36044e75e1d7SJohan Hovold 36054e75e1d7SJohan Hovold /** 36064e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 36074e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 36084e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 36094e75e1d7SJohan Hovold * 36104e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 36114e75e1d7SJohan Hovold * any reference held to the old node. 36124e75e1d7SJohan Hovold */ 36134e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 36144e75e1d7SJohan Hovold { 36154e75e1d7SJohan Hovold of_node_put(dev->of_node); 36164e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 36174e75e1d7SJohan Hovold dev->of_node_reused = true; 36184e75e1d7SJohan Hovold } 36194e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 362065b66682SSuzuki K Poulose 36216cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 36226cda08a2SSuzuki K Poulose { 36236cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 36246cda08a2SSuzuki K Poulose } 36256cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 36266cda08a2SSuzuki K Poulose 362765b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 362865b66682SSuzuki K Poulose { 362965b66682SSuzuki K Poulose return dev->of_node == np; 363065b66682SSuzuki K Poulose } 363165b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 363267843bbaSSuzuki K Poulose 363367843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 363467843bbaSSuzuki K Poulose { 363567843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 363667843bbaSSuzuki K Poulose } 363767843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 36384495dfddSSuzuki K Poulose 36394495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 36404495dfddSSuzuki K Poulose { 36414495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 36424495dfddSSuzuki K Poulose } 36434495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 364400500147SSuzuki K Poulose 364500500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 364600500147SSuzuki K Poulose { 364700500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 364800500147SSuzuki K Poulose } 364900500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 36506bf85ba9SSuzuki K Poulose 36516bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 36526bf85ba9SSuzuki K Poulose { 36536bf85ba9SSuzuki K Poulose return 1; 36546bf85ba9SSuzuki K Poulose } 36556bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 3656