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; 52716a7a25SSaravana Kannan static unsigned int defer_fw_devlink_count; 53716a7a25SSaravana Kannan static DEFINE_MUTEX(defer_fw_devlink_lock); 54716a7a25SSaravana Kannan static bool fw_devlink_is_permissive(void); 559ed98953SRafael J. Wysocki 569ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 579ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 589ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 599ed98953SRafael J. Wysocki 609ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 619ed98953SRafael J. Wysocki { 629ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 639ed98953SRafael J. Wysocki } 649ed98953SRafael J. Wysocki 659ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 669ed98953SRafael J. Wysocki { 679ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 689ed98953SRafael J. Wysocki } 699ed98953SRafael J. Wysocki 7068464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 719ed98953SRafael J. Wysocki { 729ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 739ed98953SRafael J. Wysocki } 749ed98953SRafael J. Wysocki 75ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 769ed98953SRafael J. Wysocki { 779ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 789ed98953SRafael J. Wysocki } 79c2fa1e1bSJoel Fernandes (Google) 80c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 81c2fa1e1bSJoel Fernandes (Google) { 82c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 83c2fa1e1bSJoel Fernandes (Google) } 849ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 859ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 869ed98953SRafael J. Wysocki 879ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 889ed98953SRafael J. Wysocki { 899ed98953SRafael J. Wysocki down_write(&device_links_lock); 909ed98953SRafael J. Wysocki } 919ed98953SRafael J. Wysocki 929ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 939ed98953SRafael J. Wysocki { 949ed98953SRafael J. Wysocki up_write(&device_links_lock); 959ed98953SRafael J. Wysocki } 969ed98953SRafael J. Wysocki 979ed98953SRafael J. Wysocki int device_links_read_lock(void) 989ed98953SRafael J. Wysocki { 999ed98953SRafael J. Wysocki down_read(&device_links_lock); 1009ed98953SRafael J. Wysocki return 0; 1019ed98953SRafael J. Wysocki } 1029ed98953SRafael J. Wysocki 1039ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 1049ed98953SRafael J. Wysocki { 1059ed98953SRafael J. Wysocki up_read(&device_links_lock); 1069ed98953SRafael J. Wysocki } 107c2fa1e1bSJoel Fernandes (Google) 108c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 109c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 110c2fa1e1bSJoel Fernandes (Google) { 111c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 112c2fa1e1bSJoel Fernandes (Google) } 113c2fa1e1bSJoel Fernandes (Google) #endif 1149ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 1159ed98953SRafael J. Wysocki 1169ed98953SRafael J. Wysocki /** 1179ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 1189ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 1199ed98953SRafael J. Wysocki * @target: Device to check against. 1209ed98953SRafael J. Wysocki * 1219ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 1229ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 1239ed98953SRafael J. Wysocki */ 1249ed98953SRafael J. Wysocki static int device_is_dependent(struct device *dev, void *target) 1259ed98953SRafael J. Wysocki { 1269ed98953SRafael J. Wysocki struct device_link *link; 1279ed98953SRafael J. Wysocki int ret; 1289ed98953SRafael J. Wysocki 129e16f4f3eSBenjamin Gaignard if (dev == target) 1309ed98953SRafael J. Wysocki return 1; 1319ed98953SRafael J. Wysocki 1329ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 1339ed98953SRafael J. Wysocki if (ret) 1349ed98953SRafael J. Wysocki return ret; 1359ed98953SRafael J. Wysocki 1369ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 13705ef983eSSaravana Kannan if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 13805ef983eSSaravana Kannan continue; 13905ef983eSSaravana Kannan 140e16f4f3eSBenjamin Gaignard if (link->consumer == target) 1419ed98953SRafael J. Wysocki return 1; 1429ed98953SRafael J. Wysocki 1439ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 1449ed98953SRafael J. Wysocki if (ret) 1459ed98953SRafael J. Wysocki break; 1469ed98953SRafael J. Wysocki } 1479ed98953SRafael J. Wysocki return ret; 1489ed98953SRafael J. Wysocki } 1499ed98953SRafael J. Wysocki 150515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 151515db266SRafael J. Wysocki struct device *consumer, 152515db266SRafael J. Wysocki struct device *supplier) 153515db266SRafael J. Wysocki { 154515db266SRafael J. Wysocki switch (supplier->links.status) { 155515db266SRafael J. Wysocki case DL_DEV_PROBING: 156515db266SRafael J. Wysocki switch (consumer->links.status) { 157515db266SRafael J. Wysocki case DL_DEV_PROBING: 158515db266SRafael J. Wysocki /* 159515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 160515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 161515db266SRafael J. Wysocki * knows that the supplier is already functional (for 162515db266SRafael J. Wysocki * example, it has just acquired some resources from the 163515db266SRafael J. Wysocki * supplier). 164515db266SRafael J. Wysocki */ 165515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 166515db266SRafael J. Wysocki break; 167515db266SRafael J. Wysocki default: 168515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 169515db266SRafael J. Wysocki break; 170515db266SRafael J. Wysocki } 171515db266SRafael J. Wysocki break; 172515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 173515db266SRafael J. Wysocki switch (consumer->links.status) { 174515db266SRafael J. Wysocki case DL_DEV_PROBING: 175515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 176515db266SRafael J. Wysocki break; 177515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 178515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 179515db266SRafael J. Wysocki break; 180515db266SRafael J. Wysocki default: 181515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 182515db266SRafael J. Wysocki break; 183515db266SRafael J. Wysocki } 184515db266SRafael J. Wysocki break; 185515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 186515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 187515db266SRafael J. Wysocki break; 188515db266SRafael J. Wysocki default: 189515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 190515db266SRafael J. Wysocki break; 191515db266SRafael J. Wysocki } 192515db266SRafael J. Wysocki } 193515db266SRafael J. Wysocki 1949ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 1959ed98953SRafael J. Wysocki { 1969ed98953SRafael J. Wysocki struct device_link *link; 1979ed98953SRafael J. Wysocki 1989ed98953SRafael J. Wysocki /* 1999ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 2009ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 2019ed98953SRafael J. Wysocki */ 2029ed98953SRafael J. Wysocki if (device_is_registered(dev)) 2039ed98953SRafael J. Wysocki devices_kset_move_last(dev); 2049ed98953SRafael J. Wysocki 2059ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 2069ed98953SRafael J. Wysocki device_pm_move_last(dev); 2079ed98953SRafael J. Wysocki 2089ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 20905ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 21005ef983eSSaravana Kannan if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 21105ef983eSSaravana Kannan continue; 2129ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 21305ef983eSSaravana Kannan } 2149ed98953SRafael J. Wysocki 2159ed98953SRafael J. Wysocki return 0; 2169ed98953SRafael J. Wysocki } 2179ed98953SRafael J. Wysocki 2189ed98953SRafael J. Wysocki /** 219494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 220494fd7b7SFeng Kan * @dev: Device to move 221494fd7b7SFeng Kan * 222494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 223494fd7b7SFeng Kan * 224494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 225494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 226494fd7b7SFeng Kan */ 227494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 228494fd7b7SFeng Kan { 229494fd7b7SFeng Kan int idx; 230494fd7b7SFeng Kan 231494fd7b7SFeng Kan idx = device_links_read_lock(); 232494fd7b7SFeng Kan device_pm_lock(); 233494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 234494fd7b7SFeng Kan device_pm_unlock(); 235494fd7b7SFeng Kan device_links_read_unlock(idx); 236494fd7b7SFeng Kan } 237494fd7b7SFeng Kan 238515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 239515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 24005ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 24105ef983eSSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 242515db266SRafael J. Wysocki 243fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 244fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 245fb583c8eSRafael J. Wysocki 246494fd7b7SFeng Kan /** 2479ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 2489ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 2499ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 2509ed98953SRafael J. Wysocki * @flags: Link flags. 2519ed98953SRafael J. Wysocki * 25221d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 25321d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 25421d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 25521d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 25621d5c57bSRafael J. Wysocki * be forced into the active metastate and reference-counted upon the creation 25721d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 25821d5c57bSRafael J. Wysocki * ignored. 25921d5c57bSRafael J. Wysocki * 260515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 261515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 262515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 26372175d4eSRafael J. Wysocki * 26472175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 26572175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 26672175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 26772175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 26872175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 26972175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 27072175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 27172175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 27272175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 27372175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 27472175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 275c8d50986SRafael J. Wysocki * 276e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 277e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 278e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 279e7dd4010SRafael J. Wysocki * be used to request the driver core to automaticall probe for a consmer 280e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 281e7dd4010SRafael J. Wysocki * 282515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 283515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 284515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 285515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 286515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 287515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 288515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 289515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 290515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 291515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 2929ed98953SRafael J. Wysocki * 2939ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 2949ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 2959ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 2969ed98953SRafael J. Wysocki * not been registered when this function is called). 2979ed98953SRafael J. Wysocki * 2989ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 2999ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 30064df1148SLukas Wunner * not be registered, however. 3019ed98953SRafael J. Wysocki */ 3029ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 3039ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 3049ed98953SRafael J. Wysocki { 3059ed98953SRafael J. Wysocki struct device_link *link; 3069ed98953SRafael J. Wysocki 307fb583c8eSRafael J. Wysocki if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || 308515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 30905ef983eSSaravana Kannan (flags & DL_FLAG_SYNC_STATE_ONLY && 31005ef983eSSaravana Kannan flags != DL_FLAG_SYNC_STATE_ONLY) || 311e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 312e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 313e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 3149ed98953SRafael J. Wysocki return NULL; 3159ed98953SRafael J. Wysocki 3165db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 3175db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 3185db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 3195db25c9eSRafael J. Wysocki return NULL; 3205db25c9eSRafael J. Wysocki } 3215db25c9eSRafael J. Wysocki } 3225db25c9eSRafael J. Wysocki 323515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 324515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 325515db266SRafael J. Wysocki 3269ed98953SRafael J. Wysocki device_links_write_lock(); 3279ed98953SRafael J. Wysocki device_pm_lock(); 3289ed98953SRafael J. Wysocki 3299ed98953SRafael J. Wysocki /* 3309ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 33105ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 33205ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 33305ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 33405ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 3359ed98953SRafael J. Wysocki */ 3369ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 33705ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 33805ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 3399ed98953SRafael J. Wysocki link = NULL; 3409ed98953SRafael J. Wysocki goto out; 3419ed98953SRafael J. Wysocki } 3429ed98953SRafael J. Wysocki 34372175d4eSRafael J. Wysocki /* 34472175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 34572175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 34672175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 34772175d4eSRafael J. Wysocki */ 34872175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 34972175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 35072175d4eSRafael J. Wysocki 351f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 352f265df55SRafael J. Wysocki if (link->consumer != consumer) 353f265df55SRafael J. Wysocki continue; 354f265df55SRafael J. Wysocki 355e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 356e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 3574c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 358e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 359e2f3cd83SRafael J. Wysocki } 360e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 36136003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 362e2f3cd83SRafael J. Wysocki } 363e2f3cd83SRafael J. Wysocki 36472175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 365ead18c23SLukas Wunner kref_get(&link->kref); 36605ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 36705ef983eSSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 36805ef983eSSaravana Kannan link->flags |= DL_FLAG_STATELESS; 36905ef983eSSaravana Kannan goto reorder; 37005ef983eSSaravana Kannan } else { 3719ed98953SRafael J. Wysocki goto out; 372ead18c23SLukas Wunner } 37305ef983eSSaravana Kannan } 3749ed98953SRafael J. Wysocki 37572175d4eSRafael J. Wysocki /* 37672175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 37772175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 37872175d4eSRafael J. Wysocki * update the existing link to stay around longer. 37972175d4eSRafael J. Wysocki */ 38072175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 38172175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 38272175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 38372175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 38472175d4eSRafael J. Wysocki } 38572175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 38672175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 38772175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 38872175d4eSRafael J. Wysocki } 389515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 390515db266SRafael J. Wysocki kref_get(&link->kref); 391515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 392515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 393515db266SRafael J. Wysocki } 39405ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 39505ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 39605ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 39705ef983eSSaravana Kannan goto reorder; 39805ef983eSSaravana Kannan } 39905ef983eSSaravana Kannan 40072175d4eSRafael J. Wysocki goto out; 40172175d4eSRafael J. Wysocki } 40272175d4eSRafael J. Wysocki 40321d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 4049ed98953SRafael J. Wysocki if (!link) 4059ed98953SRafael J. Wysocki goto out; 4069ed98953SRafael J. Wysocki 407e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 408e2f3cd83SRafael J. Wysocki 409baa8809fSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 410e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 41136003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 412e2f3cd83SRafael J. Wysocki 4134c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 41421d5c57bSRafael J. Wysocki } 415e2f3cd83SRafael J. Wysocki 4169ed98953SRafael J. Wysocki get_device(supplier); 4179ed98953SRafael J. Wysocki link->supplier = supplier; 4189ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 4199ed98953SRafael J. Wysocki get_device(consumer); 4209ed98953SRafael J. Wysocki link->consumer = consumer; 4219ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 4229ed98953SRafael J. Wysocki link->flags = flags; 423ead18c23SLukas Wunner kref_init(&link->kref); 4249ed98953SRafael J. Wysocki 42564df1148SLukas Wunner /* Determine the initial link state. */ 426515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 4279ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 428515db266SRafael J. Wysocki else 429515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 4309ed98953SRafael J. Wysocki 4319ed98953SRafael J. Wysocki /* 43215cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 43315cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 43415cfb094SRafael J. Wysocki */ 43515cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 43615cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 43715cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 43815cfb094SRafael J. Wysocki 43905ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 44005ef983eSSaravana Kannan dev_dbg(consumer, 44105ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 44205ef983eSSaravana Kannan dev_name(supplier)); 44305ef983eSSaravana Kannan goto out; 44405ef983eSSaravana Kannan } 44505ef983eSSaravana Kannan reorder: 44615cfb094SRafael J. Wysocki /* 4479ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 4489ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 4499ed98953SRafael J. Wysocki * 4509ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 4519ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 4529ed98953SRafael J. Wysocki */ 4539ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 4549ed98953SRafael J. Wysocki 4559ed98953SRafael J. Wysocki list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 4569ed98953SRafael J. Wysocki list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 4579ed98953SRafael J. Wysocki 4588a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 4599ed98953SRafael J. Wysocki 4609ed98953SRafael J. Wysocki out: 4619ed98953SRafael J. Wysocki device_pm_unlock(); 4629ed98953SRafael J. Wysocki device_links_write_unlock(); 4635db25c9eSRafael J. Wysocki 464e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 4655db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 4665db25c9eSRafael J. Wysocki 4679ed98953SRafael J. Wysocki return link; 4689ed98953SRafael J. Wysocki } 4699ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 4709ed98953SRafael J. Wysocki 471e2ae9bccSSaravana Kannan /** 472e2ae9bccSSaravana Kannan * device_link_wait_for_supplier - Add device to wait_for_suppliers list 473e2ae9bccSSaravana Kannan * @consumer: Consumer device 474e2ae9bccSSaravana Kannan * 475e2ae9bccSSaravana Kannan * Marks the @consumer device as waiting for suppliers to become available by 476e2ae9bccSSaravana Kannan * adding it to the wait_for_suppliers list. The consumer device will never be 477e2ae9bccSSaravana Kannan * probed until it's removed from the wait_for_suppliers list. 478e2ae9bccSSaravana Kannan * 479e2ae9bccSSaravana Kannan * The caller is responsible for adding the links to the supplier devices once 480e2ae9bccSSaravana Kannan * they are available and removing the @consumer device from the 481e2ae9bccSSaravana Kannan * wait_for_suppliers list once links to all the suppliers have been created. 482e2ae9bccSSaravana Kannan * 483e2ae9bccSSaravana Kannan * This function is NOT meant to be called from the probe function of the 484e2ae9bccSSaravana Kannan * consumer but rather from code that creates/adds the consumer device. 485e2ae9bccSSaravana Kannan */ 486bcbbcfd5SSaravana Kannan static void device_link_wait_for_supplier(struct device *consumer, 487bcbbcfd5SSaravana Kannan bool need_for_probe) 488e2ae9bccSSaravana Kannan { 489e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 490e2ae9bccSSaravana Kannan list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers); 491bcbbcfd5SSaravana Kannan consumer->links.need_for_probe = need_for_probe; 492e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 493e2ae9bccSSaravana Kannan } 494e2ae9bccSSaravana Kannan 495bcbbcfd5SSaravana Kannan static void device_link_wait_for_mandatory_supplier(struct device *consumer) 496bcbbcfd5SSaravana Kannan { 497bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, true); 498bcbbcfd5SSaravana Kannan } 499bcbbcfd5SSaravana Kannan 500bcbbcfd5SSaravana Kannan static void device_link_wait_for_optional_supplier(struct device *consumer) 501bcbbcfd5SSaravana Kannan { 502bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, false); 503bcbbcfd5SSaravana Kannan } 504bcbbcfd5SSaravana Kannan 505e2ae9bccSSaravana Kannan /** 506e2ae9bccSSaravana Kannan * device_link_add_missing_supplier_links - Add links from consumer devices to 507e2ae9bccSSaravana Kannan * supplier devices, leaving any 508e2ae9bccSSaravana Kannan * consumer with inactive suppliers on 509e2ae9bccSSaravana Kannan * the wait_for_suppliers list 510e2ae9bccSSaravana Kannan * 511e2ae9bccSSaravana Kannan * Loops through all consumers waiting on suppliers and tries to add all their 512e2ae9bccSSaravana Kannan * supplier links. If that succeeds, the consumer device is removed from 513e2ae9bccSSaravana Kannan * wait_for_suppliers list. Otherwise, they are left in the wait_for_suppliers 514e2ae9bccSSaravana Kannan * list. Devices left on the wait_for_suppliers list will not be probed. 515e2ae9bccSSaravana Kannan * 516e2ae9bccSSaravana Kannan * The fwnode add_links callback is expected to return 0 if it has found and 517e2ae9bccSSaravana Kannan * added all the supplier links for the consumer device. It should return an 518e2ae9bccSSaravana Kannan * error if it isn't able to do so. 519e2ae9bccSSaravana Kannan * 520e2ae9bccSSaravana Kannan * The caller of device_link_wait_for_supplier() is expected to call this once 521e2ae9bccSSaravana Kannan * it's aware of potential suppliers becoming available. 522e2ae9bccSSaravana Kannan */ 523e2ae9bccSSaravana Kannan static void device_link_add_missing_supplier_links(void) 524e2ae9bccSSaravana Kannan { 525e2ae9bccSSaravana Kannan struct device *dev, *tmp; 526e2ae9bccSSaravana Kannan 527e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 528e2ae9bccSSaravana Kannan list_for_each_entry_safe(dev, tmp, &wait_for_suppliers, 5291745d299SSaravana Kannan links.needs_suppliers) { 5301745d299SSaravana Kannan int ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 5311745d299SSaravana Kannan if (!ret) 532e2ae9bccSSaravana Kannan list_del_init(&dev->links.needs_suppliers); 533716a7a25SSaravana Kannan else if (ret != -ENODEV || fw_devlink_is_permissive()) 5341745d299SSaravana Kannan dev->links.need_for_probe = false; 5351745d299SSaravana Kannan } 536e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 537e2ae9bccSSaravana Kannan } 538e2ae9bccSSaravana Kannan 5399ed98953SRafael J. Wysocki static void device_link_free(struct device_link *link) 5409ed98953SRafael J. Wysocki { 541a1fdbfbbSRafael J. Wysocki while (refcount_dec_not_one(&link->rpm_active)) 542a1fdbfbbSRafael J. Wysocki pm_runtime_put(link->supplier); 543a1fdbfbbSRafael J. Wysocki 5449ed98953SRafael J. Wysocki put_device(link->consumer); 5459ed98953SRafael J. Wysocki put_device(link->supplier); 5469ed98953SRafael J. Wysocki kfree(link); 5479ed98953SRafael J. Wysocki } 5489ed98953SRafael J. Wysocki 5499ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 5509ed98953SRafael J. Wysocki static void __device_link_free_srcu(struct rcu_head *rhead) 5519ed98953SRafael J. Wysocki { 5529ed98953SRafael J. Wysocki device_link_free(container_of(rhead, struct device_link, rcu_head)); 5539ed98953SRafael J. Wysocki } 5549ed98953SRafael J. Wysocki 555ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5569ed98953SRafael J. Wysocki { 557ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 558ead18c23SLukas Wunner 5598a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 5609ed98953SRafael J. Wysocki dev_name(link->supplier)); 5619ed98953SRafael J. Wysocki 562baa8809fSRafael J. Wysocki if (link->flags & DL_FLAG_PM_RUNTIME) 563baa8809fSRafael J. Wysocki pm_runtime_drop_link(link->consumer); 564baa8809fSRafael J. Wysocki 5659ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 5669ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 5679ed98953SRafael J. Wysocki call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 5689ed98953SRafael J. Wysocki } 5699ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 570ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5719ed98953SRafael J. Wysocki { 572ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 573ead18c23SLukas Wunner 5749ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 5759ed98953SRafael J. Wysocki dev_name(link->supplier)); 5769ed98953SRafael J. Wysocki 577433986c2SLukas Wunner if (link->flags & DL_FLAG_PM_RUNTIME) 578433986c2SLukas Wunner pm_runtime_drop_link(link->consumer); 579433986c2SLukas Wunner 5809ed98953SRafael J. Wysocki list_del(&link->s_node); 5819ed98953SRafael J. Wysocki list_del(&link->c_node); 5829ed98953SRafael J. Wysocki device_link_free(link); 5839ed98953SRafael J. Wysocki } 5849ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 5859ed98953SRafael J. Wysocki 58672175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 58772175d4eSRafael J. Wysocki { 58872175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 58972175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 59072175d4eSRafael J. Wysocki else 59172175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 59272175d4eSRafael J. Wysocki } 59372175d4eSRafael J. Wysocki 5949ed98953SRafael J. Wysocki /** 59572175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 5969ed98953SRafael J. Wysocki * @link: Device link to delete. 5979ed98953SRafael J. Wysocki * 5989ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 599ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 600ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 601ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 6029ed98953SRafael J. Wysocki */ 6039ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 6049ed98953SRafael J. Wysocki { 6059ed98953SRafael J. Wysocki device_links_write_lock(); 6069ed98953SRafael J. Wysocki device_pm_lock(); 60772175d4eSRafael J. Wysocki device_link_put_kref(link); 6089ed98953SRafael J. Wysocki device_pm_unlock(); 6099ed98953SRafael J. Wysocki device_links_write_unlock(); 6109ed98953SRafael J. Wysocki } 6119ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 6129ed98953SRafael J. Wysocki 613d8842211Spascal paillet /** 61472175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 615d8842211Spascal paillet * @consumer: Consumer end of the link. 616d8842211Spascal paillet * @supplier: Supplier end of the link. 617d8842211Spascal paillet * 618d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 619d8842211Spascal paillet * PM. 620d8842211Spascal paillet */ 621d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 622d8842211Spascal paillet { 623d8842211Spascal paillet struct device_link *link; 624d8842211Spascal paillet 625d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 626d8842211Spascal paillet return; 627d8842211Spascal paillet 628d8842211Spascal paillet device_links_write_lock(); 629d8842211Spascal paillet device_pm_lock(); 630d8842211Spascal paillet 631d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 632d8842211Spascal paillet if (link->consumer == consumer) { 63372175d4eSRafael J. Wysocki device_link_put_kref(link); 634d8842211Spascal paillet break; 635d8842211Spascal paillet } 636d8842211Spascal paillet } 637d8842211Spascal paillet 638d8842211Spascal paillet device_pm_unlock(); 639d8842211Spascal paillet device_links_write_unlock(); 640d8842211Spascal paillet } 641d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 642d8842211Spascal paillet 6439ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 6449ed98953SRafael J. Wysocki { 6459ed98953SRafael J. Wysocki struct device_link *link; 6469ed98953SRafael J. Wysocki 6479ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) 6489ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE) 6499ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 6509ed98953SRafael J. Wysocki } 6519ed98953SRafael J. Wysocki 6529ed98953SRafael J. Wysocki /** 6539ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 6549ed98953SRafael J. Wysocki * @dev: Consumer device. 6559ed98953SRafael J. Wysocki * 6569ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 6579ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 6589ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 6599ed98953SRafael J. Wysocki * 6609ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 6619ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 6629ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 6639ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 6649ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 6659ed98953SRafael J. Wysocki * 666515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 6679ed98953SRafael J. Wysocki */ 6689ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 6699ed98953SRafael J. Wysocki { 6709ed98953SRafael J. Wysocki struct device_link *link; 6719ed98953SRafael J. Wysocki int ret = 0; 6729ed98953SRafael J. Wysocki 673e2ae9bccSSaravana Kannan /* 674e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 675e2ae9bccSSaravana Kannan * probe. 676e2ae9bccSSaravana Kannan */ 677e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 678bcbbcfd5SSaravana Kannan if (!list_empty(&dev->links.needs_suppliers) && 679bcbbcfd5SSaravana Kannan dev->links.need_for_probe) { 680e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 681e2ae9bccSSaravana Kannan return -EPROBE_DEFER; 682e2ae9bccSSaravana Kannan } 683e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 684e2ae9bccSSaravana Kannan 6859ed98953SRafael J. Wysocki device_links_write_lock(); 6869ed98953SRafael J. Wysocki 6879ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 68805ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 68905ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 6909ed98953SRafael J. Wysocki continue; 6919ed98953SRafael J. Wysocki 6929ed98953SRafael J. Wysocki if (link->status != DL_STATE_AVAILABLE) { 6939ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 6949ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 6959ed98953SRafael J. Wysocki break; 6969ed98953SRafael J. Wysocki } 6979ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 6989ed98953SRafael J. Wysocki } 6999ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 7009ed98953SRafael J. Wysocki 7019ed98953SRafael J. Wysocki device_links_write_unlock(); 7029ed98953SRafael J. Wysocki return ret; 7039ed98953SRafael J. Wysocki } 7049ed98953SRafael J. Wysocki 70526e77708SSaravana Kannan /** 70626e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 70726e77708SSaravana Kannan * @dev: Device to call sync_state() on 70826e77708SSaravana Kannan * @list: List head to queue the @dev on 70926e77708SSaravana Kannan * 71026e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 71126e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 71226e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 71326e77708SSaravana Kannan * device_links_write_lock() held. 71426e77708SSaravana Kannan * 71526e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 71626e77708SSaravana Kannan * on this list. 71726e77708SSaravana Kannan * 71826e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 71926e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 72026e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 72126e77708SSaravana Kannan * put_device() is called on this device. 72226e77708SSaravana Kannan */ 72326e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 72426e77708SSaravana Kannan struct list_head *list) 725fc5a251dSSaravana Kannan { 726fc5a251dSSaravana Kannan struct device_link *link; 727fc5a251dSSaravana Kannan 72877036165SSaravana Kannan if (!dev_has_sync_state(dev)) 72977036165SSaravana Kannan return; 730fc5a251dSSaravana Kannan if (dev->state_synced) 731fc5a251dSSaravana Kannan return; 732fc5a251dSSaravana Kannan 733fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 734fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 735fc5a251dSSaravana Kannan continue; 736fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 737fc5a251dSSaravana Kannan return; 738fc5a251dSSaravana Kannan } 739fc5a251dSSaravana Kannan 74026e77708SSaravana Kannan /* 74126e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 74226e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 74326e77708SSaravana Kannan * and probed before the list is flushed. 74426e77708SSaravana Kannan */ 74526e77708SSaravana Kannan dev->state_synced = true; 74626e77708SSaravana Kannan 74726e77708SSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 74826e77708SSaravana Kannan return; 74926e77708SSaravana Kannan 75026e77708SSaravana Kannan get_device(dev); 75126e77708SSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 75226e77708SSaravana Kannan } 75326e77708SSaravana Kannan 75426e77708SSaravana Kannan /** 75526e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 75626e77708SSaravana Kannan * @list: List of devices to call sync_state() on 75721eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 75826e77708SSaravana Kannan * 75926e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 76021eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 76121eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 76221eb93f4SSaravana Kannan * context where a device lock is already held. 76326e77708SSaravana Kannan */ 76421eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 76521eb93f4SSaravana Kannan struct device *dont_lock_dev) 76626e77708SSaravana Kannan { 76726e77708SSaravana Kannan struct device *dev, *tmp; 76826e77708SSaravana Kannan 76926e77708SSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 77026e77708SSaravana Kannan list_del_init(&dev->links.defer_sync); 77126e77708SSaravana Kannan 77221eb93f4SSaravana Kannan if (dev != dont_lock_dev) 77326e77708SSaravana Kannan device_lock(dev); 77426e77708SSaravana Kannan 775fc5a251dSSaravana Kannan if (dev->bus->sync_state) 776fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 777fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 778fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 779fc5a251dSSaravana Kannan 78021eb93f4SSaravana Kannan if (dev != dont_lock_dev) 78126e77708SSaravana Kannan device_unlock(dev); 78226e77708SSaravana Kannan 78326e77708SSaravana Kannan put_device(dev); 78426e77708SSaravana Kannan } 785fc5a251dSSaravana Kannan } 786fc5a251dSSaravana Kannan 787fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 788fc5a251dSSaravana Kannan { 789fc5a251dSSaravana Kannan device_links_write_lock(); 790fc5a251dSSaravana Kannan defer_sync_state_count++; 791fc5a251dSSaravana Kannan device_links_write_unlock(); 792fc5a251dSSaravana Kannan } 793fc5a251dSSaravana Kannan 794fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 795fc5a251dSSaravana Kannan { 796fc5a251dSSaravana Kannan struct device *dev, *tmp; 79726e77708SSaravana Kannan LIST_HEAD(sync_list); 798fc5a251dSSaravana Kannan 799fc5a251dSSaravana Kannan device_links_write_lock(); 800fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 801fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 802fc5a251dSSaravana Kannan goto out; 803fc5a251dSSaravana Kannan } 804fc5a251dSSaravana Kannan defer_sync_state_count--; 805fc5a251dSSaravana Kannan if (defer_sync_state_count) 806fc5a251dSSaravana Kannan goto out; 807fc5a251dSSaravana Kannan 808fc5a251dSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 80926e77708SSaravana Kannan /* 81026e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 81126e77708SSaravana Kannan * sync_list because defer_sync is used for both lists. 81226e77708SSaravana Kannan */ 813fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 81426e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 815fc5a251dSSaravana Kannan } 816fc5a251dSSaravana Kannan out: 817fc5a251dSSaravana Kannan device_links_write_unlock(); 81826e77708SSaravana Kannan 81921eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 820fc5a251dSSaravana Kannan } 821fc5a251dSSaravana Kannan 822fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 823fc5a251dSSaravana Kannan { 824fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 825fc5a251dSSaravana Kannan return 0; 826fc5a251dSSaravana Kannan } 827fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 828fc5a251dSSaravana Kannan 829fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 830fc5a251dSSaravana Kannan { 83177036165SSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 832fc5a251dSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 833fc5a251dSSaravana Kannan } 834fc5a251dSSaravana Kannan 8359ed98953SRafael J. Wysocki /** 8369ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 8379ed98953SRafael J. Wysocki * @dev: Device to update the links for. 8389ed98953SRafael J. Wysocki * 8399ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 8409ed98953SRafael J. Wysocki * consumers by changing their status to "available". 8419ed98953SRafael J. Wysocki * 8429ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 8439ed98953SRafael J. Wysocki * 844515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 8459ed98953SRafael J. Wysocki */ 8469ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 8479ed98953SRafael J. Wysocki { 8489ed98953SRafael J. Wysocki struct device_link *link; 84926e77708SSaravana Kannan LIST_HEAD(sync_list); 8509ed98953SRafael J. Wysocki 851bcbbcfd5SSaravana Kannan /* 852bcbbcfd5SSaravana Kannan * If a device probes successfully, it's expected to have created all 853bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 854bcbbcfd5SSaravana Kannan * them. So, it no longer needs to wait on any suppliers. 855bcbbcfd5SSaravana Kannan */ 856bcbbcfd5SSaravana Kannan mutex_lock(&wfs_lock); 857bcbbcfd5SSaravana Kannan list_del_init(&dev->links.needs_suppliers); 858bcbbcfd5SSaravana Kannan mutex_unlock(&wfs_lock); 859bcbbcfd5SSaravana Kannan 8609ed98953SRafael J. Wysocki device_links_write_lock(); 8619ed98953SRafael J. Wysocki 8629ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 863515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 8649ed98953SRafael J. Wysocki continue; 8659ed98953SRafael J. Wysocki 86615cfb094SRafael J. Wysocki /* 86715cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 86815cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 86915cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 87015cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 87115cfb094SRafael J. Wysocki */ 87215cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 87315cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 87415cfb094SRafael J. Wysocki continue; 87515cfb094SRafael J. Wysocki 8769ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 8779ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 878e7dd4010SRafael J. Wysocki 879e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 880e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 8819ed98953SRafael J. Wysocki } 8829ed98953SRafael J. Wysocki 88321eb93f4SSaravana Kannan if (defer_sync_state_count) 88421eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 88521eb93f4SSaravana Kannan else 88621eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 88721eb93f4SSaravana Kannan 8889ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 889515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 8909ed98953SRafael J. Wysocki continue; 8919ed98953SRafael J. Wysocki 8929ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 8939ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 894fc5a251dSSaravana Kannan 895fc5a251dSSaravana Kannan if (defer_sync_state_count) 896fc5a251dSSaravana Kannan __device_links_supplier_defer_sync(link->supplier); 897fc5a251dSSaravana Kannan else 89826e77708SSaravana Kannan __device_links_queue_sync_state(link->supplier, 89926e77708SSaravana Kannan &sync_list); 9009ed98953SRafael J. Wysocki } 9019ed98953SRafael J. Wysocki 9029ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 9039ed98953SRafael J. Wysocki 9049ed98953SRafael J. Wysocki device_links_write_unlock(); 90526e77708SSaravana Kannan 90621eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 9079ed98953SRafael J. Wysocki } 9089ed98953SRafael J. Wysocki 909515db266SRafael J. Wysocki static void device_link_drop_managed(struct device_link *link) 910515db266SRafael J. Wysocki { 911515db266SRafael J. Wysocki link->flags &= ~DL_FLAG_MANAGED; 912515db266SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_NONE); 913515db266SRafael J. Wysocki kref_put(&link->kref, __device_link_del); 914515db266SRafael J. Wysocki } 915515db266SRafael J. Wysocki 9169ed98953SRafael J. Wysocki /** 9179ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 9189ed98953SRafael J. Wysocki * @dev: Device without a drvier. 9199ed98953SRafael J. Wysocki * 9209ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 9219ed98953SRafael J. Wysocki * 9229ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 9239ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 9249ed98953SRafael J. Wysocki * case they need not be updated. 9259ed98953SRafael J. Wysocki * 926515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9279ed98953SRafael J. Wysocki */ 9289ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 9299ed98953SRafael J. Wysocki { 9309ed98953SRafael J. Wysocki struct device_link *link, *ln; 9319ed98953SRafael J. Wysocki 9329ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 933515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 9349ed98953SRafael J. Wysocki continue; 9359ed98953SRafael J. Wysocki 936e88728f4SVivek Gautam if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 937515db266SRafael J. Wysocki device_link_drop_managed(link); 93815cfb094SRafael J. Wysocki else if (link->status == DL_STATE_CONSUMER_PROBE || 93915cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 9409ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 9419ed98953SRafael J. Wysocki } 9429ed98953SRafael J. Wysocki 9439ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 9449ed98953SRafael J. Wysocki } 9459ed98953SRafael J. Wysocki 94615cfb094SRafael J. Wysocki /** 94715cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 94815cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 94915cfb094SRafael J. Wysocki * 95015cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 95115cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 95215cfb094SRafael J. Wysocki * appropriate. 95315cfb094SRafael J. Wysocki * 954515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 95515cfb094SRafael J. Wysocki */ 9569ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 9579ed98953SRafael J. Wysocki { 95815cfb094SRafael J. Wysocki struct device_link *link; 95915cfb094SRafael J. Wysocki 9609ed98953SRafael J. Wysocki device_links_write_lock(); 96115cfb094SRafael J. Wysocki 96215cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 963515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 96415cfb094SRafael J. Wysocki continue; 96515cfb094SRafael J. Wysocki 96615cfb094SRafael J. Wysocki /* 96715cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 96815cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 96915cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 97015cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 97115cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 97215cfb094SRafael J. Wysocki */ 97315cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 97415cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 97515cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 97615cfb094SRafael J. Wysocki } 97715cfb094SRafael J. Wysocki 9789ed98953SRafael J. Wysocki __device_links_no_driver(dev); 97915cfb094SRafael J. Wysocki 9809ed98953SRafael J. Wysocki device_links_write_unlock(); 9819ed98953SRafael J. Wysocki } 9829ed98953SRafael J. Wysocki 9839ed98953SRafael J. Wysocki /** 9849ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 9859ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 9869ed98953SRafael J. Wysocki * 9879ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 9889ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 9899ed98953SRafael J. Wysocki * appropriate. 9909ed98953SRafael J. Wysocki * 991515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9929ed98953SRafael J. Wysocki */ 9939ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 9949ed98953SRafael J. Wysocki { 995c8d50986SRafael J. Wysocki struct device_link *link, *ln; 9969ed98953SRafael J. Wysocki 9979ed98953SRafael J. Wysocki device_links_write_lock(); 9989ed98953SRafael J. Wysocki 999c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1000515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 10019ed98953SRafael J. Wysocki continue; 10029ed98953SRafael J. Wysocki 1003e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 10049ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 10051689cac5SVivek Gautam 10061689cac5SVivek Gautam /* 10071689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 10081689cac5SVivek Gautam * devices that are not active, i.e. where the link state 10091689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 10101689cac5SVivek Gautam */ 10111689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 10121689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1013515db266SRafael J. Wysocki device_link_drop_managed(link); 10141689cac5SVivek Gautam 10159ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 10169ed98953SRafael J. Wysocki } 10179ed98953SRafael J. Wysocki 1018fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 10199ed98953SRafael J. Wysocki __device_links_no_driver(dev); 10209ed98953SRafael J. Wysocki 10219ed98953SRafael J. Wysocki device_links_write_unlock(); 10229ed98953SRafael J. Wysocki } 10239ed98953SRafael J. Wysocki 10249ed98953SRafael J. Wysocki /** 10259ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 10269ed98953SRafael J. Wysocki * @dev: Device to check. 10279ed98953SRafael J. Wysocki * 10289ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 10299ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 10309ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 10319ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 10329ed98953SRafael J. Wysocki * successfully going forward. 10339ed98953SRafael J. Wysocki * 10349ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 10359ed98953SRafael J. Wysocki * 1036515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10379ed98953SRafael J. Wysocki */ 10389ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 10399ed98953SRafael J. Wysocki { 10409ed98953SRafael J. Wysocki struct device_link *link; 10419ed98953SRafael J. Wysocki bool ret = false; 10429ed98953SRafael J. Wysocki 10439ed98953SRafael J. Wysocki device_links_write_lock(); 10449ed98953SRafael J. Wysocki 10459ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1046515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 10479ed98953SRafael J. Wysocki continue; 10489ed98953SRafael J. Wysocki 10499ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 10509ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 10519ed98953SRafael J. Wysocki ret = true; 10529ed98953SRafael J. Wysocki break; 10539ed98953SRafael J. Wysocki } 10549ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 10559ed98953SRafael J. Wysocki } 10569ed98953SRafael J. Wysocki 10579ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 10589ed98953SRafael J. Wysocki 10599ed98953SRafael J. Wysocki device_links_write_unlock(); 10609ed98953SRafael J. Wysocki return ret; 10619ed98953SRafael J. Wysocki } 10629ed98953SRafael J. Wysocki 10639ed98953SRafael J. Wysocki /** 10649ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 10659ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 10669ed98953SRafael J. Wysocki * 10679ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 10689ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 10699ed98953SRafael J. Wysocki * and start over. 10709ed98953SRafael J. Wysocki * 10719ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 10729ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 10739ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 10749ed98953SRafael J. Wysocki * changed the state of the link already). 10759ed98953SRafael J. Wysocki * 1076515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10779ed98953SRafael J. Wysocki */ 10789ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 10799ed98953SRafael J. Wysocki { 10809ed98953SRafael J. Wysocki struct device_link *link; 10819ed98953SRafael J. Wysocki 10829ed98953SRafael J. Wysocki start: 10839ed98953SRafael J. Wysocki device_links_write_lock(); 10849ed98953SRafael J. Wysocki 10859ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 10869ed98953SRafael J. Wysocki enum device_link_state status; 10879ed98953SRafael J. Wysocki 108805ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 108905ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 10909ed98953SRafael J. Wysocki continue; 10919ed98953SRafael J. Wysocki 10929ed98953SRafael J. Wysocki status = link->status; 10939ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 10949ed98953SRafael J. Wysocki device_links_write_unlock(); 10959ed98953SRafael J. Wysocki 10969ed98953SRafael J. Wysocki wait_for_device_probe(); 10979ed98953SRafael J. Wysocki goto start; 10989ed98953SRafael J. Wysocki } 10999ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 11009ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 11019ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 11029ed98953SRafael J. Wysocki 11039ed98953SRafael J. Wysocki get_device(consumer); 11049ed98953SRafael J. Wysocki 11059ed98953SRafael J. Wysocki device_links_write_unlock(); 11069ed98953SRafael J. Wysocki 11079ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 11089ed98953SRafael J. Wysocki consumer->parent); 11099ed98953SRafael J. Wysocki put_device(consumer); 11109ed98953SRafael J. Wysocki goto start; 11119ed98953SRafael J. Wysocki } 11129ed98953SRafael J. Wysocki } 11139ed98953SRafael J. Wysocki 11149ed98953SRafael J. Wysocki device_links_write_unlock(); 11159ed98953SRafael J. Wysocki } 11169ed98953SRafael J. Wysocki 11179ed98953SRafael J. Wysocki /** 11189ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 11199ed98953SRafael J. Wysocki * @dev: Target device. 11209ed98953SRafael J. Wysocki */ 11219ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 11229ed98953SRafael J. Wysocki { 11239ed98953SRafael J. Wysocki struct device_link *link, *ln; 11249ed98953SRafael J. Wysocki 1125e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 1126e2ae9bccSSaravana Kannan list_del(&dev->links.needs_suppliers); 1127e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 1128e2ae9bccSSaravana Kannan 11299ed98953SRafael J. Wysocki /* 11309ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 11319ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 11329ed98953SRafael J. Wysocki */ 11339ed98953SRafael J. Wysocki device_links_write_lock(); 11349ed98953SRafael J. Wysocki 11359ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 11369ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1137ead18c23SLukas Wunner __device_link_del(&link->kref); 11389ed98953SRafael J. Wysocki } 11399ed98953SRafael J. Wysocki 11409ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 11419ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 11429ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1143ead18c23SLukas Wunner __device_link_del(&link->kref); 11449ed98953SRafael J. Wysocki } 11459ed98953SRafael J. Wysocki 11469ed98953SRafael J. Wysocki device_links_write_unlock(); 11479ed98953SRafael J. Wysocki } 11489ed98953SRafael J. Wysocki 114942926ac3SSaravana Kannan static u32 fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY; 115042926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 115142926ac3SSaravana Kannan { 115242926ac3SSaravana Kannan if (!arg) 115342926ac3SSaravana Kannan return -EINVAL; 115442926ac3SSaravana Kannan 115542926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 115642926ac3SSaravana Kannan fw_devlink_flags = 0; 115742926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 115842926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY; 115942926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 116042926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER; 116142926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 116242926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER | 116342926ac3SSaravana Kannan DL_FLAG_PM_RUNTIME; 116442926ac3SSaravana Kannan } 116542926ac3SSaravana Kannan return 0; 116642926ac3SSaravana Kannan } 116742926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 116842926ac3SSaravana Kannan 116942926ac3SSaravana Kannan u32 fw_devlink_get_flags(void) 117042926ac3SSaravana Kannan { 117142926ac3SSaravana Kannan return fw_devlink_flags; 117242926ac3SSaravana Kannan } 117342926ac3SSaravana Kannan 117442926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 117542926ac3SSaravana Kannan { 117642926ac3SSaravana Kannan return fw_devlink_flags == DL_FLAG_SYNC_STATE_ONLY; 117742926ac3SSaravana Kannan } 117842926ac3SSaravana Kannan 11795f5377eaSSaravana Kannan static void fw_devlink_link_device(struct device *dev) 11805f5377eaSSaravana Kannan { 11815f5377eaSSaravana Kannan int fw_ret; 11825f5377eaSSaravana Kannan 1183716a7a25SSaravana Kannan if (!fw_devlink_flags) 1184716a7a25SSaravana Kannan return; 1185716a7a25SSaravana Kannan 1186716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1187716a7a25SSaravana Kannan if (!defer_fw_devlink_count) 11885f5377eaSSaravana Kannan device_link_add_missing_supplier_links(); 11895f5377eaSSaravana Kannan 1190716a7a25SSaravana Kannan /* 1191716a7a25SSaravana Kannan * The device's fwnode not having add_links() doesn't affect if other 1192716a7a25SSaravana Kannan * consumers can find this device as a supplier. So, this check is 1193716a7a25SSaravana Kannan * intentionally placed after device_link_add_missing_supplier_links(). 1194716a7a25SSaravana Kannan */ 1195716a7a25SSaravana Kannan if (!fwnode_has_op(dev->fwnode, add_links)) 1196716a7a25SSaravana Kannan goto out; 1197716a7a25SSaravana Kannan 1198716a7a25SSaravana Kannan /* 1199716a7a25SSaravana Kannan * If fw_devlink is being deferred, assume all devices have mandatory 1200716a7a25SSaravana Kannan * suppliers they need to link to later. Then, when the fw_devlink is 1201716a7a25SSaravana Kannan * resumed, all these devices will get a chance to try and link to any 1202716a7a25SSaravana Kannan * suppliers they have. 1203716a7a25SSaravana Kannan */ 1204716a7a25SSaravana Kannan if (!defer_fw_devlink_count) { 12055f5377eaSSaravana Kannan fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 1206716a7a25SSaravana Kannan if (fw_ret == -ENODEV && fw_devlink_is_permissive()) 1207716a7a25SSaravana Kannan fw_ret = -EAGAIN; 1208716a7a25SSaravana Kannan } else { 1209716a7a25SSaravana Kannan fw_ret = -ENODEV; 1210716a7a25SSaravana Kannan } 1211716a7a25SSaravana Kannan 1212716a7a25SSaravana Kannan if (fw_ret == -ENODEV) 12135f5377eaSSaravana Kannan device_link_wait_for_mandatory_supplier(dev); 12145f5377eaSSaravana Kannan else if (fw_ret) 12155f5377eaSSaravana Kannan device_link_wait_for_optional_supplier(dev); 1216716a7a25SSaravana Kannan 1217716a7a25SSaravana Kannan out: 1218716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 12195f5377eaSSaravana Kannan } 12205f5377eaSSaravana Kannan 1221716a7a25SSaravana Kannan /** 1222716a7a25SSaravana Kannan * fw_devlink_pause - Pause parsing of fwnode to create device links 1223716a7a25SSaravana Kannan * 1224716a7a25SSaravana Kannan * Calling this function defers any fwnode parsing to create device links until 1225716a7a25SSaravana Kannan * fw_devlink_resume() is called. Both these functions are ref counted and the 1226716a7a25SSaravana Kannan * caller needs to match the calls. 1227716a7a25SSaravana Kannan * 1228716a7a25SSaravana Kannan * While fw_devlink is paused: 1229716a7a25SSaravana Kannan * - Any device that is added won't have its fwnode parsed to create device 1230716a7a25SSaravana Kannan * links. 1231716a7a25SSaravana Kannan * - The probe of the device will also be deferred during this period. 1232716a7a25SSaravana Kannan * - Any devices that were already added, but waiting for suppliers won't be 1233716a7a25SSaravana Kannan * able to link to newly added devices. 1234716a7a25SSaravana Kannan * 1235716a7a25SSaravana Kannan * Once fw_devlink_resume(): 1236716a7a25SSaravana Kannan * - All the fwnodes that was not parsed will be parsed. 1237716a7a25SSaravana Kannan * - All the devices that were deferred probing will be reattempted if they 1238716a7a25SSaravana Kannan * aren't waiting for any more suppliers. 1239716a7a25SSaravana Kannan * 1240716a7a25SSaravana Kannan * This pair of functions, is mainly meant to optimize the parsing of fwnodes 1241716a7a25SSaravana Kannan * when a lot of devices that need to link to each other are added in a short 1242716a7a25SSaravana Kannan * interval of time. For example, adding all the top level devices in a system. 1243716a7a25SSaravana Kannan * 1244716a7a25SSaravana Kannan * For example, if N devices are added and: 1245716a7a25SSaravana Kannan * - All the consumers are added before their suppliers 1246716a7a25SSaravana Kannan * - All the suppliers of the N devices are part of the N devices 1247716a7a25SSaravana Kannan * 1248716a7a25SSaravana Kannan * Then: 1249716a7a25SSaravana Kannan * 1250716a7a25SSaravana Kannan * - With the use of fw_devlink_pause() and fw_devlink_resume(), each device 1251716a7a25SSaravana Kannan * will only need one parsing of its fwnode because it is guaranteed to find 1252716a7a25SSaravana Kannan * all the supplier devices already registered and ready to link to. It won't 1253716a7a25SSaravana Kannan * have to do another pass later to find one or more suppliers it couldn't 1254716a7a25SSaravana Kannan * find in the first parse of the fwnode. So, we'll only need O(N) fwnode 1255716a7a25SSaravana Kannan * parses. 1256716a7a25SSaravana Kannan * 1257716a7a25SSaravana Kannan * - Without the use of fw_devlink_pause() and fw_devlink_resume(), we would 1258716a7a25SSaravana Kannan * end up doing O(N^2) parses of fwnodes because every device that's added is 1259716a7a25SSaravana Kannan * guaranteed to trigger a parse of the fwnode of every device added before 1260716a7a25SSaravana Kannan * it. This O(N^2) parse is made worse by the fact that when a fwnode of a 1261716a7a25SSaravana Kannan * device is parsed, all it descendant devices might need to have their 1262716a7a25SSaravana Kannan * fwnodes parsed too (even if the devices themselves aren't added). 1263716a7a25SSaravana Kannan */ 1264716a7a25SSaravana Kannan void fw_devlink_pause(void) 1265716a7a25SSaravana Kannan { 1266716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1267716a7a25SSaravana Kannan defer_fw_devlink_count++; 1268716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 1269716a7a25SSaravana Kannan } 1270716a7a25SSaravana Kannan 1271716a7a25SSaravana Kannan /** fw_devlink_resume - Resume parsing of fwnode to create device links 1272716a7a25SSaravana Kannan * 1273716a7a25SSaravana Kannan * This function is used in conjunction with fw_devlink_pause() and is ref 1274716a7a25SSaravana Kannan * counted. See documentation for fw_devlink_pause() for more details. 1275716a7a25SSaravana Kannan */ 1276716a7a25SSaravana Kannan void fw_devlink_resume(void) 1277716a7a25SSaravana Kannan { 1278716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1279716a7a25SSaravana Kannan if (!defer_fw_devlink_count) { 1280716a7a25SSaravana Kannan WARN(true, "Unmatched fw_devlink pause/resume!"); 1281716a7a25SSaravana Kannan goto out; 1282716a7a25SSaravana Kannan } 1283716a7a25SSaravana Kannan 1284716a7a25SSaravana Kannan defer_fw_devlink_count--; 1285716a7a25SSaravana Kannan if (defer_fw_devlink_count) 1286716a7a25SSaravana Kannan goto out; 1287716a7a25SSaravana Kannan 1288716a7a25SSaravana Kannan device_link_add_missing_supplier_links(); 1289716a7a25SSaravana Kannan driver_deferred_probe_force_trigger(); 1290716a7a25SSaravana Kannan out: 1291716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 1292716a7a25SSaravana Kannan } 12939ed98953SRafael J. Wysocki /* Device links support end. */ 12949ed98953SRafael J. Wysocki 12951da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 12961da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 1297e105b8bfSDan Williams static struct kobject *dev_kobj; 1298e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 1299e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 13001da177e4SLinus Torvalds 13015e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 13025e33bc41SRafael J. Wysocki 13035e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 13045e33bc41SRafael J. Wysocki { 13055e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 13065e33bc41SRafael J. Wysocki } 13075e33bc41SRafael J. Wysocki 13085e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 13095e33bc41SRafael J. Wysocki { 13105e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 13115e33bc41SRafael J. Wysocki } 13125e33bc41SRafael J. Wysocki 13135e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 13145e33bc41SRafael J. Wysocki { 13155e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 13165e33bc41SRafael J. Wysocki return 0; 13175e33bc41SRafael J. Wysocki 13185e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 13195e33bc41SRafael J. Wysocki msleep(5); 13205e33bc41SRafael J. Wysocki return restart_syscall(); 13215e33bc41SRafael J. Wysocki } 13225e33bc41SRafael J. Wysocki 13234e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 13244e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 13254e886c29SGreg Kroah-Hartman { 13264e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 13274e886c29SGreg Kroah-Hartman } 13284e886c29SGreg Kroah-Hartman #else 13294e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 13304e886c29SGreg Kroah-Hartman { 13314e886c29SGreg Kroah-Hartman return 1; 13324e886c29SGreg Kroah-Hartman } 13334e886c29SGreg Kroah-Hartman #endif 13341da177e4SLinus Torvalds 133507de0e86SHeikki Krogerus static int 133607de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 133707de0e86SHeikki Krogerus { 13387847a145SHeikki Krogerus int ret; 13397847a145SHeikki Krogerus 13407847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 13417847a145SHeikki Krogerus if (ret) 13427847a145SHeikki Krogerus return ret; 13437847a145SHeikki Krogerus 134459abd836SHeikki Krogerus ret = software_node_notify(dev, action); 134559abd836SHeikki Krogerus if (ret) 134659abd836SHeikki Krogerus return ret; 134759abd836SHeikki Krogerus 134807de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 134907de0e86SHeikki Krogerus platform_notify(dev); 135007de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 135107de0e86SHeikki Krogerus platform_notify_remove(dev); 135207de0e86SHeikki Krogerus return 0; 135307de0e86SHeikki Krogerus } 135407de0e86SHeikki Krogerus 13553e95637aSAlan Stern /** 13563e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 13573e95637aSAlan Stern * @dev: struct device to get the name of 13583e95637aSAlan Stern * 13593e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 13609169c012Syan * the device is not bound to a driver, it will return the name of the bus 13613e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 13623e95637aSAlan Stern * string will be returned. 13633e95637aSAlan Stern */ 1364bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 13653e95637aSAlan Stern { 13663589972eSAlan Stern struct device_driver *drv; 13673589972eSAlan Stern 13683589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 13693589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 13703589972eSAlan Stern * never change once they are set, so they don't need special care. 13713589972eSAlan Stern */ 13726aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 13733589972eSAlan Stern return drv ? drv->name : 1374a456b702SJean Delvare (dev->bus ? dev->bus->name : 1375a456b702SJean Delvare (dev->class ? dev->class->name : "")); 13763e95637aSAlan Stern } 1377310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 13783e95637aSAlan Stern 13791da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 13801da177e4SLinus Torvalds 13814a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 13824a3ad20cSGreg Kroah-Hartman char *buf) 13831da177e4SLinus Torvalds { 13841da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1385b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 13864a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 13871da177e4SLinus Torvalds 13881da177e4SLinus Torvalds if (dev_attr->show) 138954b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 1390815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 1391a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 1392a52668c6SSergey Senozhatsky dev_attr->show); 1393815d2d50SAndrew Morton } 13941da177e4SLinus Torvalds return ret; 13951da177e4SLinus Torvalds } 13961da177e4SLinus Torvalds 13974a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 13981da177e4SLinus Torvalds const char *buf, size_t count) 13991da177e4SLinus Torvalds { 14001da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1401b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 14024a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 14031da177e4SLinus Torvalds 14041da177e4SLinus Torvalds if (dev_attr->store) 140554b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 14061da177e4SLinus Torvalds return ret; 14071da177e4SLinus Torvalds } 14081da177e4SLinus Torvalds 140952cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 14101da177e4SLinus Torvalds .show = dev_attr_show, 14111da177e4SLinus Torvalds .store = dev_attr_store, 14121da177e4SLinus Torvalds }; 14131da177e4SLinus Torvalds 1414ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 1415ca22e56dSKay Sievers 1416ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 1417ca22e56dSKay Sievers struct device_attribute *attr, 1418ca22e56dSKay Sievers const char *buf, size_t size) 1419ca22e56dSKay Sievers { 1420ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1421f88184bfSKaitao cheng int ret; 1422f88184bfSKaitao cheng unsigned long new; 1423f88184bfSKaitao cheng 1424f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 1425f88184bfSKaitao cheng if (ret) 1426f88184bfSKaitao cheng return ret; 1427ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 1428ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1429ca22e56dSKay Sievers return size; 1430ca22e56dSKay Sievers } 1431ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 1432ca22e56dSKay Sievers 1433ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 1434ca22e56dSKay Sievers struct device_attribute *attr, 1435ca22e56dSKay Sievers char *buf) 1436ca22e56dSKay Sievers { 1437ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1438ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 1439ca22e56dSKay Sievers } 1440ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 1441ca22e56dSKay Sievers 1442ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 1443ca22e56dSKay Sievers struct device_attribute *attr, 1444ca22e56dSKay Sievers const char *buf, size_t size) 1445ca22e56dSKay Sievers { 1446ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1447f88184bfSKaitao cheng int ret; 1448f88184bfSKaitao cheng long new; 1449f88184bfSKaitao cheng 1450f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 1451f88184bfSKaitao cheng if (ret) 1452f88184bfSKaitao cheng return ret; 1453f88184bfSKaitao cheng 1454f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 1455ca22e56dSKay Sievers return -EINVAL; 1456ca22e56dSKay Sievers *(int *)(ea->var) = new; 1457ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1458ca22e56dSKay Sievers return size; 1459ca22e56dSKay Sievers } 1460ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 1461ca22e56dSKay Sievers 1462ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 1463ca22e56dSKay Sievers struct device_attribute *attr, 1464ca22e56dSKay Sievers char *buf) 1465ca22e56dSKay Sievers { 1466ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1467ca22e56dSKay Sievers 1468ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 1469ca22e56dSKay Sievers } 1470ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 14711da177e4SLinus Torvalds 147291872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 147391872392SBorislav Petkov const char *buf, size_t size) 147491872392SBorislav Petkov { 147591872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 147691872392SBorislav Petkov 147791872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 147891872392SBorislav Petkov return -EINVAL; 147991872392SBorislav Petkov 148091872392SBorislav Petkov return size; 148191872392SBorislav Petkov } 148291872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 148391872392SBorislav Petkov 148491872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 148591872392SBorislav Petkov char *buf) 148691872392SBorislav Petkov { 148791872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 148891872392SBorislav Petkov 148991872392SBorislav Petkov return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 149091872392SBorislav Petkov } 149191872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 149291872392SBorislav Petkov 14931da177e4SLinus Torvalds /** 14941da177e4SLinus Torvalds * device_release - free device structure. 14951da177e4SLinus Torvalds * @kobj: device's kobject. 14961da177e4SLinus Torvalds * 14971da177e4SLinus Torvalds * This is called once the reference count for the object 14981da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 14991da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 15001da177e4SLinus Torvalds */ 15011da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 15021da177e4SLinus Torvalds { 1503b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1504fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 15051da177e4SLinus Torvalds 1506a525a3ddSMing Lei /* 1507a525a3ddSMing Lei * Some platform devices are driven without driver attached 1508a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 1509a525a3ddSMing Lei * all resources are released. 1510a525a3ddSMing Lei * 1511a525a3ddSMing Lei * Drivers still can add resources into device after device 1512a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 1513a525a3ddSMing Lei * possible memory leak. 1514a525a3ddSMing Lei */ 1515a525a3ddSMing Lei devres_release_all(dev); 1516a525a3ddSMing Lei 15171da177e4SLinus Torvalds if (dev->release) 15181da177e4SLinus Torvalds dev->release(dev); 1519f9f852dfSKay Sievers else if (dev->type && dev->type->release) 1520f9f852dfSKay Sievers dev->type->release(dev); 15212620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 15222620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 1523f810a5cfSArjan van de Ven else 1524186bddb2SEzequiel 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", 15251e0b2cf9SKay Sievers dev_name(dev)); 1526fb069a5dSGreg Kroah-Hartman kfree(p); 15271da177e4SLinus Torvalds } 15281da177e4SLinus Torvalds 1529bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 1530bc451f20SEric W. Biederman { 1531b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1532bc451f20SEric W. Biederman const void *ns = NULL; 1533bc451f20SEric W. Biederman 1534bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 1535bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 1536bc451f20SEric W. Biederman 1537bc451f20SEric W. Biederman return ns; 1538bc451f20SEric W. Biederman } 1539bc451f20SEric W. Biederman 15409944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 15419944e894SDmitry Torokhov { 15429944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 15439944e894SDmitry Torokhov 15449944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 15459944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 15469944e894SDmitry Torokhov } 15479944e894SDmitry Torokhov 15488f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 15491da177e4SLinus Torvalds .release = device_release, 15501da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 1551bc451f20SEric W. Biederman .namespace = device_namespace, 15529944e894SDmitry Torokhov .get_ownership = device_get_ownership, 15531da177e4SLinus Torvalds }; 15541da177e4SLinus Torvalds 15551da177e4SLinus Torvalds 1556312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 15571da177e4SLinus Torvalds { 15581da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 15591da177e4SLinus Torvalds 15608f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 1561b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 15621da177e4SLinus Torvalds if (dev->bus) 15631da177e4SLinus Torvalds return 1; 156423681e47SGreg Kroah-Hartman if (dev->class) 156523681e47SGreg Kroah-Hartman return 1; 15661da177e4SLinus Torvalds } 15671da177e4SLinus Torvalds return 0; 15681da177e4SLinus Torvalds } 15691da177e4SLinus Torvalds 1570312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 15711da177e4SLinus Torvalds { 1572b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 15731da177e4SLinus Torvalds 157423681e47SGreg Kroah-Hartman if (dev->bus) 15751da177e4SLinus Torvalds return dev->bus->name; 157623681e47SGreg Kroah-Hartman if (dev->class) 157723681e47SGreg Kroah-Hartman return dev->class->name; 157823681e47SGreg Kroah-Hartman return NULL; 15791da177e4SLinus Torvalds } 15801da177e4SLinus Torvalds 15817eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 15827eff2e7aSKay Sievers struct kobj_uevent_env *env) 15831da177e4SLinus Torvalds { 1584b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 15851da177e4SLinus Torvalds int retval = 0; 15861da177e4SLinus Torvalds 15876fcf53acSKay Sievers /* add device node properties if present */ 158823681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 15896fcf53acSKay Sievers const char *tmp; 15906fcf53acSKay Sievers const char *name; 15912c9ede55SAl Viro umode_t mode = 0; 15924e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 15934e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 15946fcf53acSKay Sievers 15957eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 15967eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 15973c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 15986fcf53acSKay Sievers if (name) { 15996fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 1600e454cea2SKay Sievers if (mode) 1601e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 16024e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 16034e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 16044e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 16054e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 16063c2670e6SKay Sievers kfree(tmp); 16076fcf53acSKay Sievers } 160823681e47SGreg Kroah-Hartman } 160923681e47SGreg Kroah-Hartman 1610414264f9SKay Sievers if (dev->type && dev->type->name) 16117eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 1612414264f9SKay Sievers 1613239378f1SKay Sievers if (dev->driver) 16147eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 1615239378f1SKay Sievers 161607d57a32SGrant Likely /* Add common DT information about the device */ 161707d57a32SGrant Likely of_device_uevent(dev, env); 161807d57a32SGrant Likely 16191da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 16207eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 16217eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 1622f9f852dfSKay Sievers if (retval) 16237dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 16241e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 16251da177e4SLinus Torvalds } 16261da177e4SLinus Torvalds 16272620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 16287eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 16297eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 1630f9f852dfSKay Sievers if (retval) 16317dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 16321e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 16332b3a302aSHarvey Harrison __func__, retval); 16342620efefSGreg Kroah-Hartman } 1635f9f852dfSKay Sievers 1636eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 16377eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 16387eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 1639f9f852dfSKay Sievers if (retval) 16407dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 16411e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 16422b3a302aSHarvey Harrison __func__, retval); 16432620efefSGreg Kroah-Hartman } 16442620efefSGreg Kroah-Hartman 16451da177e4SLinus Torvalds return retval; 16461da177e4SLinus Torvalds } 16471da177e4SLinus Torvalds 16489cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 1649312c004dSKay Sievers .filter = dev_uevent_filter, 1650312c004dSKay Sievers .name = dev_uevent_name, 1651312c004dSKay Sievers .uevent = dev_uevent, 16521da177e4SLinus Torvalds }; 16531da177e4SLinus Torvalds 1654c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 165516574dccSKay Sievers char *buf) 165616574dccSKay Sievers { 165716574dccSKay Sievers struct kobject *top_kobj; 165816574dccSKay Sievers struct kset *kset; 16597eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 166016574dccSKay Sievers int i; 166116574dccSKay Sievers size_t count = 0; 166216574dccSKay Sievers int retval; 166316574dccSKay Sievers 166416574dccSKay Sievers /* search the kset, the device belongs to */ 166516574dccSKay Sievers top_kobj = &dev->kobj; 16665c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 166716574dccSKay Sievers top_kobj = top_kobj->parent; 166816574dccSKay Sievers if (!top_kobj->kset) 166916574dccSKay Sievers goto out; 16705c5daf65SKay Sievers 167116574dccSKay Sievers kset = top_kobj->kset; 167216574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 167316574dccSKay Sievers goto out; 167416574dccSKay Sievers 167516574dccSKay Sievers /* respect filter */ 167616574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 167716574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 167816574dccSKay Sievers goto out; 167916574dccSKay Sievers 16807eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 16817eff2e7aSKay Sievers if (!env) 1682c7308c81SGreg Kroah-Hartman return -ENOMEM; 1683c7308c81SGreg Kroah-Hartman 168416574dccSKay Sievers /* let the kset specific function add its keys */ 16857eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 168616574dccSKay Sievers if (retval) 168716574dccSKay Sievers goto out; 168816574dccSKay Sievers 168916574dccSKay Sievers /* copy keys to file */ 16907eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 16917eff2e7aSKay Sievers count += sprintf(&buf[count], "%s\n", env->envp[i]); 169216574dccSKay Sievers out: 16937eff2e7aSKay Sievers kfree(env); 169416574dccSKay Sievers return count; 169516574dccSKay Sievers } 169616574dccSKay Sievers 1697c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 1698a7fd6706SKay Sievers const char *buf, size_t count) 1699a7fd6706SKay Sievers { 1700df44b479SPeter Rajnoha int rc; 1701df44b479SPeter Rajnoha 1702df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 1703df44b479SPeter Rajnoha 1704df44b479SPeter Rajnoha if (rc) { 1705f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 1706df44b479SPeter Rajnoha return rc; 1707df44b479SPeter Rajnoha } 170860a96a59SKay Sievers 1709a7fd6706SKay Sievers return count; 1710a7fd6706SKay Sievers } 1711c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 1712a7fd6706SKay Sievers 1713c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 17144f3549d7SRafael J. Wysocki char *buf) 17154f3549d7SRafael J. Wysocki { 17164f3549d7SRafael J. Wysocki bool val; 17174f3549d7SRafael J. Wysocki 17185e33bc41SRafael J. Wysocki device_lock(dev); 17194f3549d7SRafael J. Wysocki val = !dev->offline; 17205e33bc41SRafael J. Wysocki device_unlock(dev); 17214f3549d7SRafael J. Wysocki return sprintf(buf, "%u\n", val); 17224f3549d7SRafael J. Wysocki } 17234f3549d7SRafael J. Wysocki 1724c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 17254f3549d7SRafael J. Wysocki const char *buf, size_t count) 17264f3549d7SRafael J. Wysocki { 17274f3549d7SRafael J. Wysocki bool val; 17284f3549d7SRafael J. Wysocki int ret; 17294f3549d7SRafael J. Wysocki 17304f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 17314f3549d7SRafael J. Wysocki if (ret < 0) 17324f3549d7SRafael J. Wysocki return ret; 17334f3549d7SRafael J. Wysocki 17345e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 17355e33bc41SRafael J. Wysocki if (ret) 17365e33bc41SRafael J. Wysocki return ret; 17375e33bc41SRafael J. Wysocki 17384f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 17394f3549d7SRafael J. Wysocki unlock_device_hotplug(); 17404f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 17414f3549d7SRafael J. Wysocki } 1742c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 17434f3549d7SRafael J. Wysocki 1744fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 1745621a1672SDmitry Torokhov { 17463e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 1747621a1672SDmitry Torokhov } 1748a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 1749621a1672SDmitry Torokhov 1750fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 1751a4dbd674SDavid Brownell const struct attribute_group **groups) 1752621a1672SDmitry Torokhov { 17533e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 1754621a1672SDmitry Torokhov } 1755a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 1756de0ff00dSGreg Kroah-Hartman 175757b8ff07SDmitry Torokhov union device_attr_group_devres { 175857b8ff07SDmitry Torokhov const struct attribute_group *group; 175957b8ff07SDmitry Torokhov const struct attribute_group **groups; 176057b8ff07SDmitry Torokhov }; 176157b8ff07SDmitry Torokhov 176257b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 176357b8ff07SDmitry Torokhov { 176457b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 176557b8ff07SDmitry Torokhov } 176657b8ff07SDmitry Torokhov 176757b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 176857b8ff07SDmitry Torokhov { 176957b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 177057b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 177157b8ff07SDmitry Torokhov 177257b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 177357b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 177457b8ff07SDmitry Torokhov } 177557b8ff07SDmitry Torokhov 177657b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 177757b8ff07SDmitry Torokhov { 177857b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 177957b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 178057b8ff07SDmitry Torokhov 178157b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 178257b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 178357b8ff07SDmitry Torokhov } 178457b8ff07SDmitry Torokhov 178557b8ff07SDmitry Torokhov /** 178657b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 178757b8ff07SDmitry Torokhov * @dev: The device to create the group for 178857b8ff07SDmitry Torokhov * @grp: The attribute group to create 178957b8ff07SDmitry Torokhov * 179057b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 179157b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 179257b8ff07SDmitry Torokhov * 179357b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 179457b8ff07SDmitry Torokhov */ 179557b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 179657b8ff07SDmitry Torokhov { 179757b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 179857b8ff07SDmitry Torokhov int error; 179957b8ff07SDmitry Torokhov 180057b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 180157b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 180257b8ff07SDmitry Torokhov if (!devres) 180357b8ff07SDmitry Torokhov return -ENOMEM; 180457b8ff07SDmitry Torokhov 180557b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 180657b8ff07SDmitry Torokhov if (error) { 180757b8ff07SDmitry Torokhov devres_free(devres); 180857b8ff07SDmitry Torokhov return error; 180957b8ff07SDmitry Torokhov } 181057b8ff07SDmitry Torokhov 181157b8ff07SDmitry Torokhov devres->group = grp; 181257b8ff07SDmitry Torokhov devres_add(dev, devres); 181357b8ff07SDmitry Torokhov return 0; 181457b8ff07SDmitry Torokhov } 181557b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 181657b8ff07SDmitry Torokhov 181757b8ff07SDmitry Torokhov /** 181857b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 181957b8ff07SDmitry Torokhov * @dev: device to remove the group from 182057b8ff07SDmitry Torokhov * @grp: group to remove 182157b8ff07SDmitry Torokhov * 182257b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 182357b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 182457b8ff07SDmitry Torokhov */ 182557b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 182657b8ff07SDmitry Torokhov const struct attribute_group *grp) 182757b8ff07SDmitry Torokhov { 182857b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 182957b8ff07SDmitry Torokhov devm_attr_group_match, 183057b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 183157b8ff07SDmitry Torokhov } 183257b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 183357b8ff07SDmitry Torokhov 183457b8ff07SDmitry Torokhov /** 183557b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 183657b8ff07SDmitry Torokhov * @dev: The device to create the group for 183757b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 183857b8ff07SDmitry Torokhov * 183957b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 184057b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 184157b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 184257b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 184357b8ff07SDmitry Torokhov * attribute files being created already exist. 184457b8ff07SDmitry Torokhov * 184557b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 184657b8ff07SDmitry Torokhov */ 184757b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 184857b8ff07SDmitry Torokhov const struct attribute_group **groups) 184957b8ff07SDmitry Torokhov { 185057b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 185157b8ff07SDmitry Torokhov int error; 185257b8ff07SDmitry Torokhov 185357b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 185457b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 185557b8ff07SDmitry Torokhov if (!devres) 185657b8ff07SDmitry Torokhov return -ENOMEM; 185757b8ff07SDmitry Torokhov 185857b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 185957b8ff07SDmitry Torokhov if (error) { 186057b8ff07SDmitry Torokhov devres_free(devres); 186157b8ff07SDmitry Torokhov return error; 186257b8ff07SDmitry Torokhov } 186357b8ff07SDmitry Torokhov 186457b8ff07SDmitry Torokhov devres->groups = groups; 186557b8ff07SDmitry Torokhov devres_add(dev, devres); 186657b8ff07SDmitry Torokhov return 0; 186757b8ff07SDmitry Torokhov } 186857b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 186957b8ff07SDmitry Torokhov 187057b8ff07SDmitry Torokhov /** 187157b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 187257b8ff07SDmitry Torokhov * 187357b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 187457b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 187557b8ff07SDmitry Torokhov * 187657b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 187757b8ff07SDmitry Torokhov */ 187857b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 187957b8ff07SDmitry Torokhov const struct attribute_group **groups) 188057b8ff07SDmitry Torokhov { 188157b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 188257b8ff07SDmitry Torokhov devm_attr_group_match, 188357b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 188457b8ff07SDmitry Torokhov } 188557b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 18861da177e4SLinus Torvalds 18872620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 18882620efefSGreg Kroah-Hartman { 18892620efefSGreg Kroah-Hartman struct class *class = dev->class; 1890aed65af1SStephen Hemminger const struct device_type *type = dev->type; 1891621a1672SDmitry Torokhov int error; 18922620efefSGreg Kroah-Hartman 1893621a1672SDmitry Torokhov if (class) { 1894d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 18952620efefSGreg Kroah-Hartman if (error) 1896621a1672SDmitry Torokhov return error; 1897f9f852dfSKay Sievers } 1898f9f852dfSKay Sievers 1899621a1672SDmitry Torokhov if (type) { 1900621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 1901f9f852dfSKay Sievers if (error) 1902a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 1903f9f852dfSKay Sievers } 1904621a1672SDmitry Torokhov 1905621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 1906f9f852dfSKay Sievers if (error) 1907621a1672SDmitry Torokhov goto err_remove_type_groups; 1908621a1672SDmitry Torokhov 19094f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 1910c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 19114f3549d7SRafael J. Wysocki if (error) 1912ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 19134f3549d7SRafael J. Wysocki } 19144f3549d7SRafael J. Wysocki 1915621a1672SDmitry Torokhov return 0; 1916621a1672SDmitry Torokhov 1917ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 1918ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 1919621a1672SDmitry Torokhov err_remove_type_groups: 1920621a1672SDmitry Torokhov if (type) 1921621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1922d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 1923d05a6f96SGreg Kroah-Hartman if (class) 1924d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1925f9f852dfSKay Sievers 19262620efefSGreg Kroah-Hartman return error; 19272620efefSGreg Kroah-Hartman } 19282620efefSGreg Kroah-Hartman 19292620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 19302620efefSGreg Kroah-Hartman { 19312620efefSGreg Kroah-Hartman struct class *class = dev->class; 1932aed65af1SStephen Hemminger const struct device_type *type = dev->type; 19332620efefSGreg Kroah-Hartman 1934c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 1935621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 1936f9f852dfSKay Sievers 1937621a1672SDmitry Torokhov if (type) 1938621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1939621a1672SDmitry Torokhov 1940a6b01dedSGreg Kroah-Hartman if (class) 1941d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1942c97415a7SStefan Achatz } 19432620efefSGreg Kroah-Hartman 1944c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 194523681e47SGreg Kroah-Hartman char *buf) 194623681e47SGreg Kroah-Hartman { 194723681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 194823681e47SGreg Kroah-Hartman } 1949c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 1950ad6a1e1cSTejun Heo 1951ca22e56dSKay Sievers /* /sys/devices/ */ 1952881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds /** 195552cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 195652cdbdd4SGrygorii Strashko * @deva: Device to move. 195752cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 195852cdbdd4SGrygorii Strashko */ 195952cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 196052cdbdd4SGrygorii Strashko { 196152cdbdd4SGrygorii Strashko if (!devices_kset) 196252cdbdd4SGrygorii Strashko return; 196352cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 196452cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 196552cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 196652cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 196752cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 196852cdbdd4SGrygorii Strashko } 196952cdbdd4SGrygorii Strashko 197052cdbdd4SGrygorii Strashko /** 197152cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 197252cdbdd4SGrygorii Strashko * @deva: Device to move 197352cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 197452cdbdd4SGrygorii Strashko */ 197552cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 197652cdbdd4SGrygorii Strashko { 197752cdbdd4SGrygorii Strashko if (!devices_kset) 197852cdbdd4SGrygorii Strashko return; 197952cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 198052cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 198152cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 198252cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 198352cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 198452cdbdd4SGrygorii Strashko } 198552cdbdd4SGrygorii Strashko 198652cdbdd4SGrygorii Strashko /** 198752cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 198852cdbdd4SGrygorii Strashko * @dev: device to move 198952cdbdd4SGrygorii Strashko */ 199052cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 199152cdbdd4SGrygorii Strashko { 199252cdbdd4SGrygorii Strashko if (!devices_kset) 199352cdbdd4SGrygorii Strashko return; 199452cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 199552cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 199652cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 199752cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 199852cdbdd4SGrygorii Strashko } 199952cdbdd4SGrygorii Strashko 200052cdbdd4SGrygorii Strashko /** 20011da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 20021da177e4SLinus Torvalds * @dev: device. 20031da177e4SLinus Torvalds * @attr: device attribute descriptor. 20041da177e4SLinus Torvalds */ 200526579ab7SPhil Carmody int device_create_file(struct device *dev, 200626579ab7SPhil Carmody const struct device_attribute *attr) 20071da177e4SLinus Torvalds { 20081da177e4SLinus Torvalds int error = 0; 20098f46baaaSFelipe Balbi 20108f46baaaSFelipe Balbi if (dev) { 20118f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 201297521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 201397521978Sdyoung@redhat.com attr->attr.name); 20148f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 201597521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 201697521978Sdyoung@redhat.com attr->attr.name); 20171da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 20188f46baaaSFelipe Balbi } 20198f46baaaSFelipe Balbi 20201da177e4SLinus Torvalds return error; 20211da177e4SLinus Torvalds } 202286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 20231da177e4SLinus Torvalds 20241da177e4SLinus Torvalds /** 20251da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 20261da177e4SLinus Torvalds * @dev: device. 20271da177e4SLinus Torvalds * @attr: device attribute descriptor. 20281da177e4SLinus Torvalds */ 202926579ab7SPhil Carmody void device_remove_file(struct device *dev, 203026579ab7SPhil Carmody const struct device_attribute *attr) 20311da177e4SLinus Torvalds { 20320c98b19fSCornelia Huck if (dev) 20331da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 20341da177e4SLinus Torvalds } 203586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 20361da177e4SLinus Torvalds 20372589f188SGreg Kroah-Hartman /** 20386b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 20396b0afc2aSTejun Heo * @dev: device. 20406b0afc2aSTejun Heo * @attr: device attribute descriptor. 20416b0afc2aSTejun Heo * 20426b0afc2aSTejun Heo * See kernfs_remove_self() for details. 20436b0afc2aSTejun Heo */ 20446b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 20456b0afc2aSTejun Heo const struct device_attribute *attr) 20466b0afc2aSTejun Heo { 20476b0afc2aSTejun Heo if (dev) 20486b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 20496b0afc2aSTejun Heo else 20506b0afc2aSTejun Heo return false; 20516b0afc2aSTejun Heo } 20526b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 20536b0afc2aSTejun Heo 20546b0afc2aSTejun Heo /** 20552589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 20562589f188SGreg Kroah-Hartman * @dev: device. 20572589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 20582589f188SGreg Kroah-Hartman */ 205966ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 206066ecb92bSPhil Carmody const struct bin_attribute *attr) 20612589f188SGreg Kroah-Hartman { 20622589f188SGreg Kroah-Hartman int error = -EINVAL; 20632589f188SGreg Kroah-Hartman if (dev) 20642589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 20652589f188SGreg Kroah-Hartman return error; 20662589f188SGreg Kroah-Hartman } 20672589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 20682589f188SGreg Kroah-Hartman 20692589f188SGreg Kroah-Hartman /** 20702589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 20712589f188SGreg Kroah-Hartman * @dev: device. 20722589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 20732589f188SGreg Kroah-Hartman */ 207466ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 207566ecb92bSPhil Carmody const struct bin_attribute *attr) 20762589f188SGreg Kroah-Hartman { 20772589f188SGreg Kroah-Hartman if (dev) 20782589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 20792589f188SGreg Kroah-Hartman } 20802589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 20812589f188SGreg Kroah-Hartman 208234bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 208334bb61f9SJames Bottomley { 2084f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2085f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 208634bb61f9SJames Bottomley 208734bb61f9SJames Bottomley get_device(dev); 208834bb61f9SJames Bottomley } 208934bb61f9SJames Bottomley 209034bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 209134bb61f9SJames Bottomley { 2092f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2093f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 209434bb61f9SJames Bottomley 209534bb61f9SJames Bottomley put_device(dev); 209634bb61f9SJames Bottomley } 209734bb61f9SJames Bottomley 20981da177e4SLinus Torvalds /** 20991da177e4SLinus Torvalds * device_initialize - init device structure. 21001da177e4SLinus Torvalds * @dev: device. 21011da177e4SLinus Torvalds * 21025739411aSCornelia Huck * This prepares the device for use by other layers by initializing 21035739411aSCornelia Huck * its fields. 21041da177e4SLinus Torvalds * It is the first half of device_register(), if called by 21055739411aSCornelia Huck * that function, though it can also be called separately, so one 21065739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 21075739411aSCornelia Huck * may be used for reference counting of @dev after calling this 21085739411aSCornelia Huck * function. 21095739411aSCornelia Huck * 2110b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 2111b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 2112b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 2113b10d5efdSAlan Stern * @dev. 2114b10d5efdSAlan Stern * 21155739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 21165739411aSCornelia Huck * @dev directly once you have called this function. 21171da177e4SLinus Torvalds */ 21181da177e4SLinus Torvalds void device_initialize(struct device *dev) 21191da177e4SLinus Torvalds { 2120881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 2121f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 21221da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 21233142788bSThomas Gleixner mutex_init(&dev->mutex); 212487a30e1fSDan Williams #ifdef CONFIG_PROVE_LOCKING 212587a30e1fSDan Williams mutex_init(&dev->lockdep_mutex); 212687a30e1fSDan Williams #endif 21271704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 21289ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 21299ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 21303b98aeafSAlan Stern device_pm_init(dev); 213187348136SChristoph Hellwig set_dev_node(dev, -1); 21324a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 21334a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 21344a7cc831SJiang Liu #endif 21359ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 21369ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 2137e2ae9bccSSaravana Kannan INIT_LIST_HEAD(&dev->links.needs_suppliers); 2138fc5a251dSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 21399ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 21401da177e4SLinus Torvalds } 214186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 21421da177e4SLinus Torvalds 2143d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 2144f0ee61a6SGreg Kroah-Hartman { 2145f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 2146f0ee61a6SGreg Kroah-Hartman 2147f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 21484ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 2149881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 2150f0ee61a6SGreg Kroah-Hartman 215186406245SKay Sievers return virtual_dir; 2152f0ee61a6SGreg Kroah-Hartman } 2153f0ee61a6SGreg Kroah-Hartman 2154bc451f20SEric W. Biederman struct class_dir { 2155bc451f20SEric W. Biederman struct kobject kobj; 2156bc451f20SEric W. Biederman struct class *class; 2157bc451f20SEric W. Biederman }; 2158bc451f20SEric W. Biederman 2159bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 2160bc451f20SEric W. Biederman 2161bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 2162bc451f20SEric W. Biederman { 2163bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2164bc451f20SEric W. Biederman kfree(dir); 2165bc451f20SEric W. Biederman } 2166bc451f20SEric W. Biederman 2167bc451f20SEric W. Biederman static const 2168bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 2169bc451f20SEric W. Biederman { 2170bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2171bc451f20SEric W. Biederman return dir->class->ns_type; 2172bc451f20SEric W. Biederman } 2173bc451f20SEric W. Biederman 2174bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 2175bc451f20SEric W. Biederman .release = class_dir_release, 2176bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 2177bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 2178bc451f20SEric W. Biederman }; 2179bc451f20SEric W. Biederman 2180bc451f20SEric W. Biederman static struct kobject * 2181bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 2182bc451f20SEric W. Biederman { 2183bc451f20SEric W. Biederman struct class_dir *dir; 2184bc451f20SEric W. Biederman int retval; 2185bc451f20SEric W. Biederman 2186bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 2187bc451f20SEric W. Biederman if (!dir) 218884d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 2189bc451f20SEric W. Biederman 2190bc451f20SEric W. Biederman dir->class = class; 2191bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 2192bc451f20SEric W. Biederman 21936b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 2194bc451f20SEric W. Biederman 2195bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 2196bc451f20SEric W. Biederman if (retval < 0) { 2197bc451f20SEric W. Biederman kobject_put(&dir->kobj); 219884d0c27dSTetsuo Handa return ERR_PTR(retval); 2199bc451f20SEric W. Biederman } 2200bc451f20SEric W. Biederman return &dir->kobj; 2201bc451f20SEric W. Biederman } 2202bc451f20SEric W. Biederman 2203e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 2204bc451f20SEric W. Biederman 2205c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 2206c744aeaeSCornelia Huck struct device *parent) 220740fa5422SGreg Kroah-Hartman { 220886406245SKay Sievers if (dev->class) { 220986406245SKay Sievers struct kobject *kobj = NULL; 221086406245SKay Sievers struct kobject *parent_kobj; 221186406245SKay Sievers struct kobject *k; 221286406245SKay Sievers 2213ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 221439aba963SKay Sievers /* block disks show up in /sys/block */ 2215e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 221639aba963SKay Sievers if (parent && parent->class == &block_class) 221739aba963SKay Sievers return &parent->kobj; 22186b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 221939aba963SKay Sievers } 2220ead454feSRandy Dunlap #endif 2221e52eec13SAndi Kleen 222286406245SKay Sievers /* 222386406245SKay Sievers * If we have no parent, we live in "virtual". 22240f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 22250f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 222686406245SKay Sievers */ 222786406245SKay Sievers if (parent == NULL) 222886406245SKay Sievers parent_kobj = virtual_device_parent(dev); 222924b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 223086406245SKay Sievers return &parent->kobj; 223186406245SKay Sievers else 223286406245SKay Sievers parent_kobj = &parent->kobj; 223386406245SKay Sievers 223477d3d7c1STejun Heo mutex_lock(&gdp_mutex); 223577d3d7c1STejun Heo 223686406245SKay Sievers /* find our class-directory at the parent and reference it */ 22376b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 22386b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 223986406245SKay Sievers if (k->parent == parent_kobj) { 224086406245SKay Sievers kobj = kobject_get(k); 224186406245SKay Sievers break; 224286406245SKay Sievers } 22436b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 224477d3d7c1STejun Heo if (kobj) { 224577d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 224686406245SKay Sievers return kobj; 224777d3d7c1STejun Heo } 224886406245SKay Sievers 224986406245SKay Sievers /* or create a new class-directory at the parent device */ 2250bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 22510f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 225277d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 225343968d2fSGreg Kroah-Hartman return k; 225486406245SKay Sievers } 225586406245SKay Sievers 2256ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 2257ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 2258ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 2259ca22e56dSKay Sievers 226086406245SKay Sievers if (parent) 2261c744aeaeSCornelia Huck return &parent->kobj; 2262c744aeaeSCornelia Huck return NULL; 2263c744aeaeSCornelia Huck } 2264da231fd5SKay Sievers 2265cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 2266cebf8fd1SMing Lei struct device *dev) 2267cebf8fd1SMing Lei { 2268cebf8fd1SMing Lei if (!kobj || !dev->class || 2269cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 2270cebf8fd1SMing Lei return false; 2271cebf8fd1SMing Lei return true; 2272cebf8fd1SMing Lei } 2273cebf8fd1SMing Lei 2274cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 2275cebf8fd1SMing Lei { 2276cebf8fd1SMing Lei return dev->kobj.parent; 2277cebf8fd1SMing Lei } 2278cebf8fd1SMing Lei 2279cebf8fd1SMing Lei /* 2280cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 2281cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 2282cebf8fd1SMing Lei * global lock 2283cebf8fd1SMing Lei */ 228463b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 2285da231fd5SKay Sievers { 2286ac43432cSMuchun Song unsigned int ref; 2287ac43432cSMuchun Song 22880f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 2289cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 2290da231fd5SKay Sievers return; 2291da231fd5SKay Sievers 2292e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 2293ac43432cSMuchun Song /** 2294ac43432cSMuchun Song * There is a race condition between removing glue directory 2295ac43432cSMuchun Song * and adding a new device under the glue directory. 2296ac43432cSMuchun Song * 2297ac43432cSMuchun Song * CPU1: CPU2: 2298ac43432cSMuchun Song * 2299ac43432cSMuchun Song * device_add() 2300ac43432cSMuchun Song * get_device_parent() 2301ac43432cSMuchun Song * class_dir_create_and_add() 2302ac43432cSMuchun Song * kobject_add_internal() 2303ac43432cSMuchun Song * create_dir() // create glue_dir 2304ac43432cSMuchun Song * 2305ac43432cSMuchun Song * device_add() 2306ac43432cSMuchun Song * get_device_parent() 2307ac43432cSMuchun Song * kobject_get() // get glue_dir 2308ac43432cSMuchun Song * 2309ac43432cSMuchun Song * device_del() 2310ac43432cSMuchun Song * cleanup_glue_dir() 2311ac43432cSMuchun Song * kobject_del(glue_dir) 2312ac43432cSMuchun Song * 2313ac43432cSMuchun Song * kobject_add() 2314ac43432cSMuchun Song * kobject_add_internal() 2315ac43432cSMuchun Song * create_dir() // in glue_dir 2316ac43432cSMuchun Song * sysfs_create_dir_ns() 2317ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 2318ac43432cSMuchun Song * 2319ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 2320ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 2321ac43432cSMuchun Song * 2322ac43432cSMuchun Song * // sd is freed 2323ac43432cSMuchun Song * kernfs_new_node(sd) 2324ac43432cSMuchun Song * kernfs_get(glue_dir) 2325ac43432cSMuchun Song * kernfs_add_one() 2326ac43432cSMuchun Song * kernfs_put() 2327ac43432cSMuchun Song * 2328ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 2329ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 2330ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 2331ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 2332ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 2333ac43432cSMuchun Song * 2334ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 2335ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 2336ac43432cSMuchun Song * 2337ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 2338ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 2339ac43432cSMuchun Song * for glue_dir kobj is 1. 2340ac43432cSMuchun Song */ 2341ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 2342ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 2343726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 23440f4dafc0SKay Sievers kobject_put(glue_dir); 2345e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 2346da231fd5SKay Sievers } 234763b6971aSCornelia Huck 23482ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 23492ee97cafSCornelia Huck { 23505590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 23512ee97cafSCornelia Huck int error; 23522ee97cafSCornelia Huck 23535590f319SBenjamin Herrenschmidt if (of_node) { 23540c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 23555590f319SBenjamin Herrenschmidt if (error) 23565590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 23575590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 23585590f319SBenjamin Herrenschmidt } 23595590f319SBenjamin Herrenschmidt 23602ee97cafSCornelia Huck if (!dev->class) 23612ee97cafSCornelia Huck return 0; 2362da231fd5SKay Sievers 23631fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 23646b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 23652ee97cafSCornelia Huck "subsystem"); 23662ee97cafSCornelia Huck if (error) 23675590f319SBenjamin Herrenschmidt goto out_devnode; 2368da231fd5SKay Sievers 23694e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 23704f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 23714f01a757SDmitry Torokhov "device"); 23724f01a757SDmitry Torokhov if (error) 237339aba963SKay Sievers goto out_subsys; 23742ee97cafSCornelia Huck } 237539aba963SKay Sievers 2376ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 237739aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 2378e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 237939aba963SKay Sievers return 0; 2380ead454feSRandy Dunlap #endif 238139aba963SKay Sievers 238239aba963SKay Sievers /* link in the class directory pointing to the device */ 23836b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 238439aba963SKay Sievers &dev->kobj, dev_name(dev)); 238539aba963SKay Sievers if (error) 238639aba963SKay Sievers goto out_device; 238739aba963SKay Sievers 23882ee97cafSCornelia Huck return 0; 23892ee97cafSCornelia Huck 239039aba963SKay Sievers out_device: 239139aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 2392da231fd5SKay Sievers 23932ee97cafSCornelia Huck out_subsys: 23942ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 23955590f319SBenjamin Herrenschmidt out_devnode: 23965590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 23972ee97cafSCornelia Huck return error; 23982ee97cafSCornelia Huck } 23992ee97cafSCornelia Huck 24002ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 24012ee97cafSCornelia Huck { 24025590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 24035590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 24045590f319SBenjamin Herrenschmidt 24052ee97cafSCornelia Huck if (!dev->class) 24062ee97cafSCornelia Huck return; 2407da231fd5SKay Sievers 24084e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 2409da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 24102ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 2411ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 2412e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 241339aba963SKay Sievers return; 2414ead454feSRandy Dunlap #endif 24156b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 24162ee97cafSCornelia Huck } 24172ee97cafSCornelia Huck 24181da177e4SLinus Torvalds /** 2419413c239fSStephen Rothwell * dev_set_name - set a device name 2420413c239fSStephen Rothwell * @dev: device 242146232366SRandy Dunlap * @fmt: format string for the device's name 2422413c239fSStephen Rothwell */ 2423413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 2424413c239fSStephen Rothwell { 2425413c239fSStephen Rothwell va_list vargs; 24261fa5ae85SKay Sievers int err; 2427413c239fSStephen Rothwell 2428413c239fSStephen Rothwell va_start(vargs, fmt); 24291fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 2430413c239fSStephen Rothwell va_end(vargs); 24311fa5ae85SKay Sievers return err; 2432413c239fSStephen Rothwell } 2433413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 2434413c239fSStephen Rothwell 2435413c239fSStephen Rothwell /** 2436e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 2437e105b8bfSDan Williams * @dev: device 2438e105b8bfSDan Williams * 2439e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 2440e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 2441e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 2442e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 24430d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 24440d4e293cSPeter Korsgaard * the link. 2445e105b8bfSDan Williams */ 2446e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 2447e105b8bfSDan Williams { 2448e105b8bfSDan Williams struct kobject *kobj; 2449e105b8bfSDan Williams 2450e105b8bfSDan Williams if (dev->class) 2451e105b8bfSDan Williams kobj = dev->class->dev_kobj; 2452e105b8bfSDan Williams else 2453e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 2454e105b8bfSDan Williams 2455e105b8bfSDan Williams return kobj; 2456e105b8bfSDan Williams } 2457e105b8bfSDan Williams 2458e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 2459e105b8bfSDan Williams { 2460e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2461e105b8bfSDan Williams int error = 0; 2462e105b8bfSDan Williams char devt_str[15]; 2463e105b8bfSDan Williams 2464e105b8bfSDan Williams if (kobj) { 2465e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2466e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 2467e105b8bfSDan Williams } 2468e105b8bfSDan Williams 2469e105b8bfSDan Williams return error; 2470e105b8bfSDan Williams } 2471e105b8bfSDan Williams 2472e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 2473e105b8bfSDan Williams { 2474e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2475e105b8bfSDan Williams char devt_str[15]; 2476e105b8bfSDan Williams 2477e105b8bfSDan Williams if (kobj) { 2478e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2479e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 2480e105b8bfSDan Williams } 2481e105b8bfSDan Williams } 2482e105b8bfSDan Williams 248346d3a037SShaokun Zhang static int device_private_init(struct device *dev) 2484b4028437SGreg Kroah-Hartman { 2485b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 2486b4028437SGreg Kroah-Hartman if (!dev->p) 2487b4028437SGreg Kroah-Hartman return -ENOMEM; 2488b4028437SGreg Kroah-Hartman dev->p->device = dev; 2489b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 2490b4028437SGreg Kroah-Hartman klist_children_put); 2491ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 2492b4028437SGreg Kroah-Hartman return 0; 2493b4028437SGreg Kroah-Hartman } 2494b4028437SGreg Kroah-Hartman 2495e105b8bfSDan Williams /** 24961da177e4SLinus Torvalds * device_add - add device to device hierarchy. 24971da177e4SLinus Torvalds * @dev: device. 24981da177e4SLinus Torvalds * 24991da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 25001da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 25011da177e4SLinus Torvalds * 25025739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 25031da177e4SLinus Torvalds * to the global and sibling lists for the device, then 25041da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 25055739411aSCornelia Huck * 2506b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 2507b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 2508b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 2509b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 2510b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 2511b10d5efdSAlan Stern * and register a fresh new struct device instead. 2512b10d5efdSAlan Stern * 25135739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 25145739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 25155739411aSCornelia Huck * reference instead. 2516affada72SBorislav Petkov * 2517affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 2518affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 2519affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 2520affada72SBorislav Petkov * count. 25211da177e4SLinus Torvalds */ 25221da177e4SLinus Torvalds int device_add(struct device *dev) 25231da177e4SLinus Torvalds { 252435dbf4efSViresh Kumar struct device *parent; 2525ca22e56dSKay Sievers struct kobject *kobj; 2526c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 25275f5377eaSSaravana Kannan int error = -EINVAL; 2528cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 25294dbe191cSSaravana Kannan bool is_fwnode_dev = false; 2530775b64d2SRafael J. Wysocki 25311da177e4SLinus Torvalds dev = get_device(dev); 2532c906a48aSGreg Kroah-Hartman if (!dev) 2533c906a48aSGreg Kroah-Hartman goto done; 2534c906a48aSGreg Kroah-Hartman 2535fb069a5dSGreg Kroah-Hartman if (!dev->p) { 2536b4028437SGreg Kroah-Hartman error = device_private_init(dev); 2537b4028437SGreg Kroah-Hartman if (error) 2538fb069a5dSGreg Kroah-Hartman goto done; 2539fb069a5dSGreg Kroah-Hartman } 2540fb069a5dSGreg Kroah-Hartman 25411fa5ae85SKay Sievers /* 25421fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 25431fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 25441fa5ae85SKay Sievers * the name, and force the use of dev_name() 25451fa5ae85SKay Sievers */ 25461fa5ae85SKay Sievers if (dev->init_name) { 2547acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 25481fa5ae85SKay Sievers dev->init_name = NULL; 25491fa5ae85SKay Sievers } 2550c906a48aSGreg Kroah-Hartman 2551ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 2552ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 2553ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 2554ca22e56dSKay Sievers 2555e6309e75SThomas Gleixner if (!dev_name(dev)) { 2556e6309e75SThomas Gleixner error = -EINVAL; 25575c8563d7SKay Sievers goto name_error; 2558e6309e75SThomas Gleixner } 25591da177e4SLinus Torvalds 25601e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 2561c205ef48SGreg Kroah-Hartman 25621da177e4SLinus Torvalds parent = get_device(dev->parent); 2563ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 256484d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 256584d0c27dSTetsuo Handa error = PTR_ERR(kobj); 256684d0c27dSTetsuo Handa goto parent_error; 256784d0c27dSTetsuo Handa } 2568ca22e56dSKay Sievers if (kobj) 2569ca22e56dSKay Sievers dev->kobj.parent = kobj; 25701da177e4SLinus Torvalds 25710d358f22SYinghai Lu /* use parent numa_node */ 257256f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 25730d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 25740d358f22SYinghai Lu 25751da177e4SLinus Torvalds /* first, register with generic layer. */ 25768a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 25778a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 2578cebf8fd1SMing Lei if (error) { 2579cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 25801da177e4SLinus Torvalds goto Error; 2581cebf8fd1SMing Lei } 2582a7fd6706SKay Sievers 258337022644SBrian Walsh /* notify platform of device entry */ 258407de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 258507de0e86SHeikki Krogerus if (error) 258607de0e86SHeikki Krogerus goto platform_error; 258737022644SBrian Walsh 2588c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 2589a306eea4SCornelia Huck if (error) 2590a306eea4SCornelia Huck goto attrError; 2591a7fd6706SKay Sievers 25922ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 25932ee97cafSCornelia Huck if (error) 25942ee97cafSCornelia Huck goto SymlinkError; 2595dc0afa83SCornelia Huck error = device_add_attrs(dev); 2596dc0afa83SCornelia Huck if (error) 25972620efefSGreg Kroah-Hartman goto AttrsError; 2598dc0afa83SCornelia Huck error = bus_add_device(dev); 2599dc0afa83SCornelia Huck if (error) 26001da177e4SLinus Torvalds goto BusError; 26013b98aeafSAlan Stern error = dpm_sysfs_add(dev); 260257eee3d2SRafael J. Wysocki if (error) 26033b98aeafSAlan Stern goto DPMError; 26043b98aeafSAlan Stern device_pm_add(dev); 2605ec0676eeSAlan Stern 26060cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 26070cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 26080cd75047SSergey Klyaus if (error) 26090cd75047SSergey Klyaus goto DevAttrError; 26100cd75047SSergey Klyaus 26110cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 26120cd75047SSergey Klyaus if (error) 26130cd75047SSergey Klyaus goto SysEntryError; 26140cd75047SSergey Klyaus 26150cd75047SSergey Klyaus devtmpfs_create_node(dev); 26160cd75047SSergey Klyaus } 26170cd75047SSergey Klyaus 2618ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 2619268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 2620ec0676eeSAlan Stern */ 2621ec0676eeSAlan Stern if (dev->bus) 2622ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2623ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 2624ec0676eeSAlan Stern 262553877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 2626372a67c0SSaravana Kannan 26274dbe191cSSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 2628372a67c0SSaravana Kannan dev->fwnode->dev = dev; 26294dbe191cSSaravana Kannan is_fwnode_dev = true; 26304dbe191cSSaravana Kannan } 2631372a67c0SSaravana Kannan 2632e2ae9bccSSaravana Kannan /* 2633e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 2634e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 2635e2ae9bccSSaravana Kannan * link to it. 2636e2ae9bccSSaravana Kannan * 2637e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 2638e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 2639e2ae9bccSSaravana Kannan * 2640e2ae9bccSSaravana Kannan * But this also needs to happe before bus_probe_device() to make sure 2641e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 2642e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 2643e2ae9bccSSaravana Kannan */ 26445f5377eaSSaravana Kannan if (is_fwnode_dev) 26455f5377eaSSaravana Kannan fw_devlink_link_device(dev); 2646e2ae9bccSSaravana Kannan 26472023c610SAlan Stern bus_probe_device(dev); 26481da177e4SLinus Torvalds if (parent) 2649f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2650f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 26511da177e4SLinus Torvalds 26525d9fd169SGreg Kroah-Hartman if (dev->class) { 2653ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2654c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 2655570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 26566b6e39a6SKay Sievers &dev->class->p->klist_devices); 2657c47ed219SGreg Kroah-Hartman 2658c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 2659184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2660ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2661c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 2662c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 2663ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 26645d9fd169SGreg Kroah-Hartman } 2665c906a48aSGreg Kroah-Hartman done: 26661da177e4SLinus Torvalds put_device(dev); 26671da177e4SLinus Torvalds return error; 26680cd75047SSergey Klyaus SysEntryError: 26690cd75047SSergey Klyaus if (MAJOR(dev->devt)) 26700cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 26710cd75047SSergey Klyaus DevAttrError: 26720cd75047SSergey Klyaus device_pm_remove(dev); 26730cd75047SSergey Klyaus dpm_sysfs_remove(dev); 26743b98aeafSAlan Stern DPMError: 267557eee3d2SRafael J. Wysocki bus_remove_device(dev); 267657eee3d2SRafael J. Wysocki BusError: 26772620efefSGreg Kroah-Hartman device_remove_attrs(dev); 26782620efefSGreg Kroah-Hartman AttrsError: 26792ee97cafSCornelia Huck device_remove_class_symlinks(dev); 26802ee97cafSCornelia Huck SymlinkError: 2681c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 268223681e47SGreg Kroah-Hartman attrError: 268307de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 268407de0e86SHeikki Krogerus platform_error: 2685312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2686cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 26871da177e4SLinus Torvalds kobject_del(&dev->kobj); 26881da177e4SLinus Torvalds Error: 2689cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 269084d0c27dSTetsuo Handa parent_error: 26911da177e4SLinus Torvalds put_device(parent); 26925c8563d7SKay Sievers name_error: 26935c8563d7SKay Sievers kfree(dev->p); 26945c8563d7SKay Sievers dev->p = NULL; 2695c906a48aSGreg Kroah-Hartman goto done; 26961da177e4SLinus Torvalds } 269786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 26981da177e4SLinus Torvalds 26991da177e4SLinus Torvalds /** 27001da177e4SLinus Torvalds * device_register - register a device with the system. 27011da177e4SLinus Torvalds * @dev: pointer to the device structure 27021da177e4SLinus Torvalds * 27031da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 27041da177e4SLinus Torvalds * and add it to the system. The two steps can be called 27051da177e4SLinus Torvalds * separately, but this is the easiest and most common. 27061da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 27071da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 27081da177e4SLinus Torvalds * before it is added to the hierarchy. 27095739411aSCornelia Huck * 2710b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 2711b10d5efdSAlan Stern * and device_add(). 2712b10d5efdSAlan Stern * 27135739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 27145739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 27155739411aSCornelia Huck * reference initialized in this function instead. 27161da177e4SLinus Torvalds */ 27171da177e4SLinus Torvalds int device_register(struct device *dev) 27181da177e4SLinus Torvalds { 27191da177e4SLinus Torvalds device_initialize(dev); 27201da177e4SLinus Torvalds return device_add(dev); 27211da177e4SLinus Torvalds } 272286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 27231da177e4SLinus Torvalds 27241da177e4SLinus Torvalds /** 27251da177e4SLinus Torvalds * get_device - increment reference count for device. 27261da177e4SLinus Torvalds * @dev: device. 27271da177e4SLinus Torvalds * 27281da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 27291da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 27301da177e4SLinus Torvalds * pointer passed in. 27311da177e4SLinus Torvalds */ 27321da177e4SLinus Torvalds struct device *get_device(struct device *dev) 27331da177e4SLinus Torvalds { 2734b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 27351da177e4SLinus Torvalds } 273686df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 27371da177e4SLinus Torvalds 27381da177e4SLinus Torvalds /** 27391da177e4SLinus Torvalds * put_device - decrement reference count. 27401da177e4SLinus Torvalds * @dev: device in question. 27411da177e4SLinus Torvalds */ 27421da177e4SLinus Torvalds void put_device(struct device *dev) 27431da177e4SLinus Torvalds { 2744edfaa7c3SKay Sievers /* might_sleep(); */ 27451da177e4SLinus Torvalds if (dev) 27461da177e4SLinus Torvalds kobject_put(&dev->kobj); 27471da177e4SLinus Torvalds } 274886df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 27491da177e4SLinus Torvalds 275000289cd8SDan Williams bool kill_device(struct device *dev) 275100289cd8SDan Williams { 275200289cd8SDan Williams /* 275300289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 275400289cd8SDan Williams * the update behavior is consistent with the other bitfields near 275500289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 275600289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 275700289cd8SDan Williams * underneath the device. 275800289cd8SDan Williams */ 275900289cd8SDan Williams lockdep_assert_held(&dev->mutex); 276000289cd8SDan Williams 276100289cd8SDan Williams if (dev->p->dead) 276200289cd8SDan Williams return false; 276300289cd8SDan Williams dev->p->dead = true; 276400289cd8SDan Williams return true; 276500289cd8SDan Williams } 276600289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 276700289cd8SDan Williams 27681da177e4SLinus Torvalds /** 27691da177e4SLinus Torvalds * device_del - delete device from system. 27701da177e4SLinus Torvalds * @dev: device. 27711da177e4SLinus Torvalds * 27721da177e4SLinus Torvalds * This is the first part of the device unregistration 27731da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 27741da177e4SLinus Torvalds * from here, has it removed from the other driver model 27751da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 27761da177e4SLinus Torvalds * from the kobject hierarchy. 27771da177e4SLinus Torvalds * 27781da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 27791da177e4SLinus Torvalds * also called manually. 27801da177e4SLinus Torvalds */ 27811da177e4SLinus Torvalds void device_del(struct device *dev) 27821da177e4SLinus Torvalds { 27831da177e4SLinus Torvalds struct device *parent = dev->parent; 2784cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2785c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 27861da177e4SLinus Torvalds 27873451a495SAlexander Duyck device_lock(dev); 278800289cd8SDan Williams kill_device(dev); 27893451a495SAlexander Duyck device_unlock(dev); 27903451a495SAlexander Duyck 2791372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 2792372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 2793372a67c0SSaravana Kannan 2794ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 2795ec0676eeSAlan Stern * before dpm_sysfs_remove(). 2796ec0676eeSAlan Stern */ 2797ec0676eeSAlan Stern if (dev->bus) 2798ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2799ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 28009ed98953SRafael J. Wysocki 28013b98aeafSAlan Stern dpm_sysfs_remove(dev); 28021da177e4SLinus Torvalds if (parent) 2803f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 2804e105b8bfSDan Williams if (MAJOR(dev->devt)) { 28052b2af54aSKay Sievers devtmpfs_delete_node(dev); 2806e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 2807c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 2808e105b8bfSDan Williams } 2809b9d9c82bSKay Sievers if (dev->class) { 2810da231fd5SKay Sievers device_remove_class_symlinks(dev); 281199ef3ef8SKay Sievers 2812ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2813c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 2814184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2815ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2816c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 2817c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 2818c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 2819570d0200SWei Yang klist_del(&dev->p->knode_class); 2820ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 2821b9d9c82bSKay Sievers } 2822c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 28232620efefSGreg Kroah-Hartman device_remove_attrs(dev); 282428953533SBenjamin Herrenschmidt bus_remove_device(dev); 28254b6d1f12SLongX Zhang device_pm_remove(dev); 2826d1c3414cSGrant Likely driver_deferred_probe_del(dev); 282707de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 2828478573c9SLukas Wunner device_remove_properties(dev); 28292ec16150SJeffy Chen device_links_purge(dev); 28301da177e4SLinus Torvalds 2831599bad38SJoerg Roedel if (dev->bus) 2832599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2833599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 2834312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2835cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 28361da177e4SLinus Torvalds kobject_del(&dev->kobj); 2837cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 28381da177e4SLinus Torvalds put_device(parent); 28391da177e4SLinus Torvalds } 284086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 28411da177e4SLinus Torvalds 28421da177e4SLinus Torvalds /** 28431da177e4SLinus Torvalds * device_unregister - unregister device from system. 28441da177e4SLinus Torvalds * @dev: device going away. 28451da177e4SLinus Torvalds * 28461da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 28471da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 28481da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 28491da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 28501da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 28511da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 28521da177e4SLinus Torvalds */ 28531da177e4SLinus Torvalds void device_unregister(struct device *dev) 28541da177e4SLinus Torvalds { 28551e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 28561da177e4SLinus Torvalds device_del(dev); 28571da177e4SLinus Torvalds put_device(dev); 28581da177e4SLinus Torvalds } 285986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 28601da177e4SLinus Torvalds 28613d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 28623d060aebSAndy Shevchenko { 28633d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 28643d060aebSAndy Shevchenko struct device *dev = NULL; 28653d060aebSAndy Shevchenko struct device_private *p; 28663d060aebSAndy Shevchenko 28673d060aebSAndy Shevchenko if (n) { 28683d060aebSAndy Shevchenko p = to_device_private_parent(n); 28693d060aebSAndy Shevchenko dev = p->device; 28703d060aebSAndy Shevchenko } 28713d060aebSAndy Shevchenko return dev; 28723d060aebSAndy Shevchenko } 28733d060aebSAndy Shevchenko 287436239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 287536239577Smochel@digitalimplant.org { 287636239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 2877f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 2878f791b8c8SGreg Kroah-Hartman struct device_private *p; 2879f791b8c8SGreg Kroah-Hartman 2880f791b8c8SGreg Kroah-Hartman if (n) { 2881f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 2882f791b8c8SGreg Kroah-Hartman dev = p->device; 2883f791b8c8SGreg Kroah-Hartman } 2884f791b8c8SGreg Kroah-Hartman return dev; 288536239577Smochel@digitalimplant.org } 288636239577Smochel@digitalimplant.org 28871da177e4SLinus Torvalds /** 2888e454cea2SKay Sievers * device_get_devnode - path of device node file 28896fcf53acSKay Sievers * @dev: device 2890e454cea2SKay Sievers * @mode: returned file access mode 28913c2670e6SKay Sievers * @uid: returned file owner 28923c2670e6SKay Sievers * @gid: returned file group 28936fcf53acSKay Sievers * @tmp: possibly allocated string 28946fcf53acSKay Sievers * 28956fcf53acSKay Sievers * Return the relative path of a possible device node. 28966fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 28976fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 28986fcf53acSKay Sievers * freed by the caller. 28996fcf53acSKay Sievers */ 2900e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 29014e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 29023c2670e6SKay Sievers const char **tmp) 29036fcf53acSKay Sievers { 29046fcf53acSKay Sievers char *s; 29056fcf53acSKay Sievers 29066fcf53acSKay Sievers *tmp = NULL; 29076fcf53acSKay Sievers 29086fcf53acSKay Sievers /* the device type may provide a specific name */ 2909e454cea2SKay Sievers if (dev->type && dev->type->devnode) 29103c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 29116fcf53acSKay Sievers if (*tmp) 29126fcf53acSKay Sievers return *tmp; 29136fcf53acSKay Sievers 29146fcf53acSKay Sievers /* the class may provide a specific name */ 2915e454cea2SKay Sievers if (dev->class && dev->class->devnode) 2916e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 29176fcf53acSKay Sievers if (*tmp) 29186fcf53acSKay Sievers return *tmp; 29196fcf53acSKay Sievers 29206fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 29216fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 29226fcf53acSKay Sievers return dev_name(dev); 29236fcf53acSKay Sievers 29246fcf53acSKay Sievers /* replace '!' in the name with '/' */ 2925a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 2926a29fd614SRasmus Villemoes if (!s) 29276fcf53acSKay Sievers return NULL; 2928a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 2929a29fd614SRasmus Villemoes return *tmp = s; 29306fcf53acSKay Sievers } 29316fcf53acSKay Sievers 29326fcf53acSKay Sievers /** 29331da177e4SLinus Torvalds * device_for_each_child - device child iterator. 2934c41455fbSRandy Dunlap * @parent: parent struct device. 29351da177e4SLinus Torvalds * @fn: function to be called for each device. 2936f8878dcbSRobert P. J. Day * @data: data for the callback. 29371da177e4SLinus Torvalds * 2938c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 29391da177e4SLinus Torvalds * passing it @data. 29401da177e4SLinus Torvalds * 29411da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 29421da177e4SLinus Torvalds * other than 0, we break out and return that value. 29431da177e4SLinus Torvalds */ 294436239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 29454a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 29461da177e4SLinus Torvalds { 294736239577Smochel@digitalimplant.org struct klist_iter i; 29481da177e4SLinus Torvalds struct device *child; 29491da177e4SLinus Torvalds int error = 0; 29501da177e4SLinus Torvalds 2951014c90dbSGreg Kroah-Hartman if (!parent->p) 2952014c90dbSGreg Kroah-Hartman return 0; 2953014c90dbSGreg Kroah-Hartman 2954f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 295593ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 295636239577Smochel@digitalimplant.org error = fn(child, data); 295736239577Smochel@digitalimplant.org klist_iter_exit(&i); 29581da177e4SLinus Torvalds return error; 29591da177e4SLinus Torvalds } 296086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 29611da177e4SLinus Torvalds 29625ab69981SCornelia Huck /** 29633d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 29643d060aebSAndy Shevchenko * @parent: parent struct device. 29653d060aebSAndy Shevchenko * @fn: function to be called for each device. 29663d060aebSAndy Shevchenko * @data: data for the callback. 29673d060aebSAndy Shevchenko * 29683d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 29693d060aebSAndy Shevchenko * passing it @data. 29703d060aebSAndy Shevchenko * 29713d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 29723d060aebSAndy Shevchenko * other than 0, we break out and return that value. 29733d060aebSAndy Shevchenko */ 29743d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 29753d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 29763d060aebSAndy Shevchenko { 29773d060aebSAndy Shevchenko struct klist_iter i; 29783d060aebSAndy Shevchenko struct device *child; 29793d060aebSAndy Shevchenko int error = 0; 29803d060aebSAndy Shevchenko 29813d060aebSAndy Shevchenko if (!parent->p) 29823d060aebSAndy Shevchenko return 0; 29833d060aebSAndy Shevchenko 29843d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 29853d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 29863d060aebSAndy Shevchenko error = fn(child, data); 29873d060aebSAndy Shevchenko klist_iter_exit(&i); 29883d060aebSAndy Shevchenko return error; 29893d060aebSAndy Shevchenko } 29903d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 29913d060aebSAndy Shevchenko 29923d060aebSAndy Shevchenko /** 29935ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 29945ab69981SCornelia Huck * @parent: parent struct device 29955ab69981SCornelia Huck * @match: Callback function to check device 2996f8878dcbSRobert P. J. Day * @data: Data to pass to match function 29975ab69981SCornelia Huck * 29985ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 29995ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 30005ab69981SCornelia Huck * determined by the @match callback. 30015ab69981SCornelia Huck * 30025ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 30035ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 30045ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 30055ab69981SCornelia Huck * and not iterate over any more devices. 3006a4e2400aSFederico Vaga * 3007a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 30085ab69981SCornelia Huck */ 30095ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 30104a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 30115ab69981SCornelia Huck { 30125ab69981SCornelia Huck struct klist_iter i; 30135ab69981SCornelia Huck struct device *child; 30145ab69981SCornelia Huck 30155ab69981SCornelia Huck if (!parent) 30165ab69981SCornelia Huck return NULL; 30175ab69981SCornelia Huck 3018f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 30195ab69981SCornelia Huck while ((child = next_device(&i))) 30205ab69981SCornelia Huck if (match(child, data) && get_device(child)) 30215ab69981SCornelia Huck break; 30225ab69981SCornelia Huck klist_iter_exit(&i); 30235ab69981SCornelia Huck return child; 30245ab69981SCornelia Huck } 302586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 30265ab69981SCornelia Huck 3027dad9bb01SHeikki Krogerus /** 3028dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 3029dad9bb01SHeikki Krogerus * @parent: parent struct device 3030dad9bb01SHeikki Krogerus * @name: name of the child device 3031dad9bb01SHeikki Krogerus * 3032dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 3033dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 3034dad9bb01SHeikki Krogerus * 3035dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 3036dad9bb01SHeikki Krogerus */ 3037dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 3038dad9bb01SHeikki Krogerus const char *name) 3039dad9bb01SHeikki Krogerus { 3040dad9bb01SHeikki Krogerus struct klist_iter i; 3041dad9bb01SHeikki Krogerus struct device *child; 3042dad9bb01SHeikki Krogerus 3043dad9bb01SHeikki Krogerus if (!parent) 3044dad9bb01SHeikki Krogerus return NULL; 3045dad9bb01SHeikki Krogerus 3046dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 3047dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 3048dad9bb01SHeikki Krogerus if (!strcmp(dev_name(child), name) && get_device(child)) 3049dad9bb01SHeikki Krogerus break; 3050dad9bb01SHeikki Krogerus klist_iter_exit(&i); 3051dad9bb01SHeikki Krogerus return child; 3052dad9bb01SHeikki Krogerus } 3053dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 3054dad9bb01SHeikki Krogerus 30551da177e4SLinus Torvalds int __init devices_init(void) 30561da177e4SLinus Torvalds { 3057881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 3058881c6cfdSGreg Kroah-Hartman if (!devices_kset) 3059881c6cfdSGreg Kroah-Hartman return -ENOMEM; 3060e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 3061e105b8bfSDan Williams if (!dev_kobj) 3062e105b8bfSDan Williams goto dev_kobj_err; 3063e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 3064e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 3065e105b8bfSDan Williams goto block_kobj_err; 3066e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 3067e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 3068e105b8bfSDan Williams goto char_kobj_err; 3069e105b8bfSDan Williams 3070881c6cfdSGreg Kroah-Hartman return 0; 3071e105b8bfSDan Williams 3072e105b8bfSDan Williams char_kobj_err: 3073e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 3074e105b8bfSDan Williams block_kobj_err: 3075e105b8bfSDan Williams kobject_put(dev_kobj); 3076e105b8bfSDan Williams dev_kobj_err: 3077e105b8bfSDan Williams kset_unregister(devices_kset); 3078e105b8bfSDan Williams return -ENOMEM; 30791da177e4SLinus Torvalds } 30801da177e4SLinus Torvalds 30814f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 30824f3549d7SRafael J. Wysocki { 30834f3549d7SRafael J. Wysocki int ret; 30844f3549d7SRafael J. Wysocki 30854f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 30864f3549d7SRafael J. Wysocki if (ret) 30874f3549d7SRafael J. Wysocki return ret; 30884f3549d7SRafael J. Wysocki 30894f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 30904f3549d7SRafael J. Wysocki } 30914f3549d7SRafael J. Wysocki 30924f3549d7SRafael J. Wysocki /** 30934f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 30944f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 30954f3549d7SRafael J. Wysocki * 30964f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 30974f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 30984f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 30994f3549d7SRafael J. Wysocki * is executed. 31004f3549d7SRafael J. Wysocki * 31014f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 31024f3549d7SRafael J. Wysocki */ 31034f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 31044f3549d7SRafael J. Wysocki { 31054f3549d7SRafael J. Wysocki int ret; 31064f3549d7SRafael J. Wysocki 31074f3549d7SRafael J. Wysocki if (dev->offline_disabled) 31084f3549d7SRafael J. Wysocki return -EPERM; 31094f3549d7SRafael J. Wysocki 31104f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 31114f3549d7SRafael J. Wysocki if (ret) 31124f3549d7SRafael J. Wysocki return ret; 31134f3549d7SRafael J. Wysocki 31144f3549d7SRafael J. Wysocki device_lock(dev); 31154f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 31164f3549d7SRafael J. Wysocki if (dev->offline) { 31174f3549d7SRafael J. Wysocki ret = 1; 31184f3549d7SRafael J. Wysocki } else { 31194f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 31204f3549d7SRafael J. Wysocki if (!ret) { 31214f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 31224f3549d7SRafael J. Wysocki dev->offline = true; 31234f3549d7SRafael J. Wysocki } 31244f3549d7SRafael J. Wysocki } 31254f3549d7SRafael J. Wysocki } 31264f3549d7SRafael J. Wysocki device_unlock(dev); 31274f3549d7SRafael J. Wysocki 31284f3549d7SRafael J. Wysocki return ret; 31294f3549d7SRafael J. Wysocki } 31304f3549d7SRafael J. Wysocki 31314f3549d7SRafael J. Wysocki /** 31324f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 31334f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 31344f3549d7SRafael J. Wysocki * 31354f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 31364f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 31374f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 31384f3549d7SRafael J. Wysocki * 31394f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 31404f3549d7SRafael J. Wysocki */ 31414f3549d7SRafael J. Wysocki int device_online(struct device *dev) 31424f3549d7SRafael J. Wysocki { 31434f3549d7SRafael J. Wysocki int ret = 0; 31444f3549d7SRafael J. Wysocki 31454f3549d7SRafael J. Wysocki device_lock(dev); 31464f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 31474f3549d7SRafael J. Wysocki if (dev->offline) { 31484f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 31494f3549d7SRafael J. Wysocki if (!ret) { 31504f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 31514f3549d7SRafael J. Wysocki dev->offline = false; 31524f3549d7SRafael J. Wysocki } 31534f3549d7SRafael J. Wysocki } else { 31544f3549d7SRafael J. Wysocki ret = 1; 31554f3549d7SRafael J. Wysocki } 31564f3549d7SRafael J. Wysocki } 31574f3549d7SRafael J. Wysocki device_unlock(dev); 31584f3549d7SRafael J. Wysocki 31594f3549d7SRafael J. Wysocki return ret; 31604f3549d7SRafael J. Wysocki } 31614f3549d7SRafael J. Wysocki 31627f100d15SKarthigan Srinivasan struct root_device { 31630aa0dc41SMark McLoughlin struct device dev; 31640aa0dc41SMark McLoughlin struct module *owner; 31650aa0dc41SMark McLoughlin }; 31660aa0dc41SMark McLoughlin 316793058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 3168481e2079SFerenc Wagner { 3169481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 3170481e2079SFerenc Wagner } 31710aa0dc41SMark McLoughlin 31720aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 31730aa0dc41SMark McLoughlin { 31740aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 31750aa0dc41SMark McLoughlin } 31760aa0dc41SMark McLoughlin 31770aa0dc41SMark McLoughlin /** 31780aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 31790aa0dc41SMark McLoughlin * @name: root device name 31800aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 31810aa0dc41SMark McLoughlin * 31820aa0dc41SMark McLoughlin * This function allocates a root device and registers it 31830aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 31840aa0dc41SMark McLoughlin * device, use root_device_unregister(). 31850aa0dc41SMark McLoughlin * 31860aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 31870aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 31880aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 31890aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 31900aa0dc41SMark McLoughlin * 31910aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 31920aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 31930aa0dc41SMark McLoughlin * in sysfs. 31940aa0dc41SMark McLoughlin * 3195f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3196f0eae0edSJani Nikula * 31970aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 31980aa0dc41SMark McLoughlin */ 31990aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 32000aa0dc41SMark McLoughlin { 32010aa0dc41SMark McLoughlin struct root_device *root; 32020aa0dc41SMark McLoughlin int err = -ENOMEM; 32030aa0dc41SMark McLoughlin 32040aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 32050aa0dc41SMark McLoughlin if (!root) 32060aa0dc41SMark McLoughlin return ERR_PTR(err); 32070aa0dc41SMark McLoughlin 3208acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 32090aa0dc41SMark McLoughlin if (err) { 32100aa0dc41SMark McLoughlin kfree(root); 32110aa0dc41SMark McLoughlin return ERR_PTR(err); 32120aa0dc41SMark McLoughlin } 32130aa0dc41SMark McLoughlin 32140aa0dc41SMark McLoughlin root->dev.release = root_device_release; 32150aa0dc41SMark McLoughlin 32160aa0dc41SMark McLoughlin err = device_register(&root->dev); 32170aa0dc41SMark McLoughlin if (err) { 32180aa0dc41SMark McLoughlin put_device(&root->dev); 32190aa0dc41SMark McLoughlin return ERR_PTR(err); 32200aa0dc41SMark McLoughlin } 32210aa0dc41SMark McLoughlin 32221d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 32230aa0dc41SMark McLoughlin if (owner) { 32240aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 32250aa0dc41SMark McLoughlin 32260aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 32270aa0dc41SMark McLoughlin if (err) { 32280aa0dc41SMark McLoughlin device_unregister(&root->dev); 32290aa0dc41SMark McLoughlin return ERR_PTR(err); 32300aa0dc41SMark McLoughlin } 32310aa0dc41SMark McLoughlin root->owner = owner; 32320aa0dc41SMark McLoughlin } 32330aa0dc41SMark McLoughlin #endif 32340aa0dc41SMark McLoughlin 32350aa0dc41SMark McLoughlin return &root->dev; 32360aa0dc41SMark McLoughlin } 32370aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 32380aa0dc41SMark McLoughlin 32390aa0dc41SMark McLoughlin /** 32400aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 32417cbcf225SRandy Dunlap * @dev: device going away 32420aa0dc41SMark McLoughlin * 32430aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 32440aa0dc41SMark McLoughlin * root_device_register(). 32450aa0dc41SMark McLoughlin */ 32460aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 32470aa0dc41SMark McLoughlin { 32480aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 32490aa0dc41SMark McLoughlin 32500aa0dc41SMark McLoughlin if (root->owner) 32510aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 32520aa0dc41SMark McLoughlin 32530aa0dc41SMark McLoughlin device_unregister(dev); 32540aa0dc41SMark McLoughlin } 32550aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 32560aa0dc41SMark McLoughlin 325723681e47SGreg Kroah-Hartman 325823681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 325923681e47SGreg Kroah-Hartman { 32601e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 326123681e47SGreg Kroah-Hartman kfree(dev); 326223681e47SGreg Kroah-Hartman } 326323681e47SGreg Kroah-Hartman 32646a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 326539ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 326639ef3112SGuenter Roeck dev_t devt, void *drvdata, 326739ef3112SGuenter Roeck const struct attribute_group **groups, 326839ef3112SGuenter Roeck const char *fmt, va_list args) 326939ef3112SGuenter Roeck { 327039ef3112SGuenter Roeck struct device *dev = NULL; 327139ef3112SGuenter Roeck int retval = -ENODEV; 327239ef3112SGuenter Roeck 327339ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 327439ef3112SGuenter Roeck goto error; 327539ef3112SGuenter Roeck 327639ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 327739ef3112SGuenter Roeck if (!dev) { 327839ef3112SGuenter Roeck retval = -ENOMEM; 327939ef3112SGuenter Roeck goto error; 328039ef3112SGuenter Roeck } 328139ef3112SGuenter Roeck 3282bbc780f8SDavid Herrmann device_initialize(dev); 328339ef3112SGuenter Roeck dev->devt = devt; 328439ef3112SGuenter Roeck dev->class = class; 328539ef3112SGuenter Roeck dev->parent = parent; 328639ef3112SGuenter Roeck dev->groups = groups; 328739ef3112SGuenter Roeck dev->release = device_create_release; 328839ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 328939ef3112SGuenter Roeck 329039ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 329139ef3112SGuenter Roeck if (retval) 329239ef3112SGuenter Roeck goto error; 329339ef3112SGuenter Roeck 3294bbc780f8SDavid Herrmann retval = device_add(dev); 329539ef3112SGuenter Roeck if (retval) 329639ef3112SGuenter Roeck goto error; 329739ef3112SGuenter Roeck 329839ef3112SGuenter Roeck return dev; 329939ef3112SGuenter Roeck 330039ef3112SGuenter Roeck error: 330139ef3112SGuenter Roeck put_device(dev); 330239ef3112SGuenter Roeck return ERR_PTR(retval); 330339ef3112SGuenter Roeck } 330439ef3112SGuenter Roeck 330523681e47SGreg Kroah-Hartman /** 33068882b394SGreg Kroah-Hartman * device_create_vargs - creates a device and registers it with sysfs 33078882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 33088882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 33098882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 33108882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 33118882b394SGreg Kroah-Hartman * @fmt: string for the device's name 33128882b394SGreg Kroah-Hartman * @args: va_list for the device's name 33138882b394SGreg Kroah-Hartman * 33148882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 33158882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 33168882b394SGreg Kroah-Hartman * 33178882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 33188882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 33198882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 33208882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 33218882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 33228882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 33238882b394SGreg Kroah-Hartman * pointer. 33248882b394SGreg Kroah-Hartman * 3325f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3326f0eae0edSJani Nikula * 33278882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 33288882b394SGreg Kroah-Hartman * been created with a call to class_create(). 33298882b394SGreg Kroah-Hartman */ 33308882b394SGreg Kroah-Hartman struct device *device_create_vargs(struct class *class, struct device *parent, 33318882b394SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, 33328882b394SGreg Kroah-Hartman va_list args) 33338882b394SGreg Kroah-Hartman { 333439ef3112SGuenter Roeck return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 333539ef3112SGuenter Roeck fmt, args); 33368882b394SGreg Kroah-Hartman } 33378882b394SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_vargs); 33388882b394SGreg Kroah-Hartman 33398882b394SGreg Kroah-Hartman /** 33404e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 33418882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 33428882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 33438882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 33448882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 33458882b394SGreg Kroah-Hartman * @fmt: string for the device's name 33468882b394SGreg Kroah-Hartman * 33478882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 33488882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 33498882b394SGreg Kroah-Hartman * 33508882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 33518882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 33528882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 33538882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 33548882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 33558882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 33568882b394SGreg Kroah-Hartman * pointer. 33578882b394SGreg Kroah-Hartman * 3358f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3359f0eae0edSJani Nikula * 33608882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 33618882b394SGreg Kroah-Hartman * been created with a call to class_create(). 33628882b394SGreg Kroah-Hartman */ 33634e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 33644e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 33658882b394SGreg Kroah-Hartman { 33668882b394SGreg Kroah-Hartman va_list vargs; 33678882b394SGreg Kroah-Hartman struct device *dev; 33688882b394SGreg Kroah-Hartman 33698882b394SGreg Kroah-Hartman va_start(vargs, fmt); 33708882b394SGreg Kroah-Hartman dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 33718882b394SGreg Kroah-Hartman va_end(vargs); 33728882b394SGreg Kroah-Hartman return dev; 33738882b394SGreg Kroah-Hartman } 33744e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 33758882b394SGreg Kroah-Hartman 337639ef3112SGuenter Roeck /** 337739ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 337839ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 337939ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 338039ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 338139ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 338239ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 338339ef3112SGuenter Roeck * @fmt: string for the device's name 338439ef3112SGuenter Roeck * 338539ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 338639ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 338739ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 338839ef3112SGuenter Roeck * be created automatically. 338939ef3112SGuenter Roeck * 339039ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 339139ef3112SGuenter Roeck * the dev_t is not 0,0. 339239ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 339339ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 339439ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 339539ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 339639ef3112SGuenter Roeck * pointer. 339739ef3112SGuenter Roeck * 339839ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 339939ef3112SGuenter Roeck * 340039ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 340139ef3112SGuenter Roeck * been created with a call to class_create(). 340239ef3112SGuenter Roeck */ 340339ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 340439ef3112SGuenter Roeck struct device *parent, dev_t devt, 340539ef3112SGuenter Roeck void *drvdata, 340639ef3112SGuenter Roeck const struct attribute_group **groups, 340739ef3112SGuenter Roeck const char *fmt, ...) 340839ef3112SGuenter Roeck { 340939ef3112SGuenter Roeck va_list vargs; 341039ef3112SGuenter Roeck struct device *dev; 341139ef3112SGuenter Roeck 341239ef3112SGuenter Roeck va_start(vargs, fmt); 341339ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 341439ef3112SGuenter Roeck fmt, vargs); 341539ef3112SGuenter Roeck va_end(vargs); 341639ef3112SGuenter Roeck return dev; 341739ef3112SGuenter Roeck } 341839ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 341939ef3112SGuenter Roeck 3420775b64d2SRafael J. Wysocki /** 3421775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 3422775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 3423775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 3424775b64d2SRafael J. Wysocki * 3425775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 3426775b64d2SRafael J. Wysocki * call to device_create(). 3427775b64d2SRafael J. Wysocki */ 3428775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 3429775b64d2SRafael J. Wysocki { 3430775b64d2SRafael J. Wysocki struct device *dev; 3431775b64d2SRafael J. Wysocki 34324495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 3433cd35449bSDave Young if (dev) { 3434cd35449bSDave Young put_device(dev); 343523681e47SGreg Kroah-Hartman device_unregister(dev); 343623681e47SGreg Kroah-Hartman } 3437cd35449bSDave Young } 343823681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 3439a2de48caSGreg Kroah-Hartman 3440a2de48caSGreg Kroah-Hartman /** 3441a2de48caSGreg Kroah-Hartman * device_rename - renames a device 3442a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 3443a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 3444030c1d2bSEric W. Biederman * 3445030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 3446030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 3447030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 3448030c1d2bSEric W. Biederman * won't conflict with other devices. 3449c6c0ac66SMichael Ellerman * 3450a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 3451a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 3452a5462516STimur Tabi * some insight: 3453a5462516STimur Tabi * 3454a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 3455a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 3456a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 3457a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 3458a5462516STimur Tabi * 3459a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 3460a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 3461a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 3462a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 3463a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 3464a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 3465a5462516STimur Tabi * 3466a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 3467a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 3468a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 3469a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 3470a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 3471a5462516STimur Tabi * reasons. 3472a5462516STimur Tabi * 3473a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 3474a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 3475a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 3476a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 3477a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 3478a2de48caSGreg Kroah-Hartman */ 34796937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 3480a2de48caSGreg Kroah-Hartman { 34814b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 34822ee97cafSCornelia Huck char *old_device_name = NULL; 3483a2de48caSGreg Kroah-Hartman int error; 3484a2de48caSGreg Kroah-Hartman 3485a2de48caSGreg Kroah-Hartman dev = get_device(dev); 3486a2de48caSGreg Kroah-Hartman if (!dev) 3487a2de48caSGreg Kroah-Hartman return -EINVAL; 3488a2de48caSGreg Kroah-Hartman 348969df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 3490a2de48caSGreg Kroah-Hartman 34911fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 34922ee97cafSCornelia Huck if (!old_device_name) { 3493952ab431SJesper Juhl error = -ENOMEM; 34942ee97cafSCornelia Huck goto out; 3495952ab431SJesper Juhl } 3496a2de48caSGreg Kroah-Hartman 3497f349cf34SEric W. Biederman if (dev->class) { 34984b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 34994b30ee58STejun Heo kobj, old_device_name, 35004b30ee58STejun Heo new_name, kobject_namespace(kobj)); 3501f349cf34SEric W. Biederman if (error) 3502f349cf34SEric W. Biederman goto out; 3503f349cf34SEric W. Biederman } 350439aba963SKay Sievers 35054b30ee58STejun Heo error = kobject_rename(kobj, new_name); 35061fa5ae85SKay Sievers if (error) 35072ee97cafSCornelia Huck goto out; 3508a2de48caSGreg Kroah-Hartman 35092ee97cafSCornelia Huck out: 3510a2de48caSGreg Kroah-Hartman put_device(dev); 3511a2de48caSGreg Kroah-Hartman 35122ee97cafSCornelia Huck kfree(old_device_name); 3513a2de48caSGreg Kroah-Hartman 3514a2de48caSGreg Kroah-Hartman return error; 3515a2de48caSGreg Kroah-Hartman } 3516a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 35178a82472fSCornelia Huck 35188a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 35198a82472fSCornelia Huck struct device *old_parent, 35208a82472fSCornelia Huck struct device *new_parent) 35218a82472fSCornelia Huck { 3522f7f3461dSGreg Kroah-Hartman int error = 0; 35238a82472fSCornelia Huck 3524f7f3461dSGreg Kroah-Hartman if (old_parent) 3525f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 3526f7f3461dSGreg Kroah-Hartman if (new_parent) 3527f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 3528f7f3461dSGreg Kroah-Hartman "device"); 3529f7f3461dSGreg Kroah-Hartman return error; 35308a82472fSCornelia Huck } 35318a82472fSCornelia Huck 35328a82472fSCornelia Huck /** 35338a82472fSCornelia Huck * device_move - moves a device to a new parent 35348a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 353513509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 3536ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 35378a82472fSCornelia Huck */ 3538ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 3539ffa6a705SCornelia Huck enum dpm_order dpm_order) 35408a82472fSCornelia Huck { 35418a82472fSCornelia Huck int error; 35428a82472fSCornelia Huck struct device *old_parent; 3543c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 35448a82472fSCornelia Huck 35458a82472fSCornelia Huck dev = get_device(dev); 35468a82472fSCornelia Huck if (!dev) 35478a82472fSCornelia Huck return -EINVAL; 35488a82472fSCornelia Huck 3549ffa6a705SCornelia Huck device_pm_lock(); 35508a82472fSCornelia Huck new_parent = get_device(new_parent); 3551c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 355284d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 355384d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 355484d0c27dSTetsuo Handa put_device(new_parent); 355584d0c27dSTetsuo Handa goto out; 355684d0c27dSTetsuo Handa } 355763b6971aSCornelia Huck 35581e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 35591e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 3560c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 35618a82472fSCornelia Huck if (error) { 356263b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 35638a82472fSCornelia Huck put_device(new_parent); 35648a82472fSCornelia Huck goto out; 35658a82472fSCornelia Huck } 35668a82472fSCornelia Huck old_parent = dev->parent; 35678a82472fSCornelia Huck dev->parent = new_parent; 35688a82472fSCornelia Huck if (old_parent) 3569f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 35700d358f22SYinghai Lu if (new_parent) { 3571f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3572f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 35730d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 35740d358f22SYinghai Lu } 35750d358f22SYinghai Lu 3576bdd4034dSRabin Vincent if (dev->class) { 35778a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 35788a82472fSCornelia Huck if (error) { 35798a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 35808a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 35818a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 3582c744aeaeSCornelia Huck if (new_parent) 3583f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 35840d358f22SYinghai Lu dev->parent = old_parent; 35850d358f22SYinghai Lu if (old_parent) { 3586f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3587f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 35880d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 35890d358f22SYinghai Lu } 35908a82472fSCornelia Huck } 359163b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 35928a82472fSCornelia Huck put_device(new_parent); 35938a82472fSCornelia Huck goto out; 35948a82472fSCornelia Huck } 3595bdd4034dSRabin Vincent } 3596ffa6a705SCornelia Huck switch (dpm_order) { 3597ffa6a705SCornelia Huck case DPM_ORDER_NONE: 3598ffa6a705SCornelia Huck break; 3599ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 3600ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 360152cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 3602ffa6a705SCornelia Huck break; 3603ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 3604ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 360552cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 3606ffa6a705SCornelia Huck break; 3607ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 3608ffa6a705SCornelia Huck device_pm_move_last(dev); 360952cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 3610ffa6a705SCornelia Huck break; 3611ffa6a705SCornelia Huck } 3612bdd4034dSRabin Vincent 36138a82472fSCornelia Huck put_device(old_parent); 36148a82472fSCornelia Huck out: 3615ffa6a705SCornelia Huck device_pm_unlock(); 36168a82472fSCornelia Huck put_device(dev); 36178a82472fSCornelia Huck return error; 36188a82472fSCornelia Huck } 36198a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 362037b0c020SGreg Kroah-Hartman 3621b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 3622b8f33e5dSChristian Brauner kgid_t kgid) 3623b8f33e5dSChristian Brauner { 3624b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3625b8f33e5dSChristian Brauner struct class *class = dev->class; 3626b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 3627b8f33e5dSChristian Brauner int error; 3628b8f33e5dSChristian Brauner 3629b8f33e5dSChristian Brauner if (class) { 3630b8f33e5dSChristian Brauner /* 3631b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 3632b8f33e5dSChristian Brauner * @kuid/@kgid. 3633b8f33e5dSChristian Brauner */ 3634b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 3635b8f33e5dSChristian Brauner kgid); 3636b8f33e5dSChristian Brauner if (error) 3637b8f33e5dSChristian Brauner return error; 3638b8f33e5dSChristian Brauner } 3639b8f33e5dSChristian Brauner 3640b8f33e5dSChristian Brauner if (type) { 3641b8f33e5dSChristian Brauner /* 3642b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 3643b8f33e5dSChristian Brauner * @kuid/@kgid. 3644b8f33e5dSChristian Brauner */ 3645b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 3646b8f33e5dSChristian Brauner kgid); 3647b8f33e5dSChristian Brauner if (error) 3648b8f33e5dSChristian Brauner return error; 3649b8f33e5dSChristian Brauner } 3650b8f33e5dSChristian Brauner 3651b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 3652b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 3653b8f33e5dSChristian Brauner if (error) 3654b8f33e5dSChristian Brauner return error; 3655b8f33e5dSChristian Brauner 3656b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 3657b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 3658b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 3659b8f33e5dSChristian Brauner kuid, kgid); 3660b8f33e5dSChristian Brauner if (error) 3661b8f33e5dSChristian Brauner return error; 3662b8f33e5dSChristian Brauner } 3663b8f33e5dSChristian Brauner 3664b8f33e5dSChristian Brauner return 0; 3665b8f33e5dSChristian Brauner } 3666b8f33e5dSChristian Brauner 3667b8f33e5dSChristian Brauner /** 3668b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 3669b8f33e5dSChristian Brauner * @dev: device. 3670b8f33e5dSChristian Brauner * @kuid: new owner's kuid 3671b8f33e5dSChristian Brauner * @kgid: new owner's kgid 3672b8f33e5dSChristian Brauner * 3673b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 3674b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 3675b8f33e5dSChristian Brauner * core. 3676b8f33e5dSChristian Brauner * 3677b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 3678b8f33e5dSChristian Brauner */ 3679b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 3680b8f33e5dSChristian Brauner { 3681b8f33e5dSChristian Brauner int error; 3682b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3683b8f33e5dSChristian Brauner 3684b8f33e5dSChristian Brauner dev = get_device(dev); 3685b8f33e5dSChristian Brauner if (!dev) 3686b8f33e5dSChristian Brauner return -EINVAL; 3687b8f33e5dSChristian Brauner 3688b8f33e5dSChristian Brauner /* 3689b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 3690b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 3691b8f33e5dSChristian Brauner */ 3692b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 3693b8f33e5dSChristian Brauner if (error) 3694b8f33e5dSChristian Brauner goto out; 3695b8f33e5dSChristian Brauner 3696b8f33e5dSChristian Brauner /* 3697b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 3698b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 3699b8f33e5dSChristian Brauner * that step here. 3700b8f33e5dSChristian Brauner */ 3701b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 3702b8f33e5dSChristian Brauner kgid); 3703b8f33e5dSChristian Brauner if (error) 3704b8f33e5dSChristian Brauner goto out; 3705b8f33e5dSChristian Brauner 3706b8f33e5dSChristian Brauner /* 3707b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 3708b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 3709b8f33e5dSChristian Brauner * to @kuid/@kgid. 3710b8f33e5dSChristian Brauner */ 3711b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 3712b8f33e5dSChristian Brauner if (error) 3713b8f33e5dSChristian Brauner goto out; 3714b8f33e5dSChristian Brauner 37153b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 37163b52fc5dSChristian Brauner if (error) 37173b52fc5dSChristian Brauner goto out; 37183b52fc5dSChristian Brauner 3719b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 3720b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 3721b8f33e5dSChristian Brauner goto out; 3722b8f33e5dSChristian Brauner #endif 3723b8f33e5dSChristian Brauner 3724b8f33e5dSChristian Brauner /* 3725b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 3726b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 3727b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 3728b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 3729b8f33e5dSChristian Brauner */ 3730b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 3731b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 3732b8f33e5dSChristian Brauner if (error) 3733b8f33e5dSChristian Brauner goto out; 3734b8f33e5dSChristian Brauner 3735b8f33e5dSChristian Brauner out: 3736b8f33e5dSChristian Brauner put_device(dev); 3737b8f33e5dSChristian Brauner return error; 3738b8f33e5dSChristian Brauner } 3739b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 3740b8f33e5dSChristian Brauner 374137b0c020SGreg Kroah-Hartman /** 374237b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 374337b0c020SGreg Kroah-Hartman */ 374437b0c020SGreg Kroah-Hartman void device_shutdown(void) 374537b0c020SGreg Kroah-Hartman { 3746f123db8eSBenson Leung struct device *dev, *parent; 374737b0c020SGreg Kroah-Hartman 37483297c8fcSPingfan Liu wait_for_device_probe(); 37493297c8fcSPingfan Liu device_block_probing(); 37503297c8fcSPingfan Liu 375165650b35SRafael J. Wysocki cpufreq_suspend(); 375265650b35SRafael J. Wysocki 37536245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 37546245838fSHugh Daschbach /* 37556245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 37566245838fSHugh Daschbach * Beware that device unplug events may also start pulling 37576245838fSHugh Daschbach * devices offline, even as the system is shutting down. 37586245838fSHugh Daschbach */ 37596245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 37606245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 37616245838fSHugh Daschbach kobj.entry); 3762d1c6c030SMing Lei 3763d1c6c030SMing Lei /* 3764d1c6c030SMing Lei * hold reference count of device's parent to 3765d1c6c030SMing Lei * prevent it from being freed because parent's 3766d1c6c030SMing Lei * lock is to be held 3767d1c6c030SMing Lei */ 3768f123db8eSBenson Leung parent = get_device(dev->parent); 37696245838fSHugh Daschbach get_device(dev); 37706245838fSHugh Daschbach /* 37716245838fSHugh Daschbach * Make sure the device is off the kset list, in the 37726245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 37736245838fSHugh Daschbach */ 37746245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 37756245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 3776fe6b91f4SAlan Stern 3777d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 3778f123db8eSBenson Leung if (parent) 3779f123db8eSBenson Leung device_lock(parent); 3780d1c6c030SMing Lei device_lock(dev); 3781d1c6c030SMing Lei 3782fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 3783fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 3784fe6b91f4SAlan Stern pm_runtime_barrier(dev); 37856245838fSHugh Daschbach 37867521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 3787f77af151SJosh Zimmerman if (initcall_debug) 37887521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 37897521621eSMichal Suchanek dev->class->shutdown_pre(dev); 37907521621eSMichal Suchanek } 37917521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 37920246c4faSShuoX Liu if (initcall_debug) 37930246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 379437b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 379537b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 37960246c4faSShuoX Liu if (initcall_debug) 37970246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 379837b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 379937b0c020SGreg Kroah-Hartman } 3800d1c6c030SMing Lei 3801d1c6c030SMing Lei device_unlock(dev); 3802f123db8eSBenson Leung if (parent) 3803f123db8eSBenson Leung device_unlock(parent); 3804d1c6c030SMing Lei 38056245838fSHugh Daschbach put_device(dev); 3806f123db8eSBenson Leung put_device(parent); 38076245838fSHugh Daschbach 38086245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 380937b0c020SGreg Kroah-Hartman } 38106245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 381137b0c020SGreg Kroah-Hartman } 381299bcf217SJoe Perches 381399bcf217SJoe Perches /* 381499bcf217SJoe Perches * Device logging functions 381599bcf217SJoe Perches */ 381699bcf217SJoe Perches 381799bcf217SJoe Perches #ifdef CONFIG_PRINTK 3818666f355fSJoe Perches static int 3819666f355fSJoe Perches create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 382099bcf217SJoe Perches { 3821c4e00daaSKay Sievers const char *subsys; 3822798efc60SJoe Perches size_t pos = 0; 382399bcf217SJoe Perches 3824c4e00daaSKay Sievers if (dev->class) 3825c4e00daaSKay Sievers subsys = dev->class->name; 3826c4e00daaSKay Sievers else if (dev->bus) 3827c4e00daaSKay Sievers subsys = dev->bus->name; 3828c4e00daaSKay Sievers else 3829798efc60SJoe Perches return 0; 3830c4e00daaSKay Sievers 3831798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 3832655e5b7cSBen Hutchings if (pos >= hdrlen) 3833655e5b7cSBen Hutchings goto overflow; 3834c4e00daaSKay Sievers 3835c4e00daaSKay Sievers /* 3836c4e00daaSKay Sievers * Add device identifier DEVICE=: 3837c4e00daaSKay Sievers * b12:8 block dev_t 3838c4e00daaSKay Sievers * c127:3 char dev_t 3839c4e00daaSKay Sievers * n8 netdev ifindex 3840c4e00daaSKay Sievers * +sound:card0 subsystem:devname 3841c4e00daaSKay Sievers */ 3842c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 3843c4e00daaSKay Sievers char c; 3844c4e00daaSKay Sievers 3845c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 3846c4e00daaSKay Sievers c = 'b'; 3847c4e00daaSKay Sievers else 3848c4e00daaSKay Sievers c = 'c'; 3849798efc60SJoe Perches pos++; 3850798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3851c4e00daaSKay Sievers "DEVICE=%c%u:%u", 3852c4e00daaSKay Sievers c, MAJOR(dev->devt), MINOR(dev->devt)); 3853c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 3854c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 3855c4e00daaSKay Sievers 3856798efc60SJoe Perches pos++; 3857798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3858c4e00daaSKay Sievers "DEVICE=n%u", net->ifindex); 3859c4e00daaSKay Sievers } else { 3860798efc60SJoe Perches pos++; 3861798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3862c4e00daaSKay Sievers "DEVICE=+%s:%s", subsys, dev_name(dev)); 3863c4e00daaSKay Sievers } 3864af7f2158SJim Cromie 3865655e5b7cSBen Hutchings if (pos >= hdrlen) 3866655e5b7cSBen Hutchings goto overflow; 3867655e5b7cSBen Hutchings 3868798efc60SJoe Perches return pos; 3869655e5b7cSBen Hutchings 3870655e5b7cSBen Hutchings overflow: 3871655e5b7cSBen Hutchings dev_WARN(dev, "device/subsystem name too long"); 3872655e5b7cSBen Hutchings return 0; 387399bcf217SJoe Perches } 3874798efc60SJoe Perches 387505e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 387605e4e5b8SJoe Perches const char *fmt, va_list args) 387705e4e5b8SJoe Perches { 387805e4e5b8SJoe Perches char hdr[128]; 387905e4e5b8SJoe Perches size_t hdrlen; 388005e4e5b8SJoe Perches 388105e4e5b8SJoe Perches hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 388205e4e5b8SJoe Perches 388305e4e5b8SJoe Perches return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 388405e4e5b8SJoe Perches } 388505e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 388605e4e5b8SJoe Perches 388705e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 388805e4e5b8SJoe Perches { 388905e4e5b8SJoe Perches va_list args; 389005e4e5b8SJoe Perches int r; 389105e4e5b8SJoe Perches 389205e4e5b8SJoe Perches va_start(args, fmt); 389305e4e5b8SJoe Perches 389405e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 389505e4e5b8SJoe Perches 389605e4e5b8SJoe Perches va_end(args); 389705e4e5b8SJoe Perches 389805e4e5b8SJoe Perches return r; 389905e4e5b8SJoe Perches } 390005e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 390105e4e5b8SJoe Perches 3902d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 3903798efc60SJoe Perches struct va_format *vaf) 3904798efc60SJoe Perches { 3905d1f1052cSJoe Perches if (dev) 3906d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 3907798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 3908d1f1052cSJoe Perches else 3909d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 3910798efc60SJoe Perches } 391199bcf217SJoe Perches 3912d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 391399bcf217SJoe Perches const char *fmt, ...) 391499bcf217SJoe Perches { 391599bcf217SJoe Perches struct va_format vaf; 391699bcf217SJoe Perches va_list args; 391799bcf217SJoe Perches 391899bcf217SJoe Perches va_start(args, fmt); 391999bcf217SJoe Perches 392099bcf217SJoe Perches vaf.fmt = fmt; 392199bcf217SJoe Perches vaf.va = &args; 392299bcf217SJoe Perches 3923d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 3924798efc60SJoe Perches 392599bcf217SJoe Perches va_end(args); 392699bcf217SJoe Perches } 392799bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 392899bcf217SJoe Perches 392999bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 3930d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 393199bcf217SJoe Perches { \ 393299bcf217SJoe Perches struct va_format vaf; \ 393399bcf217SJoe Perches va_list args; \ 393499bcf217SJoe Perches \ 393599bcf217SJoe Perches va_start(args, fmt); \ 393699bcf217SJoe Perches \ 393799bcf217SJoe Perches vaf.fmt = fmt; \ 393899bcf217SJoe Perches vaf.va = &args; \ 393999bcf217SJoe Perches \ 3940d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 3941798efc60SJoe Perches \ 394299bcf217SJoe Perches va_end(args); \ 394399bcf217SJoe Perches } \ 394499bcf217SJoe Perches EXPORT_SYMBOL(func); 394599bcf217SJoe Perches 3946663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 3947663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 3948663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 3949663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 3950663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 3951663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 395299bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 395399bcf217SJoe Perches 395499bcf217SJoe Perches #endif 395597badf87SRafael J. Wysocki 395697badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 395797badf87SRafael J. Wysocki { 395897badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 395997badf87SRafael J. Wysocki } 396097badf87SRafael J. Wysocki 396197badf87SRafael J. Wysocki /** 396297badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 396397badf87SRafael J. Wysocki * @dev: Device to handle. 396497badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 396597badf87SRafael J. Wysocki * 396697badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 396797badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 396897badf87SRafael J. Wysocki */ 396997badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 397097badf87SRafael J. Wysocki { 397197badf87SRafael J. Wysocki if (fwnode) { 397297badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 397397badf87SRafael J. Wysocki 397497badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 397597badf87SRafael J. Wysocki fn = fn->secondary; 397697badf87SRafael J. Wysocki 397755f89a8aSMika Westerberg if (fn) { 397855f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 397997badf87SRafael J. Wysocki fwnode->secondary = fn; 398055f89a8aSMika Westerberg } 398197badf87SRafael J. Wysocki dev->fwnode = fwnode; 398297badf87SRafael J. Wysocki } else { 398397badf87SRafael J. Wysocki dev->fwnode = fwnode_is_primary(dev->fwnode) ? 398497badf87SRafael J. Wysocki dev->fwnode->secondary : NULL; 398597badf87SRafael J. Wysocki } 398697badf87SRafael J. Wysocki } 398797badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 398897badf87SRafael J. Wysocki 398997badf87SRafael J. Wysocki /** 399097badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 399197badf87SRafael J. Wysocki * @dev: Device to handle. 399297badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 399397badf87SRafael J. Wysocki * 399497badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 399597badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 399697badf87SRafael J. Wysocki * @fwnode. 399797badf87SRafael J. Wysocki */ 399897badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 399997badf87SRafael J. Wysocki { 400097badf87SRafael J. Wysocki if (fwnode) 400197badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 400297badf87SRafael J. Wysocki 400397badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 400497badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 400597badf87SRafael J. Wysocki else 400697badf87SRafael J. Wysocki dev->fwnode = fwnode; 400797badf87SRafael J. Wysocki } 40084e75e1d7SJohan Hovold 40094e75e1d7SJohan Hovold /** 40104e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 40114e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 40124e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 40134e75e1d7SJohan Hovold * 40144e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 40154e75e1d7SJohan Hovold * any reference held to the old node. 40164e75e1d7SJohan Hovold */ 40174e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 40184e75e1d7SJohan Hovold { 40194e75e1d7SJohan Hovold of_node_put(dev->of_node); 40204e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 40214e75e1d7SJohan Hovold dev->of_node_reused = true; 40224e75e1d7SJohan Hovold } 40234e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 402465b66682SSuzuki K Poulose 40256cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 40266cda08a2SSuzuki K Poulose { 40276cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 40286cda08a2SSuzuki K Poulose } 40296cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 40306cda08a2SSuzuki K Poulose 403165b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 403265b66682SSuzuki K Poulose { 403365b66682SSuzuki K Poulose return dev->of_node == np; 403465b66682SSuzuki K Poulose } 403565b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 403667843bbaSSuzuki K Poulose 403767843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 403867843bbaSSuzuki K Poulose { 403967843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 404067843bbaSSuzuki K Poulose } 404167843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 40424495dfddSSuzuki K Poulose 40434495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 40444495dfddSSuzuki K Poulose { 40454495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 40464495dfddSSuzuki K Poulose } 40474495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 404800500147SSuzuki K Poulose 404900500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 405000500147SSuzuki K Poulose { 405100500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 405200500147SSuzuki K Poulose } 405300500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 40546bf85ba9SSuzuki K Poulose 40556bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 40566bf85ba9SSuzuki K Poulose { 40576bf85ba9SSuzuki K Poulose return 1; 40586bf85ba9SSuzuki K Poulose } 40596bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 4060