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); 36621c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 36744e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 36844e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 36905ef983eSSaravana Kannan goto reorder; 37044e96049SSaravana Kannan } else { 37144e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 3729ed98953SRafael J. Wysocki goto out; 373ead18c23SLukas Wunner } 37444e96049SSaravana Kannan } 3759ed98953SRafael J. Wysocki 37672175d4eSRafael J. Wysocki /* 37772175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 37872175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 37972175d4eSRafael J. Wysocki * update the existing link to stay around longer. 38072175d4eSRafael J. Wysocki */ 38172175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 38272175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 38372175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 38472175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 38572175d4eSRafael J. Wysocki } 38672175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 38772175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 38872175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 38972175d4eSRafael J. Wysocki } 390515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 391515db266SRafael J. Wysocki kref_get(&link->kref); 392515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 393515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 394515db266SRafael J. Wysocki } 39505ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 39605ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 39705ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 39805ef983eSSaravana Kannan goto reorder; 39905ef983eSSaravana Kannan } 40005ef983eSSaravana Kannan 40172175d4eSRafael J. Wysocki goto out; 40272175d4eSRafael J. Wysocki } 40372175d4eSRafael J. Wysocki 40421d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 4059ed98953SRafael J. Wysocki if (!link) 4069ed98953SRafael J. Wysocki goto out; 4079ed98953SRafael J. Wysocki 408e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 409e2f3cd83SRafael J. Wysocki 410baa8809fSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 411e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 41236003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 413e2f3cd83SRafael J. Wysocki 4144c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 41521d5c57bSRafael J. Wysocki } 416e2f3cd83SRafael J. Wysocki 4179ed98953SRafael J. Wysocki get_device(supplier); 4189ed98953SRafael J. Wysocki link->supplier = supplier; 4199ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 4209ed98953SRafael J. Wysocki get_device(consumer); 4219ed98953SRafael J. Wysocki link->consumer = consumer; 4229ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 4239ed98953SRafael J. Wysocki link->flags = flags; 424ead18c23SLukas Wunner kref_init(&link->kref); 4259ed98953SRafael J. Wysocki 42664df1148SLukas Wunner /* Determine the initial link state. */ 427515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 4289ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 429515db266SRafael J. Wysocki else 430515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 4319ed98953SRafael J. Wysocki 4329ed98953SRafael J. Wysocki /* 43315cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 43415cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 43515cfb094SRafael J. Wysocki */ 43615cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 43715cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 43815cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 43915cfb094SRafael J. Wysocki 44021c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 44121c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 44221c27f06SSaravana Kannan 44305ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 44405ef983eSSaravana Kannan dev_dbg(consumer, 44505ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 44605ef983eSSaravana Kannan dev_name(supplier)); 44705ef983eSSaravana Kannan goto out; 44805ef983eSSaravana Kannan } 44921c27f06SSaravana Kannan 45005ef983eSSaravana Kannan reorder: 45115cfb094SRafael J. Wysocki /* 4529ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 4539ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 4549ed98953SRafael J. Wysocki * 4559ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 4569ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 4579ed98953SRafael J. Wysocki */ 4589ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 4599ed98953SRafael J. Wysocki 4608a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 4619ed98953SRafael J. Wysocki 4629ed98953SRafael J. Wysocki out: 4639ed98953SRafael J. Wysocki device_pm_unlock(); 4649ed98953SRafael J. Wysocki device_links_write_unlock(); 4655db25c9eSRafael J. Wysocki 466e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 4675db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 4685db25c9eSRafael J. Wysocki 4699ed98953SRafael J. Wysocki return link; 4709ed98953SRafael J. Wysocki } 4719ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 4729ed98953SRafael J. Wysocki 473e2ae9bccSSaravana Kannan /** 474e2ae9bccSSaravana Kannan * device_link_wait_for_supplier - Add device to wait_for_suppliers list 475e2ae9bccSSaravana Kannan * @consumer: Consumer device 476e2ae9bccSSaravana Kannan * 477e2ae9bccSSaravana Kannan * Marks the @consumer device as waiting for suppliers to become available by 478e2ae9bccSSaravana Kannan * adding it to the wait_for_suppliers list. The consumer device will never be 479e2ae9bccSSaravana Kannan * probed until it's removed from the wait_for_suppliers list. 480e2ae9bccSSaravana Kannan * 481e2ae9bccSSaravana Kannan * The caller is responsible for adding the links to the supplier devices once 482e2ae9bccSSaravana Kannan * they are available and removing the @consumer device from the 483e2ae9bccSSaravana Kannan * wait_for_suppliers list once links to all the suppliers have been created. 484e2ae9bccSSaravana Kannan * 485e2ae9bccSSaravana Kannan * This function is NOT meant to be called from the probe function of the 486e2ae9bccSSaravana Kannan * consumer but rather from code that creates/adds the consumer device. 487e2ae9bccSSaravana Kannan */ 488bcbbcfd5SSaravana Kannan static void device_link_wait_for_supplier(struct device *consumer, 489bcbbcfd5SSaravana Kannan bool need_for_probe) 490e2ae9bccSSaravana Kannan { 491e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 492e2ae9bccSSaravana Kannan list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers); 493bcbbcfd5SSaravana Kannan consumer->links.need_for_probe = need_for_probe; 494e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 495e2ae9bccSSaravana Kannan } 496e2ae9bccSSaravana Kannan 497bcbbcfd5SSaravana Kannan static void device_link_wait_for_mandatory_supplier(struct device *consumer) 498bcbbcfd5SSaravana Kannan { 499bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, true); 500bcbbcfd5SSaravana Kannan } 501bcbbcfd5SSaravana Kannan 502bcbbcfd5SSaravana Kannan static void device_link_wait_for_optional_supplier(struct device *consumer) 503bcbbcfd5SSaravana Kannan { 504bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, false); 505bcbbcfd5SSaravana Kannan } 506bcbbcfd5SSaravana Kannan 507e2ae9bccSSaravana Kannan /** 508e2ae9bccSSaravana Kannan * device_link_add_missing_supplier_links - Add links from consumer devices to 509e2ae9bccSSaravana Kannan * supplier devices, leaving any 510e2ae9bccSSaravana Kannan * consumer with inactive suppliers on 511e2ae9bccSSaravana Kannan * the wait_for_suppliers list 512e2ae9bccSSaravana Kannan * 513e2ae9bccSSaravana Kannan * Loops through all consumers waiting on suppliers and tries to add all their 514e2ae9bccSSaravana Kannan * supplier links. If that succeeds, the consumer device is removed from 515e2ae9bccSSaravana Kannan * wait_for_suppliers list. Otherwise, they are left in the wait_for_suppliers 516e2ae9bccSSaravana Kannan * list. Devices left on the wait_for_suppliers list will not be probed. 517e2ae9bccSSaravana Kannan * 518e2ae9bccSSaravana Kannan * The fwnode add_links callback is expected to return 0 if it has found and 519e2ae9bccSSaravana Kannan * added all the supplier links for the consumer device. It should return an 520e2ae9bccSSaravana Kannan * error if it isn't able to do so. 521e2ae9bccSSaravana Kannan * 522e2ae9bccSSaravana Kannan * The caller of device_link_wait_for_supplier() is expected to call this once 523e2ae9bccSSaravana Kannan * it's aware of potential suppliers becoming available. 524e2ae9bccSSaravana Kannan */ 525e2ae9bccSSaravana Kannan static void device_link_add_missing_supplier_links(void) 526e2ae9bccSSaravana Kannan { 527e2ae9bccSSaravana Kannan struct device *dev, *tmp; 528e2ae9bccSSaravana Kannan 529e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 530e2ae9bccSSaravana Kannan list_for_each_entry_safe(dev, tmp, &wait_for_suppliers, 5311745d299SSaravana Kannan links.needs_suppliers) { 5321745d299SSaravana Kannan int ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 5331745d299SSaravana Kannan if (!ret) 534e2ae9bccSSaravana Kannan list_del_init(&dev->links.needs_suppliers); 535716a7a25SSaravana Kannan else if (ret != -ENODEV || fw_devlink_is_permissive()) 5361745d299SSaravana Kannan dev->links.need_for_probe = false; 5371745d299SSaravana Kannan } 538e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 539e2ae9bccSSaravana Kannan } 540e2ae9bccSSaravana Kannan 5419ed98953SRafael J. Wysocki static void device_link_free(struct device_link *link) 5429ed98953SRafael J. Wysocki { 543a1fdbfbbSRafael J. Wysocki while (refcount_dec_not_one(&link->rpm_active)) 544a1fdbfbbSRafael J. Wysocki pm_runtime_put(link->supplier); 545a1fdbfbbSRafael J. Wysocki 5469ed98953SRafael J. Wysocki put_device(link->consumer); 5479ed98953SRafael J. Wysocki put_device(link->supplier); 5489ed98953SRafael J. Wysocki kfree(link); 5499ed98953SRafael J. Wysocki } 5509ed98953SRafael J. Wysocki 5519ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 5529ed98953SRafael J. Wysocki static void __device_link_free_srcu(struct rcu_head *rhead) 5539ed98953SRafael J. Wysocki { 5549ed98953SRafael J. Wysocki device_link_free(container_of(rhead, struct device_link, rcu_head)); 5559ed98953SRafael J. Wysocki } 5569ed98953SRafael J. Wysocki 557ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5589ed98953SRafael J. Wysocki { 559ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 560ead18c23SLukas Wunner 5618a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 5629ed98953SRafael J. Wysocki dev_name(link->supplier)); 5639ed98953SRafael J. Wysocki 564baa8809fSRafael J. Wysocki if (link->flags & DL_FLAG_PM_RUNTIME) 565baa8809fSRafael J. Wysocki pm_runtime_drop_link(link->consumer); 566baa8809fSRafael J. Wysocki 5679ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 5689ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 5699ed98953SRafael J. Wysocki call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 5709ed98953SRafael J. Wysocki } 5719ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 572ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 5739ed98953SRafael J. Wysocki { 574ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 575ead18c23SLukas Wunner 5769ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 5779ed98953SRafael J. Wysocki dev_name(link->supplier)); 5789ed98953SRafael J. Wysocki 579433986c2SLukas Wunner if (link->flags & DL_FLAG_PM_RUNTIME) 580433986c2SLukas Wunner pm_runtime_drop_link(link->consumer); 581433986c2SLukas Wunner 5829ed98953SRafael J. Wysocki list_del(&link->s_node); 5839ed98953SRafael J. Wysocki list_del(&link->c_node); 5849ed98953SRafael J. Wysocki device_link_free(link); 5859ed98953SRafael J. Wysocki } 5869ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 5879ed98953SRafael J. Wysocki 58872175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 58972175d4eSRafael J. Wysocki { 59072175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 59172175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 59272175d4eSRafael J. Wysocki else 59372175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 59472175d4eSRafael J. Wysocki } 59572175d4eSRafael J. Wysocki 5969ed98953SRafael J. Wysocki /** 59772175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 5989ed98953SRafael J. Wysocki * @link: Device link to delete. 5999ed98953SRafael J. Wysocki * 6009ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 601ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 602ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 603ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 6049ed98953SRafael J. Wysocki */ 6059ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 6069ed98953SRafael J. Wysocki { 6079ed98953SRafael J. Wysocki device_links_write_lock(); 6089ed98953SRafael J. Wysocki device_pm_lock(); 60972175d4eSRafael J. Wysocki device_link_put_kref(link); 6109ed98953SRafael J. Wysocki device_pm_unlock(); 6119ed98953SRafael J. Wysocki device_links_write_unlock(); 6129ed98953SRafael J. Wysocki } 6139ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 6149ed98953SRafael J. Wysocki 615d8842211Spascal paillet /** 61672175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 617d8842211Spascal paillet * @consumer: Consumer end of the link. 618d8842211Spascal paillet * @supplier: Supplier end of the link. 619d8842211Spascal paillet * 620d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 621d8842211Spascal paillet * PM. 622d8842211Spascal paillet */ 623d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 624d8842211Spascal paillet { 625d8842211Spascal paillet struct device_link *link; 626d8842211Spascal paillet 627d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 628d8842211Spascal paillet return; 629d8842211Spascal paillet 630d8842211Spascal paillet device_links_write_lock(); 631d8842211Spascal paillet device_pm_lock(); 632d8842211Spascal paillet 633d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 634d8842211Spascal paillet if (link->consumer == consumer) { 63572175d4eSRafael J. Wysocki device_link_put_kref(link); 636d8842211Spascal paillet break; 637d8842211Spascal paillet } 638d8842211Spascal paillet } 639d8842211Spascal paillet 640d8842211Spascal paillet device_pm_unlock(); 641d8842211Spascal paillet device_links_write_unlock(); 642d8842211Spascal paillet } 643d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 644d8842211Spascal paillet 6459ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 6469ed98953SRafael J. Wysocki { 6479ed98953SRafael J. Wysocki struct device_link *link; 6489ed98953SRafael J. Wysocki 6498c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) { 6508c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE) 6518c3e315dSSaravana Kannan continue; 6528c3e315dSSaravana Kannan 6538c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 6549ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 6558c3e315dSSaravana Kannan } else { 6568c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 6578c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 6588c3e315dSSaravana Kannan } 6598c3e315dSSaravana Kannan } 6609ed98953SRafael J. Wysocki } 6619ed98953SRafael J. Wysocki 6629ed98953SRafael J. Wysocki /** 6639ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 6649ed98953SRafael J. Wysocki * @dev: Consumer device. 6659ed98953SRafael J. Wysocki * 6669ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 6679ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 6689ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 6699ed98953SRafael J. Wysocki * 6709ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 6719ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 6729ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 6739ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 6749ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 6759ed98953SRafael J. Wysocki * 676515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 6779ed98953SRafael J. Wysocki */ 6789ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 6799ed98953SRafael J. Wysocki { 6809ed98953SRafael J. Wysocki struct device_link *link; 6819ed98953SRafael J. Wysocki int ret = 0; 6829ed98953SRafael J. Wysocki 683e2ae9bccSSaravana Kannan /* 684e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 685e2ae9bccSSaravana Kannan * probe. 686e2ae9bccSSaravana Kannan */ 687e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 688bcbbcfd5SSaravana Kannan if (!list_empty(&dev->links.needs_suppliers) && 689bcbbcfd5SSaravana Kannan dev->links.need_for_probe) { 690e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 691e2ae9bccSSaravana Kannan return -EPROBE_DEFER; 692e2ae9bccSSaravana Kannan } 693e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 694e2ae9bccSSaravana Kannan 6959ed98953SRafael J. Wysocki device_links_write_lock(); 6969ed98953SRafael J. Wysocki 6979ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 6988c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 6999ed98953SRafael J. Wysocki continue; 7009ed98953SRafael J. Wysocki 7018c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE && 7028c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { 7039ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 7049ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 7059ed98953SRafael J. Wysocki break; 7069ed98953SRafael J. Wysocki } 7079ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 7089ed98953SRafael J. Wysocki } 7099ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 7109ed98953SRafael J. Wysocki 7119ed98953SRafael J. Wysocki device_links_write_unlock(); 7129ed98953SRafael J. Wysocki return ret; 7139ed98953SRafael J. Wysocki } 7149ed98953SRafael J. Wysocki 71526e77708SSaravana Kannan /** 71626e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 71726e77708SSaravana Kannan * @dev: Device to call sync_state() on 71826e77708SSaravana Kannan * @list: List head to queue the @dev on 71926e77708SSaravana Kannan * 72026e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 72126e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 72226e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 72326e77708SSaravana Kannan * device_links_write_lock() held. 72426e77708SSaravana Kannan * 72526e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 72626e77708SSaravana Kannan * on this list. 72726e77708SSaravana Kannan * 72826e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 72926e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 73026e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 73126e77708SSaravana Kannan * put_device() is called on this device. 73226e77708SSaravana Kannan */ 73326e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 73426e77708SSaravana Kannan struct list_head *list) 735fc5a251dSSaravana Kannan { 736fc5a251dSSaravana Kannan struct device_link *link; 737fc5a251dSSaravana Kannan 73877036165SSaravana Kannan if (!dev_has_sync_state(dev)) 73977036165SSaravana Kannan return; 740fc5a251dSSaravana Kannan if (dev->state_synced) 741fc5a251dSSaravana Kannan return; 742fc5a251dSSaravana Kannan 743fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 744fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 745fc5a251dSSaravana Kannan continue; 746fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 747fc5a251dSSaravana Kannan return; 748fc5a251dSSaravana Kannan } 749fc5a251dSSaravana Kannan 75026e77708SSaravana Kannan /* 75126e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 75226e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 75326e77708SSaravana Kannan * and probed before the list is flushed. 75426e77708SSaravana Kannan */ 75526e77708SSaravana Kannan dev->state_synced = true; 75626e77708SSaravana Kannan 757ec7bd784SSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_hook))) 75826e77708SSaravana Kannan return; 75926e77708SSaravana Kannan 76026e77708SSaravana Kannan get_device(dev); 761ec7bd784SSaravana Kannan list_add_tail(&dev->links.defer_hook, list); 76226e77708SSaravana Kannan } 76326e77708SSaravana Kannan 76426e77708SSaravana Kannan /** 76526e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 76626e77708SSaravana Kannan * @list: List of devices to call sync_state() on 76721eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 76826e77708SSaravana Kannan * 76926e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 77021eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 77121eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 77221eb93f4SSaravana Kannan * context where a device lock is already held. 77326e77708SSaravana Kannan */ 77421eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 77521eb93f4SSaravana Kannan struct device *dont_lock_dev) 77626e77708SSaravana Kannan { 77726e77708SSaravana Kannan struct device *dev, *tmp; 77826e77708SSaravana Kannan 779ec7bd784SSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_hook) { 780ec7bd784SSaravana Kannan list_del_init(&dev->links.defer_hook); 78126e77708SSaravana Kannan 78221eb93f4SSaravana Kannan if (dev != dont_lock_dev) 78326e77708SSaravana Kannan device_lock(dev); 78426e77708SSaravana Kannan 785fc5a251dSSaravana Kannan if (dev->bus->sync_state) 786fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 787fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 788fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 789fc5a251dSSaravana Kannan 79021eb93f4SSaravana Kannan if (dev != dont_lock_dev) 79126e77708SSaravana Kannan device_unlock(dev); 79226e77708SSaravana Kannan 79326e77708SSaravana Kannan put_device(dev); 79426e77708SSaravana Kannan } 795fc5a251dSSaravana Kannan } 796fc5a251dSSaravana Kannan 797fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 798fc5a251dSSaravana Kannan { 799fc5a251dSSaravana Kannan device_links_write_lock(); 800fc5a251dSSaravana Kannan defer_sync_state_count++; 801fc5a251dSSaravana Kannan device_links_write_unlock(); 802fc5a251dSSaravana Kannan } 803fc5a251dSSaravana Kannan 804fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 805fc5a251dSSaravana Kannan { 806fc5a251dSSaravana Kannan struct device *dev, *tmp; 80726e77708SSaravana Kannan LIST_HEAD(sync_list); 808fc5a251dSSaravana Kannan 809fc5a251dSSaravana Kannan device_links_write_lock(); 810fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 811fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 812fc5a251dSSaravana Kannan goto out; 813fc5a251dSSaravana Kannan } 814fc5a251dSSaravana Kannan defer_sync_state_count--; 815fc5a251dSSaravana Kannan if (defer_sync_state_count) 816fc5a251dSSaravana Kannan goto out; 817fc5a251dSSaravana Kannan 818ec7bd784SSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_hook) { 81926e77708SSaravana Kannan /* 82026e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 821ec7bd784SSaravana Kannan * sync_list because defer_hook is used for both lists. 82226e77708SSaravana Kannan */ 823ec7bd784SSaravana Kannan list_del_init(&dev->links.defer_hook); 82426e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 825fc5a251dSSaravana Kannan } 826fc5a251dSSaravana Kannan out: 827fc5a251dSSaravana Kannan device_links_write_unlock(); 82826e77708SSaravana Kannan 82921eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 830fc5a251dSSaravana Kannan } 831fc5a251dSSaravana Kannan 832fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 833fc5a251dSSaravana Kannan { 834fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 835fc5a251dSSaravana Kannan return 0; 836fc5a251dSSaravana Kannan } 837fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 838fc5a251dSSaravana Kannan 839fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 840fc5a251dSSaravana Kannan { 841ec7bd784SSaravana Kannan if (list_empty(&sup->links.defer_hook) && dev_has_sync_state(sup)) 842ec7bd784SSaravana Kannan list_add_tail(&sup->links.defer_hook, &deferred_sync); 843fc5a251dSSaravana Kannan } 844fc5a251dSSaravana Kannan 84521c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link) 84621c27f06SSaravana Kannan { 84721c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED; 84821c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE); 84921c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del); 85021c27f06SSaravana Kannan } 85121c27f06SSaravana Kannan 8529ed98953SRafael J. Wysocki /** 8539ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 8549ed98953SRafael J. Wysocki * @dev: Device to update the links for. 8559ed98953SRafael J. Wysocki * 8569ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 8579ed98953SRafael J. Wysocki * consumers by changing their status to "available". 8589ed98953SRafael J. Wysocki * 8599ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 8609ed98953SRafael J. Wysocki * 861515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 8629ed98953SRafael J. Wysocki */ 8639ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 8649ed98953SRafael J. Wysocki { 86521c27f06SSaravana Kannan struct device_link *link, *ln; 86626e77708SSaravana Kannan LIST_HEAD(sync_list); 8679ed98953SRafael J. Wysocki 868bcbbcfd5SSaravana Kannan /* 869bcbbcfd5SSaravana Kannan * If a device probes successfully, it's expected to have created all 870bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 871bcbbcfd5SSaravana Kannan * them. So, it no longer needs to wait on any suppliers. 872bcbbcfd5SSaravana Kannan */ 873bcbbcfd5SSaravana Kannan mutex_lock(&wfs_lock); 874bcbbcfd5SSaravana Kannan list_del_init(&dev->links.needs_suppliers); 875bcbbcfd5SSaravana Kannan mutex_unlock(&wfs_lock); 876bcbbcfd5SSaravana Kannan 8779ed98953SRafael J. Wysocki device_links_write_lock(); 8789ed98953SRafael J. Wysocki 8799ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 880515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 8819ed98953SRafael J. Wysocki continue; 8829ed98953SRafael J. Wysocki 88315cfb094SRafael J. Wysocki /* 88415cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 88515cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 88615cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 88715cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 88815cfb094SRafael J. Wysocki */ 88915cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 89015cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 89115cfb094SRafael J. Wysocki continue; 89215cfb094SRafael J. Wysocki 8939ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 8949ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 895e7dd4010SRafael J. Wysocki 896e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 897e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 8989ed98953SRafael J. Wysocki } 8999ed98953SRafael J. Wysocki 90021eb93f4SSaravana Kannan if (defer_sync_state_count) 90121eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 90221eb93f4SSaravana Kannan else 90321eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 90421eb93f4SSaravana Kannan 90521c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 90621c27f06SSaravana Kannan struct device *supplier; 90721c27f06SSaravana Kannan 908515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 9099ed98953SRafael J. Wysocki continue; 9109ed98953SRafael J. Wysocki 91121c27f06SSaravana Kannan supplier = link->supplier; 91221c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { 91321c27f06SSaravana Kannan /* 91421c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no 91521c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's 91621c27f06SSaravana Kannan * save to drop the managed link completely. 91721c27f06SSaravana Kannan */ 91821c27f06SSaravana Kannan device_link_drop_managed(link); 91921c27f06SSaravana Kannan } else { 9209ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 9219ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 92221c27f06SSaravana Kannan } 923fc5a251dSSaravana Kannan 92421c27f06SSaravana Kannan /* 92521c27f06SSaravana Kannan * This needs to be done even for the deleted 92621c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last 92721c27f06SSaravana Kannan * device link that was preventing the supplier from getting a 92821c27f06SSaravana Kannan * sync_state() call. 92921c27f06SSaravana Kannan */ 930fc5a251dSSaravana Kannan if (defer_sync_state_count) 93121c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier); 932fc5a251dSSaravana Kannan else 93321c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list); 9349ed98953SRafael J. Wysocki } 9359ed98953SRafael J. Wysocki 9369ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 9379ed98953SRafael J. Wysocki 9389ed98953SRafael J. Wysocki device_links_write_unlock(); 93926e77708SSaravana Kannan 94021eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 9419ed98953SRafael J. Wysocki } 9429ed98953SRafael J. Wysocki 9439ed98953SRafael J. Wysocki /** 9449ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 9459ed98953SRafael J. Wysocki * @dev: Device without a drvier. 9469ed98953SRafael J. Wysocki * 9479ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 9489ed98953SRafael J. Wysocki * 9499ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 9509ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 9519ed98953SRafael J. Wysocki * case they need not be updated. 9529ed98953SRafael J. Wysocki * 953515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 9549ed98953SRafael J. Wysocki */ 9559ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 9569ed98953SRafael J. Wysocki { 9579ed98953SRafael J. Wysocki struct device_link *link, *ln; 9589ed98953SRafael J. Wysocki 9599ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 960515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 9619ed98953SRafael J. Wysocki continue; 9629ed98953SRafael J. Wysocki 9638c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 964515db266SRafael J. Wysocki device_link_drop_managed(link); 9658c3e315dSSaravana Kannan continue; 9668c3e315dSSaravana Kannan } 9678c3e315dSSaravana Kannan 9688c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE && 9698c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE) 9708c3e315dSSaravana Kannan continue; 9718c3e315dSSaravana Kannan 9728c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 9739ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 9748c3e315dSSaravana Kannan } else { 9758c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 9768c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 9778c3e315dSSaravana Kannan } 9789ed98953SRafael J. Wysocki } 9799ed98953SRafael J. Wysocki 9809ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 9819ed98953SRafael J. Wysocki } 9829ed98953SRafael J. Wysocki 98315cfb094SRafael J. Wysocki /** 98415cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 98515cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 98615cfb094SRafael J. Wysocki * 98715cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 98815cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 98915cfb094SRafael J. Wysocki * appropriate. 99015cfb094SRafael J. Wysocki * 991515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 99215cfb094SRafael J. Wysocki */ 9939ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 9949ed98953SRafael J. Wysocki { 99515cfb094SRafael J. Wysocki struct device_link *link; 99615cfb094SRafael J. Wysocki 9979ed98953SRafael J. Wysocki device_links_write_lock(); 99815cfb094SRafael J. Wysocki 99915cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1000515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 100115cfb094SRafael J. Wysocki continue; 100215cfb094SRafael J. Wysocki 100315cfb094SRafael J. Wysocki /* 100415cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 100515cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 100615cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 100715cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 100815cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 100915cfb094SRafael J. Wysocki */ 101015cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 101115cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 101215cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 101315cfb094SRafael J. Wysocki } 101415cfb094SRafael J. Wysocki 10159ed98953SRafael J. Wysocki __device_links_no_driver(dev); 101615cfb094SRafael J. Wysocki 10179ed98953SRafael J. Wysocki device_links_write_unlock(); 10189ed98953SRafael J. Wysocki } 10199ed98953SRafael J. Wysocki 10209ed98953SRafael J. Wysocki /** 10219ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 10229ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 10239ed98953SRafael J. Wysocki * 10249ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 10259ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 10269ed98953SRafael J. Wysocki * appropriate. 10279ed98953SRafael J. Wysocki * 1028515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10299ed98953SRafael J. Wysocki */ 10309ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 10319ed98953SRafael J. Wysocki { 1032c8d50986SRafael J. Wysocki struct device_link *link, *ln; 10339ed98953SRafael J. Wysocki 10349ed98953SRafael J. Wysocki device_links_write_lock(); 10359ed98953SRafael J. Wysocki 1036c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1037515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 10389ed98953SRafael J. Wysocki continue; 10399ed98953SRafael J. Wysocki 1040e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 10419ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 10421689cac5SVivek Gautam 10431689cac5SVivek Gautam /* 10441689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 10451689cac5SVivek Gautam * devices that are not active, i.e. where the link state 10461689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 10471689cac5SVivek Gautam */ 10481689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 10491689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1050515db266SRafael J. Wysocki device_link_drop_managed(link); 10511689cac5SVivek Gautam 10529ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 10539ed98953SRafael J. Wysocki } 10549ed98953SRafael J. Wysocki 1055ec7bd784SSaravana Kannan list_del_init(&dev->links.defer_hook); 10569ed98953SRafael J. Wysocki __device_links_no_driver(dev); 10579ed98953SRafael J. Wysocki 10589ed98953SRafael J. Wysocki device_links_write_unlock(); 10599ed98953SRafael J. Wysocki } 10609ed98953SRafael J. Wysocki 10619ed98953SRafael J. Wysocki /** 10629ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 10639ed98953SRafael J. Wysocki * @dev: Device to check. 10649ed98953SRafael J. Wysocki * 10659ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 10669ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 10679ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 10689ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 10699ed98953SRafael J. Wysocki * successfully going forward. 10709ed98953SRafael J. Wysocki * 10719ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 10729ed98953SRafael J. Wysocki * 1073515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10749ed98953SRafael J. Wysocki */ 10759ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 10769ed98953SRafael J. Wysocki { 10779ed98953SRafael J. Wysocki struct device_link *link; 10789ed98953SRafael J. Wysocki bool ret = false; 10799ed98953SRafael J. Wysocki 10809ed98953SRafael J. Wysocki device_links_write_lock(); 10819ed98953SRafael J. Wysocki 10829ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1083515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 10849ed98953SRafael J. Wysocki continue; 10859ed98953SRafael J. Wysocki 10869ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 10879ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 10889ed98953SRafael J. Wysocki ret = true; 10899ed98953SRafael J. Wysocki break; 10909ed98953SRafael J. Wysocki } 10919ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 10929ed98953SRafael J. Wysocki } 10939ed98953SRafael J. Wysocki 10949ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 10959ed98953SRafael J. Wysocki 10969ed98953SRafael J. Wysocki device_links_write_unlock(); 10979ed98953SRafael J. Wysocki return ret; 10989ed98953SRafael J. Wysocki } 10999ed98953SRafael J. Wysocki 11009ed98953SRafael J. Wysocki /** 11019ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 11029ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 11039ed98953SRafael J. Wysocki * 11049ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 11059ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 11069ed98953SRafael J. Wysocki * and start over. 11079ed98953SRafael J. Wysocki * 11089ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 11099ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 11109ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 11119ed98953SRafael J. Wysocki * changed the state of the link already). 11129ed98953SRafael J. Wysocki * 1113515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 11149ed98953SRafael J. Wysocki */ 11159ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 11169ed98953SRafael J. Wysocki { 11179ed98953SRafael J. Wysocki struct device_link *link; 11189ed98953SRafael J. Wysocki 11199ed98953SRafael J. Wysocki start: 11209ed98953SRafael J. Wysocki device_links_write_lock(); 11219ed98953SRafael J. Wysocki 11229ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 11239ed98953SRafael J. Wysocki enum device_link_state status; 11249ed98953SRafael J. Wysocki 112505ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 112605ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 11279ed98953SRafael J. Wysocki continue; 11289ed98953SRafael J. Wysocki 11299ed98953SRafael J. Wysocki status = link->status; 11309ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 11319ed98953SRafael J. Wysocki device_links_write_unlock(); 11329ed98953SRafael J. Wysocki 11339ed98953SRafael J. Wysocki wait_for_device_probe(); 11349ed98953SRafael J. Wysocki goto start; 11359ed98953SRafael J. Wysocki } 11369ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 11379ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 11389ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 11399ed98953SRafael J. Wysocki 11409ed98953SRafael J. Wysocki get_device(consumer); 11419ed98953SRafael J. Wysocki 11429ed98953SRafael J. Wysocki device_links_write_unlock(); 11439ed98953SRafael J. Wysocki 11449ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 11459ed98953SRafael J. Wysocki consumer->parent); 11469ed98953SRafael J. Wysocki put_device(consumer); 11479ed98953SRafael J. Wysocki goto start; 11489ed98953SRafael J. Wysocki } 11499ed98953SRafael J. Wysocki } 11509ed98953SRafael J. Wysocki 11519ed98953SRafael J. Wysocki device_links_write_unlock(); 11529ed98953SRafael J. Wysocki } 11539ed98953SRafael J. Wysocki 11549ed98953SRafael J. Wysocki /** 11559ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 11569ed98953SRafael J. Wysocki * @dev: Target device. 11579ed98953SRafael J. Wysocki */ 11589ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 11599ed98953SRafael J. Wysocki { 11609ed98953SRafael J. Wysocki struct device_link *link, *ln; 11619ed98953SRafael J. Wysocki 1162e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 1163e2ae9bccSSaravana Kannan list_del(&dev->links.needs_suppliers); 1164e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 1165e2ae9bccSSaravana Kannan 11669ed98953SRafael J. Wysocki /* 11679ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 11689ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 11699ed98953SRafael J. Wysocki */ 11709ed98953SRafael J. Wysocki device_links_write_lock(); 11719ed98953SRafael J. Wysocki 11729ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 11739ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1174ead18c23SLukas Wunner __device_link_del(&link->kref); 11759ed98953SRafael J. Wysocki } 11769ed98953SRafael J. Wysocki 11779ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 11789ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 11799ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1180ead18c23SLukas Wunner __device_link_del(&link->kref); 11819ed98953SRafael J. Wysocki } 11829ed98953SRafael J. Wysocki 11839ed98953SRafael J. Wysocki device_links_write_unlock(); 11849ed98953SRafael J. Wysocki } 11859ed98953SRafael J. Wysocki 118642926ac3SSaravana Kannan static u32 fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY; 118742926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 118842926ac3SSaravana Kannan { 118942926ac3SSaravana Kannan if (!arg) 119042926ac3SSaravana Kannan return -EINVAL; 119142926ac3SSaravana Kannan 119242926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 119342926ac3SSaravana Kannan fw_devlink_flags = 0; 119442926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 119542926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY; 119642926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 119742926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER; 119842926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 119942926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER | 120042926ac3SSaravana Kannan DL_FLAG_PM_RUNTIME; 120142926ac3SSaravana Kannan } 120242926ac3SSaravana Kannan return 0; 120342926ac3SSaravana Kannan } 120442926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 120542926ac3SSaravana Kannan 120642926ac3SSaravana Kannan u32 fw_devlink_get_flags(void) 120742926ac3SSaravana Kannan { 120842926ac3SSaravana Kannan return fw_devlink_flags; 120942926ac3SSaravana Kannan } 121042926ac3SSaravana Kannan 121142926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 121242926ac3SSaravana Kannan { 121342926ac3SSaravana Kannan return fw_devlink_flags == DL_FLAG_SYNC_STATE_ONLY; 121442926ac3SSaravana Kannan } 121542926ac3SSaravana Kannan 12165f5377eaSSaravana Kannan static void fw_devlink_link_device(struct device *dev) 12175f5377eaSSaravana Kannan { 12185f5377eaSSaravana Kannan int fw_ret; 12195f5377eaSSaravana Kannan 1220716a7a25SSaravana Kannan if (!fw_devlink_flags) 1221716a7a25SSaravana Kannan return; 1222716a7a25SSaravana Kannan 1223716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1224716a7a25SSaravana Kannan if (!defer_fw_devlink_count) 12255f5377eaSSaravana Kannan device_link_add_missing_supplier_links(); 12265f5377eaSSaravana Kannan 1227716a7a25SSaravana Kannan /* 1228716a7a25SSaravana Kannan * The device's fwnode not having add_links() doesn't affect if other 1229716a7a25SSaravana Kannan * consumers can find this device as a supplier. So, this check is 1230716a7a25SSaravana Kannan * intentionally placed after device_link_add_missing_supplier_links(). 1231716a7a25SSaravana Kannan */ 1232716a7a25SSaravana Kannan if (!fwnode_has_op(dev->fwnode, add_links)) 1233716a7a25SSaravana Kannan goto out; 1234716a7a25SSaravana Kannan 1235716a7a25SSaravana Kannan /* 1236716a7a25SSaravana Kannan * If fw_devlink is being deferred, assume all devices have mandatory 1237716a7a25SSaravana Kannan * suppliers they need to link to later. Then, when the fw_devlink is 1238716a7a25SSaravana Kannan * resumed, all these devices will get a chance to try and link to any 1239716a7a25SSaravana Kannan * suppliers they have. 1240716a7a25SSaravana Kannan */ 1241716a7a25SSaravana Kannan if (!defer_fw_devlink_count) { 12425f5377eaSSaravana Kannan fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 1243716a7a25SSaravana Kannan if (fw_ret == -ENODEV && fw_devlink_is_permissive()) 1244716a7a25SSaravana Kannan fw_ret = -EAGAIN; 1245716a7a25SSaravana Kannan } else { 1246716a7a25SSaravana Kannan fw_ret = -ENODEV; 1247716a7a25SSaravana Kannan } 1248716a7a25SSaravana Kannan 1249716a7a25SSaravana Kannan if (fw_ret == -ENODEV) 12505f5377eaSSaravana Kannan device_link_wait_for_mandatory_supplier(dev); 12515f5377eaSSaravana Kannan else if (fw_ret) 12525f5377eaSSaravana Kannan device_link_wait_for_optional_supplier(dev); 1253716a7a25SSaravana Kannan 1254716a7a25SSaravana Kannan out: 1255716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 12565f5377eaSSaravana Kannan } 12575f5377eaSSaravana Kannan 1258716a7a25SSaravana Kannan /** 1259716a7a25SSaravana Kannan * fw_devlink_pause - Pause parsing of fwnode to create device links 1260716a7a25SSaravana Kannan * 1261716a7a25SSaravana Kannan * Calling this function defers any fwnode parsing to create device links until 1262716a7a25SSaravana Kannan * fw_devlink_resume() is called. Both these functions are ref counted and the 1263716a7a25SSaravana Kannan * caller needs to match the calls. 1264716a7a25SSaravana Kannan * 1265716a7a25SSaravana Kannan * While fw_devlink is paused: 1266716a7a25SSaravana Kannan * - Any device that is added won't have its fwnode parsed to create device 1267716a7a25SSaravana Kannan * links. 1268716a7a25SSaravana Kannan * - The probe of the device will also be deferred during this period. 1269716a7a25SSaravana Kannan * - Any devices that were already added, but waiting for suppliers won't be 1270716a7a25SSaravana Kannan * able to link to newly added devices. 1271716a7a25SSaravana Kannan * 1272716a7a25SSaravana Kannan * Once fw_devlink_resume(): 1273716a7a25SSaravana Kannan * - All the fwnodes that was not parsed will be parsed. 1274716a7a25SSaravana Kannan * - All the devices that were deferred probing will be reattempted if they 1275716a7a25SSaravana Kannan * aren't waiting for any more suppliers. 1276716a7a25SSaravana Kannan * 1277716a7a25SSaravana Kannan * This pair of functions, is mainly meant to optimize the parsing of fwnodes 1278716a7a25SSaravana Kannan * when a lot of devices that need to link to each other are added in a short 1279716a7a25SSaravana Kannan * interval of time. For example, adding all the top level devices in a system. 1280716a7a25SSaravana Kannan * 1281716a7a25SSaravana Kannan * For example, if N devices are added and: 1282716a7a25SSaravana Kannan * - All the consumers are added before their suppliers 1283716a7a25SSaravana Kannan * - All the suppliers of the N devices are part of the N devices 1284716a7a25SSaravana Kannan * 1285716a7a25SSaravana Kannan * Then: 1286716a7a25SSaravana Kannan * 1287716a7a25SSaravana Kannan * - With the use of fw_devlink_pause() and fw_devlink_resume(), each device 1288716a7a25SSaravana Kannan * will only need one parsing of its fwnode because it is guaranteed to find 1289716a7a25SSaravana Kannan * all the supplier devices already registered and ready to link to. It won't 1290716a7a25SSaravana Kannan * have to do another pass later to find one or more suppliers it couldn't 1291716a7a25SSaravana Kannan * find in the first parse of the fwnode. So, we'll only need O(N) fwnode 1292716a7a25SSaravana Kannan * parses. 1293716a7a25SSaravana Kannan * 1294716a7a25SSaravana Kannan * - Without the use of fw_devlink_pause() and fw_devlink_resume(), we would 1295716a7a25SSaravana Kannan * end up doing O(N^2) parses of fwnodes because every device that's added is 1296716a7a25SSaravana Kannan * guaranteed to trigger a parse of the fwnode of every device added before 1297716a7a25SSaravana Kannan * it. This O(N^2) parse is made worse by the fact that when a fwnode of a 1298716a7a25SSaravana Kannan * device is parsed, all it descendant devices might need to have their 1299716a7a25SSaravana Kannan * fwnodes parsed too (even if the devices themselves aren't added). 1300716a7a25SSaravana Kannan */ 1301716a7a25SSaravana Kannan void fw_devlink_pause(void) 1302716a7a25SSaravana Kannan { 1303716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1304716a7a25SSaravana Kannan defer_fw_devlink_count++; 1305716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 1306716a7a25SSaravana Kannan } 1307716a7a25SSaravana Kannan 1308716a7a25SSaravana Kannan /** fw_devlink_resume - Resume parsing of fwnode to create device links 1309716a7a25SSaravana Kannan * 1310716a7a25SSaravana Kannan * This function is used in conjunction with fw_devlink_pause() and is ref 1311716a7a25SSaravana Kannan * counted. See documentation for fw_devlink_pause() for more details. 1312716a7a25SSaravana Kannan */ 1313716a7a25SSaravana Kannan void fw_devlink_resume(void) 1314716a7a25SSaravana Kannan { 1315716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1316716a7a25SSaravana Kannan if (!defer_fw_devlink_count) { 1317716a7a25SSaravana Kannan WARN(true, "Unmatched fw_devlink pause/resume!"); 1318716a7a25SSaravana Kannan goto out; 1319716a7a25SSaravana Kannan } 1320716a7a25SSaravana Kannan 1321716a7a25SSaravana Kannan defer_fw_devlink_count--; 1322716a7a25SSaravana Kannan if (defer_fw_devlink_count) 1323716a7a25SSaravana Kannan goto out; 1324716a7a25SSaravana Kannan 1325716a7a25SSaravana Kannan device_link_add_missing_supplier_links(); 1326716a7a25SSaravana Kannan out: 1327716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 1328716a7a25SSaravana Kannan } 13299ed98953SRafael J. Wysocki /* Device links support end. */ 13309ed98953SRafael J. Wysocki 13311da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 13321da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 1333e105b8bfSDan Williams static struct kobject *dev_kobj; 1334e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 1335e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 13361da177e4SLinus Torvalds 13375e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 13385e33bc41SRafael J. Wysocki 13395e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 13405e33bc41SRafael J. Wysocki { 13415e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 13425e33bc41SRafael J. Wysocki } 13435e33bc41SRafael J. Wysocki 13445e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 13455e33bc41SRafael J. Wysocki { 13465e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 13475e33bc41SRafael J. Wysocki } 13485e33bc41SRafael J. Wysocki 13495e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 13505e33bc41SRafael J. Wysocki { 13515e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 13525e33bc41SRafael J. Wysocki return 0; 13535e33bc41SRafael J. Wysocki 13545e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 13555e33bc41SRafael J. Wysocki msleep(5); 13565e33bc41SRafael J. Wysocki return restart_syscall(); 13575e33bc41SRafael J. Wysocki } 13585e33bc41SRafael J. Wysocki 13594e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 13604e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 13614e886c29SGreg Kroah-Hartman { 13624e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 13634e886c29SGreg Kroah-Hartman } 13644e886c29SGreg Kroah-Hartman #else 13654e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 13664e886c29SGreg Kroah-Hartman { 13674e886c29SGreg Kroah-Hartman return 1; 13684e886c29SGreg Kroah-Hartman } 13694e886c29SGreg Kroah-Hartman #endif 13701da177e4SLinus Torvalds 137107de0e86SHeikki Krogerus static int 137207de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 137307de0e86SHeikki Krogerus { 13747847a145SHeikki Krogerus int ret; 13757847a145SHeikki Krogerus 13767847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 13777847a145SHeikki Krogerus if (ret) 13787847a145SHeikki Krogerus return ret; 13797847a145SHeikki Krogerus 138059abd836SHeikki Krogerus ret = software_node_notify(dev, action); 138159abd836SHeikki Krogerus if (ret) 138259abd836SHeikki Krogerus return ret; 138359abd836SHeikki Krogerus 138407de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 138507de0e86SHeikki Krogerus platform_notify(dev); 138607de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 138707de0e86SHeikki Krogerus platform_notify_remove(dev); 138807de0e86SHeikki Krogerus return 0; 138907de0e86SHeikki Krogerus } 139007de0e86SHeikki Krogerus 13913e95637aSAlan Stern /** 13923e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 13933e95637aSAlan Stern * @dev: struct device to get the name of 13943e95637aSAlan Stern * 13953e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 13969169c012Syan * the device is not bound to a driver, it will return the name of the bus 13973e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 13983e95637aSAlan Stern * string will be returned. 13993e95637aSAlan Stern */ 1400bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 14013e95637aSAlan Stern { 14023589972eSAlan Stern struct device_driver *drv; 14033589972eSAlan Stern 14043589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 14053589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 14063589972eSAlan Stern * never change once they are set, so they don't need special care. 14073589972eSAlan Stern */ 14086aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 14093589972eSAlan Stern return drv ? drv->name : 1410a456b702SJean Delvare (dev->bus ? dev->bus->name : 1411a456b702SJean Delvare (dev->class ? dev->class->name : "")); 14123e95637aSAlan Stern } 1413310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 14143e95637aSAlan Stern 14151da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 14161da177e4SLinus Torvalds 14174a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 14184a3ad20cSGreg Kroah-Hartman char *buf) 14191da177e4SLinus Torvalds { 14201da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1421b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 14224a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds if (dev_attr->show) 142554b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 1426815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 1427a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 1428a52668c6SSergey Senozhatsky dev_attr->show); 1429815d2d50SAndrew Morton } 14301da177e4SLinus Torvalds return ret; 14311da177e4SLinus Torvalds } 14321da177e4SLinus Torvalds 14334a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 14341da177e4SLinus Torvalds const char *buf, size_t count) 14351da177e4SLinus Torvalds { 14361da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1437b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 14384a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds if (dev_attr->store) 144154b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 14421da177e4SLinus Torvalds return ret; 14431da177e4SLinus Torvalds } 14441da177e4SLinus Torvalds 144552cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 14461da177e4SLinus Torvalds .show = dev_attr_show, 14471da177e4SLinus Torvalds .store = dev_attr_store, 14481da177e4SLinus Torvalds }; 14491da177e4SLinus Torvalds 1450ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 1451ca22e56dSKay Sievers 1452ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 1453ca22e56dSKay Sievers struct device_attribute *attr, 1454ca22e56dSKay Sievers const char *buf, size_t size) 1455ca22e56dSKay Sievers { 1456ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1457f88184bfSKaitao cheng int ret; 1458f88184bfSKaitao cheng unsigned long new; 1459f88184bfSKaitao cheng 1460f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 1461f88184bfSKaitao cheng if (ret) 1462f88184bfSKaitao cheng return ret; 1463ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 1464ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1465ca22e56dSKay Sievers return size; 1466ca22e56dSKay Sievers } 1467ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 1468ca22e56dSKay Sievers 1469ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 1470ca22e56dSKay Sievers struct device_attribute *attr, 1471ca22e56dSKay Sievers char *buf) 1472ca22e56dSKay Sievers { 1473ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1474ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 1475ca22e56dSKay Sievers } 1476ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 1477ca22e56dSKay Sievers 1478ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 1479ca22e56dSKay Sievers struct device_attribute *attr, 1480ca22e56dSKay Sievers const char *buf, size_t size) 1481ca22e56dSKay Sievers { 1482ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1483f88184bfSKaitao cheng int ret; 1484f88184bfSKaitao cheng long new; 1485f88184bfSKaitao cheng 1486f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 1487f88184bfSKaitao cheng if (ret) 1488f88184bfSKaitao cheng return ret; 1489f88184bfSKaitao cheng 1490f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 1491ca22e56dSKay Sievers return -EINVAL; 1492ca22e56dSKay Sievers *(int *)(ea->var) = new; 1493ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1494ca22e56dSKay Sievers return size; 1495ca22e56dSKay Sievers } 1496ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 1497ca22e56dSKay Sievers 1498ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 1499ca22e56dSKay Sievers struct device_attribute *attr, 1500ca22e56dSKay Sievers char *buf) 1501ca22e56dSKay Sievers { 1502ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1503ca22e56dSKay Sievers 1504ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 1505ca22e56dSKay Sievers } 1506ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 15071da177e4SLinus Torvalds 150891872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 150991872392SBorislav Petkov const char *buf, size_t size) 151091872392SBorislav Petkov { 151191872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 151291872392SBorislav Petkov 151391872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 151491872392SBorislav Petkov return -EINVAL; 151591872392SBorislav Petkov 151691872392SBorislav Petkov return size; 151791872392SBorislav Petkov } 151891872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 151991872392SBorislav Petkov 152091872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 152191872392SBorislav Petkov char *buf) 152291872392SBorislav Petkov { 152391872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 152491872392SBorislav Petkov 152591872392SBorislav Petkov return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 152691872392SBorislav Petkov } 152791872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 152891872392SBorislav Petkov 15291da177e4SLinus Torvalds /** 15301da177e4SLinus Torvalds * device_release - free device structure. 15311da177e4SLinus Torvalds * @kobj: device's kobject. 15321da177e4SLinus Torvalds * 15331da177e4SLinus Torvalds * This is called once the reference count for the object 15341da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 15351da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 15361da177e4SLinus Torvalds */ 15371da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 15381da177e4SLinus Torvalds { 1539b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1540fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 15411da177e4SLinus Torvalds 1542a525a3ddSMing Lei /* 1543a525a3ddSMing Lei * Some platform devices are driven without driver attached 1544a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 1545a525a3ddSMing Lei * all resources are released. 1546a525a3ddSMing Lei * 1547a525a3ddSMing Lei * Drivers still can add resources into device after device 1548a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 1549a525a3ddSMing Lei * possible memory leak. 1550a525a3ddSMing Lei */ 1551a525a3ddSMing Lei devres_release_all(dev); 1552a525a3ddSMing Lei 15531da177e4SLinus Torvalds if (dev->release) 15541da177e4SLinus Torvalds dev->release(dev); 1555f9f852dfSKay Sievers else if (dev->type && dev->type->release) 1556f9f852dfSKay Sievers dev->type->release(dev); 15572620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 15582620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 1559f810a5cfSArjan van de Ven else 15600c1bc6b8SMauro Carvalho Chehab WARN(1, KERN_ERR "Device '%s' does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kobject.rst.\n", 15611e0b2cf9SKay Sievers dev_name(dev)); 1562fb069a5dSGreg Kroah-Hartman kfree(p); 15631da177e4SLinus Torvalds } 15641da177e4SLinus Torvalds 1565bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 1566bc451f20SEric W. Biederman { 1567b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1568bc451f20SEric W. Biederman const void *ns = NULL; 1569bc451f20SEric W. Biederman 1570bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 1571bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 1572bc451f20SEric W. Biederman 1573bc451f20SEric W. Biederman return ns; 1574bc451f20SEric W. Biederman } 1575bc451f20SEric W. Biederman 15769944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 15779944e894SDmitry Torokhov { 15789944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 15799944e894SDmitry Torokhov 15809944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 15819944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 15829944e894SDmitry Torokhov } 15839944e894SDmitry Torokhov 15848f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 15851da177e4SLinus Torvalds .release = device_release, 15861da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 1587bc451f20SEric W. Biederman .namespace = device_namespace, 15889944e894SDmitry Torokhov .get_ownership = device_get_ownership, 15891da177e4SLinus Torvalds }; 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds 1592312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 15931da177e4SLinus Torvalds { 15941da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 15951da177e4SLinus Torvalds 15968f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 1597b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 15981da177e4SLinus Torvalds if (dev->bus) 15991da177e4SLinus Torvalds return 1; 160023681e47SGreg Kroah-Hartman if (dev->class) 160123681e47SGreg Kroah-Hartman return 1; 16021da177e4SLinus Torvalds } 16031da177e4SLinus Torvalds return 0; 16041da177e4SLinus Torvalds } 16051da177e4SLinus Torvalds 1606312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 16071da177e4SLinus Torvalds { 1608b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 16091da177e4SLinus Torvalds 161023681e47SGreg Kroah-Hartman if (dev->bus) 16111da177e4SLinus Torvalds return dev->bus->name; 161223681e47SGreg Kroah-Hartman if (dev->class) 161323681e47SGreg Kroah-Hartman return dev->class->name; 161423681e47SGreg Kroah-Hartman return NULL; 16151da177e4SLinus Torvalds } 16161da177e4SLinus Torvalds 16177eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 16187eff2e7aSKay Sievers struct kobj_uevent_env *env) 16191da177e4SLinus Torvalds { 1620b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 16211da177e4SLinus Torvalds int retval = 0; 16221da177e4SLinus Torvalds 16236fcf53acSKay Sievers /* add device node properties if present */ 162423681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 16256fcf53acSKay Sievers const char *tmp; 16266fcf53acSKay Sievers const char *name; 16272c9ede55SAl Viro umode_t mode = 0; 16284e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 16294e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 16306fcf53acSKay Sievers 16317eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 16327eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 16333c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 16346fcf53acSKay Sievers if (name) { 16356fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 1636e454cea2SKay Sievers if (mode) 1637e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 16384e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 16394e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 16404e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 16414e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 16423c2670e6SKay Sievers kfree(tmp); 16436fcf53acSKay Sievers } 164423681e47SGreg Kroah-Hartman } 164523681e47SGreg Kroah-Hartman 1646414264f9SKay Sievers if (dev->type && dev->type->name) 16477eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 1648414264f9SKay Sievers 1649239378f1SKay Sievers if (dev->driver) 16507eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 1651239378f1SKay Sievers 165207d57a32SGrant Likely /* Add common DT information about the device */ 165307d57a32SGrant Likely of_device_uevent(dev, env); 165407d57a32SGrant Likely 16551da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 16567eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 16577eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 1658f9f852dfSKay Sievers if (retval) 16597dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 16601e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 16611da177e4SLinus Torvalds } 16621da177e4SLinus Torvalds 16632620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 16647eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 16657eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 1666f9f852dfSKay Sievers if (retval) 16677dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 16681e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 16692b3a302aSHarvey Harrison __func__, retval); 16702620efefSGreg Kroah-Hartman } 1671f9f852dfSKay Sievers 1672eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 16737eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 16747eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 1675f9f852dfSKay Sievers if (retval) 16767dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 16771e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 16782b3a302aSHarvey Harrison __func__, retval); 16792620efefSGreg Kroah-Hartman } 16802620efefSGreg Kroah-Hartman 16811da177e4SLinus Torvalds return retval; 16821da177e4SLinus Torvalds } 16831da177e4SLinus Torvalds 16849cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 1685312c004dSKay Sievers .filter = dev_uevent_filter, 1686312c004dSKay Sievers .name = dev_uevent_name, 1687312c004dSKay Sievers .uevent = dev_uevent, 16881da177e4SLinus Torvalds }; 16891da177e4SLinus Torvalds 1690c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 169116574dccSKay Sievers char *buf) 169216574dccSKay Sievers { 169316574dccSKay Sievers struct kobject *top_kobj; 169416574dccSKay Sievers struct kset *kset; 16957eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 169616574dccSKay Sievers int i; 169716574dccSKay Sievers size_t count = 0; 169816574dccSKay Sievers int retval; 169916574dccSKay Sievers 170016574dccSKay Sievers /* search the kset, the device belongs to */ 170116574dccSKay Sievers top_kobj = &dev->kobj; 17025c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 170316574dccSKay Sievers top_kobj = top_kobj->parent; 170416574dccSKay Sievers if (!top_kobj->kset) 170516574dccSKay Sievers goto out; 17065c5daf65SKay Sievers 170716574dccSKay Sievers kset = top_kobj->kset; 170816574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 170916574dccSKay Sievers goto out; 171016574dccSKay Sievers 171116574dccSKay Sievers /* respect filter */ 171216574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 171316574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 171416574dccSKay Sievers goto out; 171516574dccSKay Sievers 17167eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 17177eff2e7aSKay Sievers if (!env) 1718c7308c81SGreg Kroah-Hartman return -ENOMEM; 1719c7308c81SGreg Kroah-Hartman 172016574dccSKay Sievers /* let the kset specific function add its keys */ 17217eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 172216574dccSKay Sievers if (retval) 172316574dccSKay Sievers goto out; 172416574dccSKay Sievers 172516574dccSKay Sievers /* copy keys to file */ 17267eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 17277eff2e7aSKay Sievers count += sprintf(&buf[count], "%s\n", env->envp[i]); 172816574dccSKay Sievers out: 17297eff2e7aSKay Sievers kfree(env); 173016574dccSKay Sievers return count; 173116574dccSKay Sievers } 173216574dccSKay Sievers 1733c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 1734a7fd6706SKay Sievers const char *buf, size_t count) 1735a7fd6706SKay Sievers { 1736df44b479SPeter Rajnoha int rc; 1737df44b479SPeter Rajnoha 1738df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 1739df44b479SPeter Rajnoha 1740df44b479SPeter Rajnoha if (rc) { 1741f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 1742df44b479SPeter Rajnoha return rc; 1743df44b479SPeter Rajnoha } 174460a96a59SKay Sievers 1745a7fd6706SKay Sievers return count; 1746a7fd6706SKay Sievers } 1747c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 1748a7fd6706SKay Sievers 1749c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 17504f3549d7SRafael J. Wysocki char *buf) 17514f3549d7SRafael J. Wysocki { 17524f3549d7SRafael J. Wysocki bool val; 17534f3549d7SRafael J. Wysocki 17545e33bc41SRafael J. Wysocki device_lock(dev); 17554f3549d7SRafael J. Wysocki val = !dev->offline; 17565e33bc41SRafael J. Wysocki device_unlock(dev); 17574f3549d7SRafael J. Wysocki return sprintf(buf, "%u\n", val); 17584f3549d7SRafael J. Wysocki } 17594f3549d7SRafael J. Wysocki 1760c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 17614f3549d7SRafael J. Wysocki const char *buf, size_t count) 17624f3549d7SRafael J. Wysocki { 17634f3549d7SRafael J. Wysocki bool val; 17644f3549d7SRafael J. Wysocki int ret; 17654f3549d7SRafael J. Wysocki 17664f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 17674f3549d7SRafael J. Wysocki if (ret < 0) 17684f3549d7SRafael J. Wysocki return ret; 17694f3549d7SRafael J. Wysocki 17705e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 17715e33bc41SRafael J. Wysocki if (ret) 17725e33bc41SRafael J. Wysocki return ret; 17735e33bc41SRafael J. Wysocki 17744f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 17754f3549d7SRafael J. Wysocki unlock_device_hotplug(); 17764f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 17774f3549d7SRafael J. Wysocki } 1778c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 17794f3549d7SRafael J. Wysocki 1780fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 1781621a1672SDmitry Torokhov { 17823e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 1783621a1672SDmitry Torokhov } 1784a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 1785621a1672SDmitry Torokhov 1786fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 1787a4dbd674SDavid Brownell const struct attribute_group **groups) 1788621a1672SDmitry Torokhov { 17893e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 1790621a1672SDmitry Torokhov } 1791a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 1792de0ff00dSGreg Kroah-Hartman 179357b8ff07SDmitry Torokhov union device_attr_group_devres { 179457b8ff07SDmitry Torokhov const struct attribute_group *group; 179557b8ff07SDmitry Torokhov const struct attribute_group **groups; 179657b8ff07SDmitry Torokhov }; 179757b8ff07SDmitry Torokhov 179857b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 179957b8ff07SDmitry Torokhov { 180057b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 180157b8ff07SDmitry Torokhov } 180257b8ff07SDmitry Torokhov 180357b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 180457b8ff07SDmitry Torokhov { 180557b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 180657b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 180757b8ff07SDmitry Torokhov 180857b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 180957b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 181057b8ff07SDmitry Torokhov } 181157b8ff07SDmitry Torokhov 181257b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 181357b8ff07SDmitry Torokhov { 181457b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 181557b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 181657b8ff07SDmitry Torokhov 181757b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 181857b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 181957b8ff07SDmitry Torokhov } 182057b8ff07SDmitry Torokhov 182157b8ff07SDmitry Torokhov /** 182257b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 182357b8ff07SDmitry Torokhov * @dev: The device to create the group for 182457b8ff07SDmitry Torokhov * @grp: The attribute group to create 182557b8ff07SDmitry Torokhov * 182657b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 182757b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 182857b8ff07SDmitry Torokhov * 182957b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 183057b8ff07SDmitry Torokhov */ 183157b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 183257b8ff07SDmitry Torokhov { 183357b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 183457b8ff07SDmitry Torokhov int error; 183557b8ff07SDmitry Torokhov 183657b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 183757b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 183857b8ff07SDmitry Torokhov if (!devres) 183957b8ff07SDmitry Torokhov return -ENOMEM; 184057b8ff07SDmitry Torokhov 184157b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 184257b8ff07SDmitry Torokhov if (error) { 184357b8ff07SDmitry Torokhov devres_free(devres); 184457b8ff07SDmitry Torokhov return error; 184557b8ff07SDmitry Torokhov } 184657b8ff07SDmitry Torokhov 184757b8ff07SDmitry Torokhov devres->group = grp; 184857b8ff07SDmitry Torokhov devres_add(dev, devres); 184957b8ff07SDmitry Torokhov return 0; 185057b8ff07SDmitry Torokhov } 185157b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 185257b8ff07SDmitry Torokhov 185357b8ff07SDmitry Torokhov /** 185457b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 185557b8ff07SDmitry Torokhov * @dev: device to remove the group from 185657b8ff07SDmitry Torokhov * @grp: group to remove 185757b8ff07SDmitry Torokhov * 185857b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 185957b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 186057b8ff07SDmitry Torokhov */ 186157b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 186257b8ff07SDmitry Torokhov const struct attribute_group *grp) 186357b8ff07SDmitry Torokhov { 186457b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 186557b8ff07SDmitry Torokhov devm_attr_group_match, 186657b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 186757b8ff07SDmitry Torokhov } 186857b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 186957b8ff07SDmitry Torokhov 187057b8ff07SDmitry Torokhov /** 187157b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 187257b8ff07SDmitry Torokhov * @dev: The device to create the group for 187357b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 187457b8ff07SDmitry Torokhov * 187557b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 187657b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 187757b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 187857b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 187957b8ff07SDmitry Torokhov * attribute files being created already exist. 188057b8ff07SDmitry Torokhov * 188157b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 188257b8ff07SDmitry Torokhov */ 188357b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 188457b8ff07SDmitry Torokhov const struct attribute_group **groups) 188557b8ff07SDmitry Torokhov { 188657b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 188757b8ff07SDmitry Torokhov int error; 188857b8ff07SDmitry Torokhov 188957b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 189057b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 189157b8ff07SDmitry Torokhov if (!devres) 189257b8ff07SDmitry Torokhov return -ENOMEM; 189357b8ff07SDmitry Torokhov 189457b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 189557b8ff07SDmitry Torokhov if (error) { 189657b8ff07SDmitry Torokhov devres_free(devres); 189757b8ff07SDmitry Torokhov return error; 189857b8ff07SDmitry Torokhov } 189957b8ff07SDmitry Torokhov 190057b8ff07SDmitry Torokhov devres->groups = groups; 190157b8ff07SDmitry Torokhov devres_add(dev, devres); 190257b8ff07SDmitry Torokhov return 0; 190357b8ff07SDmitry Torokhov } 190457b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 190557b8ff07SDmitry Torokhov 190657b8ff07SDmitry Torokhov /** 190757b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 190857b8ff07SDmitry Torokhov * 190957b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 191057b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 191157b8ff07SDmitry Torokhov * 191257b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 191357b8ff07SDmitry Torokhov */ 191457b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 191557b8ff07SDmitry Torokhov const struct attribute_group **groups) 191657b8ff07SDmitry Torokhov { 191757b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 191857b8ff07SDmitry Torokhov devm_attr_group_match, 191957b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 192057b8ff07SDmitry Torokhov } 192157b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 19221da177e4SLinus Torvalds 19232620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 19242620efefSGreg Kroah-Hartman { 19252620efefSGreg Kroah-Hartman struct class *class = dev->class; 1926aed65af1SStephen Hemminger const struct device_type *type = dev->type; 1927621a1672SDmitry Torokhov int error; 19282620efefSGreg Kroah-Hartman 1929621a1672SDmitry Torokhov if (class) { 1930d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 19312620efefSGreg Kroah-Hartman if (error) 1932621a1672SDmitry Torokhov return error; 1933f9f852dfSKay Sievers } 1934f9f852dfSKay Sievers 1935621a1672SDmitry Torokhov if (type) { 1936621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 1937f9f852dfSKay Sievers if (error) 1938a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 1939f9f852dfSKay Sievers } 1940621a1672SDmitry Torokhov 1941621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 1942f9f852dfSKay Sievers if (error) 1943621a1672SDmitry Torokhov goto err_remove_type_groups; 1944621a1672SDmitry Torokhov 19454f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 1946c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 19474f3549d7SRafael J. Wysocki if (error) 1948ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 19494f3549d7SRafael J. Wysocki } 19504f3549d7SRafael J. Wysocki 1951621a1672SDmitry Torokhov return 0; 1952621a1672SDmitry Torokhov 1953ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 1954ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 1955621a1672SDmitry Torokhov err_remove_type_groups: 1956621a1672SDmitry Torokhov if (type) 1957621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1958d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 1959d05a6f96SGreg Kroah-Hartman if (class) 1960d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1961f9f852dfSKay Sievers 19622620efefSGreg Kroah-Hartman return error; 19632620efefSGreg Kroah-Hartman } 19642620efefSGreg Kroah-Hartman 19652620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 19662620efefSGreg Kroah-Hartman { 19672620efefSGreg Kroah-Hartman struct class *class = dev->class; 1968aed65af1SStephen Hemminger const struct device_type *type = dev->type; 19692620efefSGreg Kroah-Hartman 1970c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 1971621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 1972f9f852dfSKay Sievers 1973621a1672SDmitry Torokhov if (type) 1974621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1975621a1672SDmitry Torokhov 1976a6b01dedSGreg Kroah-Hartman if (class) 1977d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1978c97415a7SStefan Achatz } 19792620efefSGreg Kroah-Hartman 1980c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 198123681e47SGreg Kroah-Hartman char *buf) 198223681e47SGreg Kroah-Hartman { 198323681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 198423681e47SGreg Kroah-Hartman } 1985c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 1986ad6a1e1cSTejun Heo 1987ca22e56dSKay Sievers /* /sys/devices/ */ 1988881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds /** 199152cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 199252cdbdd4SGrygorii Strashko * @deva: Device to move. 199352cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 199452cdbdd4SGrygorii Strashko */ 199552cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 199652cdbdd4SGrygorii Strashko { 199752cdbdd4SGrygorii Strashko if (!devices_kset) 199852cdbdd4SGrygorii Strashko return; 199952cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 200052cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 200152cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 200252cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 200352cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 200452cdbdd4SGrygorii Strashko } 200552cdbdd4SGrygorii Strashko 200652cdbdd4SGrygorii Strashko /** 200752cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 200852cdbdd4SGrygorii Strashko * @deva: Device to move 200952cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 201052cdbdd4SGrygorii Strashko */ 201152cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 201252cdbdd4SGrygorii Strashko { 201352cdbdd4SGrygorii Strashko if (!devices_kset) 201452cdbdd4SGrygorii Strashko return; 201552cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 201652cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 201752cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 201852cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 201952cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 202052cdbdd4SGrygorii Strashko } 202152cdbdd4SGrygorii Strashko 202252cdbdd4SGrygorii Strashko /** 202352cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 202452cdbdd4SGrygorii Strashko * @dev: device to move 202552cdbdd4SGrygorii Strashko */ 202652cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 202752cdbdd4SGrygorii Strashko { 202852cdbdd4SGrygorii Strashko if (!devices_kset) 202952cdbdd4SGrygorii Strashko return; 203052cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 203152cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 203252cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 203352cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 203452cdbdd4SGrygorii Strashko } 203552cdbdd4SGrygorii Strashko 203652cdbdd4SGrygorii Strashko /** 20371da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 20381da177e4SLinus Torvalds * @dev: device. 20391da177e4SLinus Torvalds * @attr: device attribute descriptor. 20401da177e4SLinus Torvalds */ 204126579ab7SPhil Carmody int device_create_file(struct device *dev, 204226579ab7SPhil Carmody const struct device_attribute *attr) 20431da177e4SLinus Torvalds { 20441da177e4SLinus Torvalds int error = 0; 20458f46baaaSFelipe Balbi 20468f46baaaSFelipe Balbi if (dev) { 20478f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 204897521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 204997521978Sdyoung@redhat.com attr->attr.name); 20508f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 205197521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 205297521978Sdyoung@redhat.com attr->attr.name); 20531da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 20548f46baaaSFelipe Balbi } 20558f46baaaSFelipe Balbi 20561da177e4SLinus Torvalds return error; 20571da177e4SLinus Torvalds } 205886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds /** 20611da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 20621da177e4SLinus Torvalds * @dev: device. 20631da177e4SLinus Torvalds * @attr: device attribute descriptor. 20641da177e4SLinus Torvalds */ 206526579ab7SPhil Carmody void device_remove_file(struct device *dev, 206626579ab7SPhil Carmody const struct device_attribute *attr) 20671da177e4SLinus Torvalds { 20680c98b19fSCornelia Huck if (dev) 20691da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 20701da177e4SLinus Torvalds } 207186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 20721da177e4SLinus Torvalds 20732589f188SGreg Kroah-Hartman /** 20746b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 20756b0afc2aSTejun Heo * @dev: device. 20766b0afc2aSTejun Heo * @attr: device attribute descriptor. 20776b0afc2aSTejun Heo * 20786b0afc2aSTejun Heo * See kernfs_remove_self() for details. 20796b0afc2aSTejun Heo */ 20806b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 20816b0afc2aSTejun Heo const struct device_attribute *attr) 20826b0afc2aSTejun Heo { 20836b0afc2aSTejun Heo if (dev) 20846b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 20856b0afc2aSTejun Heo else 20866b0afc2aSTejun Heo return false; 20876b0afc2aSTejun Heo } 20886b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 20896b0afc2aSTejun Heo 20906b0afc2aSTejun Heo /** 20912589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 20922589f188SGreg Kroah-Hartman * @dev: device. 20932589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 20942589f188SGreg Kroah-Hartman */ 209566ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 209666ecb92bSPhil Carmody const struct bin_attribute *attr) 20972589f188SGreg Kroah-Hartman { 20982589f188SGreg Kroah-Hartman int error = -EINVAL; 20992589f188SGreg Kroah-Hartman if (dev) 21002589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 21012589f188SGreg Kroah-Hartman return error; 21022589f188SGreg Kroah-Hartman } 21032589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 21042589f188SGreg Kroah-Hartman 21052589f188SGreg Kroah-Hartman /** 21062589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 21072589f188SGreg Kroah-Hartman * @dev: device. 21082589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 21092589f188SGreg Kroah-Hartman */ 211066ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 211166ecb92bSPhil Carmody const struct bin_attribute *attr) 21122589f188SGreg Kroah-Hartman { 21132589f188SGreg Kroah-Hartman if (dev) 21142589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 21152589f188SGreg Kroah-Hartman } 21162589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 21172589f188SGreg Kroah-Hartman 211834bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 211934bb61f9SJames Bottomley { 2120f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2121f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 212234bb61f9SJames Bottomley 212334bb61f9SJames Bottomley get_device(dev); 212434bb61f9SJames Bottomley } 212534bb61f9SJames Bottomley 212634bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 212734bb61f9SJames Bottomley { 2128f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2129f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 213034bb61f9SJames Bottomley 213134bb61f9SJames Bottomley put_device(dev); 213234bb61f9SJames Bottomley } 213334bb61f9SJames Bottomley 21341da177e4SLinus Torvalds /** 21351da177e4SLinus Torvalds * device_initialize - init device structure. 21361da177e4SLinus Torvalds * @dev: device. 21371da177e4SLinus Torvalds * 21385739411aSCornelia Huck * This prepares the device for use by other layers by initializing 21395739411aSCornelia Huck * its fields. 21401da177e4SLinus Torvalds * It is the first half of device_register(), if called by 21415739411aSCornelia Huck * that function, though it can also be called separately, so one 21425739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 21435739411aSCornelia Huck * may be used for reference counting of @dev after calling this 21445739411aSCornelia Huck * function. 21455739411aSCornelia Huck * 2146b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 2147b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 2148b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 2149b10d5efdSAlan Stern * @dev. 2150b10d5efdSAlan Stern * 21515739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 21525739411aSCornelia Huck * @dev directly once you have called this function. 21531da177e4SLinus Torvalds */ 21541da177e4SLinus Torvalds void device_initialize(struct device *dev) 21551da177e4SLinus Torvalds { 2156881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 2157f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 21581da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 21593142788bSThomas Gleixner mutex_init(&dev->mutex); 216087a30e1fSDan Williams #ifdef CONFIG_PROVE_LOCKING 216187a30e1fSDan Williams mutex_init(&dev->lockdep_mutex); 216287a30e1fSDan Williams #endif 21631704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 21649ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 21659ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 21663b98aeafSAlan Stern device_pm_init(dev); 216787348136SChristoph Hellwig set_dev_node(dev, -1); 21684a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 21694a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 21704a7cc831SJiang Liu #endif 21719ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 21729ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 2173e2ae9bccSSaravana Kannan INIT_LIST_HEAD(&dev->links.needs_suppliers); 2174ec7bd784SSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_hook); 21759ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 21761da177e4SLinus Torvalds } 217786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 21781da177e4SLinus Torvalds 2179d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 2180f0ee61a6SGreg Kroah-Hartman { 2181f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 2182f0ee61a6SGreg Kroah-Hartman 2183f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 21844ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 2185881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 2186f0ee61a6SGreg Kroah-Hartman 218786406245SKay Sievers return virtual_dir; 2188f0ee61a6SGreg Kroah-Hartman } 2189f0ee61a6SGreg Kroah-Hartman 2190bc451f20SEric W. Biederman struct class_dir { 2191bc451f20SEric W. Biederman struct kobject kobj; 2192bc451f20SEric W. Biederman struct class *class; 2193bc451f20SEric W. Biederman }; 2194bc451f20SEric W. Biederman 2195bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 2196bc451f20SEric W. Biederman 2197bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 2198bc451f20SEric W. Biederman { 2199bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2200bc451f20SEric W. Biederman kfree(dir); 2201bc451f20SEric W. Biederman } 2202bc451f20SEric W. Biederman 2203bc451f20SEric W. Biederman static const 2204bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 2205bc451f20SEric W. Biederman { 2206bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2207bc451f20SEric W. Biederman return dir->class->ns_type; 2208bc451f20SEric W. Biederman } 2209bc451f20SEric W. Biederman 2210bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 2211bc451f20SEric W. Biederman .release = class_dir_release, 2212bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 2213bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 2214bc451f20SEric W. Biederman }; 2215bc451f20SEric W. Biederman 2216bc451f20SEric W. Biederman static struct kobject * 2217bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 2218bc451f20SEric W. Biederman { 2219bc451f20SEric W. Biederman struct class_dir *dir; 2220bc451f20SEric W. Biederman int retval; 2221bc451f20SEric W. Biederman 2222bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 2223bc451f20SEric W. Biederman if (!dir) 222484d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 2225bc451f20SEric W. Biederman 2226bc451f20SEric W. Biederman dir->class = class; 2227bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 2228bc451f20SEric W. Biederman 22296b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 2230bc451f20SEric W. Biederman 2231bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 2232bc451f20SEric W. Biederman if (retval < 0) { 2233bc451f20SEric W. Biederman kobject_put(&dir->kobj); 223484d0c27dSTetsuo Handa return ERR_PTR(retval); 2235bc451f20SEric W. Biederman } 2236bc451f20SEric W. Biederman return &dir->kobj; 2237bc451f20SEric W. Biederman } 2238bc451f20SEric W. Biederman 2239e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 2240bc451f20SEric W. Biederman 2241c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 2242c744aeaeSCornelia Huck struct device *parent) 224340fa5422SGreg Kroah-Hartman { 224486406245SKay Sievers if (dev->class) { 224586406245SKay Sievers struct kobject *kobj = NULL; 224686406245SKay Sievers struct kobject *parent_kobj; 224786406245SKay Sievers struct kobject *k; 224886406245SKay Sievers 2249ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 225039aba963SKay Sievers /* block disks show up in /sys/block */ 2251e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 225239aba963SKay Sievers if (parent && parent->class == &block_class) 225339aba963SKay Sievers return &parent->kobj; 22546b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 225539aba963SKay Sievers } 2256ead454feSRandy Dunlap #endif 2257e52eec13SAndi Kleen 225886406245SKay Sievers /* 225986406245SKay Sievers * If we have no parent, we live in "virtual". 22600f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 22610f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 226286406245SKay Sievers */ 226386406245SKay Sievers if (parent == NULL) 226486406245SKay Sievers parent_kobj = virtual_device_parent(dev); 226524b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 226686406245SKay Sievers return &parent->kobj; 226786406245SKay Sievers else 226886406245SKay Sievers parent_kobj = &parent->kobj; 226986406245SKay Sievers 227077d3d7c1STejun Heo mutex_lock(&gdp_mutex); 227177d3d7c1STejun Heo 227286406245SKay Sievers /* find our class-directory at the parent and reference it */ 22736b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 22746b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 227586406245SKay Sievers if (k->parent == parent_kobj) { 227686406245SKay Sievers kobj = kobject_get(k); 227786406245SKay Sievers break; 227886406245SKay Sievers } 22796b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 228077d3d7c1STejun Heo if (kobj) { 228177d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 228286406245SKay Sievers return kobj; 228377d3d7c1STejun Heo } 228486406245SKay Sievers 228586406245SKay Sievers /* or create a new class-directory at the parent device */ 2286bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 22870f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 228877d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 228943968d2fSGreg Kroah-Hartman return k; 229086406245SKay Sievers } 229186406245SKay Sievers 2292ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 2293ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 2294ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 2295ca22e56dSKay Sievers 229686406245SKay Sievers if (parent) 2297c744aeaeSCornelia Huck return &parent->kobj; 2298c744aeaeSCornelia Huck return NULL; 2299c744aeaeSCornelia Huck } 2300da231fd5SKay Sievers 2301cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 2302cebf8fd1SMing Lei struct device *dev) 2303cebf8fd1SMing Lei { 2304cebf8fd1SMing Lei if (!kobj || !dev->class || 2305cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 2306cebf8fd1SMing Lei return false; 2307cebf8fd1SMing Lei return true; 2308cebf8fd1SMing Lei } 2309cebf8fd1SMing Lei 2310cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 2311cebf8fd1SMing Lei { 2312cebf8fd1SMing Lei return dev->kobj.parent; 2313cebf8fd1SMing Lei } 2314cebf8fd1SMing Lei 2315cebf8fd1SMing Lei /* 2316cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 2317cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 2318cebf8fd1SMing Lei * global lock 2319cebf8fd1SMing Lei */ 232063b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 2321da231fd5SKay Sievers { 2322ac43432cSMuchun Song unsigned int ref; 2323ac43432cSMuchun Song 23240f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 2325cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 2326da231fd5SKay Sievers return; 2327da231fd5SKay Sievers 2328e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 2329ac43432cSMuchun Song /** 2330ac43432cSMuchun Song * There is a race condition between removing glue directory 2331ac43432cSMuchun Song * and adding a new device under the glue directory. 2332ac43432cSMuchun Song * 2333ac43432cSMuchun Song * CPU1: CPU2: 2334ac43432cSMuchun Song * 2335ac43432cSMuchun Song * device_add() 2336ac43432cSMuchun Song * get_device_parent() 2337ac43432cSMuchun Song * class_dir_create_and_add() 2338ac43432cSMuchun Song * kobject_add_internal() 2339ac43432cSMuchun Song * create_dir() // create glue_dir 2340ac43432cSMuchun Song * 2341ac43432cSMuchun Song * device_add() 2342ac43432cSMuchun Song * get_device_parent() 2343ac43432cSMuchun Song * kobject_get() // get glue_dir 2344ac43432cSMuchun Song * 2345ac43432cSMuchun Song * device_del() 2346ac43432cSMuchun Song * cleanup_glue_dir() 2347ac43432cSMuchun Song * kobject_del(glue_dir) 2348ac43432cSMuchun Song * 2349ac43432cSMuchun Song * kobject_add() 2350ac43432cSMuchun Song * kobject_add_internal() 2351ac43432cSMuchun Song * create_dir() // in glue_dir 2352ac43432cSMuchun Song * sysfs_create_dir_ns() 2353ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 2354ac43432cSMuchun Song * 2355ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 2356ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 2357ac43432cSMuchun Song * 2358ac43432cSMuchun Song * // sd is freed 2359ac43432cSMuchun Song * kernfs_new_node(sd) 2360ac43432cSMuchun Song * kernfs_get(glue_dir) 2361ac43432cSMuchun Song * kernfs_add_one() 2362ac43432cSMuchun Song * kernfs_put() 2363ac43432cSMuchun Song * 2364ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 2365ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 2366ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 2367ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 2368ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 2369ac43432cSMuchun Song * 2370ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 2371ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 2372ac43432cSMuchun Song * 2373ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 2374ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 2375ac43432cSMuchun Song * for glue_dir kobj is 1. 2376ac43432cSMuchun Song */ 2377ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 2378ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 2379726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 23800f4dafc0SKay Sievers kobject_put(glue_dir); 2381e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 2382da231fd5SKay Sievers } 238363b6971aSCornelia Huck 23842ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 23852ee97cafSCornelia Huck { 23865590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 23872ee97cafSCornelia Huck int error; 23882ee97cafSCornelia Huck 23895590f319SBenjamin Herrenschmidt if (of_node) { 23900c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 23915590f319SBenjamin Herrenschmidt if (error) 23925590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 23935590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 23945590f319SBenjamin Herrenschmidt } 23955590f319SBenjamin Herrenschmidt 23962ee97cafSCornelia Huck if (!dev->class) 23972ee97cafSCornelia Huck return 0; 2398da231fd5SKay Sievers 23991fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 24006b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 24012ee97cafSCornelia Huck "subsystem"); 24022ee97cafSCornelia Huck if (error) 24035590f319SBenjamin Herrenschmidt goto out_devnode; 2404da231fd5SKay Sievers 24054e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 24064f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 24074f01a757SDmitry Torokhov "device"); 24084f01a757SDmitry Torokhov if (error) 240939aba963SKay Sievers goto out_subsys; 24102ee97cafSCornelia Huck } 241139aba963SKay Sievers 2412ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 241339aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 2414e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 241539aba963SKay Sievers return 0; 2416ead454feSRandy Dunlap #endif 241739aba963SKay Sievers 241839aba963SKay Sievers /* link in the class directory pointing to the device */ 24196b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 242039aba963SKay Sievers &dev->kobj, dev_name(dev)); 242139aba963SKay Sievers if (error) 242239aba963SKay Sievers goto out_device; 242339aba963SKay Sievers 24242ee97cafSCornelia Huck return 0; 24252ee97cafSCornelia Huck 242639aba963SKay Sievers out_device: 242739aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 2428da231fd5SKay Sievers 24292ee97cafSCornelia Huck out_subsys: 24302ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 24315590f319SBenjamin Herrenschmidt out_devnode: 24325590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 24332ee97cafSCornelia Huck return error; 24342ee97cafSCornelia Huck } 24352ee97cafSCornelia Huck 24362ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 24372ee97cafSCornelia Huck { 24385590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 24395590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 24405590f319SBenjamin Herrenschmidt 24412ee97cafSCornelia Huck if (!dev->class) 24422ee97cafSCornelia Huck return; 2443da231fd5SKay Sievers 24444e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 2445da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 24462ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 2447ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 2448e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 244939aba963SKay Sievers return; 2450ead454feSRandy Dunlap #endif 24516b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 24522ee97cafSCornelia Huck } 24532ee97cafSCornelia Huck 24541da177e4SLinus Torvalds /** 2455413c239fSStephen Rothwell * dev_set_name - set a device name 2456413c239fSStephen Rothwell * @dev: device 245746232366SRandy Dunlap * @fmt: format string for the device's name 2458413c239fSStephen Rothwell */ 2459413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 2460413c239fSStephen Rothwell { 2461413c239fSStephen Rothwell va_list vargs; 24621fa5ae85SKay Sievers int err; 2463413c239fSStephen Rothwell 2464413c239fSStephen Rothwell va_start(vargs, fmt); 24651fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 2466413c239fSStephen Rothwell va_end(vargs); 24671fa5ae85SKay Sievers return err; 2468413c239fSStephen Rothwell } 2469413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 2470413c239fSStephen Rothwell 2471413c239fSStephen Rothwell /** 2472e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 2473e105b8bfSDan Williams * @dev: device 2474e105b8bfSDan Williams * 2475e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 2476e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 2477e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 2478e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 24790d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 24800d4e293cSPeter Korsgaard * the link. 2481e105b8bfSDan Williams */ 2482e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 2483e105b8bfSDan Williams { 2484e105b8bfSDan Williams struct kobject *kobj; 2485e105b8bfSDan Williams 2486e105b8bfSDan Williams if (dev->class) 2487e105b8bfSDan Williams kobj = dev->class->dev_kobj; 2488e105b8bfSDan Williams else 2489e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 2490e105b8bfSDan Williams 2491e105b8bfSDan Williams return kobj; 2492e105b8bfSDan Williams } 2493e105b8bfSDan Williams 2494e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 2495e105b8bfSDan Williams { 2496e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2497e105b8bfSDan Williams int error = 0; 2498e105b8bfSDan Williams char devt_str[15]; 2499e105b8bfSDan Williams 2500e105b8bfSDan Williams if (kobj) { 2501e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2502e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 2503e105b8bfSDan Williams } 2504e105b8bfSDan Williams 2505e105b8bfSDan Williams return error; 2506e105b8bfSDan Williams } 2507e105b8bfSDan Williams 2508e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 2509e105b8bfSDan Williams { 2510e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2511e105b8bfSDan Williams char devt_str[15]; 2512e105b8bfSDan Williams 2513e105b8bfSDan Williams if (kobj) { 2514e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2515e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 2516e105b8bfSDan Williams } 2517e105b8bfSDan Williams } 2518e105b8bfSDan Williams 251946d3a037SShaokun Zhang static int device_private_init(struct device *dev) 2520b4028437SGreg Kroah-Hartman { 2521b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 2522b4028437SGreg Kroah-Hartman if (!dev->p) 2523b4028437SGreg Kroah-Hartman return -ENOMEM; 2524b4028437SGreg Kroah-Hartman dev->p->device = dev; 2525b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 2526b4028437SGreg Kroah-Hartman klist_children_put); 2527ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 2528b4028437SGreg Kroah-Hartman return 0; 2529b4028437SGreg Kroah-Hartman } 2530b4028437SGreg Kroah-Hartman 2531e105b8bfSDan Williams /** 25321da177e4SLinus Torvalds * device_add - add device to device hierarchy. 25331da177e4SLinus Torvalds * @dev: device. 25341da177e4SLinus Torvalds * 25351da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 25361da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 25371da177e4SLinus Torvalds * 25385739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 25391da177e4SLinus Torvalds * to the global and sibling lists for the device, then 25401da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 25415739411aSCornelia Huck * 2542b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 2543b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 2544b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 2545b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 2546b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 2547b10d5efdSAlan Stern * and register a fresh new struct device instead. 2548b10d5efdSAlan Stern * 25495739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 25505739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 25515739411aSCornelia Huck * reference instead. 2552affada72SBorislav Petkov * 2553affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 2554affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 2555affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 2556affada72SBorislav Petkov * count. 25571da177e4SLinus Torvalds */ 25581da177e4SLinus Torvalds int device_add(struct device *dev) 25591da177e4SLinus Torvalds { 256035dbf4efSViresh Kumar struct device *parent; 2561ca22e56dSKay Sievers struct kobject *kobj; 2562c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 25635f5377eaSSaravana Kannan int error = -EINVAL; 2564cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2565775b64d2SRafael J. Wysocki 25661da177e4SLinus Torvalds dev = get_device(dev); 2567c906a48aSGreg Kroah-Hartman if (!dev) 2568c906a48aSGreg Kroah-Hartman goto done; 2569c906a48aSGreg Kroah-Hartman 2570fb069a5dSGreg Kroah-Hartman if (!dev->p) { 2571b4028437SGreg Kroah-Hartman error = device_private_init(dev); 2572b4028437SGreg Kroah-Hartman if (error) 2573fb069a5dSGreg Kroah-Hartman goto done; 2574fb069a5dSGreg Kroah-Hartman } 2575fb069a5dSGreg Kroah-Hartman 25761fa5ae85SKay Sievers /* 25771fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 25781fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 25791fa5ae85SKay Sievers * the name, and force the use of dev_name() 25801fa5ae85SKay Sievers */ 25811fa5ae85SKay Sievers if (dev->init_name) { 2582acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 25831fa5ae85SKay Sievers dev->init_name = NULL; 25841fa5ae85SKay Sievers } 2585c906a48aSGreg Kroah-Hartman 2586ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 2587ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 2588ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 2589ca22e56dSKay Sievers 2590e6309e75SThomas Gleixner if (!dev_name(dev)) { 2591e6309e75SThomas Gleixner error = -EINVAL; 25925c8563d7SKay Sievers goto name_error; 2593e6309e75SThomas Gleixner } 25941da177e4SLinus Torvalds 25951e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 2596c205ef48SGreg Kroah-Hartman 25971da177e4SLinus Torvalds parent = get_device(dev->parent); 2598ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 259984d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 260084d0c27dSTetsuo Handa error = PTR_ERR(kobj); 260184d0c27dSTetsuo Handa goto parent_error; 260284d0c27dSTetsuo Handa } 2603ca22e56dSKay Sievers if (kobj) 2604ca22e56dSKay Sievers dev->kobj.parent = kobj; 26051da177e4SLinus Torvalds 26060d358f22SYinghai Lu /* use parent numa_node */ 260756f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 26080d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 26090d358f22SYinghai Lu 26101da177e4SLinus Torvalds /* first, register with generic layer. */ 26118a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 26128a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 2613cebf8fd1SMing Lei if (error) { 2614cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 26151da177e4SLinus Torvalds goto Error; 2616cebf8fd1SMing Lei } 2617a7fd6706SKay Sievers 261837022644SBrian Walsh /* notify platform of device entry */ 261907de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 262007de0e86SHeikki Krogerus if (error) 262107de0e86SHeikki Krogerus goto platform_error; 262237022644SBrian Walsh 2623c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 2624a306eea4SCornelia Huck if (error) 2625a306eea4SCornelia Huck goto attrError; 2626a7fd6706SKay Sievers 26272ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 26282ee97cafSCornelia Huck if (error) 26292ee97cafSCornelia Huck goto SymlinkError; 2630dc0afa83SCornelia Huck error = device_add_attrs(dev); 2631dc0afa83SCornelia Huck if (error) 26322620efefSGreg Kroah-Hartman goto AttrsError; 2633dc0afa83SCornelia Huck error = bus_add_device(dev); 2634dc0afa83SCornelia Huck if (error) 26351da177e4SLinus Torvalds goto BusError; 26363b98aeafSAlan Stern error = dpm_sysfs_add(dev); 263757eee3d2SRafael J. Wysocki if (error) 26383b98aeafSAlan Stern goto DPMError; 26393b98aeafSAlan Stern device_pm_add(dev); 2640ec0676eeSAlan Stern 26410cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 26420cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 26430cd75047SSergey Klyaus if (error) 26440cd75047SSergey Klyaus goto DevAttrError; 26450cd75047SSergey Klyaus 26460cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 26470cd75047SSergey Klyaus if (error) 26480cd75047SSergey Klyaus goto SysEntryError; 26490cd75047SSergey Klyaus 26500cd75047SSergey Klyaus devtmpfs_create_node(dev); 26510cd75047SSergey Klyaus } 26520cd75047SSergey Klyaus 2653ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 2654268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 2655ec0676eeSAlan Stern */ 2656ec0676eeSAlan Stern if (dev->bus) 2657ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2658ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 2659ec0676eeSAlan Stern 266053877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 2661372a67c0SSaravana Kannan 2662e2ae9bccSSaravana Kannan /* 2663e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 2664e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 2665e2ae9bccSSaravana Kannan * link to it. 2666e2ae9bccSSaravana Kannan * 2667e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 2668e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 2669e2ae9bccSSaravana Kannan * 26702cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure 2671e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 2672e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 2673e2ae9bccSSaravana Kannan */ 26742cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 26752cd38fd1SSaravana Kannan dev->fwnode->dev = dev; 26765f5377eaSSaravana Kannan fw_devlink_link_device(dev); 267703324507SSaravana Kannan } 2678e2ae9bccSSaravana Kannan 26792023c610SAlan Stern bus_probe_device(dev); 26801da177e4SLinus Torvalds if (parent) 2681f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2682f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 26831da177e4SLinus Torvalds 26845d9fd169SGreg Kroah-Hartman if (dev->class) { 2685ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2686c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 2687570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 26886b6e39a6SKay Sievers &dev->class->p->klist_devices); 2689c47ed219SGreg Kroah-Hartman 2690c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 2691184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2692ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2693c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 2694c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 2695ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 26965d9fd169SGreg Kroah-Hartman } 2697c906a48aSGreg Kroah-Hartman done: 26981da177e4SLinus Torvalds put_device(dev); 26991da177e4SLinus Torvalds return error; 27000cd75047SSergey Klyaus SysEntryError: 27010cd75047SSergey Klyaus if (MAJOR(dev->devt)) 27020cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 27030cd75047SSergey Klyaus DevAttrError: 27040cd75047SSergey Klyaus device_pm_remove(dev); 27050cd75047SSergey Klyaus dpm_sysfs_remove(dev); 27063b98aeafSAlan Stern DPMError: 270757eee3d2SRafael J. Wysocki bus_remove_device(dev); 270857eee3d2SRafael J. Wysocki BusError: 27092620efefSGreg Kroah-Hartman device_remove_attrs(dev); 27102620efefSGreg Kroah-Hartman AttrsError: 27112ee97cafSCornelia Huck device_remove_class_symlinks(dev); 27122ee97cafSCornelia Huck SymlinkError: 2713c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 271423681e47SGreg Kroah-Hartman attrError: 271507de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 271607de0e86SHeikki Krogerus platform_error: 2717312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2718cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 27191da177e4SLinus Torvalds kobject_del(&dev->kobj); 27201da177e4SLinus Torvalds Error: 2721cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 272284d0c27dSTetsuo Handa parent_error: 27231da177e4SLinus Torvalds put_device(parent); 27245c8563d7SKay Sievers name_error: 27255c8563d7SKay Sievers kfree(dev->p); 27265c8563d7SKay Sievers dev->p = NULL; 2727c906a48aSGreg Kroah-Hartman goto done; 27281da177e4SLinus Torvalds } 272986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 27301da177e4SLinus Torvalds 27311da177e4SLinus Torvalds /** 27321da177e4SLinus Torvalds * device_register - register a device with the system. 27331da177e4SLinus Torvalds * @dev: pointer to the device structure 27341da177e4SLinus Torvalds * 27351da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 27361da177e4SLinus Torvalds * and add it to the system. The two steps can be called 27371da177e4SLinus Torvalds * separately, but this is the easiest and most common. 27381da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 27391da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 27401da177e4SLinus Torvalds * before it is added to the hierarchy. 27415739411aSCornelia Huck * 2742b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 2743b10d5efdSAlan Stern * and device_add(). 2744b10d5efdSAlan Stern * 27455739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 27465739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 27475739411aSCornelia Huck * reference initialized in this function instead. 27481da177e4SLinus Torvalds */ 27491da177e4SLinus Torvalds int device_register(struct device *dev) 27501da177e4SLinus Torvalds { 27511da177e4SLinus Torvalds device_initialize(dev); 27521da177e4SLinus Torvalds return device_add(dev); 27531da177e4SLinus Torvalds } 275486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 27551da177e4SLinus Torvalds 27561da177e4SLinus Torvalds /** 27571da177e4SLinus Torvalds * get_device - increment reference count for device. 27581da177e4SLinus Torvalds * @dev: device. 27591da177e4SLinus Torvalds * 27601da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 27611da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 27621da177e4SLinus Torvalds * pointer passed in. 27631da177e4SLinus Torvalds */ 27641da177e4SLinus Torvalds struct device *get_device(struct device *dev) 27651da177e4SLinus Torvalds { 2766b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 27671da177e4SLinus Torvalds } 276886df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 27691da177e4SLinus Torvalds 27701da177e4SLinus Torvalds /** 27711da177e4SLinus Torvalds * put_device - decrement reference count. 27721da177e4SLinus Torvalds * @dev: device in question. 27731da177e4SLinus Torvalds */ 27741da177e4SLinus Torvalds void put_device(struct device *dev) 27751da177e4SLinus Torvalds { 2776edfaa7c3SKay Sievers /* might_sleep(); */ 27771da177e4SLinus Torvalds if (dev) 27781da177e4SLinus Torvalds kobject_put(&dev->kobj); 27791da177e4SLinus Torvalds } 278086df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 27811da177e4SLinus Torvalds 278200289cd8SDan Williams bool kill_device(struct device *dev) 278300289cd8SDan Williams { 278400289cd8SDan Williams /* 278500289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 278600289cd8SDan Williams * the update behavior is consistent with the other bitfields near 278700289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 278800289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 278900289cd8SDan Williams * underneath the device. 279000289cd8SDan Williams */ 279100289cd8SDan Williams lockdep_assert_held(&dev->mutex); 279200289cd8SDan Williams 279300289cd8SDan Williams if (dev->p->dead) 279400289cd8SDan Williams return false; 279500289cd8SDan Williams dev->p->dead = true; 279600289cd8SDan Williams return true; 279700289cd8SDan Williams } 279800289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 279900289cd8SDan Williams 28001da177e4SLinus Torvalds /** 28011da177e4SLinus Torvalds * device_del - delete device from system. 28021da177e4SLinus Torvalds * @dev: device. 28031da177e4SLinus Torvalds * 28041da177e4SLinus Torvalds * This is the first part of the device unregistration 28051da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 28061da177e4SLinus Torvalds * from here, has it removed from the other driver model 28071da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 28081da177e4SLinus Torvalds * from the kobject hierarchy. 28091da177e4SLinus Torvalds * 28101da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 28111da177e4SLinus Torvalds * also called manually. 28121da177e4SLinus Torvalds */ 28131da177e4SLinus Torvalds void device_del(struct device *dev) 28141da177e4SLinus Torvalds { 28151da177e4SLinus Torvalds struct device *parent = dev->parent; 2816cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2817c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 28181da177e4SLinus Torvalds 28193451a495SAlexander Duyck device_lock(dev); 282000289cd8SDan Williams kill_device(dev); 28213451a495SAlexander Duyck device_unlock(dev); 28223451a495SAlexander Duyck 2823372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 2824372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 2825372a67c0SSaravana Kannan 2826ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 2827ec0676eeSAlan Stern * before dpm_sysfs_remove(). 2828ec0676eeSAlan Stern */ 2829ec0676eeSAlan Stern if (dev->bus) 2830ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2831ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 28329ed98953SRafael J. Wysocki 28333b98aeafSAlan Stern dpm_sysfs_remove(dev); 28341da177e4SLinus Torvalds if (parent) 2835f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 2836e105b8bfSDan Williams if (MAJOR(dev->devt)) { 28372b2af54aSKay Sievers devtmpfs_delete_node(dev); 2838e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 2839c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 2840e105b8bfSDan Williams } 2841b9d9c82bSKay Sievers if (dev->class) { 2842da231fd5SKay Sievers device_remove_class_symlinks(dev); 284399ef3ef8SKay Sievers 2844ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2845c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 2846184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2847ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2848c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 2849c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 2850c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 2851570d0200SWei Yang klist_del(&dev->p->knode_class); 2852ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 2853b9d9c82bSKay Sievers } 2854c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 28552620efefSGreg Kroah-Hartman device_remove_attrs(dev); 285628953533SBenjamin Herrenschmidt bus_remove_device(dev); 28574b6d1f12SLongX Zhang device_pm_remove(dev); 2858d1c3414cSGrant Likely driver_deferred_probe_del(dev); 285907de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 2860478573c9SLukas Wunner device_remove_properties(dev); 28612ec16150SJeffy Chen device_links_purge(dev); 28621da177e4SLinus Torvalds 2863599bad38SJoerg Roedel if (dev->bus) 2864599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2865599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 2866312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2867cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 28681da177e4SLinus Torvalds kobject_del(&dev->kobj); 2869cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 28701da177e4SLinus Torvalds put_device(parent); 28711da177e4SLinus Torvalds } 287286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 28731da177e4SLinus Torvalds 28741da177e4SLinus Torvalds /** 28751da177e4SLinus Torvalds * device_unregister - unregister device from system. 28761da177e4SLinus Torvalds * @dev: device going away. 28771da177e4SLinus Torvalds * 28781da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 28791da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 28801da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 28811da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 28821da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 28831da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 28841da177e4SLinus Torvalds */ 28851da177e4SLinus Torvalds void device_unregister(struct device *dev) 28861da177e4SLinus Torvalds { 28871e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 28881da177e4SLinus Torvalds device_del(dev); 28891da177e4SLinus Torvalds put_device(dev); 28901da177e4SLinus Torvalds } 289186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 28921da177e4SLinus Torvalds 28933d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 28943d060aebSAndy Shevchenko { 28953d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 28963d060aebSAndy Shevchenko struct device *dev = NULL; 28973d060aebSAndy Shevchenko struct device_private *p; 28983d060aebSAndy Shevchenko 28993d060aebSAndy Shevchenko if (n) { 29003d060aebSAndy Shevchenko p = to_device_private_parent(n); 29013d060aebSAndy Shevchenko dev = p->device; 29023d060aebSAndy Shevchenko } 29033d060aebSAndy Shevchenko return dev; 29043d060aebSAndy Shevchenko } 29053d060aebSAndy Shevchenko 290636239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 290736239577Smochel@digitalimplant.org { 290836239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 2909f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 2910f791b8c8SGreg Kroah-Hartman struct device_private *p; 2911f791b8c8SGreg Kroah-Hartman 2912f791b8c8SGreg Kroah-Hartman if (n) { 2913f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 2914f791b8c8SGreg Kroah-Hartman dev = p->device; 2915f791b8c8SGreg Kroah-Hartman } 2916f791b8c8SGreg Kroah-Hartman return dev; 291736239577Smochel@digitalimplant.org } 291836239577Smochel@digitalimplant.org 29191da177e4SLinus Torvalds /** 2920e454cea2SKay Sievers * device_get_devnode - path of device node file 29216fcf53acSKay Sievers * @dev: device 2922e454cea2SKay Sievers * @mode: returned file access mode 29233c2670e6SKay Sievers * @uid: returned file owner 29243c2670e6SKay Sievers * @gid: returned file group 29256fcf53acSKay Sievers * @tmp: possibly allocated string 29266fcf53acSKay Sievers * 29276fcf53acSKay Sievers * Return the relative path of a possible device node. 29286fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 29296fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 29306fcf53acSKay Sievers * freed by the caller. 29316fcf53acSKay Sievers */ 2932e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 29334e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 29343c2670e6SKay Sievers const char **tmp) 29356fcf53acSKay Sievers { 29366fcf53acSKay Sievers char *s; 29376fcf53acSKay Sievers 29386fcf53acSKay Sievers *tmp = NULL; 29396fcf53acSKay Sievers 29406fcf53acSKay Sievers /* the device type may provide a specific name */ 2941e454cea2SKay Sievers if (dev->type && dev->type->devnode) 29423c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 29436fcf53acSKay Sievers if (*tmp) 29446fcf53acSKay Sievers return *tmp; 29456fcf53acSKay Sievers 29466fcf53acSKay Sievers /* the class may provide a specific name */ 2947e454cea2SKay Sievers if (dev->class && dev->class->devnode) 2948e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 29496fcf53acSKay Sievers if (*tmp) 29506fcf53acSKay Sievers return *tmp; 29516fcf53acSKay Sievers 29526fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 29536fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 29546fcf53acSKay Sievers return dev_name(dev); 29556fcf53acSKay Sievers 29566fcf53acSKay Sievers /* replace '!' in the name with '/' */ 2957a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 2958a29fd614SRasmus Villemoes if (!s) 29596fcf53acSKay Sievers return NULL; 2960a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 2961a29fd614SRasmus Villemoes return *tmp = s; 29626fcf53acSKay Sievers } 29636fcf53acSKay Sievers 29646fcf53acSKay Sievers /** 29651da177e4SLinus Torvalds * device_for_each_child - device child iterator. 2966c41455fbSRandy Dunlap * @parent: parent struct device. 29671da177e4SLinus Torvalds * @fn: function to be called for each device. 2968f8878dcbSRobert P. J. Day * @data: data for the callback. 29691da177e4SLinus Torvalds * 2970c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 29711da177e4SLinus Torvalds * passing it @data. 29721da177e4SLinus Torvalds * 29731da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 29741da177e4SLinus Torvalds * other than 0, we break out and return that value. 29751da177e4SLinus Torvalds */ 297636239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 29774a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 29781da177e4SLinus Torvalds { 297936239577Smochel@digitalimplant.org struct klist_iter i; 29801da177e4SLinus Torvalds struct device *child; 29811da177e4SLinus Torvalds int error = 0; 29821da177e4SLinus Torvalds 2983014c90dbSGreg Kroah-Hartman if (!parent->p) 2984014c90dbSGreg Kroah-Hartman return 0; 2985014c90dbSGreg Kroah-Hartman 2986f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 298793ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 298836239577Smochel@digitalimplant.org error = fn(child, data); 298936239577Smochel@digitalimplant.org klist_iter_exit(&i); 29901da177e4SLinus Torvalds return error; 29911da177e4SLinus Torvalds } 299286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 29931da177e4SLinus Torvalds 29945ab69981SCornelia Huck /** 29953d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 29963d060aebSAndy Shevchenko * @parent: parent struct device. 29973d060aebSAndy Shevchenko * @fn: function to be called for each device. 29983d060aebSAndy Shevchenko * @data: data for the callback. 29993d060aebSAndy Shevchenko * 30003d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 30013d060aebSAndy Shevchenko * passing it @data. 30023d060aebSAndy Shevchenko * 30033d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 30043d060aebSAndy Shevchenko * other than 0, we break out and return that value. 30053d060aebSAndy Shevchenko */ 30063d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 30073d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 30083d060aebSAndy Shevchenko { 30093d060aebSAndy Shevchenko struct klist_iter i; 30103d060aebSAndy Shevchenko struct device *child; 30113d060aebSAndy Shevchenko int error = 0; 30123d060aebSAndy Shevchenko 30133d060aebSAndy Shevchenko if (!parent->p) 30143d060aebSAndy Shevchenko return 0; 30153d060aebSAndy Shevchenko 30163d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 30173d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 30183d060aebSAndy Shevchenko error = fn(child, data); 30193d060aebSAndy Shevchenko klist_iter_exit(&i); 30203d060aebSAndy Shevchenko return error; 30213d060aebSAndy Shevchenko } 30223d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 30233d060aebSAndy Shevchenko 30243d060aebSAndy Shevchenko /** 30255ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 30265ab69981SCornelia Huck * @parent: parent struct device 30275ab69981SCornelia Huck * @match: Callback function to check device 3028f8878dcbSRobert P. J. Day * @data: Data to pass to match function 30295ab69981SCornelia Huck * 30305ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 30315ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 30325ab69981SCornelia Huck * determined by the @match callback. 30335ab69981SCornelia Huck * 30345ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 30355ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 30365ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 30375ab69981SCornelia Huck * and not iterate over any more devices. 3038a4e2400aSFederico Vaga * 3039a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 30405ab69981SCornelia Huck */ 30415ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 30424a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 30435ab69981SCornelia Huck { 30445ab69981SCornelia Huck struct klist_iter i; 30455ab69981SCornelia Huck struct device *child; 30465ab69981SCornelia Huck 30475ab69981SCornelia Huck if (!parent) 30485ab69981SCornelia Huck return NULL; 30495ab69981SCornelia Huck 3050f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 30515ab69981SCornelia Huck while ((child = next_device(&i))) 30525ab69981SCornelia Huck if (match(child, data) && get_device(child)) 30535ab69981SCornelia Huck break; 30545ab69981SCornelia Huck klist_iter_exit(&i); 30555ab69981SCornelia Huck return child; 30565ab69981SCornelia Huck } 305786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 30585ab69981SCornelia Huck 3059dad9bb01SHeikki Krogerus /** 3060dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 3061dad9bb01SHeikki Krogerus * @parent: parent struct device 3062dad9bb01SHeikki Krogerus * @name: name of the child device 3063dad9bb01SHeikki Krogerus * 3064dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 3065dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 3066dad9bb01SHeikki Krogerus * 3067dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 3068dad9bb01SHeikki Krogerus */ 3069dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 3070dad9bb01SHeikki Krogerus const char *name) 3071dad9bb01SHeikki Krogerus { 3072dad9bb01SHeikki Krogerus struct klist_iter i; 3073dad9bb01SHeikki Krogerus struct device *child; 3074dad9bb01SHeikki Krogerus 3075dad9bb01SHeikki Krogerus if (!parent) 3076dad9bb01SHeikki Krogerus return NULL; 3077dad9bb01SHeikki Krogerus 3078dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 3079dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 3080dad9bb01SHeikki Krogerus if (!strcmp(dev_name(child), name) && get_device(child)) 3081dad9bb01SHeikki Krogerus break; 3082dad9bb01SHeikki Krogerus klist_iter_exit(&i); 3083dad9bb01SHeikki Krogerus return child; 3084dad9bb01SHeikki Krogerus } 3085dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 3086dad9bb01SHeikki Krogerus 30871da177e4SLinus Torvalds int __init devices_init(void) 30881da177e4SLinus Torvalds { 3089881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 3090881c6cfdSGreg Kroah-Hartman if (!devices_kset) 3091881c6cfdSGreg Kroah-Hartman return -ENOMEM; 3092e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 3093e105b8bfSDan Williams if (!dev_kobj) 3094e105b8bfSDan Williams goto dev_kobj_err; 3095e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 3096e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 3097e105b8bfSDan Williams goto block_kobj_err; 3098e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 3099e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 3100e105b8bfSDan Williams goto char_kobj_err; 3101e105b8bfSDan Williams 3102881c6cfdSGreg Kroah-Hartman return 0; 3103e105b8bfSDan Williams 3104e105b8bfSDan Williams char_kobj_err: 3105e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 3106e105b8bfSDan Williams block_kobj_err: 3107e105b8bfSDan Williams kobject_put(dev_kobj); 3108e105b8bfSDan Williams dev_kobj_err: 3109e105b8bfSDan Williams kset_unregister(devices_kset); 3110e105b8bfSDan Williams return -ENOMEM; 31111da177e4SLinus Torvalds } 31121da177e4SLinus Torvalds 31134f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 31144f3549d7SRafael J. Wysocki { 31154f3549d7SRafael J. Wysocki int ret; 31164f3549d7SRafael J. Wysocki 31174f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 31184f3549d7SRafael J. Wysocki if (ret) 31194f3549d7SRafael J. Wysocki return ret; 31204f3549d7SRafael J. Wysocki 31214f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 31224f3549d7SRafael J. Wysocki } 31234f3549d7SRafael J. Wysocki 31244f3549d7SRafael J. Wysocki /** 31254f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 31264f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 31274f3549d7SRafael J. Wysocki * 31284f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 31294f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 31304f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 31314f3549d7SRafael J. Wysocki * is executed. 31324f3549d7SRafael J. Wysocki * 31334f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 31344f3549d7SRafael J. Wysocki */ 31354f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 31364f3549d7SRafael J. Wysocki { 31374f3549d7SRafael J. Wysocki int ret; 31384f3549d7SRafael J. Wysocki 31394f3549d7SRafael J. Wysocki if (dev->offline_disabled) 31404f3549d7SRafael J. Wysocki return -EPERM; 31414f3549d7SRafael J. Wysocki 31424f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 31434f3549d7SRafael J. Wysocki if (ret) 31444f3549d7SRafael J. Wysocki return ret; 31454f3549d7SRafael J. Wysocki 31464f3549d7SRafael J. Wysocki device_lock(dev); 31474f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 31484f3549d7SRafael J. Wysocki if (dev->offline) { 31494f3549d7SRafael J. Wysocki ret = 1; 31504f3549d7SRafael J. Wysocki } else { 31514f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 31524f3549d7SRafael J. Wysocki if (!ret) { 31534f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 31544f3549d7SRafael J. Wysocki dev->offline = true; 31554f3549d7SRafael J. Wysocki } 31564f3549d7SRafael J. Wysocki } 31574f3549d7SRafael J. Wysocki } 31584f3549d7SRafael J. Wysocki device_unlock(dev); 31594f3549d7SRafael J. Wysocki 31604f3549d7SRafael J. Wysocki return ret; 31614f3549d7SRafael J. Wysocki } 31624f3549d7SRafael J. Wysocki 31634f3549d7SRafael J. Wysocki /** 31644f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 31654f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 31664f3549d7SRafael J. Wysocki * 31674f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 31684f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 31694f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 31704f3549d7SRafael J. Wysocki * 31714f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 31724f3549d7SRafael J. Wysocki */ 31734f3549d7SRafael J. Wysocki int device_online(struct device *dev) 31744f3549d7SRafael J. Wysocki { 31754f3549d7SRafael J. Wysocki int ret = 0; 31764f3549d7SRafael J. Wysocki 31774f3549d7SRafael J. Wysocki device_lock(dev); 31784f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 31794f3549d7SRafael J. Wysocki if (dev->offline) { 31804f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 31814f3549d7SRafael J. Wysocki if (!ret) { 31824f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 31834f3549d7SRafael J. Wysocki dev->offline = false; 31844f3549d7SRafael J. Wysocki } 31854f3549d7SRafael J. Wysocki } else { 31864f3549d7SRafael J. Wysocki ret = 1; 31874f3549d7SRafael J. Wysocki } 31884f3549d7SRafael J. Wysocki } 31894f3549d7SRafael J. Wysocki device_unlock(dev); 31904f3549d7SRafael J. Wysocki 31914f3549d7SRafael J. Wysocki return ret; 31924f3549d7SRafael J. Wysocki } 31934f3549d7SRafael J. Wysocki 31947f100d15SKarthigan Srinivasan struct root_device { 31950aa0dc41SMark McLoughlin struct device dev; 31960aa0dc41SMark McLoughlin struct module *owner; 31970aa0dc41SMark McLoughlin }; 31980aa0dc41SMark McLoughlin 319993058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 3200481e2079SFerenc Wagner { 3201481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 3202481e2079SFerenc Wagner } 32030aa0dc41SMark McLoughlin 32040aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 32050aa0dc41SMark McLoughlin { 32060aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 32070aa0dc41SMark McLoughlin } 32080aa0dc41SMark McLoughlin 32090aa0dc41SMark McLoughlin /** 32100aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 32110aa0dc41SMark McLoughlin * @name: root device name 32120aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 32130aa0dc41SMark McLoughlin * 32140aa0dc41SMark McLoughlin * This function allocates a root device and registers it 32150aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 32160aa0dc41SMark McLoughlin * device, use root_device_unregister(). 32170aa0dc41SMark McLoughlin * 32180aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 32190aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 32200aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 32210aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 32220aa0dc41SMark McLoughlin * 32230aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 32240aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 32250aa0dc41SMark McLoughlin * in sysfs. 32260aa0dc41SMark McLoughlin * 3227f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3228f0eae0edSJani Nikula * 32290aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 32300aa0dc41SMark McLoughlin */ 32310aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 32320aa0dc41SMark McLoughlin { 32330aa0dc41SMark McLoughlin struct root_device *root; 32340aa0dc41SMark McLoughlin int err = -ENOMEM; 32350aa0dc41SMark McLoughlin 32360aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 32370aa0dc41SMark McLoughlin if (!root) 32380aa0dc41SMark McLoughlin return ERR_PTR(err); 32390aa0dc41SMark McLoughlin 3240acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 32410aa0dc41SMark McLoughlin if (err) { 32420aa0dc41SMark McLoughlin kfree(root); 32430aa0dc41SMark McLoughlin return ERR_PTR(err); 32440aa0dc41SMark McLoughlin } 32450aa0dc41SMark McLoughlin 32460aa0dc41SMark McLoughlin root->dev.release = root_device_release; 32470aa0dc41SMark McLoughlin 32480aa0dc41SMark McLoughlin err = device_register(&root->dev); 32490aa0dc41SMark McLoughlin if (err) { 32500aa0dc41SMark McLoughlin put_device(&root->dev); 32510aa0dc41SMark McLoughlin return ERR_PTR(err); 32520aa0dc41SMark McLoughlin } 32530aa0dc41SMark McLoughlin 32541d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 32550aa0dc41SMark McLoughlin if (owner) { 32560aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 32570aa0dc41SMark McLoughlin 32580aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 32590aa0dc41SMark McLoughlin if (err) { 32600aa0dc41SMark McLoughlin device_unregister(&root->dev); 32610aa0dc41SMark McLoughlin return ERR_PTR(err); 32620aa0dc41SMark McLoughlin } 32630aa0dc41SMark McLoughlin root->owner = owner; 32640aa0dc41SMark McLoughlin } 32650aa0dc41SMark McLoughlin #endif 32660aa0dc41SMark McLoughlin 32670aa0dc41SMark McLoughlin return &root->dev; 32680aa0dc41SMark McLoughlin } 32690aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 32700aa0dc41SMark McLoughlin 32710aa0dc41SMark McLoughlin /** 32720aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 32737cbcf225SRandy Dunlap * @dev: device going away 32740aa0dc41SMark McLoughlin * 32750aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 32760aa0dc41SMark McLoughlin * root_device_register(). 32770aa0dc41SMark McLoughlin */ 32780aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 32790aa0dc41SMark McLoughlin { 32800aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 32810aa0dc41SMark McLoughlin 32820aa0dc41SMark McLoughlin if (root->owner) 32830aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 32840aa0dc41SMark McLoughlin 32850aa0dc41SMark McLoughlin device_unregister(dev); 32860aa0dc41SMark McLoughlin } 32870aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 32880aa0dc41SMark McLoughlin 328923681e47SGreg Kroah-Hartman 329023681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 329123681e47SGreg Kroah-Hartman { 32921e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 329323681e47SGreg Kroah-Hartman kfree(dev); 329423681e47SGreg Kroah-Hartman } 329523681e47SGreg Kroah-Hartman 32966a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 329739ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 329839ef3112SGuenter Roeck dev_t devt, void *drvdata, 329939ef3112SGuenter Roeck const struct attribute_group **groups, 330039ef3112SGuenter Roeck const char *fmt, va_list args) 330139ef3112SGuenter Roeck { 330239ef3112SGuenter Roeck struct device *dev = NULL; 330339ef3112SGuenter Roeck int retval = -ENODEV; 330439ef3112SGuenter Roeck 330539ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 330639ef3112SGuenter Roeck goto error; 330739ef3112SGuenter Roeck 330839ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 330939ef3112SGuenter Roeck if (!dev) { 331039ef3112SGuenter Roeck retval = -ENOMEM; 331139ef3112SGuenter Roeck goto error; 331239ef3112SGuenter Roeck } 331339ef3112SGuenter Roeck 3314bbc780f8SDavid Herrmann device_initialize(dev); 331539ef3112SGuenter Roeck dev->devt = devt; 331639ef3112SGuenter Roeck dev->class = class; 331739ef3112SGuenter Roeck dev->parent = parent; 331839ef3112SGuenter Roeck dev->groups = groups; 331939ef3112SGuenter Roeck dev->release = device_create_release; 332039ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 332139ef3112SGuenter Roeck 332239ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 332339ef3112SGuenter Roeck if (retval) 332439ef3112SGuenter Roeck goto error; 332539ef3112SGuenter Roeck 3326bbc780f8SDavid Herrmann retval = device_add(dev); 332739ef3112SGuenter Roeck if (retval) 332839ef3112SGuenter Roeck goto error; 332939ef3112SGuenter Roeck 333039ef3112SGuenter Roeck return dev; 333139ef3112SGuenter Roeck 333239ef3112SGuenter Roeck error: 333339ef3112SGuenter Roeck put_device(dev); 333439ef3112SGuenter Roeck return ERR_PTR(retval); 333539ef3112SGuenter Roeck } 333639ef3112SGuenter Roeck 333723681e47SGreg Kroah-Hartman /** 33384e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 33398882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 33408882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 33418882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 33428882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 33438882b394SGreg Kroah-Hartman * @fmt: string for the device's name 33448882b394SGreg Kroah-Hartman * 33458882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 33468882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 33478882b394SGreg Kroah-Hartman * 33488882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 33498882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 33508882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 33518882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 33528882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 33538882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 33548882b394SGreg Kroah-Hartman * pointer. 33558882b394SGreg Kroah-Hartman * 3356f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3357f0eae0edSJani Nikula * 33588882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 33598882b394SGreg Kroah-Hartman * been created with a call to class_create(). 33608882b394SGreg Kroah-Hartman */ 33614e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 33624e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 33638882b394SGreg Kroah-Hartman { 33648882b394SGreg Kroah-Hartman va_list vargs; 33658882b394SGreg Kroah-Hartman struct device *dev; 33668882b394SGreg Kroah-Hartman 33678882b394SGreg Kroah-Hartman va_start(vargs, fmt); 33684c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL, 33694c747466SChristoph Hellwig fmt, vargs); 33708882b394SGreg Kroah-Hartman va_end(vargs); 33718882b394SGreg Kroah-Hartman return dev; 33728882b394SGreg Kroah-Hartman } 33734e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 33748882b394SGreg Kroah-Hartman 337539ef3112SGuenter Roeck /** 337639ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 337739ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 337839ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 337939ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 338039ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 338139ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 338239ef3112SGuenter Roeck * @fmt: string for the device's name 338339ef3112SGuenter Roeck * 338439ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 338539ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 338639ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 338739ef3112SGuenter Roeck * be created automatically. 338839ef3112SGuenter Roeck * 338939ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 339039ef3112SGuenter Roeck * the dev_t is not 0,0. 339139ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 339239ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 339339ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 339439ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 339539ef3112SGuenter Roeck * pointer. 339639ef3112SGuenter Roeck * 339739ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 339839ef3112SGuenter Roeck * 339939ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 340039ef3112SGuenter Roeck * been created with a call to class_create(). 340139ef3112SGuenter Roeck */ 340239ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 340339ef3112SGuenter Roeck struct device *parent, dev_t devt, 340439ef3112SGuenter Roeck void *drvdata, 340539ef3112SGuenter Roeck const struct attribute_group **groups, 340639ef3112SGuenter Roeck const char *fmt, ...) 340739ef3112SGuenter Roeck { 340839ef3112SGuenter Roeck va_list vargs; 340939ef3112SGuenter Roeck struct device *dev; 341039ef3112SGuenter Roeck 341139ef3112SGuenter Roeck va_start(vargs, fmt); 341239ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 341339ef3112SGuenter Roeck fmt, vargs); 341439ef3112SGuenter Roeck va_end(vargs); 341539ef3112SGuenter Roeck return dev; 341639ef3112SGuenter Roeck } 341739ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 341839ef3112SGuenter Roeck 3419775b64d2SRafael J. Wysocki /** 3420775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 3421775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 3422775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 3423775b64d2SRafael J. Wysocki * 3424775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 3425775b64d2SRafael J. Wysocki * call to device_create(). 3426775b64d2SRafael J. Wysocki */ 3427775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 3428775b64d2SRafael J. Wysocki { 3429775b64d2SRafael J. Wysocki struct device *dev; 3430775b64d2SRafael J. Wysocki 34314495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 3432cd35449bSDave Young if (dev) { 3433cd35449bSDave Young put_device(dev); 343423681e47SGreg Kroah-Hartman device_unregister(dev); 343523681e47SGreg Kroah-Hartman } 3436cd35449bSDave Young } 343723681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 3438a2de48caSGreg Kroah-Hartman 3439a2de48caSGreg Kroah-Hartman /** 3440a2de48caSGreg Kroah-Hartman * device_rename - renames a device 3441a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 3442a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 3443030c1d2bSEric W. Biederman * 3444030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 3445030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 3446030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 3447030c1d2bSEric W. Biederman * won't conflict with other devices. 3448c6c0ac66SMichael Ellerman * 3449a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 3450a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 3451a5462516STimur Tabi * some insight: 3452a5462516STimur Tabi * 3453a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 3454a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 3455a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 3456a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 3457a5462516STimur Tabi * 3458a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 3459a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 3460a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 3461a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 3462a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 3463a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 3464a5462516STimur Tabi * 3465a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 3466a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 3467a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 3468a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 3469a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 3470a5462516STimur Tabi * reasons. 3471a5462516STimur Tabi * 3472a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 3473a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 3474a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 3475a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 3476a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 3477a2de48caSGreg Kroah-Hartman */ 34786937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 3479a2de48caSGreg Kroah-Hartman { 34804b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 34812ee97cafSCornelia Huck char *old_device_name = NULL; 3482a2de48caSGreg Kroah-Hartman int error; 3483a2de48caSGreg Kroah-Hartman 3484a2de48caSGreg Kroah-Hartman dev = get_device(dev); 3485a2de48caSGreg Kroah-Hartman if (!dev) 3486a2de48caSGreg Kroah-Hartman return -EINVAL; 3487a2de48caSGreg Kroah-Hartman 348869df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 3489a2de48caSGreg Kroah-Hartman 34901fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 34912ee97cafSCornelia Huck if (!old_device_name) { 3492952ab431SJesper Juhl error = -ENOMEM; 34932ee97cafSCornelia Huck goto out; 3494952ab431SJesper Juhl } 3495a2de48caSGreg Kroah-Hartman 3496f349cf34SEric W. Biederman if (dev->class) { 34974b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 34984b30ee58STejun Heo kobj, old_device_name, 34994b30ee58STejun Heo new_name, kobject_namespace(kobj)); 3500f349cf34SEric W. Biederman if (error) 3501f349cf34SEric W. Biederman goto out; 3502f349cf34SEric W. Biederman } 350339aba963SKay Sievers 35044b30ee58STejun Heo error = kobject_rename(kobj, new_name); 35051fa5ae85SKay Sievers if (error) 35062ee97cafSCornelia Huck goto out; 3507a2de48caSGreg Kroah-Hartman 35082ee97cafSCornelia Huck out: 3509a2de48caSGreg Kroah-Hartman put_device(dev); 3510a2de48caSGreg Kroah-Hartman 35112ee97cafSCornelia Huck kfree(old_device_name); 3512a2de48caSGreg Kroah-Hartman 3513a2de48caSGreg Kroah-Hartman return error; 3514a2de48caSGreg Kroah-Hartman } 3515a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 35168a82472fSCornelia Huck 35178a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 35188a82472fSCornelia Huck struct device *old_parent, 35198a82472fSCornelia Huck struct device *new_parent) 35208a82472fSCornelia Huck { 3521f7f3461dSGreg Kroah-Hartman int error = 0; 35228a82472fSCornelia Huck 3523f7f3461dSGreg Kroah-Hartman if (old_parent) 3524f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 3525f7f3461dSGreg Kroah-Hartman if (new_parent) 3526f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 3527f7f3461dSGreg Kroah-Hartman "device"); 3528f7f3461dSGreg Kroah-Hartman return error; 35298a82472fSCornelia Huck } 35308a82472fSCornelia Huck 35318a82472fSCornelia Huck /** 35328a82472fSCornelia Huck * device_move - moves a device to a new parent 35338a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 353413509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 3535ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 35368a82472fSCornelia Huck */ 3537ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 3538ffa6a705SCornelia Huck enum dpm_order dpm_order) 35398a82472fSCornelia Huck { 35408a82472fSCornelia Huck int error; 35418a82472fSCornelia Huck struct device *old_parent; 3542c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 35438a82472fSCornelia Huck 35448a82472fSCornelia Huck dev = get_device(dev); 35458a82472fSCornelia Huck if (!dev) 35468a82472fSCornelia Huck return -EINVAL; 35478a82472fSCornelia Huck 3548ffa6a705SCornelia Huck device_pm_lock(); 35498a82472fSCornelia Huck new_parent = get_device(new_parent); 3550c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 355184d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 355284d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 355384d0c27dSTetsuo Handa put_device(new_parent); 355484d0c27dSTetsuo Handa goto out; 355584d0c27dSTetsuo Handa } 355663b6971aSCornelia Huck 35571e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 35581e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 3559c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 35608a82472fSCornelia Huck if (error) { 356163b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 35628a82472fSCornelia Huck put_device(new_parent); 35638a82472fSCornelia Huck goto out; 35648a82472fSCornelia Huck } 35658a82472fSCornelia Huck old_parent = dev->parent; 35668a82472fSCornelia Huck dev->parent = new_parent; 35678a82472fSCornelia Huck if (old_parent) 3568f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 35690d358f22SYinghai Lu if (new_parent) { 3570f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3571f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 35720d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 35730d358f22SYinghai Lu } 35740d358f22SYinghai Lu 3575bdd4034dSRabin Vincent if (dev->class) { 35768a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 35778a82472fSCornelia Huck if (error) { 35788a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 35798a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 35808a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 3581c744aeaeSCornelia Huck if (new_parent) 3582f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 35830d358f22SYinghai Lu dev->parent = old_parent; 35840d358f22SYinghai Lu if (old_parent) { 3585f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3586f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 35870d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 35880d358f22SYinghai Lu } 35898a82472fSCornelia Huck } 359063b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 35918a82472fSCornelia Huck put_device(new_parent); 35928a82472fSCornelia Huck goto out; 35938a82472fSCornelia Huck } 3594bdd4034dSRabin Vincent } 3595ffa6a705SCornelia Huck switch (dpm_order) { 3596ffa6a705SCornelia Huck case DPM_ORDER_NONE: 3597ffa6a705SCornelia Huck break; 3598ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 3599ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 360052cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 3601ffa6a705SCornelia Huck break; 3602ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 3603ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 360452cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 3605ffa6a705SCornelia Huck break; 3606ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 3607ffa6a705SCornelia Huck device_pm_move_last(dev); 360852cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 3609ffa6a705SCornelia Huck break; 3610ffa6a705SCornelia Huck } 3611bdd4034dSRabin Vincent 36128a82472fSCornelia Huck put_device(old_parent); 36138a82472fSCornelia Huck out: 3614ffa6a705SCornelia Huck device_pm_unlock(); 36158a82472fSCornelia Huck put_device(dev); 36168a82472fSCornelia Huck return error; 36178a82472fSCornelia Huck } 36188a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 361937b0c020SGreg Kroah-Hartman 3620b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 3621b8f33e5dSChristian Brauner kgid_t kgid) 3622b8f33e5dSChristian Brauner { 3623b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3624b8f33e5dSChristian Brauner struct class *class = dev->class; 3625b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 3626b8f33e5dSChristian Brauner int error; 3627b8f33e5dSChristian Brauner 3628b8f33e5dSChristian Brauner if (class) { 3629b8f33e5dSChristian Brauner /* 3630b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 3631b8f33e5dSChristian Brauner * @kuid/@kgid. 3632b8f33e5dSChristian Brauner */ 3633b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 3634b8f33e5dSChristian Brauner kgid); 3635b8f33e5dSChristian Brauner if (error) 3636b8f33e5dSChristian Brauner return error; 3637b8f33e5dSChristian Brauner } 3638b8f33e5dSChristian Brauner 3639b8f33e5dSChristian Brauner if (type) { 3640b8f33e5dSChristian Brauner /* 3641b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 3642b8f33e5dSChristian Brauner * @kuid/@kgid. 3643b8f33e5dSChristian Brauner */ 3644b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 3645b8f33e5dSChristian Brauner kgid); 3646b8f33e5dSChristian Brauner if (error) 3647b8f33e5dSChristian Brauner return error; 3648b8f33e5dSChristian Brauner } 3649b8f33e5dSChristian Brauner 3650b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 3651b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 3652b8f33e5dSChristian Brauner if (error) 3653b8f33e5dSChristian Brauner return error; 3654b8f33e5dSChristian Brauner 3655b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 3656b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 3657b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 3658b8f33e5dSChristian Brauner kuid, kgid); 3659b8f33e5dSChristian Brauner if (error) 3660b8f33e5dSChristian Brauner return error; 3661b8f33e5dSChristian Brauner } 3662b8f33e5dSChristian Brauner 3663b8f33e5dSChristian Brauner return 0; 3664b8f33e5dSChristian Brauner } 3665b8f33e5dSChristian Brauner 3666b8f33e5dSChristian Brauner /** 3667b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 3668b8f33e5dSChristian Brauner * @dev: device. 3669b8f33e5dSChristian Brauner * @kuid: new owner's kuid 3670b8f33e5dSChristian Brauner * @kgid: new owner's kgid 3671b8f33e5dSChristian Brauner * 3672b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 3673b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 3674b8f33e5dSChristian Brauner * core. 3675b8f33e5dSChristian Brauner * 3676b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 3677b8f33e5dSChristian Brauner */ 3678b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 3679b8f33e5dSChristian Brauner { 3680b8f33e5dSChristian Brauner int error; 3681b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3682b8f33e5dSChristian Brauner 3683b8f33e5dSChristian Brauner dev = get_device(dev); 3684b8f33e5dSChristian Brauner if (!dev) 3685b8f33e5dSChristian Brauner return -EINVAL; 3686b8f33e5dSChristian Brauner 3687b8f33e5dSChristian Brauner /* 3688b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 3689b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 3690b8f33e5dSChristian Brauner */ 3691b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 3692b8f33e5dSChristian Brauner if (error) 3693b8f33e5dSChristian Brauner goto out; 3694b8f33e5dSChristian Brauner 3695b8f33e5dSChristian Brauner /* 3696b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 3697b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 3698b8f33e5dSChristian Brauner * that step here. 3699b8f33e5dSChristian Brauner */ 3700b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 3701b8f33e5dSChristian Brauner kgid); 3702b8f33e5dSChristian Brauner if (error) 3703b8f33e5dSChristian Brauner goto out; 3704b8f33e5dSChristian Brauner 3705b8f33e5dSChristian Brauner /* 3706b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 3707b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 3708b8f33e5dSChristian Brauner * to @kuid/@kgid. 3709b8f33e5dSChristian Brauner */ 3710b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 3711b8f33e5dSChristian Brauner if (error) 3712b8f33e5dSChristian Brauner goto out; 3713b8f33e5dSChristian Brauner 37143b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 37153b52fc5dSChristian Brauner if (error) 37163b52fc5dSChristian Brauner goto out; 37173b52fc5dSChristian Brauner 3718b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 3719b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 3720b8f33e5dSChristian Brauner goto out; 3721b8f33e5dSChristian Brauner #endif 3722b8f33e5dSChristian Brauner 3723b8f33e5dSChristian Brauner /* 3724b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 3725b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 3726b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 3727b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 3728b8f33e5dSChristian Brauner */ 3729b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 3730b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 3731b8f33e5dSChristian Brauner if (error) 3732b8f33e5dSChristian Brauner goto out; 3733b8f33e5dSChristian Brauner 3734b8f33e5dSChristian Brauner out: 3735b8f33e5dSChristian Brauner put_device(dev); 3736b8f33e5dSChristian Brauner return error; 3737b8f33e5dSChristian Brauner } 3738b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 3739b8f33e5dSChristian Brauner 374037b0c020SGreg Kroah-Hartman /** 374137b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 374237b0c020SGreg Kroah-Hartman */ 374337b0c020SGreg Kroah-Hartman void device_shutdown(void) 374437b0c020SGreg Kroah-Hartman { 3745f123db8eSBenson Leung struct device *dev, *parent; 374637b0c020SGreg Kroah-Hartman 37473297c8fcSPingfan Liu wait_for_device_probe(); 37483297c8fcSPingfan Liu device_block_probing(); 37493297c8fcSPingfan Liu 375065650b35SRafael J. Wysocki cpufreq_suspend(); 375165650b35SRafael J. Wysocki 37526245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 37536245838fSHugh Daschbach /* 37546245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 37556245838fSHugh Daschbach * Beware that device unplug events may also start pulling 37566245838fSHugh Daschbach * devices offline, even as the system is shutting down. 37576245838fSHugh Daschbach */ 37586245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 37596245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 37606245838fSHugh Daschbach kobj.entry); 3761d1c6c030SMing Lei 3762d1c6c030SMing Lei /* 3763d1c6c030SMing Lei * hold reference count of device's parent to 3764d1c6c030SMing Lei * prevent it from being freed because parent's 3765d1c6c030SMing Lei * lock is to be held 3766d1c6c030SMing Lei */ 3767f123db8eSBenson Leung parent = get_device(dev->parent); 37686245838fSHugh Daschbach get_device(dev); 37696245838fSHugh Daschbach /* 37706245838fSHugh Daschbach * Make sure the device is off the kset list, in the 37716245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 37726245838fSHugh Daschbach */ 37736245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 37746245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 3775fe6b91f4SAlan Stern 3776d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 3777f123db8eSBenson Leung if (parent) 3778f123db8eSBenson Leung device_lock(parent); 3779d1c6c030SMing Lei device_lock(dev); 3780d1c6c030SMing Lei 3781fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 3782fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 3783fe6b91f4SAlan Stern pm_runtime_barrier(dev); 37846245838fSHugh Daschbach 37857521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 3786f77af151SJosh Zimmerman if (initcall_debug) 37877521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 37887521621eSMichal Suchanek dev->class->shutdown_pre(dev); 37897521621eSMichal Suchanek } 37907521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 37910246c4faSShuoX Liu if (initcall_debug) 37920246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 379337b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 379437b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 37950246c4faSShuoX Liu if (initcall_debug) 37960246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 379737b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 379837b0c020SGreg Kroah-Hartman } 3799d1c6c030SMing Lei 3800d1c6c030SMing Lei device_unlock(dev); 3801f123db8eSBenson Leung if (parent) 3802f123db8eSBenson Leung device_unlock(parent); 3803d1c6c030SMing Lei 38046245838fSHugh Daschbach put_device(dev); 3805f123db8eSBenson Leung put_device(parent); 38066245838fSHugh Daschbach 38076245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 380837b0c020SGreg Kroah-Hartman } 38096245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 381037b0c020SGreg Kroah-Hartman } 381199bcf217SJoe Perches 381299bcf217SJoe Perches /* 381399bcf217SJoe Perches * Device logging functions 381499bcf217SJoe Perches */ 381599bcf217SJoe Perches 381699bcf217SJoe Perches #ifdef CONFIG_PRINTK 3817666f355fSJoe Perches static int 3818666f355fSJoe Perches create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 381999bcf217SJoe Perches { 3820c4e00daaSKay Sievers const char *subsys; 3821798efc60SJoe Perches size_t pos = 0; 382299bcf217SJoe Perches 3823c4e00daaSKay Sievers if (dev->class) 3824c4e00daaSKay Sievers subsys = dev->class->name; 3825c4e00daaSKay Sievers else if (dev->bus) 3826c4e00daaSKay Sievers subsys = dev->bus->name; 3827c4e00daaSKay Sievers else 3828798efc60SJoe Perches return 0; 3829c4e00daaSKay Sievers 3830798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 3831655e5b7cSBen Hutchings if (pos >= hdrlen) 3832655e5b7cSBen Hutchings goto overflow; 3833c4e00daaSKay Sievers 3834c4e00daaSKay Sievers /* 3835c4e00daaSKay Sievers * Add device identifier DEVICE=: 3836c4e00daaSKay Sievers * b12:8 block dev_t 3837c4e00daaSKay Sievers * c127:3 char dev_t 3838c4e00daaSKay Sievers * n8 netdev ifindex 3839c4e00daaSKay Sievers * +sound:card0 subsystem:devname 3840c4e00daaSKay Sievers */ 3841c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 3842c4e00daaSKay Sievers char c; 3843c4e00daaSKay Sievers 3844c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 3845c4e00daaSKay Sievers c = 'b'; 3846c4e00daaSKay Sievers else 3847c4e00daaSKay Sievers c = 'c'; 3848798efc60SJoe Perches pos++; 3849798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3850c4e00daaSKay Sievers "DEVICE=%c%u:%u", 3851c4e00daaSKay Sievers c, MAJOR(dev->devt), MINOR(dev->devt)); 3852c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 3853c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 3854c4e00daaSKay Sievers 3855798efc60SJoe Perches pos++; 3856798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3857c4e00daaSKay Sievers "DEVICE=n%u", net->ifindex); 3858c4e00daaSKay Sievers } else { 3859798efc60SJoe Perches pos++; 3860798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3861c4e00daaSKay Sievers "DEVICE=+%s:%s", subsys, dev_name(dev)); 3862c4e00daaSKay Sievers } 3863af7f2158SJim Cromie 3864655e5b7cSBen Hutchings if (pos >= hdrlen) 3865655e5b7cSBen Hutchings goto overflow; 3866655e5b7cSBen Hutchings 3867798efc60SJoe Perches return pos; 3868655e5b7cSBen Hutchings 3869655e5b7cSBen Hutchings overflow: 3870655e5b7cSBen Hutchings dev_WARN(dev, "device/subsystem name too long"); 3871655e5b7cSBen Hutchings return 0; 387299bcf217SJoe Perches } 3873798efc60SJoe Perches 387405e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 387505e4e5b8SJoe Perches const char *fmt, va_list args) 387605e4e5b8SJoe Perches { 387705e4e5b8SJoe Perches char hdr[128]; 387805e4e5b8SJoe Perches size_t hdrlen; 387905e4e5b8SJoe Perches 388005e4e5b8SJoe Perches hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 388105e4e5b8SJoe Perches 388205e4e5b8SJoe Perches return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 388305e4e5b8SJoe Perches } 388405e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 388505e4e5b8SJoe Perches 388605e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 388705e4e5b8SJoe Perches { 388805e4e5b8SJoe Perches va_list args; 388905e4e5b8SJoe Perches int r; 389005e4e5b8SJoe Perches 389105e4e5b8SJoe Perches va_start(args, fmt); 389205e4e5b8SJoe Perches 389305e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 389405e4e5b8SJoe Perches 389505e4e5b8SJoe Perches va_end(args); 389605e4e5b8SJoe Perches 389705e4e5b8SJoe Perches return r; 389805e4e5b8SJoe Perches } 389905e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 390005e4e5b8SJoe Perches 3901d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 3902798efc60SJoe Perches struct va_format *vaf) 3903798efc60SJoe Perches { 3904d1f1052cSJoe Perches if (dev) 3905d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 3906798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 3907d1f1052cSJoe Perches else 3908d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 3909798efc60SJoe Perches } 391099bcf217SJoe Perches 3911d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 391299bcf217SJoe Perches const char *fmt, ...) 391399bcf217SJoe Perches { 391499bcf217SJoe Perches struct va_format vaf; 391599bcf217SJoe Perches va_list args; 391699bcf217SJoe Perches 391799bcf217SJoe Perches va_start(args, fmt); 391899bcf217SJoe Perches 391999bcf217SJoe Perches vaf.fmt = fmt; 392099bcf217SJoe Perches vaf.va = &args; 392199bcf217SJoe Perches 3922d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 3923798efc60SJoe Perches 392499bcf217SJoe Perches va_end(args); 392599bcf217SJoe Perches } 392699bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 392799bcf217SJoe Perches 392899bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 3929d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 393099bcf217SJoe Perches { \ 393199bcf217SJoe Perches struct va_format vaf; \ 393299bcf217SJoe Perches va_list args; \ 393399bcf217SJoe Perches \ 393499bcf217SJoe Perches va_start(args, fmt); \ 393599bcf217SJoe Perches \ 393699bcf217SJoe Perches vaf.fmt = fmt; \ 393799bcf217SJoe Perches vaf.va = &args; \ 393899bcf217SJoe Perches \ 3939d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 3940798efc60SJoe Perches \ 394199bcf217SJoe Perches va_end(args); \ 394299bcf217SJoe Perches } \ 394399bcf217SJoe Perches EXPORT_SYMBOL(func); 394499bcf217SJoe Perches 3945663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 3946663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 3947663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 3948663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 3949663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 3950663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 395199bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 395299bcf217SJoe Perches 395399bcf217SJoe Perches #endif 395497badf87SRafael J. Wysocki 395597badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 395697badf87SRafael J. Wysocki { 395797badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 395897badf87SRafael J. Wysocki } 395997badf87SRafael J. Wysocki 396097badf87SRafael J. Wysocki /** 396197badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 396297badf87SRafael J. Wysocki * @dev: Device to handle. 396397badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 396497badf87SRafael J. Wysocki * 396597badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 396697badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 396797badf87SRafael J. Wysocki */ 396897badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 396997badf87SRafael J. Wysocki { 397097badf87SRafael J. Wysocki if (fwnode) { 397197badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 397297badf87SRafael J. Wysocki 397397badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 397497badf87SRafael J. Wysocki fn = fn->secondary; 397597badf87SRafael J. Wysocki 397655f89a8aSMika Westerberg if (fn) { 397755f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 397897badf87SRafael J. Wysocki fwnode->secondary = fn; 397955f89a8aSMika Westerberg } 398097badf87SRafael J. Wysocki dev->fwnode = fwnode; 398197badf87SRafael J. Wysocki } else { 398297badf87SRafael J. Wysocki dev->fwnode = fwnode_is_primary(dev->fwnode) ? 398397badf87SRafael J. Wysocki dev->fwnode->secondary : NULL; 398497badf87SRafael J. Wysocki } 398597badf87SRafael J. Wysocki } 398697badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 398797badf87SRafael J. Wysocki 398897badf87SRafael J. Wysocki /** 398997badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 399097badf87SRafael J. Wysocki * @dev: Device to handle. 399197badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 399297badf87SRafael J. Wysocki * 399397badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 399497badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 399597badf87SRafael J. Wysocki * @fwnode. 399697badf87SRafael J. Wysocki */ 399797badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 399897badf87SRafael J. Wysocki { 399997badf87SRafael J. Wysocki if (fwnode) 400097badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 400197badf87SRafael J. Wysocki 400297badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 400397badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 400497badf87SRafael J. Wysocki else 400597badf87SRafael J. Wysocki dev->fwnode = fwnode; 400697badf87SRafael J. Wysocki } 400796489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 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