1989d42e8SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * drivers/base/core.c - core driver model code (device registration, etc) 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright (c) 2002-3 Patrick Mochel 61da177e4SLinus Torvalds * Copyright (c) 2002-3 Open Source Development Labs 764bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 864bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Novell, Inc. 91da177e4SLinus Torvalds */ 101da177e4SLinus Torvalds 117847a145SHeikki Krogerus #include <linux/acpi.h> 1265650b35SRafael J. Wysocki #include <linux/cpufreq.h> 131da177e4SLinus Torvalds #include <linux/device.h> 141da177e4SLinus Torvalds #include <linux/err.h> 1597badf87SRafael J. Wysocki #include <linux/fwnode.h> 161da177e4SLinus Torvalds #include <linux/init.h> 171da177e4SLinus Torvalds #include <linux/module.h> 181da177e4SLinus Torvalds #include <linux/slab.h> 191da177e4SLinus Torvalds #include <linux/string.h> 2023681e47SGreg Kroah-Hartman #include <linux/kdev_t.h> 21116af378SBenjamin Herrenschmidt #include <linux/notifier.h> 2207d57a32SGrant Likely #include <linux/of.h> 2307d57a32SGrant Likely #include <linux/of_device.h> 24da231fd5SKay Sievers #include <linux/genhd.h> 25f75b1c60SDave Young #include <linux/mutex.h> 26af8db150SPeter Chen #include <linux/pm_runtime.h> 27c4e00daaSKay Sievers #include <linux/netdevice.h> 28174cd4b1SIngo Molnar #include <linux/sched/signal.h> 2963967685SGreg Kroah-Hartman #include <linux/sysfs.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include "base.h" 321da177e4SLinus Torvalds #include "power/power.h" 331da177e4SLinus Torvalds 34e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 35e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 36e52eec13SAndi Kleen long sysfs_deprecated = 1; 37e52eec13SAndi Kleen #else 38e52eec13SAndi Kleen long sysfs_deprecated = 0; 39e52eec13SAndi Kleen #endif 403454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 41e52eec13SAndi Kleen { 4234da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 43e52eec13SAndi Kleen } 44e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 45e52eec13SAndi Kleen #endif 46e52eec13SAndi Kleen 479ed98953SRafael J. Wysocki /* Device links support. */ 48e2ae9bccSSaravana Kannan static LIST_HEAD(wait_for_suppliers); 49e2ae9bccSSaravana Kannan static DEFINE_MUTEX(wfs_lock); 50fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 51fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 529ed98953SRafael J. Wysocki 539ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 549ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 559ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 569ed98953SRafael J. Wysocki 579ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 589ed98953SRafael J. Wysocki { 599ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 609ed98953SRafael J. Wysocki } 619ed98953SRafael J. Wysocki 629ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 639ed98953SRafael J. Wysocki { 649ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 659ed98953SRafael J. Wysocki } 669ed98953SRafael J. Wysocki 6768464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 689ed98953SRafael J. Wysocki { 699ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 709ed98953SRafael J. Wysocki } 719ed98953SRafael J. Wysocki 72ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 739ed98953SRafael J. Wysocki { 749ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 759ed98953SRafael J. Wysocki } 76c2fa1e1bSJoel Fernandes (Google) 77c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 78c2fa1e1bSJoel Fernandes (Google) { 79c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 80c2fa1e1bSJoel Fernandes (Google) } 819ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 829ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 839ed98953SRafael J. Wysocki 849ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 859ed98953SRafael J. Wysocki { 869ed98953SRafael J. Wysocki down_write(&device_links_lock); 879ed98953SRafael J. Wysocki } 889ed98953SRafael J. Wysocki 899ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 909ed98953SRafael J. Wysocki { 919ed98953SRafael J. Wysocki up_write(&device_links_lock); 929ed98953SRafael J. Wysocki } 939ed98953SRafael J. Wysocki 949ed98953SRafael J. Wysocki int device_links_read_lock(void) 959ed98953SRafael J. Wysocki { 969ed98953SRafael J. Wysocki down_read(&device_links_lock); 979ed98953SRafael J. Wysocki return 0; 989ed98953SRafael J. Wysocki } 999ed98953SRafael J. Wysocki 1009ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 1019ed98953SRafael J. Wysocki { 1029ed98953SRafael J. Wysocki up_read(&device_links_lock); 1039ed98953SRafael J. Wysocki } 104c2fa1e1bSJoel Fernandes (Google) 105c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 106c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 107c2fa1e1bSJoel Fernandes (Google) { 108c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 109c2fa1e1bSJoel Fernandes (Google) } 110c2fa1e1bSJoel Fernandes (Google) #endif 1119ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 1129ed98953SRafael J. Wysocki 1139ed98953SRafael J. Wysocki /** 1149ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 1159ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 1169ed98953SRafael J. Wysocki * @target: Device to check against. 1179ed98953SRafael J. Wysocki * 1189ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 1199ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 1209ed98953SRafael J. Wysocki */ 1219ed98953SRafael J. Wysocki static int device_is_dependent(struct device *dev, void *target) 1229ed98953SRafael J. Wysocki { 1239ed98953SRafael J. Wysocki struct device_link *link; 1249ed98953SRafael J. Wysocki int ret; 1259ed98953SRafael J. Wysocki 126e16f4f3eSBenjamin Gaignard if (dev == target) 1279ed98953SRafael J. Wysocki return 1; 1289ed98953SRafael J. Wysocki 1299ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 1309ed98953SRafael J. Wysocki if (ret) 1319ed98953SRafael J. Wysocki return ret; 1329ed98953SRafael J. Wysocki 1339ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 13405ef983eSSaravana Kannan if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 13505ef983eSSaravana Kannan continue; 13605ef983eSSaravana Kannan 137e16f4f3eSBenjamin Gaignard if (link->consumer == target) 1389ed98953SRafael J. Wysocki return 1; 1399ed98953SRafael J. Wysocki 1409ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 1419ed98953SRafael J. Wysocki if (ret) 1429ed98953SRafael J. Wysocki break; 1439ed98953SRafael J. Wysocki } 1449ed98953SRafael J. Wysocki return ret; 1459ed98953SRafael J. Wysocki } 1469ed98953SRafael J. Wysocki 147515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 148515db266SRafael J. Wysocki struct device *consumer, 149515db266SRafael J. Wysocki struct device *supplier) 150515db266SRafael J. Wysocki { 151515db266SRafael J. Wysocki switch (supplier->links.status) { 152515db266SRafael J. Wysocki case DL_DEV_PROBING: 153515db266SRafael J. Wysocki switch (consumer->links.status) { 154515db266SRafael J. Wysocki case DL_DEV_PROBING: 155515db266SRafael J. Wysocki /* 156515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 157515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 158515db266SRafael J. Wysocki * knows that the supplier is already functional (for 159515db266SRafael J. Wysocki * example, it has just acquired some resources from the 160515db266SRafael J. Wysocki * supplier). 161515db266SRafael J. Wysocki */ 162515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 163515db266SRafael J. Wysocki break; 164515db266SRafael J. Wysocki default: 165515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 166515db266SRafael J. Wysocki break; 167515db266SRafael J. Wysocki } 168515db266SRafael J. Wysocki break; 169515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 170515db266SRafael J. Wysocki switch (consumer->links.status) { 171515db266SRafael J. Wysocki case DL_DEV_PROBING: 172515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 173515db266SRafael J. Wysocki break; 174515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 175515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 176515db266SRafael J. Wysocki break; 177515db266SRafael J. Wysocki default: 178515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 179515db266SRafael J. Wysocki break; 180515db266SRafael J. Wysocki } 181515db266SRafael J. Wysocki break; 182515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 183515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 184515db266SRafael J. Wysocki break; 185515db266SRafael J. Wysocki default: 186515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 187515db266SRafael J. Wysocki break; 188515db266SRafael J. Wysocki } 189515db266SRafael J. Wysocki } 190515db266SRafael J. Wysocki 1919ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 1929ed98953SRafael J. Wysocki { 1939ed98953SRafael J. Wysocki struct device_link *link; 1949ed98953SRafael J. Wysocki 1959ed98953SRafael J. Wysocki /* 1969ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 1979ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 1989ed98953SRafael J. Wysocki */ 1999ed98953SRafael J. Wysocki if (device_is_registered(dev)) 2009ed98953SRafael J. Wysocki devices_kset_move_last(dev); 2019ed98953SRafael J. Wysocki 2029ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 2039ed98953SRafael J. Wysocki device_pm_move_last(dev); 2049ed98953SRafael J. Wysocki 2059ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 20605ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 20705ef983eSSaravana Kannan if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 20805ef983eSSaravana Kannan continue; 2099ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 21005ef983eSSaravana Kannan } 2119ed98953SRafael J. Wysocki 2129ed98953SRafael J. Wysocki return 0; 2139ed98953SRafael J. Wysocki } 2149ed98953SRafael J. Wysocki 2159ed98953SRafael J. Wysocki /** 216494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 217494fd7b7SFeng Kan * @dev: Device to move 218494fd7b7SFeng Kan * 219494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 220494fd7b7SFeng Kan * 221494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 222494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 223494fd7b7SFeng Kan */ 224494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 225494fd7b7SFeng Kan { 226494fd7b7SFeng Kan int idx; 227494fd7b7SFeng Kan 228494fd7b7SFeng Kan idx = device_links_read_lock(); 229494fd7b7SFeng Kan device_pm_lock(); 230494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 231494fd7b7SFeng Kan device_pm_unlock(); 232494fd7b7SFeng Kan device_links_read_unlock(idx); 233494fd7b7SFeng Kan } 234494fd7b7SFeng Kan 235515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 236515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 23705ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 23805ef983eSSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 239515db266SRafael J. Wysocki 240fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 241fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 242fb583c8eSRafael J. Wysocki 243494fd7b7SFeng Kan /** 2449ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 2459ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 2469ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 2479ed98953SRafael J. Wysocki * @flags: Link flags. 2489ed98953SRafael J. Wysocki * 24921d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 25021d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 25121d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 25221d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 25321d5c57bSRafael J. Wysocki * be forced into the active metastate and reference-counted upon the creation 25421d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 25521d5c57bSRafael J. Wysocki * ignored. 25621d5c57bSRafael J. Wysocki * 257515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 258515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 259515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 26072175d4eSRafael J. Wysocki * 26172175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 26272175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 26372175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 26472175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 26572175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 26672175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 26772175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 26872175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 26972175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 27072175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 27172175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 272c8d50986SRafael J. Wysocki * 273e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 274e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 275e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 276e7dd4010SRafael J. Wysocki * be used to request the driver core to automaticall probe for a consmer 277e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 278e7dd4010SRafael J. Wysocki * 279515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 280515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 281515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 282515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 283515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 284515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 285515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 286515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 287515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 288515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 2899ed98953SRafael J. Wysocki * 2909ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 2919ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 2929ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 2939ed98953SRafael J. Wysocki * not been registered when this function is called). 2949ed98953SRafael J. Wysocki * 2959ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 2969ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 29764df1148SLukas Wunner * not be registered, however. 2989ed98953SRafael J. Wysocki */ 2999ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 3009ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 3019ed98953SRafael J. Wysocki { 3029ed98953SRafael J. Wysocki struct device_link *link; 3039ed98953SRafael J. Wysocki 304fb583c8eSRafael J. Wysocki if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || 305515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 30605ef983eSSaravana Kannan (flags & DL_FLAG_SYNC_STATE_ONLY && 30705ef983eSSaravana Kannan flags != DL_FLAG_SYNC_STATE_ONLY) || 308e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 309e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 310e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 3119ed98953SRafael J. Wysocki return NULL; 3129ed98953SRafael J. Wysocki 3135db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 3145db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 3155db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 3165db25c9eSRafael J. Wysocki return NULL; 3175db25c9eSRafael J. Wysocki } 3185db25c9eSRafael J. Wysocki } 3195db25c9eSRafael J. Wysocki 320515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 321515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 322515db266SRafael J. Wysocki 3239ed98953SRafael J. Wysocki device_links_write_lock(); 3249ed98953SRafael J. Wysocki device_pm_lock(); 3259ed98953SRafael J. Wysocki 3269ed98953SRafael J. Wysocki /* 3279ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 32805ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 32905ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 33005ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 33105ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 3329ed98953SRafael J. Wysocki */ 3339ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 33405ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 33505ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 3369ed98953SRafael J. Wysocki link = NULL; 3379ed98953SRafael J. Wysocki goto out; 3389ed98953SRafael J. Wysocki } 3399ed98953SRafael J. Wysocki 34072175d4eSRafael J. Wysocki /* 34172175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 34272175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 34372175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 34472175d4eSRafael J. Wysocki */ 34572175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 34672175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 34772175d4eSRafael J. Wysocki 348f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 349f265df55SRafael J. Wysocki if (link->consumer != consumer) 350f265df55SRafael J. Wysocki continue; 351f265df55SRafael J. Wysocki 352e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 353e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 3544c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 355e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 356e2f3cd83SRafael J. Wysocki } 357e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 35836003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 359e2f3cd83SRafael J. Wysocki } 360e2f3cd83SRafael J. Wysocki 36172175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 362ead18c23SLukas Wunner kref_get(&link->kref); 36305ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 36405ef983eSSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 36505ef983eSSaravana Kannan link->flags |= DL_FLAG_STATELESS; 36605ef983eSSaravana Kannan goto reorder; 36705ef983eSSaravana Kannan } else { 3689ed98953SRafael J. Wysocki goto out; 369ead18c23SLukas Wunner } 37005ef983eSSaravana Kannan } 3719ed98953SRafael J. Wysocki 37272175d4eSRafael J. Wysocki /* 37372175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 37472175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 37572175d4eSRafael J. Wysocki * update the existing link to stay around longer. 37672175d4eSRafael J. Wysocki */ 37772175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 37872175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 37972175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 38072175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 38172175d4eSRafael J. Wysocki } 38272175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 38372175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 38472175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 38572175d4eSRafael J. Wysocki } 386515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 387515db266SRafael J. Wysocki kref_get(&link->kref); 388515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 389515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 390515db266SRafael J. Wysocki } 39105ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 39205ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 39305ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 39405ef983eSSaravana Kannan goto reorder; 39505ef983eSSaravana Kannan } 39605ef983eSSaravana Kannan 39772175d4eSRafael J. Wysocki goto out; 39872175d4eSRafael J. Wysocki } 39972175d4eSRafael J. Wysocki 40021d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 4019ed98953SRafael J. Wysocki if (!link) 4029ed98953SRafael J. Wysocki goto out; 4039ed98953SRafael J. Wysocki 404e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 405e2f3cd83SRafael J. Wysocki 406baa8809fSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 407e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 40836003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 409e2f3cd83SRafael J. Wysocki 4104c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 41121d5c57bSRafael J. Wysocki } 412e2f3cd83SRafael J. Wysocki 4139ed98953SRafael J. Wysocki get_device(supplier); 4149ed98953SRafael J. Wysocki link->supplier = supplier; 4159ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 4169ed98953SRafael J. Wysocki get_device(consumer); 4179ed98953SRafael J. Wysocki link->consumer = consumer; 4189ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 4199ed98953SRafael J. Wysocki link->flags = flags; 420ead18c23SLukas Wunner kref_init(&link->kref); 4219ed98953SRafael J. Wysocki 42264df1148SLukas Wunner /* Determine the initial link state. */ 423515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 4249ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 425515db266SRafael J. Wysocki else 426515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 4279ed98953SRafael J. Wysocki 4289ed98953SRafael J. Wysocki /* 42915cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 43015cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 43115cfb094SRafael J. Wysocki */ 43215cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 43315cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 43415cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 43515cfb094SRafael J. Wysocki 43605ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 43705ef983eSSaravana Kannan dev_dbg(consumer, 43805ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 43905ef983eSSaravana Kannan dev_name(supplier)); 44005ef983eSSaravana Kannan goto out; 44105ef983eSSaravana Kannan } 44205ef983eSSaravana Kannan reorder: 44315cfb094SRafael J. Wysocki /* 4449ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 4459ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 4469ed98953SRafael J. Wysocki * 4479ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 4489ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 4499ed98953SRafael J. Wysocki */ 4509ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 4519ed98953SRafael J. Wysocki 4529ed98953SRafael J. Wysocki list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 4539ed98953SRafael J. Wysocki list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 4549ed98953SRafael J. Wysocki 4558a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 4569ed98953SRafael J. Wysocki 4579ed98953SRafael J. Wysocki out: 4589ed98953SRafael J. Wysocki device_pm_unlock(); 4599ed98953SRafael J. Wysocki device_links_write_unlock(); 4605db25c9eSRafael J. Wysocki 461e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 4625db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 4635db25c9eSRafael J. Wysocki 4649ed98953SRafael J. Wysocki return link; 4659ed98953SRafael J. Wysocki } 4669ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 4679ed98953SRafael J. Wysocki 468e2ae9bccSSaravana Kannan /** 469e2ae9bccSSaravana Kannan * device_link_wait_for_supplier - Add device to wait_for_suppliers list 470e2ae9bccSSaravana Kannan * @consumer: Consumer device 471e2ae9bccSSaravana Kannan * 472e2ae9bccSSaravana Kannan * Marks the @consumer device as waiting for suppliers to become available by 473e2ae9bccSSaravana Kannan * adding it to the wait_for_suppliers list. The consumer device will never be 474e2ae9bccSSaravana Kannan * probed until it's removed from the wait_for_suppliers list. 475e2ae9bccSSaravana Kannan * 476e2ae9bccSSaravana Kannan * The caller is responsible for adding the links to the supplier devices once 477e2ae9bccSSaravana Kannan * they are available and removing the @consumer device from the 478e2ae9bccSSaravana Kannan * wait_for_suppliers list once links to all the suppliers have been created. 479e2ae9bccSSaravana Kannan * 480e2ae9bccSSaravana Kannan * This function is NOT meant to be called from the probe function of the 481e2ae9bccSSaravana Kannan * consumer but rather from code that creates/adds the consumer device. 482e2ae9bccSSaravana Kannan */ 483bcbbcfd5SSaravana Kannan static void device_link_wait_for_supplier(struct device *consumer, 484bcbbcfd5SSaravana Kannan bool need_for_probe) 485e2ae9bccSSaravana Kannan { 486e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 487e2ae9bccSSaravana Kannan list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers); 488bcbbcfd5SSaravana Kannan consumer->links.need_for_probe = need_for_probe; 489e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 490e2ae9bccSSaravana Kannan } 491e2ae9bccSSaravana Kannan 492bcbbcfd5SSaravana Kannan static void device_link_wait_for_mandatory_supplier(struct device *consumer) 493bcbbcfd5SSaravana Kannan { 494bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, true); 495bcbbcfd5SSaravana Kannan } 496bcbbcfd5SSaravana Kannan 497bcbbcfd5SSaravana Kannan static void device_link_wait_for_optional_supplier(struct device *consumer) 498bcbbcfd5SSaravana Kannan { 499bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, false); 500bcbbcfd5SSaravana Kannan } 501bcbbcfd5SSaravana Kannan 502e2ae9bccSSaravana Kannan /** 503e2ae9bccSSaravana Kannan * device_link_add_missing_supplier_links - Add links from consumer devices to 504e2ae9bccSSaravana Kannan * supplier devices, leaving any 505e2ae9bccSSaravana Kannan * consumer with inactive suppliers on 506e2ae9bccSSaravana Kannan * the wait_for_suppliers list 507e2ae9bccSSaravana Kannan * 508e2ae9bccSSaravana Kannan * Loops through all consumers waiting on suppliers and tries to add all their 509e2ae9bccSSaravana Kannan * supplier links. If that succeeds, the consumer device is removed from 510e2ae9bccSSaravana Kannan * wait_for_suppliers list. Otherwise, they are left in the wait_for_suppliers 511e2ae9bccSSaravana Kannan * list. Devices left on the wait_for_suppliers list will not be probed. 512e2ae9bccSSaravana Kannan * 513e2ae9bccSSaravana Kannan * The fwnode add_links callback is expected to return 0 if it has found and 514e2ae9bccSSaravana Kannan * added all the supplier links for the consumer device. It should return an 515e2ae9bccSSaravana Kannan * error if it isn't able to do so. 516e2ae9bccSSaravana Kannan * 517e2ae9bccSSaravana Kannan * The caller of device_link_wait_for_supplier() is expected to call this once 518e2ae9bccSSaravana Kannan * it's aware of potential suppliers becoming available. 519e2ae9bccSSaravana Kannan */ 520e2ae9bccSSaravana Kannan static void device_link_add_missing_supplier_links(void) 521e2ae9bccSSaravana Kannan { 522e2ae9bccSSaravana Kannan struct device *dev, *tmp; 523e2ae9bccSSaravana Kannan 524e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 525e2ae9bccSSaravana Kannan list_for_each_entry_safe(dev, tmp, &wait_for_suppliers, 5261745d299SSaravana Kannan links.needs_suppliers) { 5271745d299SSaravana Kannan int ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 5281745d299SSaravana Kannan if (!ret) 529e2ae9bccSSaravana Kannan list_del_init(&dev->links.needs_suppliers); 5301745d299SSaravana Kannan else if (ret != -ENODEV) 5311745d299SSaravana Kannan dev->links.need_for_probe = false; 5321745d299SSaravana Kannan } 533e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 534e2ae9bccSSaravana Kannan } 535e2ae9bccSSaravana Kannan 5369ed98953SRafael J. Wysocki static void device_link_free(struct device_link *link) 5379ed98953SRafael J. Wysocki { 538a1fdbfbbSRafael J. Wysocki while (refcount_dec_not_one(&link->rpm_active)) 539a1fdbfbbSRafael J. Wysocki pm_runtime_put(link->supplier); 540a1fdbfbbSRafael J. Wysocki 5419ed98953SRafael J. Wysocki put_device(link->consumer); 5429ed98953SRafael J. Wysocki put_device(link->supplier); 5439ed98953SRafael J. Wysocki kfree(link); 5449ed98953SRafael J. Wysocki } 5459ed98953SRafael J. Wysocki 5469ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 5479ed98953SRafael J. Wysocki static void __device_link_free_srcu(struct rcu_head *rhead) 5489ed98953SRafael J. Wysocki { 5499ed98953SRafael J. Wysocki device_link_free(container_of(rhead, struct device_link, rcu_head)); 5509ed98953SRafael J. Wysocki } 5519ed98953SRafael J. Wysocki 552ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5539ed98953SRafael J. Wysocki { 554ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 555ead18c23SLukas Wunner 5568a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 5579ed98953SRafael J. Wysocki dev_name(link->supplier)); 5589ed98953SRafael J. Wysocki 559baa8809fSRafael J. Wysocki if (link->flags & DL_FLAG_PM_RUNTIME) 560baa8809fSRafael J. Wysocki pm_runtime_drop_link(link->consumer); 561baa8809fSRafael J. Wysocki 5629ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 5639ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 5649ed98953SRafael J. Wysocki call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 5659ed98953SRafael J. Wysocki } 5669ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 567ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5689ed98953SRafael J. Wysocki { 569ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 570ead18c23SLukas Wunner 5719ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 5729ed98953SRafael J. Wysocki dev_name(link->supplier)); 5739ed98953SRafael J. Wysocki 574433986c2SLukas Wunner if (link->flags & DL_FLAG_PM_RUNTIME) 575433986c2SLukas Wunner pm_runtime_drop_link(link->consumer); 576433986c2SLukas Wunner 5779ed98953SRafael J. Wysocki list_del(&link->s_node); 5789ed98953SRafael J. Wysocki list_del(&link->c_node); 5799ed98953SRafael J. Wysocki device_link_free(link); 5809ed98953SRafael J. Wysocki } 5819ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 5829ed98953SRafael J. Wysocki 58372175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 58472175d4eSRafael J. Wysocki { 58572175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 58672175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 58772175d4eSRafael J. Wysocki else 58872175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 58972175d4eSRafael J. Wysocki } 59072175d4eSRafael J. Wysocki 5919ed98953SRafael J. Wysocki /** 59272175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 5939ed98953SRafael J. Wysocki * @link: Device link to delete. 5949ed98953SRafael J. Wysocki * 5959ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 596ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 597ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 598ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 5999ed98953SRafael J. Wysocki */ 6009ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 6019ed98953SRafael J. Wysocki { 6029ed98953SRafael J. Wysocki device_links_write_lock(); 6039ed98953SRafael J. Wysocki device_pm_lock(); 60472175d4eSRafael J. Wysocki device_link_put_kref(link); 6059ed98953SRafael J. Wysocki device_pm_unlock(); 6069ed98953SRafael J. Wysocki device_links_write_unlock(); 6079ed98953SRafael J. Wysocki } 6089ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 6099ed98953SRafael J. Wysocki 610d8842211Spascal paillet /** 61172175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 612d8842211Spascal paillet * @consumer: Consumer end of the link. 613d8842211Spascal paillet * @supplier: Supplier end of the link. 614d8842211Spascal paillet * 615d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 616d8842211Spascal paillet * PM. 617d8842211Spascal paillet */ 618d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 619d8842211Spascal paillet { 620d8842211Spascal paillet struct device_link *link; 621d8842211Spascal paillet 622d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 623d8842211Spascal paillet return; 624d8842211Spascal paillet 625d8842211Spascal paillet device_links_write_lock(); 626d8842211Spascal paillet device_pm_lock(); 627d8842211Spascal paillet 628d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 629d8842211Spascal paillet if (link->consumer == consumer) { 63072175d4eSRafael J. Wysocki device_link_put_kref(link); 631d8842211Spascal paillet break; 632d8842211Spascal paillet } 633d8842211Spascal paillet } 634d8842211Spascal paillet 635d8842211Spascal paillet device_pm_unlock(); 636d8842211Spascal paillet device_links_write_unlock(); 637d8842211Spascal paillet } 638d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 639d8842211Spascal paillet 6409ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 6419ed98953SRafael J. Wysocki { 6429ed98953SRafael J. Wysocki struct device_link *link; 6439ed98953SRafael J. Wysocki 6449ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) 6459ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE) 6469ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 6479ed98953SRafael J. Wysocki } 6489ed98953SRafael J. Wysocki 6499ed98953SRafael J. Wysocki /** 6509ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 6519ed98953SRafael J. Wysocki * @dev: Consumer device. 6529ed98953SRafael J. Wysocki * 6539ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 6549ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 6559ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 6569ed98953SRafael J. Wysocki * 6579ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 6589ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 6599ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 6609ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 6619ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 6629ed98953SRafael J. Wysocki * 663515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 6649ed98953SRafael J. Wysocki */ 6659ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 6669ed98953SRafael J. Wysocki { 6679ed98953SRafael J. Wysocki struct device_link *link; 6689ed98953SRafael J. Wysocki int ret = 0; 6699ed98953SRafael J. Wysocki 670e2ae9bccSSaravana Kannan /* 671e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 672e2ae9bccSSaravana Kannan * probe. 673e2ae9bccSSaravana Kannan */ 674e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 675bcbbcfd5SSaravana Kannan if (!list_empty(&dev->links.needs_suppliers) && 676bcbbcfd5SSaravana Kannan dev->links.need_for_probe) { 677e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 678e2ae9bccSSaravana Kannan return -EPROBE_DEFER; 679e2ae9bccSSaravana Kannan } 680e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 681e2ae9bccSSaravana Kannan 6829ed98953SRafael J. Wysocki device_links_write_lock(); 6839ed98953SRafael J. Wysocki 6849ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 68505ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 68605ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 6879ed98953SRafael J. Wysocki continue; 6889ed98953SRafael J. Wysocki 6899ed98953SRafael J. Wysocki if (link->status != DL_STATE_AVAILABLE) { 6909ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 6919ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 6929ed98953SRafael J. Wysocki break; 6939ed98953SRafael J. Wysocki } 6949ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 6959ed98953SRafael J. Wysocki } 6969ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 6979ed98953SRafael J. Wysocki 6989ed98953SRafael J. Wysocki device_links_write_unlock(); 6999ed98953SRafael J. Wysocki return ret; 7009ed98953SRafael J. Wysocki } 7019ed98953SRafael J. Wysocki 70226e77708SSaravana Kannan /** 70326e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 70426e77708SSaravana Kannan * @dev: Device to call sync_state() on 70526e77708SSaravana Kannan * @list: List head to queue the @dev on 70626e77708SSaravana Kannan * 70726e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 70826e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 70926e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 71026e77708SSaravana Kannan * device_links_write_lock() held. 71126e77708SSaravana Kannan * 71226e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 71326e77708SSaravana Kannan * on this list. 71426e77708SSaravana Kannan * 71526e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 71626e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 71726e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 71826e77708SSaravana Kannan * put_device() is called on this device. 71926e77708SSaravana Kannan */ 72026e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 72126e77708SSaravana Kannan struct list_head *list) 722fc5a251dSSaravana Kannan { 723fc5a251dSSaravana Kannan struct device_link *link; 724fc5a251dSSaravana Kannan 72577036165SSaravana Kannan if (!dev_has_sync_state(dev)) 72677036165SSaravana Kannan return; 727fc5a251dSSaravana Kannan if (dev->state_synced) 728fc5a251dSSaravana Kannan return; 729fc5a251dSSaravana Kannan 730fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 731fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 732fc5a251dSSaravana Kannan continue; 733fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 734fc5a251dSSaravana Kannan return; 735fc5a251dSSaravana Kannan } 736fc5a251dSSaravana Kannan 73726e77708SSaravana Kannan /* 73826e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 73926e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 74026e77708SSaravana Kannan * and probed before the list is flushed. 74126e77708SSaravana Kannan */ 74226e77708SSaravana Kannan dev->state_synced = true; 74326e77708SSaravana Kannan 74426e77708SSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 74526e77708SSaravana Kannan return; 74626e77708SSaravana Kannan 74726e77708SSaravana Kannan get_device(dev); 74826e77708SSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 74926e77708SSaravana Kannan } 75026e77708SSaravana Kannan 75126e77708SSaravana Kannan /** 75226e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 75326e77708SSaravana Kannan * @list: List of devices to call sync_state() on 75421eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 75526e77708SSaravana Kannan * 75626e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 75721eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 75821eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 75921eb93f4SSaravana Kannan * context where a device lock is already held. 76026e77708SSaravana Kannan */ 76121eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 76221eb93f4SSaravana Kannan struct device *dont_lock_dev) 76326e77708SSaravana Kannan { 76426e77708SSaravana Kannan struct device *dev, *tmp; 76526e77708SSaravana Kannan 76626e77708SSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 76726e77708SSaravana Kannan list_del_init(&dev->links.defer_sync); 76826e77708SSaravana Kannan 76921eb93f4SSaravana Kannan if (dev != dont_lock_dev) 77026e77708SSaravana Kannan device_lock(dev); 77126e77708SSaravana Kannan 772fc5a251dSSaravana Kannan if (dev->bus->sync_state) 773fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 774fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 775fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 776fc5a251dSSaravana Kannan 77721eb93f4SSaravana Kannan if (dev != dont_lock_dev) 77826e77708SSaravana Kannan device_unlock(dev); 77926e77708SSaravana Kannan 78026e77708SSaravana Kannan put_device(dev); 78126e77708SSaravana Kannan } 782fc5a251dSSaravana Kannan } 783fc5a251dSSaravana Kannan 784fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 785fc5a251dSSaravana Kannan { 786fc5a251dSSaravana Kannan device_links_write_lock(); 787fc5a251dSSaravana Kannan defer_sync_state_count++; 788fc5a251dSSaravana Kannan device_links_write_unlock(); 789fc5a251dSSaravana Kannan } 790fc5a251dSSaravana Kannan 791fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 792fc5a251dSSaravana Kannan { 793fc5a251dSSaravana Kannan struct device *dev, *tmp; 79426e77708SSaravana Kannan LIST_HEAD(sync_list); 795fc5a251dSSaravana Kannan 796fc5a251dSSaravana Kannan device_links_write_lock(); 797fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 798fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 799fc5a251dSSaravana Kannan goto out; 800fc5a251dSSaravana Kannan } 801fc5a251dSSaravana Kannan defer_sync_state_count--; 802fc5a251dSSaravana Kannan if (defer_sync_state_count) 803fc5a251dSSaravana Kannan goto out; 804fc5a251dSSaravana Kannan 805fc5a251dSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 80626e77708SSaravana Kannan /* 80726e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 80826e77708SSaravana Kannan * sync_list because defer_sync is used for both lists. 80926e77708SSaravana Kannan */ 810fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 81126e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 812fc5a251dSSaravana Kannan } 813fc5a251dSSaravana Kannan out: 814fc5a251dSSaravana Kannan device_links_write_unlock(); 81526e77708SSaravana Kannan 81621eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 817fc5a251dSSaravana Kannan } 818fc5a251dSSaravana Kannan 819fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 820fc5a251dSSaravana Kannan { 821fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 822fc5a251dSSaravana Kannan return 0; 823fc5a251dSSaravana Kannan } 824fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 825fc5a251dSSaravana Kannan 826fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 827fc5a251dSSaravana Kannan { 82877036165SSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 829fc5a251dSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 830fc5a251dSSaravana Kannan } 831fc5a251dSSaravana Kannan 8329ed98953SRafael J. Wysocki /** 8339ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 8349ed98953SRafael J. Wysocki * @dev: Device to update the links for. 8359ed98953SRafael J. Wysocki * 8369ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 8379ed98953SRafael J. Wysocki * consumers by changing their status to "available". 8389ed98953SRafael J. Wysocki * 8399ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 8409ed98953SRafael J. Wysocki * 841515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 8429ed98953SRafael J. Wysocki */ 8439ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 8449ed98953SRafael J. Wysocki { 8459ed98953SRafael J. Wysocki struct device_link *link; 84626e77708SSaravana Kannan LIST_HEAD(sync_list); 8479ed98953SRafael J. Wysocki 848bcbbcfd5SSaravana Kannan /* 849bcbbcfd5SSaravana Kannan * If a device probes successfully, it's expected to have created all 850bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 851bcbbcfd5SSaravana Kannan * them. So, it no longer needs to wait on any suppliers. 852bcbbcfd5SSaravana Kannan */ 853bcbbcfd5SSaravana Kannan mutex_lock(&wfs_lock); 854bcbbcfd5SSaravana Kannan list_del_init(&dev->links.needs_suppliers); 855bcbbcfd5SSaravana Kannan mutex_unlock(&wfs_lock); 856bcbbcfd5SSaravana Kannan 8579ed98953SRafael J. Wysocki device_links_write_lock(); 8589ed98953SRafael J. Wysocki 8599ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 860515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 8619ed98953SRafael J. Wysocki continue; 8629ed98953SRafael J. Wysocki 86315cfb094SRafael J. Wysocki /* 86415cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 86515cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 86615cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 86715cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 86815cfb094SRafael J. Wysocki */ 86915cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 87015cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 87115cfb094SRafael J. Wysocki continue; 87215cfb094SRafael J. Wysocki 8739ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 8749ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 875e7dd4010SRafael J. Wysocki 876e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 877e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 8789ed98953SRafael J. Wysocki } 8799ed98953SRafael J. Wysocki 88021eb93f4SSaravana Kannan if (defer_sync_state_count) 88121eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 88221eb93f4SSaravana Kannan else 88321eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 88421eb93f4SSaravana Kannan 8859ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 886515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 8879ed98953SRafael J. Wysocki continue; 8889ed98953SRafael J. Wysocki 8899ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 8909ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 891fc5a251dSSaravana Kannan 892fc5a251dSSaravana Kannan if (defer_sync_state_count) 893fc5a251dSSaravana Kannan __device_links_supplier_defer_sync(link->supplier); 894fc5a251dSSaravana Kannan else 89526e77708SSaravana Kannan __device_links_queue_sync_state(link->supplier, 89626e77708SSaravana Kannan &sync_list); 8979ed98953SRafael J. Wysocki } 8989ed98953SRafael J. Wysocki 8999ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 9009ed98953SRafael J. Wysocki 9019ed98953SRafael J. Wysocki device_links_write_unlock(); 90226e77708SSaravana Kannan 90321eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 9049ed98953SRafael J. Wysocki } 9059ed98953SRafael J. Wysocki 906515db266SRafael J. Wysocki static void device_link_drop_managed(struct device_link *link) 907515db266SRafael J. Wysocki { 908515db266SRafael J. Wysocki link->flags &= ~DL_FLAG_MANAGED; 909515db266SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_NONE); 910515db266SRafael J. Wysocki kref_put(&link->kref, __device_link_del); 911515db266SRafael J. Wysocki } 912515db266SRafael J. Wysocki 9139ed98953SRafael J. Wysocki /** 9149ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 9159ed98953SRafael J. Wysocki * @dev: Device without a drvier. 9169ed98953SRafael J. Wysocki * 9179ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 9189ed98953SRafael J. Wysocki * 9199ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 9209ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 9219ed98953SRafael J. Wysocki * case they need not be updated. 9229ed98953SRafael J. Wysocki * 923515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9249ed98953SRafael J. Wysocki */ 9259ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 9269ed98953SRafael J. Wysocki { 9279ed98953SRafael J. Wysocki struct device_link *link, *ln; 9289ed98953SRafael J. Wysocki 9299ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 930515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 9319ed98953SRafael J. Wysocki continue; 9329ed98953SRafael J. Wysocki 933e88728f4SVivek Gautam if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 934515db266SRafael J. Wysocki device_link_drop_managed(link); 93515cfb094SRafael J. Wysocki else if (link->status == DL_STATE_CONSUMER_PROBE || 93615cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 9379ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 9389ed98953SRafael J. Wysocki } 9399ed98953SRafael J. Wysocki 9409ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 9419ed98953SRafael J. Wysocki } 9429ed98953SRafael J. Wysocki 94315cfb094SRafael J. Wysocki /** 94415cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 94515cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 94615cfb094SRafael J. Wysocki * 94715cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 94815cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 94915cfb094SRafael J. Wysocki * appropriate. 95015cfb094SRafael J. Wysocki * 951515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 95215cfb094SRafael J. Wysocki */ 9539ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 9549ed98953SRafael J. Wysocki { 95515cfb094SRafael J. Wysocki struct device_link *link; 95615cfb094SRafael J. Wysocki 9579ed98953SRafael J. Wysocki device_links_write_lock(); 95815cfb094SRafael J. Wysocki 95915cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 960515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 96115cfb094SRafael J. Wysocki continue; 96215cfb094SRafael J. Wysocki 96315cfb094SRafael J. Wysocki /* 96415cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 96515cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 96615cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 96715cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 96815cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 96915cfb094SRafael J. Wysocki */ 97015cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 97115cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 97215cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 97315cfb094SRafael J. Wysocki } 97415cfb094SRafael J. Wysocki 9759ed98953SRafael J. Wysocki __device_links_no_driver(dev); 97615cfb094SRafael J. Wysocki 9779ed98953SRafael J. Wysocki device_links_write_unlock(); 9789ed98953SRafael J. Wysocki } 9799ed98953SRafael J. Wysocki 9809ed98953SRafael J. Wysocki /** 9819ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 9829ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 9839ed98953SRafael J. Wysocki * 9849ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 9859ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 9869ed98953SRafael J. Wysocki * appropriate. 9879ed98953SRafael J. Wysocki * 988515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9899ed98953SRafael J. Wysocki */ 9909ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 9919ed98953SRafael J. Wysocki { 992c8d50986SRafael J. Wysocki struct device_link *link, *ln; 9939ed98953SRafael J. Wysocki 9949ed98953SRafael J. Wysocki device_links_write_lock(); 9959ed98953SRafael J. Wysocki 996c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 997515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 9989ed98953SRafael J. Wysocki continue; 9999ed98953SRafael J. Wysocki 1000e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 10019ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 10021689cac5SVivek Gautam 10031689cac5SVivek Gautam /* 10041689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 10051689cac5SVivek Gautam * devices that are not active, i.e. where the link state 10061689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 10071689cac5SVivek Gautam */ 10081689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 10091689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1010515db266SRafael J. Wysocki device_link_drop_managed(link); 10111689cac5SVivek Gautam 10129ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 10139ed98953SRafael J. Wysocki } 10149ed98953SRafael J. Wysocki 1015fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 10169ed98953SRafael J. Wysocki __device_links_no_driver(dev); 10179ed98953SRafael J. Wysocki 10189ed98953SRafael J. Wysocki device_links_write_unlock(); 10199ed98953SRafael J. Wysocki } 10209ed98953SRafael J. Wysocki 10219ed98953SRafael J. Wysocki /** 10229ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 10239ed98953SRafael J. Wysocki * @dev: Device to check. 10249ed98953SRafael J. Wysocki * 10259ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 10269ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 10279ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 10289ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 10299ed98953SRafael J. Wysocki * successfully going forward. 10309ed98953SRafael J. Wysocki * 10319ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 10329ed98953SRafael J. Wysocki * 1033515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10349ed98953SRafael J. Wysocki */ 10359ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 10369ed98953SRafael J. Wysocki { 10379ed98953SRafael J. Wysocki struct device_link *link; 10389ed98953SRafael J. Wysocki bool ret = false; 10399ed98953SRafael J. Wysocki 10409ed98953SRafael J. Wysocki device_links_write_lock(); 10419ed98953SRafael J. Wysocki 10429ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1043515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 10449ed98953SRafael J. Wysocki continue; 10459ed98953SRafael J. Wysocki 10469ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 10479ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 10489ed98953SRafael J. Wysocki ret = true; 10499ed98953SRafael J. Wysocki break; 10509ed98953SRafael J. Wysocki } 10519ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 10529ed98953SRafael J. Wysocki } 10539ed98953SRafael J. Wysocki 10549ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 10559ed98953SRafael J. Wysocki 10569ed98953SRafael J. Wysocki device_links_write_unlock(); 10579ed98953SRafael J. Wysocki return ret; 10589ed98953SRafael J. Wysocki } 10599ed98953SRafael J. Wysocki 10609ed98953SRafael J. Wysocki /** 10619ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 10629ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 10639ed98953SRafael J. Wysocki * 10649ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 10659ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 10669ed98953SRafael J. Wysocki * and start over. 10679ed98953SRafael J. Wysocki * 10689ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 10699ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 10709ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 10719ed98953SRafael J. Wysocki * changed the state of the link already). 10729ed98953SRafael J. Wysocki * 1073515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10749ed98953SRafael J. Wysocki */ 10759ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 10769ed98953SRafael J. Wysocki { 10779ed98953SRafael J. Wysocki struct device_link *link; 10789ed98953SRafael J. Wysocki 10799ed98953SRafael J. Wysocki start: 10809ed98953SRafael J. Wysocki device_links_write_lock(); 10819ed98953SRafael J. Wysocki 10829ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 10839ed98953SRafael J. Wysocki enum device_link_state status; 10849ed98953SRafael J. Wysocki 108505ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 108605ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 10879ed98953SRafael J. Wysocki continue; 10889ed98953SRafael J. Wysocki 10899ed98953SRafael J. Wysocki status = link->status; 10909ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 10919ed98953SRafael J. Wysocki device_links_write_unlock(); 10929ed98953SRafael J. Wysocki 10939ed98953SRafael J. Wysocki wait_for_device_probe(); 10949ed98953SRafael J. Wysocki goto start; 10959ed98953SRafael J. Wysocki } 10969ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 10979ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 10989ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 10999ed98953SRafael J. Wysocki 11009ed98953SRafael J. Wysocki get_device(consumer); 11019ed98953SRafael J. Wysocki 11029ed98953SRafael J. Wysocki device_links_write_unlock(); 11039ed98953SRafael J. Wysocki 11049ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 11059ed98953SRafael J. Wysocki consumer->parent); 11069ed98953SRafael J. Wysocki put_device(consumer); 11079ed98953SRafael J. Wysocki goto start; 11089ed98953SRafael J. Wysocki } 11099ed98953SRafael J. Wysocki } 11109ed98953SRafael J. Wysocki 11119ed98953SRafael J. Wysocki device_links_write_unlock(); 11129ed98953SRafael J. Wysocki } 11139ed98953SRafael J. Wysocki 11149ed98953SRafael J. Wysocki /** 11159ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 11169ed98953SRafael J. Wysocki * @dev: Target device. 11179ed98953SRafael J. Wysocki */ 11189ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 11199ed98953SRafael J. Wysocki { 11209ed98953SRafael J. Wysocki struct device_link *link, *ln; 11219ed98953SRafael J. Wysocki 1122e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 1123e2ae9bccSSaravana Kannan list_del(&dev->links.needs_suppliers); 1124e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 1125e2ae9bccSSaravana Kannan 11269ed98953SRafael J. Wysocki /* 11279ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 11289ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 11299ed98953SRafael J. Wysocki */ 11309ed98953SRafael J. Wysocki device_links_write_lock(); 11319ed98953SRafael J. Wysocki 11329ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 11339ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1134ead18c23SLukas Wunner __device_link_del(&link->kref); 11359ed98953SRafael J. Wysocki } 11369ed98953SRafael J. Wysocki 11379ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 11389ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 11399ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1140ead18c23SLukas Wunner __device_link_del(&link->kref); 11419ed98953SRafael J. Wysocki } 11429ed98953SRafael J. Wysocki 11439ed98953SRafael J. Wysocki device_links_write_unlock(); 11449ed98953SRafael J. Wysocki } 11459ed98953SRafael J. Wysocki 11469ed98953SRafael J. Wysocki /* Device links support end. */ 11479ed98953SRafael J. Wysocki 11481da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 11491da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 1150e105b8bfSDan Williams static struct kobject *dev_kobj; 1151e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 1152e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 11531da177e4SLinus Torvalds 11545e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 11555e33bc41SRafael J. Wysocki 11565e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 11575e33bc41SRafael J. Wysocki { 11585e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 11595e33bc41SRafael J. Wysocki } 11605e33bc41SRafael J. Wysocki 11615e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 11625e33bc41SRafael J. Wysocki { 11635e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 11645e33bc41SRafael J. Wysocki } 11655e33bc41SRafael J. Wysocki 11665e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 11675e33bc41SRafael J. Wysocki { 11685e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 11695e33bc41SRafael J. Wysocki return 0; 11705e33bc41SRafael J. Wysocki 11715e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 11725e33bc41SRafael J. Wysocki msleep(5); 11735e33bc41SRafael J. Wysocki return restart_syscall(); 11745e33bc41SRafael J. Wysocki } 11755e33bc41SRafael J. Wysocki 11764e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 11774e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 11784e886c29SGreg Kroah-Hartman { 11794e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 11804e886c29SGreg Kroah-Hartman } 11814e886c29SGreg Kroah-Hartman #else 11824e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 11834e886c29SGreg Kroah-Hartman { 11844e886c29SGreg Kroah-Hartman return 1; 11854e886c29SGreg Kroah-Hartman } 11864e886c29SGreg Kroah-Hartman #endif 11871da177e4SLinus Torvalds 118807de0e86SHeikki Krogerus static int 118907de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 119007de0e86SHeikki Krogerus { 11917847a145SHeikki Krogerus int ret; 11927847a145SHeikki Krogerus 11937847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 11947847a145SHeikki Krogerus if (ret) 11957847a145SHeikki Krogerus return ret; 11967847a145SHeikki Krogerus 119759abd836SHeikki Krogerus ret = software_node_notify(dev, action); 119859abd836SHeikki Krogerus if (ret) 119959abd836SHeikki Krogerus return ret; 120059abd836SHeikki Krogerus 120107de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 120207de0e86SHeikki Krogerus platform_notify(dev); 120307de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 120407de0e86SHeikki Krogerus platform_notify_remove(dev); 120507de0e86SHeikki Krogerus return 0; 120607de0e86SHeikki Krogerus } 120707de0e86SHeikki Krogerus 12083e95637aSAlan Stern /** 12093e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 12103e95637aSAlan Stern * @dev: struct device to get the name of 12113e95637aSAlan Stern * 12123e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 12139169c012Syan * the device is not bound to a driver, it will return the name of the bus 12143e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 12153e95637aSAlan Stern * string will be returned. 12163e95637aSAlan Stern */ 1217bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 12183e95637aSAlan Stern { 12193589972eSAlan Stern struct device_driver *drv; 12203589972eSAlan Stern 12213589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 12223589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 12233589972eSAlan Stern * never change once they are set, so they don't need special care. 12243589972eSAlan Stern */ 12256aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 12263589972eSAlan Stern return drv ? drv->name : 1227a456b702SJean Delvare (dev->bus ? dev->bus->name : 1228a456b702SJean Delvare (dev->class ? dev->class->name : "")); 12293e95637aSAlan Stern } 1230310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 12313e95637aSAlan Stern 12321da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 12331da177e4SLinus Torvalds 12344a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 12354a3ad20cSGreg Kroah-Hartman char *buf) 12361da177e4SLinus Torvalds { 12371da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1238b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 12394a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 12401da177e4SLinus Torvalds 12411da177e4SLinus Torvalds if (dev_attr->show) 124254b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 1243815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 1244a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 1245a52668c6SSergey Senozhatsky dev_attr->show); 1246815d2d50SAndrew Morton } 12471da177e4SLinus Torvalds return ret; 12481da177e4SLinus Torvalds } 12491da177e4SLinus Torvalds 12504a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 12511da177e4SLinus Torvalds const char *buf, size_t count) 12521da177e4SLinus Torvalds { 12531da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1254b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 12554a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 12561da177e4SLinus Torvalds 12571da177e4SLinus Torvalds if (dev_attr->store) 125854b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 12591da177e4SLinus Torvalds return ret; 12601da177e4SLinus Torvalds } 12611da177e4SLinus Torvalds 126252cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 12631da177e4SLinus Torvalds .show = dev_attr_show, 12641da177e4SLinus Torvalds .store = dev_attr_store, 12651da177e4SLinus Torvalds }; 12661da177e4SLinus Torvalds 1267ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 1268ca22e56dSKay Sievers 1269ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 1270ca22e56dSKay Sievers struct device_attribute *attr, 1271ca22e56dSKay Sievers const char *buf, size_t size) 1272ca22e56dSKay Sievers { 1273ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1274f88184bfSKaitao cheng int ret; 1275f88184bfSKaitao cheng unsigned long new; 1276f88184bfSKaitao cheng 1277f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 1278f88184bfSKaitao cheng if (ret) 1279f88184bfSKaitao cheng return ret; 1280ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 1281ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1282ca22e56dSKay Sievers return size; 1283ca22e56dSKay Sievers } 1284ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 1285ca22e56dSKay Sievers 1286ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 1287ca22e56dSKay Sievers struct device_attribute *attr, 1288ca22e56dSKay Sievers char *buf) 1289ca22e56dSKay Sievers { 1290ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1291ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 1292ca22e56dSKay Sievers } 1293ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 1294ca22e56dSKay Sievers 1295ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 1296ca22e56dSKay Sievers struct device_attribute *attr, 1297ca22e56dSKay Sievers const char *buf, size_t size) 1298ca22e56dSKay Sievers { 1299ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1300f88184bfSKaitao cheng int ret; 1301f88184bfSKaitao cheng long new; 1302f88184bfSKaitao cheng 1303f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 1304f88184bfSKaitao cheng if (ret) 1305f88184bfSKaitao cheng return ret; 1306f88184bfSKaitao cheng 1307f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 1308ca22e56dSKay Sievers return -EINVAL; 1309ca22e56dSKay Sievers *(int *)(ea->var) = new; 1310ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1311ca22e56dSKay Sievers return size; 1312ca22e56dSKay Sievers } 1313ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 1314ca22e56dSKay Sievers 1315ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 1316ca22e56dSKay Sievers struct device_attribute *attr, 1317ca22e56dSKay Sievers char *buf) 1318ca22e56dSKay Sievers { 1319ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1320ca22e56dSKay Sievers 1321ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 1322ca22e56dSKay Sievers } 1323ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 13241da177e4SLinus Torvalds 132591872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 132691872392SBorislav Petkov const char *buf, size_t size) 132791872392SBorislav Petkov { 132891872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 132991872392SBorislav Petkov 133091872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 133191872392SBorislav Petkov return -EINVAL; 133291872392SBorislav Petkov 133391872392SBorislav Petkov return size; 133491872392SBorislav Petkov } 133591872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 133691872392SBorislav Petkov 133791872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 133891872392SBorislav Petkov char *buf) 133991872392SBorislav Petkov { 134091872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 134191872392SBorislav Petkov 134291872392SBorislav Petkov return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 134391872392SBorislav Petkov } 134491872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 134591872392SBorislav Petkov 13461da177e4SLinus Torvalds /** 13471da177e4SLinus Torvalds * device_release - free device structure. 13481da177e4SLinus Torvalds * @kobj: device's kobject. 13491da177e4SLinus Torvalds * 13501da177e4SLinus Torvalds * This is called once the reference count for the object 13511da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 13521da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 13531da177e4SLinus Torvalds */ 13541da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 13551da177e4SLinus Torvalds { 1356b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1357fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 13581da177e4SLinus Torvalds 1359a525a3ddSMing Lei /* 1360a525a3ddSMing Lei * Some platform devices are driven without driver attached 1361a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 1362a525a3ddSMing Lei * all resources are released. 1363a525a3ddSMing Lei * 1364a525a3ddSMing Lei * Drivers still can add resources into device after device 1365a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 1366a525a3ddSMing Lei * possible memory leak. 1367a525a3ddSMing Lei */ 1368a525a3ddSMing Lei devres_release_all(dev); 1369a525a3ddSMing Lei 13701da177e4SLinus Torvalds if (dev->release) 13711da177e4SLinus Torvalds dev->release(dev); 1372f9f852dfSKay Sievers else if (dev->type && dev->type->release) 1373f9f852dfSKay Sievers dev->type->release(dev); 13742620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 13752620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 1376f810a5cfSArjan van de Ven else 1377186bddb2SEzequiel 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", 13781e0b2cf9SKay Sievers dev_name(dev)); 1379fb069a5dSGreg Kroah-Hartman kfree(p); 13801da177e4SLinus Torvalds } 13811da177e4SLinus Torvalds 1382bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 1383bc451f20SEric W. Biederman { 1384b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1385bc451f20SEric W. Biederman const void *ns = NULL; 1386bc451f20SEric W. Biederman 1387bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 1388bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 1389bc451f20SEric W. Biederman 1390bc451f20SEric W. Biederman return ns; 1391bc451f20SEric W. Biederman } 1392bc451f20SEric W. Biederman 13939944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 13949944e894SDmitry Torokhov { 13959944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 13969944e894SDmitry Torokhov 13979944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 13989944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 13999944e894SDmitry Torokhov } 14009944e894SDmitry Torokhov 14018f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 14021da177e4SLinus Torvalds .release = device_release, 14031da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 1404bc451f20SEric W. Biederman .namespace = device_namespace, 14059944e894SDmitry Torokhov .get_ownership = device_get_ownership, 14061da177e4SLinus Torvalds }; 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds 1409312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 14101da177e4SLinus Torvalds { 14111da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 14121da177e4SLinus Torvalds 14138f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 1414b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 14151da177e4SLinus Torvalds if (dev->bus) 14161da177e4SLinus Torvalds return 1; 141723681e47SGreg Kroah-Hartman if (dev->class) 141823681e47SGreg Kroah-Hartman return 1; 14191da177e4SLinus Torvalds } 14201da177e4SLinus Torvalds return 0; 14211da177e4SLinus Torvalds } 14221da177e4SLinus Torvalds 1423312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 14241da177e4SLinus Torvalds { 1425b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 14261da177e4SLinus Torvalds 142723681e47SGreg Kroah-Hartman if (dev->bus) 14281da177e4SLinus Torvalds return dev->bus->name; 142923681e47SGreg Kroah-Hartman if (dev->class) 143023681e47SGreg Kroah-Hartman return dev->class->name; 143123681e47SGreg Kroah-Hartman return NULL; 14321da177e4SLinus Torvalds } 14331da177e4SLinus Torvalds 14347eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 14357eff2e7aSKay Sievers struct kobj_uevent_env *env) 14361da177e4SLinus Torvalds { 1437b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 14381da177e4SLinus Torvalds int retval = 0; 14391da177e4SLinus Torvalds 14406fcf53acSKay Sievers /* add device node properties if present */ 144123681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 14426fcf53acSKay Sievers const char *tmp; 14436fcf53acSKay Sievers const char *name; 14442c9ede55SAl Viro umode_t mode = 0; 14454e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 14464e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 14476fcf53acSKay Sievers 14487eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 14497eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 14503c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 14516fcf53acSKay Sievers if (name) { 14526fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 1453e454cea2SKay Sievers if (mode) 1454e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 14554e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 14564e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 14574e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 14584e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 14593c2670e6SKay Sievers kfree(tmp); 14606fcf53acSKay Sievers } 146123681e47SGreg Kroah-Hartman } 146223681e47SGreg Kroah-Hartman 1463414264f9SKay Sievers if (dev->type && dev->type->name) 14647eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 1465414264f9SKay Sievers 1466239378f1SKay Sievers if (dev->driver) 14677eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 1468239378f1SKay Sievers 146907d57a32SGrant Likely /* Add common DT information about the device */ 147007d57a32SGrant Likely of_device_uevent(dev, env); 147107d57a32SGrant Likely 14721da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 14737eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 14747eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 1475f9f852dfSKay Sievers if (retval) 14767dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 14771e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 14781da177e4SLinus Torvalds } 14791da177e4SLinus Torvalds 14802620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 14817eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 14827eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 1483f9f852dfSKay Sievers if (retval) 14847dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 14851e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 14862b3a302aSHarvey Harrison __func__, retval); 14872620efefSGreg Kroah-Hartman } 1488f9f852dfSKay Sievers 1489eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 14907eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 14917eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 1492f9f852dfSKay Sievers if (retval) 14937dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 14941e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 14952b3a302aSHarvey Harrison __func__, retval); 14962620efefSGreg Kroah-Hartman } 14972620efefSGreg Kroah-Hartman 14981da177e4SLinus Torvalds return retval; 14991da177e4SLinus Torvalds } 15001da177e4SLinus Torvalds 15019cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 1502312c004dSKay Sievers .filter = dev_uevent_filter, 1503312c004dSKay Sievers .name = dev_uevent_name, 1504312c004dSKay Sievers .uevent = dev_uevent, 15051da177e4SLinus Torvalds }; 15061da177e4SLinus Torvalds 1507c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 150816574dccSKay Sievers char *buf) 150916574dccSKay Sievers { 151016574dccSKay Sievers struct kobject *top_kobj; 151116574dccSKay Sievers struct kset *kset; 15127eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 151316574dccSKay Sievers int i; 151416574dccSKay Sievers size_t count = 0; 151516574dccSKay Sievers int retval; 151616574dccSKay Sievers 151716574dccSKay Sievers /* search the kset, the device belongs to */ 151816574dccSKay Sievers top_kobj = &dev->kobj; 15195c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 152016574dccSKay Sievers top_kobj = top_kobj->parent; 152116574dccSKay Sievers if (!top_kobj->kset) 152216574dccSKay Sievers goto out; 15235c5daf65SKay Sievers 152416574dccSKay Sievers kset = top_kobj->kset; 152516574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 152616574dccSKay Sievers goto out; 152716574dccSKay Sievers 152816574dccSKay Sievers /* respect filter */ 152916574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 153016574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 153116574dccSKay Sievers goto out; 153216574dccSKay Sievers 15337eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 15347eff2e7aSKay Sievers if (!env) 1535c7308c81SGreg Kroah-Hartman return -ENOMEM; 1536c7308c81SGreg Kroah-Hartman 153716574dccSKay Sievers /* let the kset specific function add its keys */ 15387eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 153916574dccSKay Sievers if (retval) 154016574dccSKay Sievers goto out; 154116574dccSKay Sievers 154216574dccSKay Sievers /* copy keys to file */ 15437eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 15447eff2e7aSKay Sievers count += sprintf(&buf[count], "%s\n", env->envp[i]); 154516574dccSKay Sievers out: 15467eff2e7aSKay Sievers kfree(env); 154716574dccSKay Sievers return count; 154816574dccSKay Sievers } 154916574dccSKay Sievers 1550c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 1551a7fd6706SKay Sievers const char *buf, size_t count) 1552a7fd6706SKay Sievers { 1553df44b479SPeter Rajnoha int rc; 1554df44b479SPeter Rajnoha 1555df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 1556df44b479SPeter Rajnoha 1557df44b479SPeter Rajnoha if (rc) { 1558f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 1559df44b479SPeter Rajnoha return rc; 1560df44b479SPeter Rajnoha } 156160a96a59SKay Sievers 1562a7fd6706SKay Sievers return count; 1563a7fd6706SKay Sievers } 1564c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 1565a7fd6706SKay Sievers 1566c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 15674f3549d7SRafael J. Wysocki char *buf) 15684f3549d7SRafael J. Wysocki { 15694f3549d7SRafael J. Wysocki bool val; 15704f3549d7SRafael J. Wysocki 15715e33bc41SRafael J. Wysocki device_lock(dev); 15724f3549d7SRafael J. Wysocki val = !dev->offline; 15735e33bc41SRafael J. Wysocki device_unlock(dev); 15744f3549d7SRafael J. Wysocki return sprintf(buf, "%u\n", val); 15754f3549d7SRafael J. Wysocki } 15764f3549d7SRafael J. Wysocki 1577c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 15784f3549d7SRafael J. Wysocki const char *buf, size_t count) 15794f3549d7SRafael J. Wysocki { 15804f3549d7SRafael J. Wysocki bool val; 15814f3549d7SRafael J. Wysocki int ret; 15824f3549d7SRafael J. Wysocki 15834f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 15844f3549d7SRafael J. Wysocki if (ret < 0) 15854f3549d7SRafael J. Wysocki return ret; 15864f3549d7SRafael J. Wysocki 15875e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 15885e33bc41SRafael J. Wysocki if (ret) 15895e33bc41SRafael J. Wysocki return ret; 15905e33bc41SRafael J. Wysocki 15914f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 15924f3549d7SRafael J. Wysocki unlock_device_hotplug(); 15934f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 15944f3549d7SRafael J. Wysocki } 1595c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 15964f3549d7SRafael J. Wysocki 1597fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 1598621a1672SDmitry Torokhov { 15993e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 1600621a1672SDmitry Torokhov } 1601a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 1602621a1672SDmitry Torokhov 1603fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 1604a4dbd674SDavid Brownell const struct attribute_group **groups) 1605621a1672SDmitry Torokhov { 16063e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 1607621a1672SDmitry Torokhov } 1608a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 1609de0ff00dSGreg Kroah-Hartman 161057b8ff07SDmitry Torokhov union device_attr_group_devres { 161157b8ff07SDmitry Torokhov const struct attribute_group *group; 161257b8ff07SDmitry Torokhov const struct attribute_group **groups; 161357b8ff07SDmitry Torokhov }; 161457b8ff07SDmitry Torokhov 161557b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 161657b8ff07SDmitry Torokhov { 161757b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 161857b8ff07SDmitry Torokhov } 161957b8ff07SDmitry Torokhov 162057b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 162157b8ff07SDmitry Torokhov { 162257b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 162357b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 162457b8ff07SDmitry Torokhov 162557b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 162657b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 162757b8ff07SDmitry Torokhov } 162857b8ff07SDmitry Torokhov 162957b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 163057b8ff07SDmitry Torokhov { 163157b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 163257b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 163357b8ff07SDmitry Torokhov 163457b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 163557b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 163657b8ff07SDmitry Torokhov } 163757b8ff07SDmitry Torokhov 163857b8ff07SDmitry Torokhov /** 163957b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 164057b8ff07SDmitry Torokhov * @dev: The device to create the group for 164157b8ff07SDmitry Torokhov * @grp: The attribute group to create 164257b8ff07SDmitry Torokhov * 164357b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 164457b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 164557b8ff07SDmitry Torokhov * 164657b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 164757b8ff07SDmitry Torokhov */ 164857b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 164957b8ff07SDmitry Torokhov { 165057b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 165157b8ff07SDmitry Torokhov int error; 165257b8ff07SDmitry Torokhov 165357b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 165457b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 165557b8ff07SDmitry Torokhov if (!devres) 165657b8ff07SDmitry Torokhov return -ENOMEM; 165757b8ff07SDmitry Torokhov 165857b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 165957b8ff07SDmitry Torokhov if (error) { 166057b8ff07SDmitry Torokhov devres_free(devres); 166157b8ff07SDmitry Torokhov return error; 166257b8ff07SDmitry Torokhov } 166357b8ff07SDmitry Torokhov 166457b8ff07SDmitry Torokhov devres->group = grp; 166557b8ff07SDmitry Torokhov devres_add(dev, devres); 166657b8ff07SDmitry Torokhov return 0; 166757b8ff07SDmitry Torokhov } 166857b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 166957b8ff07SDmitry Torokhov 167057b8ff07SDmitry Torokhov /** 167157b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 167257b8ff07SDmitry Torokhov * @dev: device to remove the group from 167357b8ff07SDmitry Torokhov * @grp: group to remove 167457b8ff07SDmitry Torokhov * 167557b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 167657b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 167757b8ff07SDmitry Torokhov */ 167857b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 167957b8ff07SDmitry Torokhov const struct attribute_group *grp) 168057b8ff07SDmitry Torokhov { 168157b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 168257b8ff07SDmitry Torokhov devm_attr_group_match, 168357b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 168457b8ff07SDmitry Torokhov } 168557b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 168657b8ff07SDmitry Torokhov 168757b8ff07SDmitry Torokhov /** 168857b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 168957b8ff07SDmitry Torokhov * @dev: The device to create the group for 169057b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 169157b8ff07SDmitry Torokhov * 169257b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 169357b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 169457b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 169557b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 169657b8ff07SDmitry Torokhov * attribute files being created already exist. 169757b8ff07SDmitry Torokhov * 169857b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 169957b8ff07SDmitry Torokhov */ 170057b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 170157b8ff07SDmitry Torokhov const struct attribute_group **groups) 170257b8ff07SDmitry Torokhov { 170357b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 170457b8ff07SDmitry Torokhov int error; 170557b8ff07SDmitry Torokhov 170657b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 170757b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 170857b8ff07SDmitry Torokhov if (!devres) 170957b8ff07SDmitry Torokhov return -ENOMEM; 171057b8ff07SDmitry Torokhov 171157b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 171257b8ff07SDmitry Torokhov if (error) { 171357b8ff07SDmitry Torokhov devres_free(devres); 171457b8ff07SDmitry Torokhov return error; 171557b8ff07SDmitry Torokhov } 171657b8ff07SDmitry Torokhov 171757b8ff07SDmitry Torokhov devres->groups = groups; 171857b8ff07SDmitry Torokhov devres_add(dev, devres); 171957b8ff07SDmitry Torokhov return 0; 172057b8ff07SDmitry Torokhov } 172157b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 172257b8ff07SDmitry Torokhov 172357b8ff07SDmitry Torokhov /** 172457b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 172557b8ff07SDmitry Torokhov * 172657b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 172757b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 172857b8ff07SDmitry Torokhov * 172957b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 173057b8ff07SDmitry Torokhov */ 173157b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 173257b8ff07SDmitry Torokhov const struct attribute_group **groups) 173357b8ff07SDmitry Torokhov { 173457b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 173557b8ff07SDmitry Torokhov devm_attr_group_match, 173657b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 173757b8ff07SDmitry Torokhov } 173857b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 17391da177e4SLinus Torvalds 17402620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 17412620efefSGreg Kroah-Hartman { 17422620efefSGreg Kroah-Hartman struct class *class = dev->class; 1743aed65af1SStephen Hemminger const struct device_type *type = dev->type; 1744621a1672SDmitry Torokhov int error; 17452620efefSGreg Kroah-Hartman 1746621a1672SDmitry Torokhov if (class) { 1747d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 17482620efefSGreg Kroah-Hartman if (error) 1749621a1672SDmitry Torokhov return error; 1750f9f852dfSKay Sievers } 1751f9f852dfSKay Sievers 1752621a1672SDmitry Torokhov if (type) { 1753621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 1754f9f852dfSKay Sievers if (error) 1755a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 1756f9f852dfSKay Sievers } 1757621a1672SDmitry Torokhov 1758621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 1759f9f852dfSKay Sievers if (error) 1760621a1672SDmitry Torokhov goto err_remove_type_groups; 1761621a1672SDmitry Torokhov 17624f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 1763c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 17644f3549d7SRafael J. Wysocki if (error) 1765ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 17664f3549d7SRafael J. Wysocki } 17674f3549d7SRafael J. Wysocki 1768621a1672SDmitry Torokhov return 0; 1769621a1672SDmitry Torokhov 1770ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 1771ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 1772621a1672SDmitry Torokhov err_remove_type_groups: 1773621a1672SDmitry Torokhov if (type) 1774621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1775d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 1776d05a6f96SGreg Kroah-Hartman if (class) 1777d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1778f9f852dfSKay Sievers 17792620efefSGreg Kroah-Hartman return error; 17802620efefSGreg Kroah-Hartman } 17812620efefSGreg Kroah-Hartman 17822620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 17832620efefSGreg Kroah-Hartman { 17842620efefSGreg Kroah-Hartman struct class *class = dev->class; 1785aed65af1SStephen Hemminger const struct device_type *type = dev->type; 17862620efefSGreg Kroah-Hartman 1787c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 1788621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 1789f9f852dfSKay Sievers 1790621a1672SDmitry Torokhov if (type) 1791621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1792621a1672SDmitry Torokhov 1793a6b01dedSGreg Kroah-Hartman if (class) 1794d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1795c97415a7SStefan Achatz } 17962620efefSGreg Kroah-Hartman 1797c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 179823681e47SGreg Kroah-Hartman char *buf) 179923681e47SGreg Kroah-Hartman { 180023681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 180123681e47SGreg Kroah-Hartman } 1802c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 1803ad6a1e1cSTejun Heo 1804ca22e56dSKay Sievers /* /sys/devices/ */ 1805881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 18061da177e4SLinus Torvalds 18071da177e4SLinus Torvalds /** 180852cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 180952cdbdd4SGrygorii Strashko * @deva: Device to move. 181052cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 181152cdbdd4SGrygorii Strashko */ 181252cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 181352cdbdd4SGrygorii Strashko { 181452cdbdd4SGrygorii Strashko if (!devices_kset) 181552cdbdd4SGrygorii Strashko return; 181652cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 181752cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 181852cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 181952cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 182052cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 182152cdbdd4SGrygorii Strashko } 182252cdbdd4SGrygorii Strashko 182352cdbdd4SGrygorii Strashko /** 182452cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 182552cdbdd4SGrygorii Strashko * @deva: Device to move 182652cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 182752cdbdd4SGrygorii Strashko */ 182852cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 182952cdbdd4SGrygorii Strashko { 183052cdbdd4SGrygorii Strashko if (!devices_kset) 183152cdbdd4SGrygorii Strashko return; 183252cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 183352cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 183452cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 183552cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 183652cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 183752cdbdd4SGrygorii Strashko } 183852cdbdd4SGrygorii Strashko 183952cdbdd4SGrygorii Strashko /** 184052cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 184152cdbdd4SGrygorii Strashko * @dev: device to move 184252cdbdd4SGrygorii Strashko */ 184352cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 184452cdbdd4SGrygorii Strashko { 184552cdbdd4SGrygorii Strashko if (!devices_kset) 184652cdbdd4SGrygorii Strashko return; 184752cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 184852cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 184952cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 185052cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 185152cdbdd4SGrygorii Strashko } 185252cdbdd4SGrygorii Strashko 185352cdbdd4SGrygorii Strashko /** 18541da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 18551da177e4SLinus Torvalds * @dev: device. 18561da177e4SLinus Torvalds * @attr: device attribute descriptor. 18571da177e4SLinus Torvalds */ 185826579ab7SPhil Carmody int device_create_file(struct device *dev, 185926579ab7SPhil Carmody const struct device_attribute *attr) 18601da177e4SLinus Torvalds { 18611da177e4SLinus Torvalds int error = 0; 18628f46baaaSFelipe Balbi 18638f46baaaSFelipe Balbi if (dev) { 18648f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 186597521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 186697521978Sdyoung@redhat.com attr->attr.name); 18678f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 186897521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 186997521978Sdyoung@redhat.com attr->attr.name); 18701da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 18718f46baaaSFelipe Balbi } 18728f46baaaSFelipe Balbi 18731da177e4SLinus Torvalds return error; 18741da177e4SLinus Torvalds } 187586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds /** 18781da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 18791da177e4SLinus Torvalds * @dev: device. 18801da177e4SLinus Torvalds * @attr: device attribute descriptor. 18811da177e4SLinus Torvalds */ 188226579ab7SPhil Carmody void device_remove_file(struct device *dev, 188326579ab7SPhil Carmody const struct device_attribute *attr) 18841da177e4SLinus Torvalds { 18850c98b19fSCornelia Huck if (dev) 18861da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 18871da177e4SLinus Torvalds } 188886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 18891da177e4SLinus Torvalds 18902589f188SGreg Kroah-Hartman /** 18916b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 18926b0afc2aSTejun Heo * @dev: device. 18936b0afc2aSTejun Heo * @attr: device attribute descriptor. 18946b0afc2aSTejun Heo * 18956b0afc2aSTejun Heo * See kernfs_remove_self() for details. 18966b0afc2aSTejun Heo */ 18976b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 18986b0afc2aSTejun Heo const struct device_attribute *attr) 18996b0afc2aSTejun Heo { 19006b0afc2aSTejun Heo if (dev) 19016b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 19026b0afc2aSTejun Heo else 19036b0afc2aSTejun Heo return false; 19046b0afc2aSTejun Heo } 19056b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 19066b0afc2aSTejun Heo 19076b0afc2aSTejun Heo /** 19082589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 19092589f188SGreg Kroah-Hartman * @dev: device. 19102589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 19112589f188SGreg Kroah-Hartman */ 191266ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 191366ecb92bSPhil Carmody const struct bin_attribute *attr) 19142589f188SGreg Kroah-Hartman { 19152589f188SGreg Kroah-Hartman int error = -EINVAL; 19162589f188SGreg Kroah-Hartman if (dev) 19172589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 19182589f188SGreg Kroah-Hartman return error; 19192589f188SGreg Kroah-Hartman } 19202589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 19212589f188SGreg Kroah-Hartman 19222589f188SGreg Kroah-Hartman /** 19232589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 19242589f188SGreg Kroah-Hartman * @dev: device. 19252589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 19262589f188SGreg Kroah-Hartman */ 192766ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 192866ecb92bSPhil Carmody const struct bin_attribute *attr) 19292589f188SGreg Kroah-Hartman { 19302589f188SGreg Kroah-Hartman if (dev) 19312589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 19322589f188SGreg Kroah-Hartman } 19332589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 19342589f188SGreg Kroah-Hartman 193534bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 193634bb61f9SJames Bottomley { 1937f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1938f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 193934bb61f9SJames Bottomley 194034bb61f9SJames Bottomley get_device(dev); 194134bb61f9SJames Bottomley } 194234bb61f9SJames Bottomley 194334bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 194434bb61f9SJames Bottomley { 1945f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1946f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 194734bb61f9SJames Bottomley 194834bb61f9SJames Bottomley put_device(dev); 194934bb61f9SJames Bottomley } 195034bb61f9SJames Bottomley 19511da177e4SLinus Torvalds /** 19521da177e4SLinus Torvalds * device_initialize - init device structure. 19531da177e4SLinus Torvalds * @dev: device. 19541da177e4SLinus Torvalds * 19555739411aSCornelia Huck * This prepares the device for use by other layers by initializing 19565739411aSCornelia Huck * its fields. 19571da177e4SLinus Torvalds * It is the first half of device_register(), if called by 19585739411aSCornelia Huck * that function, though it can also be called separately, so one 19595739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 19605739411aSCornelia Huck * may be used for reference counting of @dev after calling this 19615739411aSCornelia Huck * function. 19625739411aSCornelia Huck * 1963b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 1964b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 1965b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 1966b10d5efdSAlan Stern * @dev. 1967b10d5efdSAlan Stern * 19685739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 19695739411aSCornelia Huck * @dev directly once you have called this function. 19701da177e4SLinus Torvalds */ 19711da177e4SLinus Torvalds void device_initialize(struct device *dev) 19721da177e4SLinus Torvalds { 1973881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 1974f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 19751da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 19763142788bSThomas Gleixner mutex_init(&dev->mutex); 197787a30e1fSDan Williams #ifdef CONFIG_PROVE_LOCKING 197887a30e1fSDan Williams mutex_init(&dev->lockdep_mutex); 197987a30e1fSDan Williams #endif 19801704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 19819ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 19829ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 19833b98aeafSAlan Stern device_pm_init(dev); 198487348136SChristoph Hellwig set_dev_node(dev, -1); 19854a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 19864a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 19874a7cc831SJiang Liu #endif 19889ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 19899ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 1990e2ae9bccSSaravana Kannan INIT_LIST_HEAD(&dev->links.needs_suppliers); 1991fc5a251dSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 19929ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 19931da177e4SLinus Torvalds } 199486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 19951da177e4SLinus Torvalds 1996d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 1997f0ee61a6SGreg Kroah-Hartman { 1998f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 1999f0ee61a6SGreg Kroah-Hartman 2000f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 20014ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 2002881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 2003f0ee61a6SGreg Kroah-Hartman 200486406245SKay Sievers return virtual_dir; 2005f0ee61a6SGreg Kroah-Hartman } 2006f0ee61a6SGreg Kroah-Hartman 2007bc451f20SEric W. Biederman struct class_dir { 2008bc451f20SEric W. Biederman struct kobject kobj; 2009bc451f20SEric W. Biederman struct class *class; 2010bc451f20SEric W. Biederman }; 2011bc451f20SEric W. Biederman 2012bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 2013bc451f20SEric W. Biederman 2014bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 2015bc451f20SEric W. Biederman { 2016bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2017bc451f20SEric W. Biederman kfree(dir); 2018bc451f20SEric W. Biederman } 2019bc451f20SEric W. Biederman 2020bc451f20SEric W. Biederman static const 2021bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 2022bc451f20SEric W. Biederman { 2023bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2024bc451f20SEric W. Biederman return dir->class->ns_type; 2025bc451f20SEric W. Biederman } 2026bc451f20SEric W. Biederman 2027bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 2028bc451f20SEric W. Biederman .release = class_dir_release, 2029bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 2030bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 2031bc451f20SEric W. Biederman }; 2032bc451f20SEric W. Biederman 2033bc451f20SEric W. Biederman static struct kobject * 2034bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 2035bc451f20SEric W. Biederman { 2036bc451f20SEric W. Biederman struct class_dir *dir; 2037bc451f20SEric W. Biederman int retval; 2038bc451f20SEric W. Biederman 2039bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 2040bc451f20SEric W. Biederman if (!dir) 204184d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 2042bc451f20SEric W. Biederman 2043bc451f20SEric W. Biederman dir->class = class; 2044bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 2045bc451f20SEric W. Biederman 20466b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 2047bc451f20SEric W. Biederman 2048bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 2049bc451f20SEric W. Biederman if (retval < 0) { 2050bc451f20SEric W. Biederman kobject_put(&dir->kobj); 205184d0c27dSTetsuo Handa return ERR_PTR(retval); 2052bc451f20SEric W. Biederman } 2053bc451f20SEric W. Biederman return &dir->kobj; 2054bc451f20SEric W. Biederman } 2055bc451f20SEric W. Biederman 2056e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 2057bc451f20SEric W. Biederman 2058c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 2059c744aeaeSCornelia Huck struct device *parent) 206040fa5422SGreg Kroah-Hartman { 206186406245SKay Sievers if (dev->class) { 206286406245SKay Sievers struct kobject *kobj = NULL; 206386406245SKay Sievers struct kobject *parent_kobj; 206486406245SKay Sievers struct kobject *k; 206586406245SKay Sievers 2066ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 206739aba963SKay Sievers /* block disks show up in /sys/block */ 2068e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 206939aba963SKay Sievers if (parent && parent->class == &block_class) 207039aba963SKay Sievers return &parent->kobj; 20716b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 207239aba963SKay Sievers } 2073ead454feSRandy Dunlap #endif 2074e52eec13SAndi Kleen 207586406245SKay Sievers /* 207686406245SKay Sievers * If we have no parent, we live in "virtual". 20770f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 20780f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 207986406245SKay Sievers */ 208086406245SKay Sievers if (parent == NULL) 208186406245SKay Sievers parent_kobj = virtual_device_parent(dev); 208224b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 208386406245SKay Sievers return &parent->kobj; 208486406245SKay Sievers else 208586406245SKay Sievers parent_kobj = &parent->kobj; 208686406245SKay Sievers 208777d3d7c1STejun Heo mutex_lock(&gdp_mutex); 208877d3d7c1STejun Heo 208986406245SKay Sievers /* find our class-directory at the parent and reference it */ 20906b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 20916b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 209286406245SKay Sievers if (k->parent == parent_kobj) { 209386406245SKay Sievers kobj = kobject_get(k); 209486406245SKay Sievers break; 209586406245SKay Sievers } 20966b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 209777d3d7c1STejun Heo if (kobj) { 209877d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 209986406245SKay Sievers return kobj; 210077d3d7c1STejun Heo } 210186406245SKay Sievers 210286406245SKay Sievers /* or create a new class-directory at the parent device */ 2103bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 21040f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 210577d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 210643968d2fSGreg Kroah-Hartman return k; 210786406245SKay Sievers } 210886406245SKay Sievers 2109ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 2110ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 2111ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 2112ca22e56dSKay Sievers 211386406245SKay Sievers if (parent) 2114c744aeaeSCornelia Huck return &parent->kobj; 2115c744aeaeSCornelia Huck return NULL; 2116c744aeaeSCornelia Huck } 2117da231fd5SKay Sievers 2118cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 2119cebf8fd1SMing Lei struct device *dev) 2120cebf8fd1SMing Lei { 2121cebf8fd1SMing Lei if (!kobj || !dev->class || 2122cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 2123cebf8fd1SMing Lei return false; 2124cebf8fd1SMing Lei return true; 2125cebf8fd1SMing Lei } 2126cebf8fd1SMing Lei 2127cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 2128cebf8fd1SMing Lei { 2129cebf8fd1SMing Lei return dev->kobj.parent; 2130cebf8fd1SMing Lei } 2131cebf8fd1SMing Lei 2132cebf8fd1SMing Lei /* 2133cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 2134cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 2135cebf8fd1SMing Lei * global lock 2136cebf8fd1SMing Lei */ 213763b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 2138da231fd5SKay Sievers { 2139ac43432cSMuchun Song unsigned int ref; 2140ac43432cSMuchun Song 21410f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 2142cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 2143da231fd5SKay Sievers return; 2144da231fd5SKay Sievers 2145e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 2146ac43432cSMuchun Song /** 2147ac43432cSMuchun Song * There is a race condition between removing glue directory 2148ac43432cSMuchun Song * and adding a new device under the glue directory. 2149ac43432cSMuchun Song * 2150ac43432cSMuchun Song * CPU1: CPU2: 2151ac43432cSMuchun Song * 2152ac43432cSMuchun Song * device_add() 2153ac43432cSMuchun Song * get_device_parent() 2154ac43432cSMuchun Song * class_dir_create_and_add() 2155ac43432cSMuchun Song * kobject_add_internal() 2156ac43432cSMuchun Song * create_dir() // create glue_dir 2157ac43432cSMuchun Song * 2158ac43432cSMuchun Song * device_add() 2159ac43432cSMuchun Song * get_device_parent() 2160ac43432cSMuchun Song * kobject_get() // get glue_dir 2161ac43432cSMuchun Song * 2162ac43432cSMuchun Song * device_del() 2163ac43432cSMuchun Song * cleanup_glue_dir() 2164ac43432cSMuchun Song * kobject_del(glue_dir) 2165ac43432cSMuchun Song * 2166ac43432cSMuchun Song * kobject_add() 2167ac43432cSMuchun Song * kobject_add_internal() 2168ac43432cSMuchun Song * create_dir() // in glue_dir 2169ac43432cSMuchun Song * sysfs_create_dir_ns() 2170ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 2171ac43432cSMuchun Song * 2172ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 2173ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 2174ac43432cSMuchun Song * 2175ac43432cSMuchun Song * // sd is freed 2176ac43432cSMuchun Song * kernfs_new_node(sd) 2177ac43432cSMuchun Song * kernfs_get(glue_dir) 2178ac43432cSMuchun Song * kernfs_add_one() 2179ac43432cSMuchun Song * kernfs_put() 2180ac43432cSMuchun Song * 2181ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 2182ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 2183ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 2184ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 2185ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 2186ac43432cSMuchun Song * 2187ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 2188ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 2189ac43432cSMuchun Song * 2190ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 2191ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 2192ac43432cSMuchun Song * for glue_dir kobj is 1. 2193ac43432cSMuchun Song */ 2194ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 2195ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 2196726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 21970f4dafc0SKay Sievers kobject_put(glue_dir); 2198e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 2199da231fd5SKay Sievers } 220063b6971aSCornelia Huck 22012ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 22022ee97cafSCornelia Huck { 22035590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 22042ee97cafSCornelia Huck int error; 22052ee97cafSCornelia Huck 22065590f319SBenjamin Herrenschmidt if (of_node) { 22070c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 22085590f319SBenjamin Herrenschmidt if (error) 22095590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 22105590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 22115590f319SBenjamin Herrenschmidt } 22125590f319SBenjamin Herrenschmidt 22132ee97cafSCornelia Huck if (!dev->class) 22142ee97cafSCornelia Huck return 0; 2215da231fd5SKay Sievers 22161fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 22176b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 22182ee97cafSCornelia Huck "subsystem"); 22192ee97cafSCornelia Huck if (error) 22205590f319SBenjamin Herrenschmidt goto out_devnode; 2221da231fd5SKay Sievers 22224e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 22234f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 22244f01a757SDmitry Torokhov "device"); 22254f01a757SDmitry Torokhov if (error) 222639aba963SKay Sievers goto out_subsys; 22272ee97cafSCornelia Huck } 222839aba963SKay Sievers 2229ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 223039aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 2231e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 223239aba963SKay Sievers return 0; 2233ead454feSRandy Dunlap #endif 223439aba963SKay Sievers 223539aba963SKay Sievers /* link in the class directory pointing to the device */ 22366b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 223739aba963SKay Sievers &dev->kobj, dev_name(dev)); 223839aba963SKay Sievers if (error) 223939aba963SKay Sievers goto out_device; 224039aba963SKay Sievers 22412ee97cafSCornelia Huck return 0; 22422ee97cafSCornelia Huck 224339aba963SKay Sievers out_device: 224439aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 2245da231fd5SKay Sievers 22462ee97cafSCornelia Huck out_subsys: 22472ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 22485590f319SBenjamin Herrenschmidt out_devnode: 22495590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 22502ee97cafSCornelia Huck return error; 22512ee97cafSCornelia Huck } 22522ee97cafSCornelia Huck 22532ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 22542ee97cafSCornelia Huck { 22555590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 22565590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 22575590f319SBenjamin Herrenschmidt 22582ee97cafSCornelia Huck if (!dev->class) 22592ee97cafSCornelia Huck return; 2260da231fd5SKay Sievers 22614e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 2262da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 22632ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 2264ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 2265e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 226639aba963SKay Sievers return; 2267ead454feSRandy Dunlap #endif 22686b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 22692ee97cafSCornelia Huck } 22702ee97cafSCornelia Huck 22711da177e4SLinus Torvalds /** 2272413c239fSStephen Rothwell * dev_set_name - set a device name 2273413c239fSStephen Rothwell * @dev: device 227446232366SRandy Dunlap * @fmt: format string for the device's name 2275413c239fSStephen Rothwell */ 2276413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 2277413c239fSStephen Rothwell { 2278413c239fSStephen Rothwell va_list vargs; 22791fa5ae85SKay Sievers int err; 2280413c239fSStephen Rothwell 2281413c239fSStephen Rothwell va_start(vargs, fmt); 22821fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 2283413c239fSStephen Rothwell va_end(vargs); 22841fa5ae85SKay Sievers return err; 2285413c239fSStephen Rothwell } 2286413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 2287413c239fSStephen Rothwell 2288413c239fSStephen Rothwell /** 2289e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 2290e105b8bfSDan Williams * @dev: device 2291e105b8bfSDan Williams * 2292e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 2293e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 2294e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 2295e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 22960d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 22970d4e293cSPeter Korsgaard * the link. 2298e105b8bfSDan Williams */ 2299e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 2300e105b8bfSDan Williams { 2301e105b8bfSDan Williams struct kobject *kobj; 2302e105b8bfSDan Williams 2303e105b8bfSDan Williams if (dev->class) 2304e105b8bfSDan Williams kobj = dev->class->dev_kobj; 2305e105b8bfSDan Williams else 2306e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 2307e105b8bfSDan Williams 2308e105b8bfSDan Williams return kobj; 2309e105b8bfSDan Williams } 2310e105b8bfSDan Williams 2311e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 2312e105b8bfSDan Williams { 2313e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2314e105b8bfSDan Williams int error = 0; 2315e105b8bfSDan Williams char devt_str[15]; 2316e105b8bfSDan Williams 2317e105b8bfSDan Williams if (kobj) { 2318e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2319e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 2320e105b8bfSDan Williams } 2321e105b8bfSDan Williams 2322e105b8bfSDan Williams return error; 2323e105b8bfSDan Williams } 2324e105b8bfSDan Williams 2325e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 2326e105b8bfSDan Williams { 2327e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2328e105b8bfSDan Williams char devt_str[15]; 2329e105b8bfSDan Williams 2330e105b8bfSDan Williams if (kobj) { 2331e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2332e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 2333e105b8bfSDan Williams } 2334e105b8bfSDan Williams } 2335e105b8bfSDan Williams 233646d3a037SShaokun Zhang static int device_private_init(struct device *dev) 2337b4028437SGreg Kroah-Hartman { 2338b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 2339b4028437SGreg Kroah-Hartman if (!dev->p) 2340b4028437SGreg Kroah-Hartman return -ENOMEM; 2341b4028437SGreg Kroah-Hartman dev->p->device = dev; 2342b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 2343b4028437SGreg Kroah-Hartman klist_children_put); 2344ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 2345b4028437SGreg Kroah-Hartman return 0; 2346b4028437SGreg Kroah-Hartman } 2347b4028437SGreg Kroah-Hartman 234818555cb6SGreg Kroah-Hartman static u32 fw_devlink_flags; 23498375e74fSSaravana Kannan static int __init fw_devlink_setup(char *arg) 23508375e74fSSaravana Kannan { 23518375e74fSSaravana Kannan if (!arg) 23528375e74fSSaravana Kannan return -EINVAL; 23538375e74fSSaravana Kannan 23548375e74fSSaravana Kannan if (strcmp(arg, "off") == 0) { 23558375e74fSSaravana Kannan fw_devlink_flags = 0; 23568375e74fSSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 23578375e74fSSaravana Kannan fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY; 23588375e74fSSaravana Kannan } else if (strcmp(arg, "on") == 0) { 23598375e74fSSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER; 23608375e74fSSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 23618375e74fSSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER | 23628375e74fSSaravana Kannan DL_FLAG_PM_RUNTIME; 23638375e74fSSaravana Kannan } 23648375e74fSSaravana Kannan return 0; 23658375e74fSSaravana Kannan } 23668375e74fSSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 23678375e74fSSaravana Kannan 23688375e74fSSaravana Kannan u32 fw_devlink_get_flags(void) 23698375e74fSSaravana Kannan { 23708375e74fSSaravana Kannan return fw_devlink_flags; 23718375e74fSSaravana Kannan } 23728375e74fSSaravana Kannan 2373e105b8bfSDan Williams /** 23741da177e4SLinus Torvalds * device_add - add device to device hierarchy. 23751da177e4SLinus Torvalds * @dev: device. 23761da177e4SLinus Torvalds * 23771da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 23781da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 23791da177e4SLinus Torvalds * 23805739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 23811da177e4SLinus Torvalds * to the global and sibling lists for the device, then 23821da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 23835739411aSCornelia Huck * 2384b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 2385b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 2386b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 2387b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 2388b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 2389b10d5efdSAlan Stern * and register a fresh new struct device instead. 2390b10d5efdSAlan Stern * 23915739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 23925739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 23935739411aSCornelia Huck * reference instead. 2394affada72SBorislav Petkov * 2395affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 2396affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 2397affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 2398affada72SBorislav Petkov * count. 23991da177e4SLinus Torvalds */ 24001da177e4SLinus Torvalds int device_add(struct device *dev) 24011da177e4SLinus Torvalds { 240235dbf4efSViresh Kumar struct device *parent; 2403ca22e56dSKay Sievers struct kobject *kobj; 2404c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 240503324507SSaravana Kannan int error = -EINVAL, fw_ret; 2406cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 24074dbe191cSSaravana Kannan bool is_fwnode_dev = false; 2408775b64d2SRafael J. Wysocki 24091da177e4SLinus Torvalds dev = get_device(dev); 2410c906a48aSGreg Kroah-Hartman if (!dev) 2411c906a48aSGreg Kroah-Hartman goto done; 2412c906a48aSGreg Kroah-Hartman 2413fb069a5dSGreg Kroah-Hartman if (!dev->p) { 2414b4028437SGreg Kroah-Hartman error = device_private_init(dev); 2415b4028437SGreg Kroah-Hartman if (error) 2416fb069a5dSGreg Kroah-Hartman goto done; 2417fb069a5dSGreg Kroah-Hartman } 2418fb069a5dSGreg Kroah-Hartman 24191fa5ae85SKay Sievers /* 24201fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 24211fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 24221fa5ae85SKay Sievers * the name, and force the use of dev_name() 24231fa5ae85SKay Sievers */ 24241fa5ae85SKay Sievers if (dev->init_name) { 2425acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 24261fa5ae85SKay Sievers dev->init_name = NULL; 24271fa5ae85SKay Sievers } 2428c906a48aSGreg Kroah-Hartman 2429ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 2430ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 2431ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 2432ca22e56dSKay Sievers 2433e6309e75SThomas Gleixner if (!dev_name(dev)) { 2434e6309e75SThomas Gleixner error = -EINVAL; 24355c8563d7SKay Sievers goto name_error; 2436e6309e75SThomas Gleixner } 24371da177e4SLinus Torvalds 24381e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 2439c205ef48SGreg Kroah-Hartman 24401da177e4SLinus Torvalds parent = get_device(dev->parent); 2441ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 244284d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 244384d0c27dSTetsuo Handa error = PTR_ERR(kobj); 244484d0c27dSTetsuo Handa goto parent_error; 244584d0c27dSTetsuo Handa } 2446ca22e56dSKay Sievers if (kobj) 2447ca22e56dSKay Sievers dev->kobj.parent = kobj; 24481da177e4SLinus Torvalds 24490d358f22SYinghai Lu /* use parent numa_node */ 245056f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 24510d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 24520d358f22SYinghai Lu 24531da177e4SLinus Torvalds /* first, register with generic layer. */ 24548a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 24558a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 2456cebf8fd1SMing Lei if (error) { 2457cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 24581da177e4SLinus Torvalds goto Error; 2459cebf8fd1SMing Lei } 2460a7fd6706SKay Sievers 246137022644SBrian Walsh /* notify platform of device entry */ 246207de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 246307de0e86SHeikki Krogerus if (error) 246407de0e86SHeikki Krogerus goto platform_error; 246537022644SBrian Walsh 2466c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 2467a306eea4SCornelia Huck if (error) 2468a306eea4SCornelia Huck goto attrError; 2469a7fd6706SKay Sievers 24702ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 24712ee97cafSCornelia Huck if (error) 24722ee97cafSCornelia Huck goto SymlinkError; 2473dc0afa83SCornelia Huck error = device_add_attrs(dev); 2474dc0afa83SCornelia Huck if (error) 24752620efefSGreg Kroah-Hartman goto AttrsError; 2476dc0afa83SCornelia Huck error = bus_add_device(dev); 2477dc0afa83SCornelia Huck if (error) 24781da177e4SLinus Torvalds goto BusError; 24793b98aeafSAlan Stern error = dpm_sysfs_add(dev); 248057eee3d2SRafael J. Wysocki if (error) 24813b98aeafSAlan Stern goto DPMError; 24823b98aeafSAlan Stern device_pm_add(dev); 2483ec0676eeSAlan Stern 24840cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 24850cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 24860cd75047SSergey Klyaus if (error) 24870cd75047SSergey Klyaus goto DevAttrError; 24880cd75047SSergey Klyaus 24890cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 24900cd75047SSergey Klyaus if (error) 24910cd75047SSergey Klyaus goto SysEntryError; 24920cd75047SSergey Klyaus 24930cd75047SSergey Klyaus devtmpfs_create_node(dev); 24940cd75047SSergey Klyaus } 24950cd75047SSergey Klyaus 2496ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 2497268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 2498ec0676eeSAlan Stern */ 2499ec0676eeSAlan Stern if (dev->bus) 2500ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2501ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 2502ec0676eeSAlan Stern 250353877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 2504372a67c0SSaravana Kannan 25054dbe191cSSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 2506372a67c0SSaravana Kannan dev->fwnode->dev = dev; 25074dbe191cSSaravana Kannan is_fwnode_dev = true; 25084dbe191cSSaravana Kannan } 2509372a67c0SSaravana Kannan 2510e2ae9bccSSaravana Kannan /* 2511e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 2512e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 2513e2ae9bccSSaravana Kannan * link to it. 2514e2ae9bccSSaravana Kannan * 2515e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 2516e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 2517e2ae9bccSSaravana Kannan * 2518e2ae9bccSSaravana Kannan * But this also needs to happe before bus_probe_device() to make sure 2519e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 2520e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 2521e2ae9bccSSaravana Kannan */ 2522e2ae9bccSSaravana Kannan device_link_add_missing_supplier_links(); 2523e2ae9bccSSaravana Kannan 25244dbe191cSSaravana Kannan if (fw_devlink_flags && is_fwnode_dev && 25254dbe191cSSaravana Kannan fwnode_has_op(dev->fwnode, add_links)) { 252603324507SSaravana Kannan fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 252703324507SSaravana Kannan if (fw_ret == -ENODEV) 252803324507SSaravana Kannan device_link_wait_for_mandatory_supplier(dev); 252903324507SSaravana Kannan else if (fw_ret) 253003324507SSaravana Kannan device_link_wait_for_optional_supplier(dev); 253103324507SSaravana Kannan } 2532e2ae9bccSSaravana Kannan 25332023c610SAlan Stern bus_probe_device(dev); 25341da177e4SLinus Torvalds if (parent) 2535f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2536f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 25371da177e4SLinus Torvalds 25385d9fd169SGreg Kroah-Hartman if (dev->class) { 2539ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2540c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 2541570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 25426b6e39a6SKay Sievers &dev->class->p->klist_devices); 2543c47ed219SGreg Kroah-Hartman 2544c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 2545184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2546ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2547c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 2548c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 2549ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 25505d9fd169SGreg Kroah-Hartman } 2551c906a48aSGreg Kroah-Hartman done: 25521da177e4SLinus Torvalds put_device(dev); 25531da177e4SLinus Torvalds return error; 25540cd75047SSergey Klyaus SysEntryError: 25550cd75047SSergey Klyaus if (MAJOR(dev->devt)) 25560cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 25570cd75047SSergey Klyaus DevAttrError: 25580cd75047SSergey Klyaus device_pm_remove(dev); 25590cd75047SSergey Klyaus dpm_sysfs_remove(dev); 25603b98aeafSAlan Stern DPMError: 256157eee3d2SRafael J. Wysocki bus_remove_device(dev); 256257eee3d2SRafael J. Wysocki BusError: 25632620efefSGreg Kroah-Hartman device_remove_attrs(dev); 25642620efefSGreg Kroah-Hartman AttrsError: 25652ee97cafSCornelia Huck device_remove_class_symlinks(dev); 25662ee97cafSCornelia Huck SymlinkError: 2567c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 256823681e47SGreg Kroah-Hartman attrError: 256907de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 257007de0e86SHeikki Krogerus platform_error: 2571312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2572cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 25731da177e4SLinus Torvalds kobject_del(&dev->kobj); 25741da177e4SLinus Torvalds Error: 2575cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 257684d0c27dSTetsuo Handa parent_error: 25771da177e4SLinus Torvalds put_device(parent); 25785c8563d7SKay Sievers name_error: 25795c8563d7SKay Sievers kfree(dev->p); 25805c8563d7SKay Sievers dev->p = NULL; 2581c906a48aSGreg Kroah-Hartman goto done; 25821da177e4SLinus Torvalds } 258386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 25841da177e4SLinus Torvalds 25851da177e4SLinus Torvalds /** 25861da177e4SLinus Torvalds * device_register - register a device with the system. 25871da177e4SLinus Torvalds * @dev: pointer to the device structure 25881da177e4SLinus Torvalds * 25891da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 25901da177e4SLinus Torvalds * and add it to the system. The two steps can be called 25911da177e4SLinus Torvalds * separately, but this is the easiest and most common. 25921da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 25931da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 25941da177e4SLinus Torvalds * before it is added to the hierarchy. 25955739411aSCornelia Huck * 2596b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 2597b10d5efdSAlan Stern * and device_add(). 2598b10d5efdSAlan Stern * 25995739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 26005739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 26015739411aSCornelia Huck * reference initialized in this function instead. 26021da177e4SLinus Torvalds */ 26031da177e4SLinus Torvalds int device_register(struct device *dev) 26041da177e4SLinus Torvalds { 26051da177e4SLinus Torvalds device_initialize(dev); 26061da177e4SLinus Torvalds return device_add(dev); 26071da177e4SLinus Torvalds } 260886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 26091da177e4SLinus Torvalds 26101da177e4SLinus Torvalds /** 26111da177e4SLinus Torvalds * get_device - increment reference count for device. 26121da177e4SLinus Torvalds * @dev: device. 26131da177e4SLinus Torvalds * 26141da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 26151da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 26161da177e4SLinus Torvalds * pointer passed in. 26171da177e4SLinus Torvalds */ 26181da177e4SLinus Torvalds struct device *get_device(struct device *dev) 26191da177e4SLinus Torvalds { 2620b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 26211da177e4SLinus Torvalds } 262286df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 26231da177e4SLinus Torvalds 26241da177e4SLinus Torvalds /** 26251da177e4SLinus Torvalds * put_device - decrement reference count. 26261da177e4SLinus Torvalds * @dev: device in question. 26271da177e4SLinus Torvalds */ 26281da177e4SLinus Torvalds void put_device(struct device *dev) 26291da177e4SLinus Torvalds { 2630edfaa7c3SKay Sievers /* might_sleep(); */ 26311da177e4SLinus Torvalds if (dev) 26321da177e4SLinus Torvalds kobject_put(&dev->kobj); 26331da177e4SLinus Torvalds } 263486df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 26351da177e4SLinus Torvalds 263600289cd8SDan Williams bool kill_device(struct device *dev) 263700289cd8SDan Williams { 263800289cd8SDan Williams /* 263900289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 264000289cd8SDan Williams * the update behavior is consistent with the other bitfields near 264100289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 264200289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 264300289cd8SDan Williams * underneath the device. 264400289cd8SDan Williams */ 264500289cd8SDan Williams lockdep_assert_held(&dev->mutex); 264600289cd8SDan Williams 264700289cd8SDan Williams if (dev->p->dead) 264800289cd8SDan Williams return false; 264900289cd8SDan Williams dev->p->dead = true; 265000289cd8SDan Williams return true; 265100289cd8SDan Williams } 265200289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 265300289cd8SDan Williams 26541da177e4SLinus Torvalds /** 26551da177e4SLinus Torvalds * device_del - delete device from system. 26561da177e4SLinus Torvalds * @dev: device. 26571da177e4SLinus Torvalds * 26581da177e4SLinus Torvalds * This is the first part of the device unregistration 26591da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 26601da177e4SLinus Torvalds * from here, has it removed from the other driver model 26611da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 26621da177e4SLinus Torvalds * from the kobject hierarchy. 26631da177e4SLinus Torvalds * 26641da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 26651da177e4SLinus Torvalds * also called manually. 26661da177e4SLinus Torvalds */ 26671da177e4SLinus Torvalds void device_del(struct device *dev) 26681da177e4SLinus Torvalds { 26691da177e4SLinus Torvalds struct device *parent = dev->parent; 2670cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2671c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 26721da177e4SLinus Torvalds 26733451a495SAlexander Duyck device_lock(dev); 267400289cd8SDan Williams kill_device(dev); 26753451a495SAlexander Duyck device_unlock(dev); 26763451a495SAlexander Duyck 2677372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 2678372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 2679372a67c0SSaravana Kannan 2680ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 2681ec0676eeSAlan Stern * before dpm_sysfs_remove(). 2682ec0676eeSAlan Stern */ 2683ec0676eeSAlan Stern if (dev->bus) 2684ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2685ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 26869ed98953SRafael J. Wysocki 26873b98aeafSAlan Stern dpm_sysfs_remove(dev); 26881da177e4SLinus Torvalds if (parent) 2689f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 2690e105b8bfSDan Williams if (MAJOR(dev->devt)) { 26912b2af54aSKay Sievers devtmpfs_delete_node(dev); 2692e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 2693c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 2694e105b8bfSDan Williams } 2695b9d9c82bSKay Sievers if (dev->class) { 2696da231fd5SKay Sievers device_remove_class_symlinks(dev); 269799ef3ef8SKay Sievers 2698ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2699c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 2700184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2701ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2702c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 2703c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 2704c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 2705570d0200SWei Yang klist_del(&dev->p->knode_class); 2706ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 2707b9d9c82bSKay Sievers } 2708c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 27092620efefSGreg Kroah-Hartman device_remove_attrs(dev); 271028953533SBenjamin Herrenschmidt bus_remove_device(dev); 27114b6d1f12SLongX Zhang device_pm_remove(dev); 2712d1c3414cSGrant Likely driver_deferred_probe_del(dev); 271307de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 2714478573c9SLukas Wunner device_remove_properties(dev); 27152ec16150SJeffy Chen device_links_purge(dev); 27161da177e4SLinus Torvalds 2717599bad38SJoerg Roedel if (dev->bus) 2718599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2719599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 2720312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2721cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 27221da177e4SLinus Torvalds kobject_del(&dev->kobj); 2723cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 27241da177e4SLinus Torvalds put_device(parent); 27251da177e4SLinus Torvalds } 272686df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 27271da177e4SLinus Torvalds 27281da177e4SLinus Torvalds /** 27291da177e4SLinus Torvalds * device_unregister - unregister device from system. 27301da177e4SLinus Torvalds * @dev: device going away. 27311da177e4SLinus Torvalds * 27321da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 27331da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 27341da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 27351da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 27361da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 27371da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 27381da177e4SLinus Torvalds */ 27391da177e4SLinus Torvalds void device_unregister(struct device *dev) 27401da177e4SLinus Torvalds { 27411e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 27421da177e4SLinus Torvalds device_del(dev); 27431da177e4SLinus Torvalds put_device(dev); 27441da177e4SLinus Torvalds } 274586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 27461da177e4SLinus Torvalds 27473d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 27483d060aebSAndy Shevchenko { 27493d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 27503d060aebSAndy Shevchenko struct device *dev = NULL; 27513d060aebSAndy Shevchenko struct device_private *p; 27523d060aebSAndy Shevchenko 27533d060aebSAndy Shevchenko if (n) { 27543d060aebSAndy Shevchenko p = to_device_private_parent(n); 27553d060aebSAndy Shevchenko dev = p->device; 27563d060aebSAndy Shevchenko } 27573d060aebSAndy Shevchenko return dev; 27583d060aebSAndy Shevchenko } 27593d060aebSAndy Shevchenko 276036239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 276136239577Smochel@digitalimplant.org { 276236239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 2763f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 2764f791b8c8SGreg Kroah-Hartman struct device_private *p; 2765f791b8c8SGreg Kroah-Hartman 2766f791b8c8SGreg Kroah-Hartman if (n) { 2767f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 2768f791b8c8SGreg Kroah-Hartman dev = p->device; 2769f791b8c8SGreg Kroah-Hartman } 2770f791b8c8SGreg Kroah-Hartman return dev; 277136239577Smochel@digitalimplant.org } 277236239577Smochel@digitalimplant.org 27731da177e4SLinus Torvalds /** 2774e454cea2SKay Sievers * device_get_devnode - path of device node file 27756fcf53acSKay Sievers * @dev: device 2776e454cea2SKay Sievers * @mode: returned file access mode 27773c2670e6SKay Sievers * @uid: returned file owner 27783c2670e6SKay Sievers * @gid: returned file group 27796fcf53acSKay Sievers * @tmp: possibly allocated string 27806fcf53acSKay Sievers * 27816fcf53acSKay Sievers * Return the relative path of a possible device node. 27826fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 27836fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 27846fcf53acSKay Sievers * freed by the caller. 27856fcf53acSKay Sievers */ 2786e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 27874e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 27883c2670e6SKay Sievers const char **tmp) 27896fcf53acSKay Sievers { 27906fcf53acSKay Sievers char *s; 27916fcf53acSKay Sievers 27926fcf53acSKay Sievers *tmp = NULL; 27936fcf53acSKay Sievers 27946fcf53acSKay Sievers /* the device type may provide a specific name */ 2795e454cea2SKay Sievers if (dev->type && dev->type->devnode) 27963c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 27976fcf53acSKay Sievers if (*tmp) 27986fcf53acSKay Sievers return *tmp; 27996fcf53acSKay Sievers 28006fcf53acSKay Sievers /* the class may provide a specific name */ 2801e454cea2SKay Sievers if (dev->class && dev->class->devnode) 2802e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 28036fcf53acSKay Sievers if (*tmp) 28046fcf53acSKay Sievers return *tmp; 28056fcf53acSKay Sievers 28066fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 28076fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 28086fcf53acSKay Sievers return dev_name(dev); 28096fcf53acSKay Sievers 28106fcf53acSKay Sievers /* replace '!' in the name with '/' */ 2811a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 2812a29fd614SRasmus Villemoes if (!s) 28136fcf53acSKay Sievers return NULL; 2814a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 2815a29fd614SRasmus Villemoes return *tmp = s; 28166fcf53acSKay Sievers } 28176fcf53acSKay Sievers 28186fcf53acSKay Sievers /** 28191da177e4SLinus Torvalds * device_for_each_child - device child iterator. 2820c41455fbSRandy Dunlap * @parent: parent struct device. 28211da177e4SLinus Torvalds * @fn: function to be called for each device. 2822f8878dcbSRobert P. J. Day * @data: data for the callback. 28231da177e4SLinus Torvalds * 2824c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 28251da177e4SLinus Torvalds * passing it @data. 28261da177e4SLinus Torvalds * 28271da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 28281da177e4SLinus Torvalds * other than 0, we break out and return that value. 28291da177e4SLinus Torvalds */ 283036239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 28314a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 28321da177e4SLinus Torvalds { 283336239577Smochel@digitalimplant.org struct klist_iter i; 28341da177e4SLinus Torvalds struct device *child; 28351da177e4SLinus Torvalds int error = 0; 28361da177e4SLinus Torvalds 2837014c90dbSGreg Kroah-Hartman if (!parent->p) 2838014c90dbSGreg Kroah-Hartman return 0; 2839014c90dbSGreg Kroah-Hartman 2840f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 284193ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 284236239577Smochel@digitalimplant.org error = fn(child, data); 284336239577Smochel@digitalimplant.org klist_iter_exit(&i); 28441da177e4SLinus Torvalds return error; 28451da177e4SLinus Torvalds } 284686df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 28471da177e4SLinus Torvalds 28485ab69981SCornelia Huck /** 28493d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 28503d060aebSAndy Shevchenko * @parent: parent struct device. 28513d060aebSAndy Shevchenko * @fn: function to be called for each device. 28523d060aebSAndy Shevchenko * @data: data for the callback. 28533d060aebSAndy Shevchenko * 28543d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 28553d060aebSAndy Shevchenko * passing it @data. 28563d060aebSAndy Shevchenko * 28573d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 28583d060aebSAndy Shevchenko * other than 0, we break out and return that value. 28593d060aebSAndy Shevchenko */ 28603d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 28613d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 28623d060aebSAndy Shevchenko { 28633d060aebSAndy Shevchenko struct klist_iter i; 28643d060aebSAndy Shevchenko struct device *child; 28653d060aebSAndy Shevchenko int error = 0; 28663d060aebSAndy Shevchenko 28673d060aebSAndy Shevchenko if (!parent->p) 28683d060aebSAndy Shevchenko return 0; 28693d060aebSAndy Shevchenko 28703d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 28713d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 28723d060aebSAndy Shevchenko error = fn(child, data); 28733d060aebSAndy Shevchenko klist_iter_exit(&i); 28743d060aebSAndy Shevchenko return error; 28753d060aebSAndy Shevchenko } 28763d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 28773d060aebSAndy Shevchenko 28783d060aebSAndy Shevchenko /** 28795ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 28805ab69981SCornelia Huck * @parent: parent struct device 28815ab69981SCornelia Huck * @match: Callback function to check device 2882f8878dcbSRobert P. J. Day * @data: Data to pass to match function 28835ab69981SCornelia Huck * 28845ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 28855ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 28865ab69981SCornelia Huck * determined by the @match callback. 28875ab69981SCornelia Huck * 28885ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 28895ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 28905ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 28915ab69981SCornelia Huck * and not iterate over any more devices. 2892a4e2400aSFederico Vaga * 2893a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 28945ab69981SCornelia Huck */ 28955ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 28964a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 28975ab69981SCornelia Huck { 28985ab69981SCornelia Huck struct klist_iter i; 28995ab69981SCornelia Huck struct device *child; 29005ab69981SCornelia Huck 29015ab69981SCornelia Huck if (!parent) 29025ab69981SCornelia Huck return NULL; 29035ab69981SCornelia Huck 2904f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 29055ab69981SCornelia Huck while ((child = next_device(&i))) 29065ab69981SCornelia Huck if (match(child, data) && get_device(child)) 29075ab69981SCornelia Huck break; 29085ab69981SCornelia Huck klist_iter_exit(&i); 29095ab69981SCornelia Huck return child; 29105ab69981SCornelia Huck } 291186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 29125ab69981SCornelia Huck 2913dad9bb01SHeikki Krogerus /** 2914dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 2915dad9bb01SHeikki Krogerus * @parent: parent struct device 2916dad9bb01SHeikki Krogerus * @name: name of the child device 2917dad9bb01SHeikki Krogerus * 2918dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 2919dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 2920dad9bb01SHeikki Krogerus * 2921dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 2922dad9bb01SHeikki Krogerus */ 2923dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 2924dad9bb01SHeikki Krogerus const char *name) 2925dad9bb01SHeikki Krogerus { 2926dad9bb01SHeikki Krogerus struct klist_iter i; 2927dad9bb01SHeikki Krogerus struct device *child; 2928dad9bb01SHeikki Krogerus 2929dad9bb01SHeikki Krogerus if (!parent) 2930dad9bb01SHeikki Krogerus return NULL; 2931dad9bb01SHeikki Krogerus 2932dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 2933dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 2934dad9bb01SHeikki Krogerus if (!strcmp(dev_name(child), name) && get_device(child)) 2935dad9bb01SHeikki Krogerus break; 2936dad9bb01SHeikki Krogerus klist_iter_exit(&i); 2937dad9bb01SHeikki Krogerus return child; 2938dad9bb01SHeikki Krogerus } 2939dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 2940dad9bb01SHeikki Krogerus 29411da177e4SLinus Torvalds int __init devices_init(void) 29421da177e4SLinus Torvalds { 2943881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 2944881c6cfdSGreg Kroah-Hartman if (!devices_kset) 2945881c6cfdSGreg Kroah-Hartman return -ENOMEM; 2946e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 2947e105b8bfSDan Williams if (!dev_kobj) 2948e105b8bfSDan Williams goto dev_kobj_err; 2949e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 2950e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 2951e105b8bfSDan Williams goto block_kobj_err; 2952e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 2953e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 2954e105b8bfSDan Williams goto char_kobj_err; 2955e105b8bfSDan Williams 2956881c6cfdSGreg Kroah-Hartman return 0; 2957e105b8bfSDan Williams 2958e105b8bfSDan Williams char_kobj_err: 2959e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 2960e105b8bfSDan Williams block_kobj_err: 2961e105b8bfSDan Williams kobject_put(dev_kobj); 2962e105b8bfSDan Williams dev_kobj_err: 2963e105b8bfSDan Williams kset_unregister(devices_kset); 2964e105b8bfSDan Williams return -ENOMEM; 29651da177e4SLinus Torvalds } 29661da177e4SLinus Torvalds 29674f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 29684f3549d7SRafael J. Wysocki { 29694f3549d7SRafael J. Wysocki int ret; 29704f3549d7SRafael J. Wysocki 29714f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 29724f3549d7SRafael J. Wysocki if (ret) 29734f3549d7SRafael J. Wysocki return ret; 29744f3549d7SRafael J. Wysocki 29754f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 29764f3549d7SRafael J. Wysocki } 29774f3549d7SRafael J. Wysocki 29784f3549d7SRafael J. Wysocki /** 29794f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 29804f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 29814f3549d7SRafael J. Wysocki * 29824f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 29834f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 29844f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 29854f3549d7SRafael J. Wysocki * is executed. 29864f3549d7SRafael J. Wysocki * 29874f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 29884f3549d7SRafael J. Wysocki */ 29894f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 29904f3549d7SRafael J. Wysocki { 29914f3549d7SRafael J. Wysocki int ret; 29924f3549d7SRafael J. Wysocki 29934f3549d7SRafael J. Wysocki if (dev->offline_disabled) 29944f3549d7SRafael J. Wysocki return -EPERM; 29954f3549d7SRafael J. Wysocki 29964f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 29974f3549d7SRafael J. Wysocki if (ret) 29984f3549d7SRafael J. Wysocki return ret; 29994f3549d7SRafael J. Wysocki 30004f3549d7SRafael J. Wysocki device_lock(dev); 30014f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 30024f3549d7SRafael J. Wysocki if (dev->offline) { 30034f3549d7SRafael J. Wysocki ret = 1; 30044f3549d7SRafael J. Wysocki } else { 30054f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 30064f3549d7SRafael J. Wysocki if (!ret) { 30074f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 30084f3549d7SRafael J. Wysocki dev->offline = true; 30094f3549d7SRafael J. Wysocki } 30104f3549d7SRafael J. Wysocki } 30114f3549d7SRafael J. Wysocki } 30124f3549d7SRafael J. Wysocki device_unlock(dev); 30134f3549d7SRafael J. Wysocki 30144f3549d7SRafael J. Wysocki return ret; 30154f3549d7SRafael J. Wysocki } 30164f3549d7SRafael J. Wysocki 30174f3549d7SRafael J. Wysocki /** 30184f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 30194f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 30204f3549d7SRafael J. Wysocki * 30214f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 30224f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 30234f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 30244f3549d7SRafael J. Wysocki * 30254f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 30264f3549d7SRafael J. Wysocki */ 30274f3549d7SRafael J. Wysocki int device_online(struct device *dev) 30284f3549d7SRafael J. Wysocki { 30294f3549d7SRafael J. Wysocki int ret = 0; 30304f3549d7SRafael J. Wysocki 30314f3549d7SRafael J. Wysocki device_lock(dev); 30324f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 30334f3549d7SRafael J. Wysocki if (dev->offline) { 30344f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 30354f3549d7SRafael J. Wysocki if (!ret) { 30364f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 30374f3549d7SRafael J. Wysocki dev->offline = false; 30384f3549d7SRafael J. Wysocki } 30394f3549d7SRafael J. Wysocki } else { 30404f3549d7SRafael J. Wysocki ret = 1; 30414f3549d7SRafael J. Wysocki } 30424f3549d7SRafael J. Wysocki } 30434f3549d7SRafael J. Wysocki device_unlock(dev); 30444f3549d7SRafael J. Wysocki 30454f3549d7SRafael J. Wysocki return ret; 30464f3549d7SRafael J. Wysocki } 30474f3549d7SRafael J. Wysocki 30487f100d15SKarthigan Srinivasan struct root_device { 30490aa0dc41SMark McLoughlin struct device dev; 30500aa0dc41SMark McLoughlin struct module *owner; 30510aa0dc41SMark McLoughlin }; 30520aa0dc41SMark McLoughlin 305393058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 3054481e2079SFerenc Wagner { 3055481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 3056481e2079SFerenc Wagner } 30570aa0dc41SMark McLoughlin 30580aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 30590aa0dc41SMark McLoughlin { 30600aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 30610aa0dc41SMark McLoughlin } 30620aa0dc41SMark McLoughlin 30630aa0dc41SMark McLoughlin /** 30640aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 30650aa0dc41SMark McLoughlin * @name: root device name 30660aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 30670aa0dc41SMark McLoughlin * 30680aa0dc41SMark McLoughlin * This function allocates a root device and registers it 30690aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 30700aa0dc41SMark McLoughlin * device, use root_device_unregister(). 30710aa0dc41SMark McLoughlin * 30720aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 30730aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 30740aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 30750aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 30760aa0dc41SMark McLoughlin * 30770aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 30780aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 30790aa0dc41SMark McLoughlin * in sysfs. 30800aa0dc41SMark McLoughlin * 3081f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3082f0eae0edSJani Nikula * 30830aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 30840aa0dc41SMark McLoughlin */ 30850aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 30860aa0dc41SMark McLoughlin { 30870aa0dc41SMark McLoughlin struct root_device *root; 30880aa0dc41SMark McLoughlin int err = -ENOMEM; 30890aa0dc41SMark McLoughlin 30900aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 30910aa0dc41SMark McLoughlin if (!root) 30920aa0dc41SMark McLoughlin return ERR_PTR(err); 30930aa0dc41SMark McLoughlin 3094acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 30950aa0dc41SMark McLoughlin if (err) { 30960aa0dc41SMark McLoughlin kfree(root); 30970aa0dc41SMark McLoughlin return ERR_PTR(err); 30980aa0dc41SMark McLoughlin } 30990aa0dc41SMark McLoughlin 31000aa0dc41SMark McLoughlin root->dev.release = root_device_release; 31010aa0dc41SMark McLoughlin 31020aa0dc41SMark McLoughlin err = device_register(&root->dev); 31030aa0dc41SMark McLoughlin if (err) { 31040aa0dc41SMark McLoughlin put_device(&root->dev); 31050aa0dc41SMark McLoughlin return ERR_PTR(err); 31060aa0dc41SMark McLoughlin } 31070aa0dc41SMark McLoughlin 31081d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 31090aa0dc41SMark McLoughlin if (owner) { 31100aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 31110aa0dc41SMark McLoughlin 31120aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 31130aa0dc41SMark McLoughlin if (err) { 31140aa0dc41SMark McLoughlin device_unregister(&root->dev); 31150aa0dc41SMark McLoughlin return ERR_PTR(err); 31160aa0dc41SMark McLoughlin } 31170aa0dc41SMark McLoughlin root->owner = owner; 31180aa0dc41SMark McLoughlin } 31190aa0dc41SMark McLoughlin #endif 31200aa0dc41SMark McLoughlin 31210aa0dc41SMark McLoughlin return &root->dev; 31220aa0dc41SMark McLoughlin } 31230aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 31240aa0dc41SMark McLoughlin 31250aa0dc41SMark McLoughlin /** 31260aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 31277cbcf225SRandy Dunlap * @dev: device going away 31280aa0dc41SMark McLoughlin * 31290aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 31300aa0dc41SMark McLoughlin * root_device_register(). 31310aa0dc41SMark McLoughlin */ 31320aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 31330aa0dc41SMark McLoughlin { 31340aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 31350aa0dc41SMark McLoughlin 31360aa0dc41SMark McLoughlin if (root->owner) 31370aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 31380aa0dc41SMark McLoughlin 31390aa0dc41SMark McLoughlin device_unregister(dev); 31400aa0dc41SMark McLoughlin } 31410aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 31420aa0dc41SMark McLoughlin 314323681e47SGreg Kroah-Hartman 314423681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 314523681e47SGreg Kroah-Hartman { 31461e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 314723681e47SGreg Kroah-Hartman kfree(dev); 314823681e47SGreg Kroah-Hartman } 314923681e47SGreg Kroah-Hartman 31506a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 315139ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 315239ef3112SGuenter Roeck dev_t devt, void *drvdata, 315339ef3112SGuenter Roeck const struct attribute_group **groups, 315439ef3112SGuenter Roeck const char *fmt, va_list args) 315539ef3112SGuenter Roeck { 315639ef3112SGuenter Roeck struct device *dev = NULL; 315739ef3112SGuenter Roeck int retval = -ENODEV; 315839ef3112SGuenter Roeck 315939ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 316039ef3112SGuenter Roeck goto error; 316139ef3112SGuenter Roeck 316239ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 316339ef3112SGuenter Roeck if (!dev) { 316439ef3112SGuenter Roeck retval = -ENOMEM; 316539ef3112SGuenter Roeck goto error; 316639ef3112SGuenter Roeck } 316739ef3112SGuenter Roeck 3168bbc780f8SDavid Herrmann device_initialize(dev); 316939ef3112SGuenter Roeck dev->devt = devt; 317039ef3112SGuenter Roeck dev->class = class; 317139ef3112SGuenter Roeck dev->parent = parent; 317239ef3112SGuenter Roeck dev->groups = groups; 317339ef3112SGuenter Roeck dev->release = device_create_release; 317439ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 317539ef3112SGuenter Roeck 317639ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 317739ef3112SGuenter Roeck if (retval) 317839ef3112SGuenter Roeck goto error; 317939ef3112SGuenter Roeck 3180bbc780f8SDavid Herrmann retval = device_add(dev); 318139ef3112SGuenter Roeck if (retval) 318239ef3112SGuenter Roeck goto error; 318339ef3112SGuenter Roeck 318439ef3112SGuenter Roeck return dev; 318539ef3112SGuenter Roeck 318639ef3112SGuenter Roeck error: 318739ef3112SGuenter Roeck put_device(dev); 318839ef3112SGuenter Roeck return ERR_PTR(retval); 318939ef3112SGuenter Roeck } 319039ef3112SGuenter Roeck 319123681e47SGreg Kroah-Hartman /** 31928882b394SGreg Kroah-Hartman * device_create_vargs - creates a device and registers it with sysfs 31938882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 31948882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 31958882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 31968882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 31978882b394SGreg Kroah-Hartman * @fmt: string for the device's name 31988882b394SGreg Kroah-Hartman * @args: va_list for the device's name 31998882b394SGreg Kroah-Hartman * 32008882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 32018882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 32028882b394SGreg Kroah-Hartman * 32038882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 32048882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 32058882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 32068882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 32078882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 32088882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 32098882b394SGreg Kroah-Hartman * pointer. 32108882b394SGreg Kroah-Hartman * 3211f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3212f0eae0edSJani Nikula * 32138882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 32148882b394SGreg Kroah-Hartman * been created with a call to class_create(). 32158882b394SGreg Kroah-Hartman */ 32168882b394SGreg Kroah-Hartman struct device *device_create_vargs(struct class *class, struct device *parent, 32178882b394SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, 32188882b394SGreg Kroah-Hartman va_list args) 32198882b394SGreg Kroah-Hartman { 322039ef3112SGuenter Roeck return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 322139ef3112SGuenter Roeck fmt, args); 32228882b394SGreg Kroah-Hartman } 32238882b394SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_vargs); 32248882b394SGreg Kroah-Hartman 32258882b394SGreg Kroah-Hartman /** 32264e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 32278882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 32288882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 32298882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 32308882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 32318882b394SGreg Kroah-Hartman * @fmt: string for the device's name 32328882b394SGreg Kroah-Hartman * 32338882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 32348882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 32358882b394SGreg Kroah-Hartman * 32368882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 32378882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 32388882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 32398882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 32408882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 32418882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 32428882b394SGreg Kroah-Hartman * pointer. 32438882b394SGreg Kroah-Hartman * 3244f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3245f0eae0edSJani Nikula * 32468882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 32478882b394SGreg Kroah-Hartman * been created with a call to class_create(). 32488882b394SGreg Kroah-Hartman */ 32494e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 32504e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 32518882b394SGreg Kroah-Hartman { 32528882b394SGreg Kroah-Hartman va_list vargs; 32538882b394SGreg Kroah-Hartman struct device *dev; 32548882b394SGreg Kroah-Hartman 32558882b394SGreg Kroah-Hartman va_start(vargs, fmt); 32568882b394SGreg Kroah-Hartman dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 32578882b394SGreg Kroah-Hartman va_end(vargs); 32588882b394SGreg Kroah-Hartman return dev; 32598882b394SGreg Kroah-Hartman } 32604e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 32618882b394SGreg Kroah-Hartman 326239ef3112SGuenter Roeck /** 326339ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 326439ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 326539ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 326639ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 326739ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 326839ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 326939ef3112SGuenter Roeck * @fmt: string for the device's name 327039ef3112SGuenter Roeck * 327139ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 327239ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 327339ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 327439ef3112SGuenter Roeck * be created automatically. 327539ef3112SGuenter Roeck * 327639ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 327739ef3112SGuenter Roeck * the dev_t is not 0,0. 327839ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 327939ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 328039ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 328139ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 328239ef3112SGuenter Roeck * pointer. 328339ef3112SGuenter Roeck * 328439ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 328539ef3112SGuenter Roeck * 328639ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 328739ef3112SGuenter Roeck * been created with a call to class_create(). 328839ef3112SGuenter Roeck */ 328939ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 329039ef3112SGuenter Roeck struct device *parent, dev_t devt, 329139ef3112SGuenter Roeck void *drvdata, 329239ef3112SGuenter Roeck const struct attribute_group **groups, 329339ef3112SGuenter Roeck const char *fmt, ...) 329439ef3112SGuenter Roeck { 329539ef3112SGuenter Roeck va_list vargs; 329639ef3112SGuenter Roeck struct device *dev; 329739ef3112SGuenter Roeck 329839ef3112SGuenter Roeck va_start(vargs, fmt); 329939ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 330039ef3112SGuenter Roeck fmt, vargs); 330139ef3112SGuenter Roeck va_end(vargs); 330239ef3112SGuenter Roeck return dev; 330339ef3112SGuenter Roeck } 330439ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 330539ef3112SGuenter Roeck 3306775b64d2SRafael J. Wysocki /** 3307775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 3308775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 3309775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 3310775b64d2SRafael J. Wysocki * 3311775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 3312775b64d2SRafael J. Wysocki * call to device_create(). 3313775b64d2SRafael J. Wysocki */ 3314775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 3315775b64d2SRafael J. Wysocki { 3316775b64d2SRafael J. Wysocki struct device *dev; 3317775b64d2SRafael J. Wysocki 33184495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 3319cd35449bSDave Young if (dev) { 3320cd35449bSDave Young put_device(dev); 332123681e47SGreg Kroah-Hartman device_unregister(dev); 332223681e47SGreg Kroah-Hartman } 3323cd35449bSDave Young } 332423681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 3325a2de48caSGreg Kroah-Hartman 3326a2de48caSGreg Kroah-Hartman /** 3327a2de48caSGreg Kroah-Hartman * device_rename - renames a device 3328a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 3329a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 3330030c1d2bSEric W. Biederman * 3331030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 3332030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 3333030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 3334030c1d2bSEric W. Biederman * won't conflict with other devices. 3335c6c0ac66SMichael Ellerman * 3336a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 3337a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 3338a5462516STimur Tabi * some insight: 3339a5462516STimur Tabi * 3340a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 3341a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 3342a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 3343a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 3344a5462516STimur Tabi * 3345a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 3346a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 3347a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 3348a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 3349a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 3350a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 3351a5462516STimur Tabi * 3352a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 3353a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 3354a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 3355a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 3356a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 3357a5462516STimur Tabi * reasons. 3358a5462516STimur Tabi * 3359a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 3360a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 3361a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 3362a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 3363a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 3364a2de48caSGreg Kroah-Hartman */ 33656937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 3366a2de48caSGreg Kroah-Hartman { 33674b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 33682ee97cafSCornelia Huck char *old_device_name = NULL; 3369a2de48caSGreg Kroah-Hartman int error; 3370a2de48caSGreg Kroah-Hartman 3371a2de48caSGreg Kroah-Hartman dev = get_device(dev); 3372a2de48caSGreg Kroah-Hartman if (!dev) 3373a2de48caSGreg Kroah-Hartman return -EINVAL; 3374a2de48caSGreg Kroah-Hartman 337569df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 3376a2de48caSGreg Kroah-Hartman 33771fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 33782ee97cafSCornelia Huck if (!old_device_name) { 3379952ab431SJesper Juhl error = -ENOMEM; 33802ee97cafSCornelia Huck goto out; 3381952ab431SJesper Juhl } 3382a2de48caSGreg Kroah-Hartman 3383f349cf34SEric W. Biederman if (dev->class) { 33844b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 33854b30ee58STejun Heo kobj, old_device_name, 33864b30ee58STejun Heo new_name, kobject_namespace(kobj)); 3387f349cf34SEric W. Biederman if (error) 3388f349cf34SEric W. Biederman goto out; 3389f349cf34SEric W. Biederman } 339039aba963SKay Sievers 33914b30ee58STejun Heo error = kobject_rename(kobj, new_name); 33921fa5ae85SKay Sievers if (error) 33932ee97cafSCornelia Huck goto out; 3394a2de48caSGreg Kroah-Hartman 33952ee97cafSCornelia Huck out: 3396a2de48caSGreg Kroah-Hartman put_device(dev); 3397a2de48caSGreg Kroah-Hartman 33982ee97cafSCornelia Huck kfree(old_device_name); 3399a2de48caSGreg Kroah-Hartman 3400a2de48caSGreg Kroah-Hartman return error; 3401a2de48caSGreg Kroah-Hartman } 3402a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 34038a82472fSCornelia Huck 34048a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 34058a82472fSCornelia Huck struct device *old_parent, 34068a82472fSCornelia Huck struct device *new_parent) 34078a82472fSCornelia Huck { 3408f7f3461dSGreg Kroah-Hartman int error = 0; 34098a82472fSCornelia Huck 3410f7f3461dSGreg Kroah-Hartman if (old_parent) 3411f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 3412f7f3461dSGreg Kroah-Hartman if (new_parent) 3413f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 3414f7f3461dSGreg Kroah-Hartman "device"); 3415f7f3461dSGreg Kroah-Hartman return error; 34168a82472fSCornelia Huck } 34178a82472fSCornelia Huck 34188a82472fSCornelia Huck /** 34198a82472fSCornelia Huck * device_move - moves a device to a new parent 34208a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 342113509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 3422ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 34238a82472fSCornelia Huck */ 3424ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 3425ffa6a705SCornelia Huck enum dpm_order dpm_order) 34268a82472fSCornelia Huck { 34278a82472fSCornelia Huck int error; 34288a82472fSCornelia Huck struct device *old_parent; 3429c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 34308a82472fSCornelia Huck 34318a82472fSCornelia Huck dev = get_device(dev); 34328a82472fSCornelia Huck if (!dev) 34338a82472fSCornelia Huck return -EINVAL; 34348a82472fSCornelia Huck 3435ffa6a705SCornelia Huck device_pm_lock(); 34368a82472fSCornelia Huck new_parent = get_device(new_parent); 3437c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 343884d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 343984d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 344084d0c27dSTetsuo Handa put_device(new_parent); 344184d0c27dSTetsuo Handa goto out; 344284d0c27dSTetsuo Handa } 344363b6971aSCornelia Huck 34441e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 34451e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 3446c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 34478a82472fSCornelia Huck if (error) { 344863b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 34498a82472fSCornelia Huck put_device(new_parent); 34508a82472fSCornelia Huck goto out; 34518a82472fSCornelia Huck } 34528a82472fSCornelia Huck old_parent = dev->parent; 34538a82472fSCornelia Huck dev->parent = new_parent; 34548a82472fSCornelia Huck if (old_parent) 3455f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 34560d358f22SYinghai Lu if (new_parent) { 3457f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3458f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 34590d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 34600d358f22SYinghai Lu } 34610d358f22SYinghai Lu 3462bdd4034dSRabin Vincent if (dev->class) { 34638a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 34648a82472fSCornelia Huck if (error) { 34658a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 34668a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 34678a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 3468c744aeaeSCornelia Huck if (new_parent) 3469f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 34700d358f22SYinghai Lu dev->parent = old_parent; 34710d358f22SYinghai Lu if (old_parent) { 3472f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3473f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 34740d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 34750d358f22SYinghai Lu } 34768a82472fSCornelia Huck } 347763b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 34788a82472fSCornelia Huck put_device(new_parent); 34798a82472fSCornelia Huck goto out; 34808a82472fSCornelia Huck } 3481bdd4034dSRabin Vincent } 3482ffa6a705SCornelia Huck switch (dpm_order) { 3483ffa6a705SCornelia Huck case DPM_ORDER_NONE: 3484ffa6a705SCornelia Huck break; 3485ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 3486ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 348752cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 3488ffa6a705SCornelia Huck break; 3489ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 3490ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 349152cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 3492ffa6a705SCornelia Huck break; 3493ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 3494ffa6a705SCornelia Huck device_pm_move_last(dev); 349552cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 3496ffa6a705SCornelia Huck break; 3497ffa6a705SCornelia Huck } 3498bdd4034dSRabin Vincent 34998a82472fSCornelia Huck put_device(old_parent); 35008a82472fSCornelia Huck out: 3501ffa6a705SCornelia Huck device_pm_unlock(); 35028a82472fSCornelia Huck put_device(dev); 35038a82472fSCornelia Huck return error; 35048a82472fSCornelia Huck } 35058a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 350637b0c020SGreg Kroah-Hartman 3507b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 3508b8f33e5dSChristian Brauner kgid_t kgid) 3509b8f33e5dSChristian Brauner { 3510b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3511b8f33e5dSChristian Brauner struct class *class = dev->class; 3512b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 3513b8f33e5dSChristian Brauner int error; 3514b8f33e5dSChristian Brauner 3515b8f33e5dSChristian Brauner if (class) { 3516b8f33e5dSChristian Brauner /* 3517b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 3518b8f33e5dSChristian Brauner * @kuid/@kgid. 3519b8f33e5dSChristian Brauner */ 3520b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 3521b8f33e5dSChristian Brauner kgid); 3522b8f33e5dSChristian Brauner if (error) 3523b8f33e5dSChristian Brauner return error; 3524b8f33e5dSChristian Brauner } 3525b8f33e5dSChristian Brauner 3526b8f33e5dSChristian Brauner if (type) { 3527b8f33e5dSChristian Brauner /* 3528b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 3529b8f33e5dSChristian Brauner * @kuid/@kgid. 3530b8f33e5dSChristian Brauner */ 3531b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 3532b8f33e5dSChristian Brauner kgid); 3533b8f33e5dSChristian Brauner if (error) 3534b8f33e5dSChristian Brauner return error; 3535b8f33e5dSChristian Brauner } 3536b8f33e5dSChristian Brauner 3537b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 3538b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 3539b8f33e5dSChristian Brauner if (error) 3540b8f33e5dSChristian Brauner return error; 3541b8f33e5dSChristian Brauner 3542b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 3543b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 3544b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 3545b8f33e5dSChristian Brauner kuid, kgid); 3546b8f33e5dSChristian Brauner if (error) 3547b8f33e5dSChristian Brauner return error; 3548b8f33e5dSChristian Brauner } 3549b8f33e5dSChristian Brauner 3550b8f33e5dSChristian Brauner return 0; 3551b8f33e5dSChristian Brauner } 3552b8f33e5dSChristian Brauner 3553b8f33e5dSChristian Brauner /** 3554b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 3555b8f33e5dSChristian Brauner * @dev: device. 3556b8f33e5dSChristian Brauner * @kuid: new owner's kuid 3557b8f33e5dSChristian Brauner * @kgid: new owner's kgid 3558b8f33e5dSChristian Brauner * 3559b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 3560b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 3561b8f33e5dSChristian Brauner * core. 3562b8f33e5dSChristian Brauner * 3563b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 3564b8f33e5dSChristian Brauner */ 3565b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 3566b8f33e5dSChristian Brauner { 3567b8f33e5dSChristian Brauner int error; 3568b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3569b8f33e5dSChristian Brauner 3570b8f33e5dSChristian Brauner dev = get_device(dev); 3571b8f33e5dSChristian Brauner if (!dev) 3572b8f33e5dSChristian Brauner return -EINVAL; 3573b8f33e5dSChristian Brauner 3574b8f33e5dSChristian Brauner /* 3575b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 3576b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 3577b8f33e5dSChristian Brauner */ 3578b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 3579b8f33e5dSChristian Brauner if (error) 3580b8f33e5dSChristian Brauner goto out; 3581b8f33e5dSChristian Brauner 3582b8f33e5dSChristian Brauner /* 3583b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 3584b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 3585b8f33e5dSChristian Brauner * that step here. 3586b8f33e5dSChristian Brauner */ 3587b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 3588b8f33e5dSChristian Brauner kgid); 3589b8f33e5dSChristian Brauner if (error) 3590b8f33e5dSChristian Brauner goto out; 3591b8f33e5dSChristian Brauner 3592b8f33e5dSChristian Brauner /* 3593b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 3594b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 3595b8f33e5dSChristian Brauner * to @kuid/@kgid. 3596b8f33e5dSChristian Brauner */ 3597b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 3598b8f33e5dSChristian Brauner if (error) 3599b8f33e5dSChristian Brauner goto out; 3600b8f33e5dSChristian Brauner 36013b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 36023b52fc5dSChristian Brauner if (error) 36033b52fc5dSChristian Brauner goto out; 36043b52fc5dSChristian Brauner 3605b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 3606b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 3607b8f33e5dSChristian Brauner goto out; 3608b8f33e5dSChristian Brauner #endif 3609b8f33e5dSChristian Brauner 3610b8f33e5dSChristian Brauner /* 3611b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 3612b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 3613b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 3614b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 3615b8f33e5dSChristian Brauner */ 3616b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 3617b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 3618b8f33e5dSChristian Brauner if (error) 3619b8f33e5dSChristian Brauner goto out; 3620b8f33e5dSChristian Brauner 3621b8f33e5dSChristian Brauner out: 3622b8f33e5dSChristian Brauner put_device(dev); 3623b8f33e5dSChristian Brauner return error; 3624b8f33e5dSChristian Brauner } 3625b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 3626b8f33e5dSChristian Brauner 362737b0c020SGreg Kroah-Hartman /** 362837b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 362937b0c020SGreg Kroah-Hartman */ 363037b0c020SGreg Kroah-Hartman void device_shutdown(void) 363137b0c020SGreg Kroah-Hartman { 3632f123db8eSBenson Leung struct device *dev, *parent; 363337b0c020SGreg Kroah-Hartman 36343297c8fcSPingfan Liu wait_for_device_probe(); 36353297c8fcSPingfan Liu device_block_probing(); 36363297c8fcSPingfan Liu 363765650b35SRafael J. Wysocki cpufreq_suspend(); 363865650b35SRafael J. Wysocki 36396245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 36406245838fSHugh Daschbach /* 36416245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 36426245838fSHugh Daschbach * Beware that device unplug events may also start pulling 36436245838fSHugh Daschbach * devices offline, even as the system is shutting down. 36446245838fSHugh Daschbach */ 36456245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 36466245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 36476245838fSHugh Daschbach kobj.entry); 3648d1c6c030SMing Lei 3649d1c6c030SMing Lei /* 3650d1c6c030SMing Lei * hold reference count of device's parent to 3651d1c6c030SMing Lei * prevent it from being freed because parent's 3652d1c6c030SMing Lei * lock is to be held 3653d1c6c030SMing Lei */ 3654f123db8eSBenson Leung parent = get_device(dev->parent); 36556245838fSHugh Daschbach get_device(dev); 36566245838fSHugh Daschbach /* 36576245838fSHugh Daschbach * Make sure the device is off the kset list, in the 36586245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 36596245838fSHugh Daschbach */ 36606245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 36616245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 3662fe6b91f4SAlan Stern 3663d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 3664f123db8eSBenson Leung if (parent) 3665f123db8eSBenson Leung device_lock(parent); 3666d1c6c030SMing Lei device_lock(dev); 3667d1c6c030SMing Lei 3668fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 3669fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 3670fe6b91f4SAlan Stern pm_runtime_barrier(dev); 36716245838fSHugh Daschbach 36727521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 3673f77af151SJosh Zimmerman if (initcall_debug) 36747521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 36757521621eSMichal Suchanek dev->class->shutdown_pre(dev); 36767521621eSMichal Suchanek } 36777521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 36780246c4faSShuoX Liu if (initcall_debug) 36790246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 368037b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 368137b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 36820246c4faSShuoX Liu if (initcall_debug) 36830246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 368437b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 368537b0c020SGreg Kroah-Hartman } 3686d1c6c030SMing Lei 3687d1c6c030SMing Lei device_unlock(dev); 3688f123db8eSBenson Leung if (parent) 3689f123db8eSBenson Leung device_unlock(parent); 3690d1c6c030SMing Lei 36916245838fSHugh Daschbach put_device(dev); 3692f123db8eSBenson Leung put_device(parent); 36936245838fSHugh Daschbach 36946245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 369537b0c020SGreg Kroah-Hartman } 36966245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 369737b0c020SGreg Kroah-Hartman } 369899bcf217SJoe Perches 369999bcf217SJoe Perches /* 370099bcf217SJoe Perches * Device logging functions 370199bcf217SJoe Perches */ 370299bcf217SJoe Perches 370399bcf217SJoe Perches #ifdef CONFIG_PRINTK 3704666f355fSJoe Perches static int 3705666f355fSJoe Perches create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 370699bcf217SJoe Perches { 3707c4e00daaSKay Sievers const char *subsys; 3708798efc60SJoe Perches size_t pos = 0; 370999bcf217SJoe Perches 3710c4e00daaSKay Sievers if (dev->class) 3711c4e00daaSKay Sievers subsys = dev->class->name; 3712c4e00daaSKay Sievers else if (dev->bus) 3713c4e00daaSKay Sievers subsys = dev->bus->name; 3714c4e00daaSKay Sievers else 3715798efc60SJoe Perches return 0; 3716c4e00daaSKay Sievers 3717798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 3718655e5b7cSBen Hutchings if (pos >= hdrlen) 3719655e5b7cSBen Hutchings goto overflow; 3720c4e00daaSKay Sievers 3721c4e00daaSKay Sievers /* 3722c4e00daaSKay Sievers * Add device identifier DEVICE=: 3723c4e00daaSKay Sievers * b12:8 block dev_t 3724c4e00daaSKay Sievers * c127:3 char dev_t 3725c4e00daaSKay Sievers * n8 netdev ifindex 3726c4e00daaSKay Sievers * +sound:card0 subsystem:devname 3727c4e00daaSKay Sievers */ 3728c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 3729c4e00daaSKay Sievers char c; 3730c4e00daaSKay Sievers 3731c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 3732c4e00daaSKay Sievers c = 'b'; 3733c4e00daaSKay Sievers else 3734c4e00daaSKay Sievers c = 'c'; 3735798efc60SJoe Perches pos++; 3736798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3737c4e00daaSKay Sievers "DEVICE=%c%u:%u", 3738c4e00daaSKay Sievers c, MAJOR(dev->devt), MINOR(dev->devt)); 3739c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 3740c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 3741c4e00daaSKay Sievers 3742798efc60SJoe Perches pos++; 3743798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3744c4e00daaSKay Sievers "DEVICE=n%u", net->ifindex); 3745c4e00daaSKay Sievers } else { 3746798efc60SJoe Perches pos++; 3747798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3748c4e00daaSKay Sievers "DEVICE=+%s:%s", subsys, dev_name(dev)); 3749c4e00daaSKay Sievers } 3750af7f2158SJim Cromie 3751655e5b7cSBen Hutchings if (pos >= hdrlen) 3752655e5b7cSBen Hutchings goto overflow; 3753655e5b7cSBen Hutchings 3754798efc60SJoe Perches return pos; 3755655e5b7cSBen Hutchings 3756655e5b7cSBen Hutchings overflow: 3757655e5b7cSBen Hutchings dev_WARN(dev, "device/subsystem name too long"); 3758655e5b7cSBen Hutchings return 0; 375999bcf217SJoe Perches } 3760798efc60SJoe Perches 376105e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 376205e4e5b8SJoe Perches const char *fmt, va_list args) 376305e4e5b8SJoe Perches { 376405e4e5b8SJoe Perches char hdr[128]; 376505e4e5b8SJoe Perches size_t hdrlen; 376605e4e5b8SJoe Perches 376705e4e5b8SJoe Perches hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 376805e4e5b8SJoe Perches 376905e4e5b8SJoe Perches return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 377005e4e5b8SJoe Perches } 377105e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 377205e4e5b8SJoe Perches 377305e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 377405e4e5b8SJoe Perches { 377505e4e5b8SJoe Perches va_list args; 377605e4e5b8SJoe Perches int r; 377705e4e5b8SJoe Perches 377805e4e5b8SJoe Perches va_start(args, fmt); 377905e4e5b8SJoe Perches 378005e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 378105e4e5b8SJoe Perches 378205e4e5b8SJoe Perches va_end(args); 378305e4e5b8SJoe Perches 378405e4e5b8SJoe Perches return r; 378505e4e5b8SJoe Perches } 378605e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 378705e4e5b8SJoe Perches 3788d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 3789798efc60SJoe Perches struct va_format *vaf) 3790798efc60SJoe Perches { 3791d1f1052cSJoe Perches if (dev) 3792d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 3793798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 3794d1f1052cSJoe Perches else 3795d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 3796798efc60SJoe Perches } 379799bcf217SJoe Perches 3798d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 379999bcf217SJoe Perches const char *fmt, ...) 380099bcf217SJoe Perches { 380199bcf217SJoe Perches struct va_format vaf; 380299bcf217SJoe Perches va_list args; 380399bcf217SJoe Perches 380499bcf217SJoe Perches va_start(args, fmt); 380599bcf217SJoe Perches 380699bcf217SJoe Perches vaf.fmt = fmt; 380799bcf217SJoe Perches vaf.va = &args; 380899bcf217SJoe Perches 3809d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 3810798efc60SJoe Perches 381199bcf217SJoe Perches va_end(args); 381299bcf217SJoe Perches } 381399bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 381499bcf217SJoe Perches 381599bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 3816d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 381799bcf217SJoe Perches { \ 381899bcf217SJoe Perches struct va_format vaf; \ 381999bcf217SJoe Perches va_list args; \ 382099bcf217SJoe Perches \ 382199bcf217SJoe Perches va_start(args, fmt); \ 382299bcf217SJoe Perches \ 382399bcf217SJoe Perches vaf.fmt = fmt; \ 382499bcf217SJoe Perches vaf.va = &args; \ 382599bcf217SJoe Perches \ 3826d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 3827798efc60SJoe Perches \ 382899bcf217SJoe Perches va_end(args); \ 382999bcf217SJoe Perches } \ 383099bcf217SJoe Perches EXPORT_SYMBOL(func); 383199bcf217SJoe Perches 3832663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 3833663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 3834663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 3835663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 3836663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 3837663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 383899bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 383999bcf217SJoe Perches 384099bcf217SJoe Perches #endif 384197badf87SRafael J. Wysocki 384297badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 384397badf87SRafael J. Wysocki { 384497badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 384597badf87SRafael J. Wysocki } 384697badf87SRafael J. Wysocki 384797badf87SRafael J. Wysocki /** 384897badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 384997badf87SRafael J. Wysocki * @dev: Device to handle. 385097badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 385197badf87SRafael J. Wysocki * 385297badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 385397badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 385497badf87SRafael J. Wysocki */ 385597badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 385697badf87SRafael J. Wysocki { 385797badf87SRafael J. Wysocki if (fwnode) { 385897badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 385997badf87SRafael J. Wysocki 386097badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 386197badf87SRafael J. Wysocki fn = fn->secondary; 386297badf87SRafael J. Wysocki 386355f89a8aSMika Westerberg if (fn) { 386455f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 386597badf87SRafael J. Wysocki fwnode->secondary = fn; 386655f89a8aSMika Westerberg } 386797badf87SRafael J. Wysocki dev->fwnode = fwnode; 386897badf87SRafael J. Wysocki } else { 386997badf87SRafael J. Wysocki dev->fwnode = fwnode_is_primary(dev->fwnode) ? 387097badf87SRafael J. Wysocki dev->fwnode->secondary : NULL; 387197badf87SRafael J. Wysocki } 387297badf87SRafael J. Wysocki } 387397badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 387497badf87SRafael J. Wysocki 387597badf87SRafael J. Wysocki /** 387697badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 387797badf87SRafael J. Wysocki * @dev: Device to handle. 387897badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 387997badf87SRafael J. Wysocki * 388097badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 388197badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 388297badf87SRafael J. Wysocki * @fwnode. 388397badf87SRafael J. Wysocki */ 388497badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 388597badf87SRafael J. Wysocki { 388697badf87SRafael J. Wysocki if (fwnode) 388797badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 388897badf87SRafael J. Wysocki 388997badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 389097badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 389197badf87SRafael J. Wysocki else 389297badf87SRafael J. Wysocki dev->fwnode = fwnode; 389397badf87SRafael J. Wysocki } 389496489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 38954e75e1d7SJohan Hovold 38964e75e1d7SJohan Hovold /** 38974e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 38984e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 38994e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 39004e75e1d7SJohan Hovold * 39014e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 39024e75e1d7SJohan Hovold * any reference held to the old node. 39034e75e1d7SJohan Hovold */ 39044e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 39054e75e1d7SJohan Hovold { 39064e75e1d7SJohan Hovold of_node_put(dev->of_node); 39074e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 39084e75e1d7SJohan Hovold dev->of_node_reused = true; 39094e75e1d7SJohan Hovold } 39104e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 391165b66682SSuzuki K Poulose 39126cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 39136cda08a2SSuzuki K Poulose { 39146cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 39156cda08a2SSuzuki K Poulose } 39166cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 39176cda08a2SSuzuki K Poulose 391865b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 391965b66682SSuzuki K Poulose { 392065b66682SSuzuki K Poulose return dev->of_node == np; 392165b66682SSuzuki K Poulose } 392265b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 392367843bbaSSuzuki K Poulose 392467843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 392567843bbaSSuzuki K Poulose { 392667843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 392767843bbaSSuzuki K Poulose } 392867843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 39294495dfddSSuzuki K Poulose 39304495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 39314495dfddSSuzuki K Poulose { 39324495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 39334495dfddSSuzuki K Poulose } 39344495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 393500500147SSuzuki K Poulose 393600500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 393700500147SSuzuki K Poulose { 393800500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 393900500147SSuzuki K Poulose } 394000500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 39416bf85ba9SSuzuki K Poulose 39426bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 39436bf85ba9SSuzuki K Poulose { 39446bf85ba9SSuzuki K Poulose return 1; 39456bf85ba9SSuzuki K Poulose } 39466bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 3947