1989d42e8SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * drivers/base/core.c - core driver model code (device registration, etc) 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright (c) 2002-3 Patrick Mochel 61da177e4SLinus Torvalds * Copyright (c) 2002-3 Open Source Development Labs 764bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 864bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Novell, Inc. 91da177e4SLinus Torvalds */ 101da177e4SLinus Torvalds 117847a145SHeikki Krogerus #include <linux/acpi.h> 121da177e4SLinus Torvalds #include <linux/device.h> 131da177e4SLinus Torvalds #include <linux/err.h> 1497badf87SRafael J. Wysocki #include <linux/fwnode.h> 151da177e4SLinus Torvalds #include <linux/init.h> 161da177e4SLinus Torvalds #include <linux/module.h> 171da177e4SLinus Torvalds #include <linux/slab.h> 181da177e4SLinus Torvalds #include <linux/string.h> 1923681e47SGreg Kroah-Hartman #include <linux/kdev_t.h> 20116af378SBenjamin Herrenschmidt #include <linux/notifier.h> 2107d57a32SGrant Likely #include <linux/of.h> 2207d57a32SGrant Likely #include <linux/of_device.h> 23da231fd5SKay Sievers #include <linux/genhd.h> 24f75b1c60SDave Young #include <linux/mutex.h> 25af8db150SPeter Chen #include <linux/pm_runtime.h> 26c4e00daaSKay Sievers #include <linux/netdevice.h> 27174cd4b1SIngo Molnar #include <linux/sched/signal.h> 2863967685SGreg Kroah-Hartman #include <linux/sysfs.h> 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds #include "base.h" 311da177e4SLinus Torvalds #include "power/power.h" 321da177e4SLinus Torvalds 33e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 34e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 35e52eec13SAndi Kleen long sysfs_deprecated = 1; 36e52eec13SAndi Kleen #else 37e52eec13SAndi Kleen long sysfs_deprecated = 0; 38e52eec13SAndi Kleen #endif 393454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 40e52eec13SAndi Kleen { 4134da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 42e52eec13SAndi Kleen } 43e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 44e52eec13SAndi Kleen #endif 45e52eec13SAndi Kleen 469ed98953SRafael J. Wysocki /* Device links support. */ 479ed98953SRafael J. Wysocki 489ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 499ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 509ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 519ed98953SRafael J. Wysocki 529ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 539ed98953SRafael J. Wysocki { 549ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 559ed98953SRafael J. Wysocki } 569ed98953SRafael J. Wysocki 579ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 589ed98953SRafael J. Wysocki { 599ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 609ed98953SRafael J. Wysocki } 619ed98953SRafael J. Wysocki 629ed98953SRafael J. Wysocki int device_links_read_lock(void) 639ed98953SRafael J. Wysocki { 649ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 659ed98953SRafael J. Wysocki } 669ed98953SRafael J. Wysocki 679ed98953SRafael J. Wysocki void device_links_read_unlock(int idx) 689ed98953SRafael J. Wysocki { 699ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 709ed98953SRafael J. Wysocki } 719ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 729ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 739ed98953SRafael J. Wysocki 749ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 759ed98953SRafael J. Wysocki { 769ed98953SRafael J. Wysocki down_write(&device_links_lock); 779ed98953SRafael J. Wysocki } 789ed98953SRafael J. Wysocki 799ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 809ed98953SRafael J. Wysocki { 819ed98953SRafael J. Wysocki up_write(&device_links_lock); 829ed98953SRafael J. Wysocki } 839ed98953SRafael J. Wysocki 849ed98953SRafael J. Wysocki int device_links_read_lock(void) 859ed98953SRafael J. Wysocki { 869ed98953SRafael J. Wysocki down_read(&device_links_lock); 879ed98953SRafael J. Wysocki return 0; 889ed98953SRafael J. Wysocki } 899ed98953SRafael J. Wysocki 909ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 919ed98953SRafael J. Wysocki { 929ed98953SRafael J. Wysocki up_read(&device_links_lock); 939ed98953SRafael J. Wysocki } 949ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 959ed98953SRafael J. Wysocki 969ed98953SRafael J. Wysocki /** 979ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 989ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 999ed98953SRafael J. Wysocki * @target: Device to check against. 1009ed98953SRafael J. Wysocki * 1019ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 1029ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 1039ed98953SRafael J. Wysocki */ 1049ed98953SRafael J. Wysocki static int device_is_dependent(struct device *dev, void *target) 1059ed98953SRafael J. Wysocki { 1069ed98953SRafael J. Wysocki struct device_link *link; 1079ed98953SRafael J. Wysocki int ret; 1089ed98953SRafael J. Wysocki 109e16f4f3eSBenjamin Gaignard if (dev == target) 1109ed98953SRafael J. Wysocki return 1; 1119ed98953SRafael J. Wysocki 1129ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 1139ed98953SRafael J. Wysocki if (ret) 1149ed98953SRafael J. Wysocki return ret; 1159ed98953SRafael J. Wysocki 1169ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 117e16f4f3eSBenjamin Gaignard if (link->consumer == target) 1189ed98953SRafael J. Wysocki return 1; 1199ed98953SRafael J. Wysocki 1209ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 1219ed98953SRafael J. Wysocki if (ret) 1229ed98953SRafael J. Wysocki break; 1239ed98953SRafael J. Wysocki } 1249ed98953SRafael J. Wysocki return ret; 1259ed98953SRafael J. Wysocki } 1269ed98953SRafael J. Wysocki 1279ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 1289ed98953SRafael J. Wysocki { 1299ed98953SRafael J. Wysocki struct device_link *link; 1309ed98953SRafael J. Wysocki 1319ed98953SRafael J. Wysocki /* 1329ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 1339ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 1349ed98953SRafael J. Wysocki */ 1359ed98953SRafael J. Wysocki if (device_is_registered(dev)) 1369ed98953SRafael J. Wysocki devices_kset_move_last(dev); 1379ed98953SRafael J. Wysocki 1389ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 1399ed98953SRafael J. Wysocki device_pm_move_last(dev); 1409ed98953SRafael J. Wysocki 1419ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 1429ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) 1439ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 1449ed98953SRafael J. Wysocki 1459ed98953SRafael J. Wysocki return 0; 1469ed98953SRafael J. Wysocki } 1479ed98953SRafael J. Wysocki 1489ed98953SRafael J. Wysocki /** 149494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 150494fd7b7SFeng Kan * @dev: Device to move 151494fd7b7SFeng Kan * 152494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 153494fd7b7SFeng Kan * 154494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 155494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 156494fd7b7SFeng Kan */ 157494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 158494fd7b7SFeng Kan { 159494fd7b7SFeng Kan int idx; 160494fd7b7SFeng Kan 161494fd7b7SFeng Kan idx = device_links_read_lock(); 162494fd7b7SFeng Kan device_pm_lock(); 163494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 164494fd7b7SFeng Kan device_pm_unlock(); 165494fd7b7SFeng Kan device_links_read_unlock(idx); 166494fd7b7SFeng Kan } 167494fd7b7SFeng Kan 168e2f3cd83SRafael J. Wysocki static void device_link_rpm_prepare(struct device *consumer, 169e2f3cd83SRafael J. Wysocki struct device *supplier) 170e2f3cd83SRafael J. Wysocki { 171e2f3cd83SRafael J. Wysocki pm_runtime_new_link(consumer); 172e2f3cd83SRafael J. Wysocki /* 173e2f3cd83SRafael J. Wysocki * If the link is being added by the consumer driver at probe time, 174e2f3cd83SRafael J. Wysocki * balance the decrementation of the supplier's runtime PM usage counter 175e2f3cd83SRafael J. Wysocki * after consumer probe in driver_probe_device(). 176e2f3cd83SRafael J. Wysocki */ 177e2f3cd83SRafael J. Wysocki if (consumer->links.status == DL_DEV_PROBING) 178e2f3cd83SRafael J. Wysocki pm_runtime_get_noresume(supplier); 179e2f3cd83SRafael J. Wysocki } 180e2f3cd83SRafael J. Wysocki 181494fd7b7SFeng Kan /** 1829ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 1839ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 1849ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 1859ed98953SRafael J. Wysocki * @flags: Link flags. 1869ed98953SRafael J. Wysocki * 18721d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 18821d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 18921d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 19021d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 19121d5c57bSRafael J. Wysocki * be forced into the active metastate and reference-counted upon the creation 19221d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 19321d5c57bSRafael J. Wysocki * ignored. 19421d5c57bSRafael J. Wysocki * 19572175d4eSRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the link is not going to be managed by 19672175d4eSRafael J. Wysocki * the driver core and, in particular, the caller of this function is expected 19772175d4eSRafael J. Wysocki * to drop the reference to the link acquired by it directly. 19872175d4eSRafael J. Wysocki * 19972175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 20072175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 20172175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 20272175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 20372175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 20472175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 20572175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 20672175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 20772175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 20872175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 20972175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 210c8d50986SRafael J. Wysocki * 211e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 212e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 213e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 214e7dd4010SRafael J. Wysocki * be used to request the driver core to automaticall probe for a consmer 215e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 216e7dd4010SRafael J. Wysocki * 217c8d50986SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and either DL_FLAG_AUTOREMOVE_CONSUMER 218c8d50986SRafael J. Wysocki * or DL_FLAG_AUTOREMOVE_SUPPLIER set in @flags at the same time is invalid and 219c8d50986SRafael J. Wysocki * will cause NULL to be returned upfront. 2209ed98953SRafael J. Wysocki * 2219ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 2229ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 2239ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 2249ed98953SRafael J. Wysocki * not been registered when this function is called). 2259ed98953SRafael J. Wysocki * 2269ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 2279ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 22864df1148SLukas Wunner * not be registered, however. 2299ed98953SRafael J. Wysocki */ 2309ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 2319ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 2329ed98953SRafael J. Wysocki { 2339ed98953SRafael J. Wysocki struct device_link *link; 2349ed98953SRafael J. Wysocki 2359ed98953SRafael J. Wysocki if (!consumer || !supplier || 236c8d50986SRafael J. Wysocki (flags & DL_FLAG_STATELESS && 237e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 238e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | 239e7dd4010SRafael J. Wysocki DL_FLAG_AUTOPROBE_CONSUMER)) || 240e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 241e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 242e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 2439ed98953SRafael J. Wysocki return NULL; 2449ed98953SRafael J. Wysocki 2455db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 2465db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 2475db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 2485db25c9eSRafael J. Wysocki return NULL; 2495db25c9eSRafael J. Wysocki } 2505db25c9eSRafael J. Wysocki } 2515db25c9eSRafael J. Wysocki 2529ed98953SRafael J. Wysocki device_links_write_lock(); 2539ed98953SRafael J. Wysocki device_pm_lock(); 2549ed98953SRafael J. Wysocki 2559ed98953SRafael J. Wysocki /* 2569ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 2579ed98953SRafael J. Wysocki * reverse dependency between the consumer and the supplier already in 2589ed98953SRafael J. Wysocki * the graph, return NULL. 2599ed98953SRafael J. Wysocki */ 2609ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 2619ed98953SRafael J. Wysocki || device_is_dependent(consumer, supplier)) { 2629ed98953SRafael J. Wysocki link = NULL; 2639ed98953SRafael J. Wysocki goto out; 2649ed98953SRafael J. Wysocki } 2659ed98953SRafael J. Wysocki 26672175d4eSRafael J. Wysocki /* 26772175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 26872175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 26972175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 27072175d4eSRafael J. Wysocki */ 27172175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 27272175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 27372175d4eSRafael J. Wysocki 274f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 275f265df55SRafael J. Wysocki if (link->consumer != consumer) 276f265df55SRafael J. Wysocki continue; 277f265df55SRafael J. Wysocki 278f265df55SRafael J. Wysocki /* 279f265df55SRafael J. Wysocki * Don't return a stateless link if the caller wants a stateful 280f265df55SRafael J. Wysocki * one and vice versa. 281f265df55SRafael J. Wysocki */ 282f265df55SRafael J. Wysocki if (WARN_ON((flags & DL_FLAG_STATELESS) != (link->flags & DL_FLAG_STATELESS))) { 283f265df55SRafael J. Wysocki link = NULL; 284f265df55SRafael J. Wysocki goto out; 285f265df55SRafael J. Wysocki } 286f265df55SRafael J. Wysocki 287e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 288e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 289e2f3cd83SRafael J. Wysocki device_link_rpm_prepare(consumer, supplier); 290e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 291e2f3cd83SRafael J. Wysocki } 292e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 293e2f3cd83SRafael J. Wysocki refcount_inc(&link->rpm_active); 294e2f3cd83SRafael J. Wysocki } 295e2f3cd83SRafael J. Wysocki 29672175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 297ead18c23SLukas Wunner kref_get(&link->kref); 2989ed98953SRafael J. Wysocki goto out; 299ead18c23SLukas Wunner } 3009ed98953SRafael J. Wysocki 30172175d4eSRafael J. Wysocki /* 30272175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 30372175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 30472175d4eSRafael J. Wysocki * update the existing link to stay around longer. 30572175d4eSRafael J. Wysocki */ 30672175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 30772175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 30872175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 30972175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 31072175d4eSRafael J. Wysocki } 31172175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 31272175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 31372175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 31472175d4eSRafael J. Wysocki } 31572175d4eSRafael J. Wysocki goto out; 31672175d4eSRafael J. Wysocki } 31772175d4eSRafael J. Wysocki 31821d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 3199ed98953SRafael J. Wysocki if (!link) 3209ed98953SRafael J. Wysocki goto out; 3219ed98953SRafael J. Wysocki 322e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 323e2f3cd83SRafael J. Wysocki 324baa8809fSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 325e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 326e2f3cd83SRafael J. Wysocki refcount_inc(&link->rpm_active); 327e2f3cd83SRafael J. Wysocki 328e2f3cd83SRafael J. Wysocki device_link_rpm_prepare(consumer, supplier); 32921d5c57bSRafael J. Wysocki } 330e2f3cd83SRafael J. Wysocki 3319ed98953SRafael J. Wysocki get_device(supplier); 3329ed98953SRafael J. Wysocki link->supplier = supplier; 3339ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 3349ed98953SRafael J. Wysocki get_device(consumer); 3359ed98953SRafael J. Wysocki link->consumer = consumer; 3369ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 3379ed98953SRafael J. Wysocki link->flags = flags; 338ead18c23SLukas Wunner kref_init(&link->kref); 3399ed98953SRafael J. Wysocki 34064df1148SLukas Wunner /* Determine the initial link state. */ 3419ed98953SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 3429ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 3439ed98953SRafael J. Wysocki } else { 3449ed98953SRafael J. Wysocki switch (supplier->links.status) { 34515cfb094SRafael J. Wysocki case DL_DEV_PROBING: 3469ed98953SRafael J. Wysocki switch (consumer->links.status) { 3479ed98953SRafael J. Wysocki case DL_DEV_PROBING: 34821d5c57bSRafael J. Wysocki /* 34915cfb094SRafael J. Wysocki * A consumer driver can create a link to a 35015cfb094SRafael J. Wysocki * supplier that has not completed its probing 35115cfb094SRafael J. Wysocki * yet as long as it knows that the supplier is 35215cfb094SRafael J. Wysocki * already functional (for example, it has just 35315cfb094SRafael J. Wysocki * acquired some resources from the supplier). 35421d5c57bSRafael J. Wysocki */ 35515cfb094SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 35615cfb094SRafael J. Wysocki break; 35715cfb094SRafael J. Wysocki default: 35815cfb094SRafael J. Wysocki link->status = DL_STATE_DORMANT; 35915cfb094SRafael J. Wysocki break; 36015cfb094SRafael J. Wysocki } 36115cfb094SRafael J. Wysocki break; 36215cfb094SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 36315cfb094SRafael J. Wysocki switch (consumer->links.status) { 36415cfb094SRafael J. Wysocki case DL_DEV_PROBING: 3659ed98953SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 3669ed98953SRafael J. Wysocki break; 3679ed98953SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 3689ed98953SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 3699ed98953SRafael J. Wysocki break; 3709ed98953SRafael J. Wysocki default: 3719ed98953SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 3729ed98953SRafael J. Wysocki break; 3739ed98953SRafael J. Wysocki } 3749ed98953SRafael J. Wysocki break; 3759ed98953SRafael J. Wysocki case DL_DEV_UNBINDING: 3769ed98953SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 3779ed98953SRafael J. Wysocki break; 3789ed98953SRafael J. Wysocki default: 3799ed98953SRafael J. Wysocki link->status = DL_STATE_DORMANT; 3809ed98953SRafael J. Wysocki break; 3819ed98953SRafael J. Wysocki } 3829ed98953SRafael J. Wysocki } 3839ed98953SRafael J. Wysocki 3849ed98953SRafael J. Wysocki /* 38515cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 38615cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 38715cfb094SRafael J. Wysocki */ 38815cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 38915cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 39015cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 39115cfb094SRafael J. Wysocki 39215cfb094SRafael J. Wysocki /* 3939ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 3949ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 3959ed98953SRafael J. Wysocki * 3969ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 3979ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 3989ed98953SRafael J. Wysocki */ 3999ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 4009ed98953SRafael J. Wysocki 4019ed98953SRafael J. Wysocki list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 4029ed98953SRafael J. Wysocki list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 4039ed98953SRafael J. Wysocki 4048a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 4059ed98953SRafael J. Wysocki 4069ed98953SRafael J. Wysocki out: 4079ed98953SRafael J. Wysocki device_pm_unlock(); 4089ed98953SRafael J. Wysocki device_links_write_unlock(); 4095db25c9eSRafael J. Wysocki 410e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 4115db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 4125db25c9eSRafael J. Wysocki 4139ed98953SRafael J. Wysocki return link; 4149ed98953SRafael J. Wysocki } 4159ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 4169ed98953SRafael J. Wysocki 4179ed98953SRafael J. Wysocki static void device_link_free(struct device_link *link) 4189ed98953SRafael J. Wysocki { 419a1fdbfbbSRafael J. Wysocki while (refcount_dec_not_one(&link->rpm_active)) 420a1fdbfbbSRafael J. Wysocki pm_runtime_put(link->supplier); 421a1fdbfbbSRafael J. Wysocki 4229ed98953SRafael J. Wysocki put_device(link->consumer); 4239ed98953SRafael J. Wysocki put_device(link->supplier); 4249ed98953SRafael J. Wysocki kfree(link); 4259ed98953SRafael J. Wysocki } 4269ed98953SRafael J. Wysocki 4279ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 4289ed98953SRafael J. Wysocki static void __device_link_free_srcu(struct rcu_head *rhead) 4299ed98953SRafael J. Wysocki { 4309ed98953SRafael J. Wysocki device_link_free(container_of(rhead, struct device_link, rcu_head)); 4319ed98953SRafael J. Wysocki } 4329ed98953SRafael J. Wysocki 433ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 4349ed98953SRafael J. Wysocki { 435ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 436ead18c23SLukas Wunner 4378a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 4389ed98953SRafael J. Wysocki dev_name(link->supplier)); 4399ed98953SRafael J. Wysocki 440baa8809fSRafael J. Wysocki if (link->flags & DL_FLAG_PM_RUNTIME) 441baa8809fSRafael J. Wysocki pm_runtime_drop_link(link->consumer); 442baa8809fSRafael J. Wysocki 4439ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 4449ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 4459ed98953SRafael J. Wysocki call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 4469ed98953SRafael J. Wysocki } 4479ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 448ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 4499ed98953SRafael J. Wysocki { 450ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 451ead18c23SLukas Wunner 4529ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 4539ed98953SRafael J. Wysocki dev_name(link->supplier)); 4549ed98953SRafael J. Wysocki 455433986c2SLukas Wunner if (link->flags & DL_FLAG_PM_RUNTIME) 456433986c2SLukas Wunner pm_runtime_drop_link(link->consumer); 457433986c2SLukas Wunner 4589ed98953SRafael J. Wysocki list_del(&link->s_node); 4599ed98953SRafael J. Wysocki list_del(&link->c_node); 4609ed98953SRafael J. Wysocki device_link_free(link); 4619ed98953SRafael J. Wysocki } 4629ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 4639ed98953SRafael J. Wysocki 46472175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 46572175d4eSRafael J. Wysocki { 46672175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 46772175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 46872175d4eSRafael J. Wysocki else 46972175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 47072175d4eSRafael J. Wysocki } 47172175d4eSRafael J. Wysocki 4729ed98953SRafael J. Wysocki /** 47372175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 4749ed98953SRafael J. Wysocki * @link: Device link to delete. 4759ed98953SRafael J. Wysocki * 4769ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 477ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 478ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 479ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 4809ed98953SRafael J. Wysocki */ 4819ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 4829ed98953SRafael J. Wysocki { 4839ed98953SRafael J. Wysocki device_links_write_lock(); 4849ed98953SRafael J. Wysocki device_pm_lock(); 48572175d4eSRafael J. Wysocki device_link_put_kref(link); 4869ed98953SRafael J. Wysocki device_pm_unlock(); 4879ed98953SRafael J. Wysocki device_links_write_unlock(); 4889ed98953SRafael J. Wysocki } 4899ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 4909ed98953SRafael J. Wysocki 491d8842211Spascal paillet /** 49272175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 493d8842211Spascal paillet * @consumer: Consumer end of the link. 494d8842211Spascal paillet * @supplier: Supplier end of the link. 495d8842211Spascal paillet * 496d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 497d8842211Spascal paillet * PM. 498d8842211Spascal paillet */ 499d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 500d8842211Spascal paillet { 501d8842211Spascal paillet struct device_link *link; 502d8842211Spascal paillet 503d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 504d8842211Spascal paillet return; 505d8842211Spascal paillet 506d8842211Spascal paillet device_links_write_lock(); 507d8842211Spascal paillet device_pm_lock(); 508d8842211Spascal paillet 509d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 510d8842211Spascal paillet if (link->consumer == consumer) { 51172175d4eSRafael J. Wysocki device_link_put_kref(link); 512d8842211Spascal paillet break; 513d8842211Spascal paillet } 514d8842211Spascal paillet } 515d8842211Spascal paillet 516d8842211Spascal paillet device_pm_unlock(); 517d8842211Spascal paillet device_links_write_unlock(); 518d8842211Spascal paillet } 519d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 520d8842211Spascal paillet 5219ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 5229ed98953SRafael J. Wysocki { 5239ed98953SRafael J. Wysocki struct device_link *link; 5249ed98953SRafael J. Wysocki 5259ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) 5269ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE) 5279ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 5289ed98953SRafael J. Wysocki } 5299ed98953SRafael J. Wysocki 5309ed98953SRafael J. Wysocki /** 5319ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 5329ed98953SRafael J. Wysocki * @dev: Consumer device. 5339ed98953SRafael J. Wysocki * 5349ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 5359ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 5369ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 5379ed98953SRafael J. Wysocki * 5389ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 5399ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 5409ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 5419ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 5429ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 5439ed98953SRafael J. Wysocki * 5449ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 5459ed98953SRafael J. Wysocki */ 5469ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 5479ed98953SRafael J. Wysocki { 5489ed98953SRafael J. Wysocki struct device_link *link; 5499ed98953SRafael J. Wysocki int ret = 0; 5509ed98953SRafael J. Wysocki 5519ed98953SRafael J. Wysocki device_links_write_lock(); 5529ed98953SRafael J. Wysocki 5539ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 5549ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 5559ed98953SRafael J. Wysocki continue; 5569ed98953SRafael J. Wysocki 5579ed98953SRafael J. Wysocki if (link->status != DL_STATE_AVAILABLE) { 5589ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 5599ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 5609ed98953SRafael J. Wysocki break; 5619ed98953SRafael J. Wysocki } 5629ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 5639ed98953SRafael J. Wysocki } 5649ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 5659ed98953SRafael J. Wysocki 5669ed98953SRafael J. Wysocki device_links_write_unlock(); 5679ed98953SRafael J. Wysocki return ret; 5689ed98953SRafael J. Wysocki } 5699ed98953SRafael J. Wysocki 5709ed98953SRafael J. Wysocki /** 5719ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 5729ed98953SRafael J. Wysocki * @dev: Device to update the links for. 5739ed98953SRafael J. Wysocki * 5749ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 5759ed98953SRafael J. Wysocki * consumers by changing their status to "available". 5769ed98953SRafael J. Wysocki * 5779ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 5789ed98953SRafael J. Wysocki * 5799ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 5809ed98953SRafael J. Wysocki */ 5819ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 5829ed98953SRafael J. Wysocki { 5839ed98953SRafael J. Wysocki struct device_link *link; 5849ed98953SRafael J. Wysocki 5859ed98953SRafael J. Wysocki device_links_write_lock(); 5869ed98953SRafael J. Wysocki 5879ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 5889ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 5899ed98953SRafael J. Wysocki continue; 5909ed98953SRafael J. Wysocki 59115cfb094SRafael J. Wysocki /* 59215cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 59315cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 59415cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 59515cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 59615cfb094SRafael J. Wysocki */ 59715cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 59815cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 59915cfb094SRafael J. Wysocki continue; 60015cfb094SRafael J. Wysocki 6019ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 6029ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 603e7dd4010SRafael J. Wysocki 604e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 605e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 6069ed98953SRafael J. Wysocki } 6079ed98953SRafael J. Wysocki 6089ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 6099ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 6109ed98953SRafael J. Wysocki continue; 6119ed98953SRafael J. Wysocki 6129ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 6139ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 6149ed98953SRafael J. Wysocki } 6159ed98953SRafael J. Wysocki 6169ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 6179ed98953SRafael J. Wysocki 6189ed98953SRafael J. Wysocki device_links_write_unlock(); 6199ed98953SRafael J. Wysocki } 6209ed98953SRafael J. Wysocki 6219ed98953SRafael J. Wysocki /** 6229ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 6239ed98953SRafael J. Wysocki * @dev: Device without a drvier. 6249ed98953SRafael J. Wysocki * 6259ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 6269ed98953SRafael J. Wysocki * 6279ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 6289ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 6299ed98953SRafael J. Wysocki * case they need not be updated. 6309ed98953SRafael J. Wysocki * 6319ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 6329ed98953SRafael J. Wysocki */ 6339ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 6349ed98953SRafael J. Wysocki { 6359ed98953SRafael J. Wysocki struct device_link *link, *ln; 6369ed98953SRafael J. Wysocki 6379ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 6389ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 6399ed98953SRafael J. Wysocki continue; 6409ed98953SRafael J. Wysocki 641e88728f4SVivek Gautam if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 6420fe6f787SYong Wu __device_link_del(&link->kref); 64315cfb094SRafael J. Wysocki else if (link->status == DL_STATE_CONSUMER_PROBE || 64415cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 6459ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 6469ed98953SRafael J. Wysocki } 6479ed98953SRafael J. Wysocki 6489ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 6499ed98953SRafael J. Wysocki } 6509ed98953SRafael J. Wysocki 65115cfb094SRafael J. Wysocki /** 65215cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 65315cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 65415cfb094SRafael J. Wysocki * 65515cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 65615cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 65715cfb094SRafael J. Wysocki * appropriate. 65815cfb094SRafael J. Wysocki * 65915cfb094SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 66015cfb094SRafael J. Wysocki */ 6619ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 6629ed98953SRafael J. Wysocki { 66315cfb094SRafael J. Wysocki struct device_link *link; 66415cfb094SRafael J. Wysocki 6659ed98953SRafael J. Wysocki device_links_write_lock(); 66615cfb094SRafael J. Wysocki 66715cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 66815cfb094SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 66915cfb094SRafael J. Wysocki continue; 67015cfb094SRafael J. Wysocki 67115cfb094SRafael J. Wysocki /* 67215cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 67315cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 67415cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 67515cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 67615cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 67715cfb094SRafael J. Wysocki */ 67815cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 67915cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 68015cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 68115cfb094SRafael J. Wysocki } 68215cfb094SRafael J. Wysocki 6839ed98953SRafael J. Wysocki __device_links_no_driver(dev); 68415cfb094SRafael J. Wysocki 6859ed98953SRafael J. Wysocki device_links_write_unlock(); 6869ed98953SRafael J. Wysocki } 6879ed98953SRafael J. Wysocki 6889ed98953SRafael J. Wysocki /** 6899ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 6909ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 6919ed98953SRafael J. Wysocki * 6929ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 6939ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 6949ed98953SRafael J. Wysocki * appropriate. 6959ed98953SRafael J. Wysocki * 6969ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 6979ed98953SRafael J. Wysocki */ 6989ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 6999ed98953SRafael J. Wysocki { 700c8d50986SRafael J. Wysocki struct device_link *link, *ln; 7019ed98953SRafael J. Wysocki 7029ed98953SRafael J. Wysocki device_links_write_lock(); 7039ed98953SRafael J. Wysocki 704c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 7059ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 7069ed98953SRafael J. Wysocki continue; 7079ed98953SRafael J. Wysocki 708e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 7099ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 7101689cac5SVivek Gautam 7111689cac5SVivek Gautam /* 7121689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 7131689cac5SVivek Gautam * devices that are not active, i.e. where the link state 7141689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 7151689cac5SVivek Gautam */ 7161689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 7171689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 7180fe6f787SYong Wu __device_link_del(&link->kref); 7191689cac5SVivek Gautam 7209ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 7219ed98953SRafael J. Wysocki } 7229ed98953SRafael J. Wysocki 7239ed98953SRafael J. Wysocki __device_links_no_driver(dev); 7249ed98953SRafael J. Wysocki 7259ed98953SRafael J. Wysocki device_links_write_unlock(); 7269ed98953SRafael J. Wysocki } 7279ed98953SRafael J. Wysocki 7289ed98953SRafael J. Wysocki /** 7299ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 7309ed98953SRafael J. Wysocki * @dev: Device to check. 7319ed98953SRafael J. Wysocki * 7329ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 7339ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 7349ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 7359ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 7369ed98953SRafael J. Wysocki * successfully going forward. 7379ed98953SRafael J. Wysocki * 7389ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 7399ed98953SRafael J. Wysocki * 7409ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 7419ed98953SRafael J. Wysocki */ 7429ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 7439ed98953SRafael J. Wysocki { 7449ed98953SRafael J. Wysocki struct device_link *link; 7459ed98953SRafael J. Wysocki bool ret = false; 7469ed98953SRafael J. Wysocki 7479ed98953SRafael J. Wysocki device_links_write_lock(); 7489ed98953SRafael J. Wysocki 7499ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 7509ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 7519ed98953SRafael J. Wysocki continue; 7529ed98953SRafael J. Wysocki 7539ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 7549ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 7559ed98953SRafael J. Wysocki ret = true; 7569ed98953SRafael J. Wysocki break; 7579ed98953SRafael J. Wysocki } 7589ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 7599ed98953SRafael J. Wysocki } 7609ed98953SRafael J. Wysocki 7619ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 7629ed98953SRafael J. Wysocki 7639ed98953SRafael J. Wysocki device_links_write_unlock(); 7649ed98953SRafael J. Wysocki return ret; 7659ed98953SRafael J. Wysocki } 7669ed98953SRafael J. Wysocki 7679ed98953SRafael J. Wysocki /** 7689ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 7699ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 7709ed98953SRafael J. Wysocki * 7719ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 7729ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 7739ed98953SRafael J. Wysocki * and start over. 7749ed98953SRafael J. Wysocki * 7759ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 7769ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 7779ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 7789ed98953SRafael J. Wysocki * changed the state of the link already). 7799ed98953SRafael J. Wysocki * 7809ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 7819ed98953SRafael J. Wysocki */ 7829ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 7839ed98953SRafael J. Wysocki { 7849ed98953SRafael J. Wysocki struct device_link *link; 7859ed98953SRafael J. Wysocki 7869ed98953SRafael J. Wysocki start: 7879ed98953SRafael J. Wysocki device_links_write_lock(); 7889ed98953SRafael J. Wysocki 7899ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 7909ed98953SRafael J. Wysocki enum device_link_state status; 7919ed98953SRafael J. Wysocki 7929ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 7939ed98953SRafael J. Wysocki continue; 7949ed98953SRafael J. Wysocki 7959ed98953SRafael J. Wysocki status = link->status; 7969ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 7979ed98953SRafael J. Wysocki device_links_write_unlock(); 7989ed98953SRafael J. Wysocki 7999ed98953SRafael J. Wysocki wait_for_device_probe(); 8009ed98953SRafael J. Wysocki goto start; 8019ed98953SRafael J. Wysocki } 8029ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 8039ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 8049ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 8059ed98953SRafael J. Wysocki 8069ed98953SRafael J. Wysocki get_device(consumer); 8079ed98953SRafael J. Wysocki 8089ed98953SRafael J. Wysocki device_links_write_unlock(); 8099ed98953SRafael J. Wysocki 8109ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 8119ed98953SRafael J. Wysocki consumer->parent); 8129ed98953SRafael J. Wysocki put_device(consumer); 8139ed98953SRafael J. Wysocki goto start; 8149ed98953SRafael J. Wysocki } 8159ed98953SRafael J. Wysocki } 8169ed98953SRafael J. Wysocki 8179ed98953SRafael J. Wysocki device_links_write_unlock(); 8189ed98953SRafael J. Wysocki } 8199ed98953SRafael J. Wysocki 8209ed98953SRafael J. Wysocki /** 8219ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 8229ed98953SRafael J. Wysocki * @dev: Target device. 8239ed98953SRafael J. Wysocki */ 8249ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 8259ed98953SRafael J. Wysocki { 8269ed98953SRafael J. Wysocki struct device_link *link, *ln; 8279ed98953SRafael J. Wysocki 8289ed98953SRafael J. Wysocki /* 8299ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 8309ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 8319ed98953SRafael J. Wysocki */ 8329ed98953SRafael J. Wysocki device_links_write_lock(); 8339ed98953SRafael J. Wysocki 8349ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 8359ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 836ead18c23SLukas Wunner __device_link_del(&link->kref); 8379ed98953SRafael J. Wysocki } 8389ed98953SRafael J. Wysocki 8399ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 8409ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 8419ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 842ead18c23SLukas Wunner __device_link_del(&link->kref); 8439ed98953SRafael J. Wysocki } 8449ed98953SRafael J. Wysocki 8459ed98953SRafael J. Wysocki device_links_write_unlock(); 8469ed98953SRafael J. Wysocki } 8479ed98953SRafael J. Wysocki 8489ed98953SRafael J. Wysocki /* Device links support end. */ 8499ed98953SRafael J. Wysocki 8501da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 8511da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 852e105b8bfSDan Williams static struct kobject *dev_kobj; 853e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 854e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 8551da177e4SLinus Torvalds 8565e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 8575e33bc41SRafael J. Wysocki 8585e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 8595e33bc41SRafael J. Wysocki { 8605e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 8615e33bc41SRafael J. Wysocki } 8625e33bc41SRafael J. Wysocki 8635e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 8645e33bc41SRafael J. Wysocki { 8655e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 8665e33bc41SRafael J. Wysocki } 8675e33bc41SRafael J. Wysocki 8685e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 8695e33bc41SRafael J. Wysocki { 8705e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 8715e33bc41SRafael J. Wysocki return 0; 8725e33bc41SRafael J. Wysocki 8735e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 8745e33bc41SRafael J. Wysocki msleep(5); 8755e33bc41SRafael J. Wysocki return restart_syscall(); 8765e33bc41SRafael J. Wysocki } 8775e33bc41SRafael J. Wysocki 8784e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 8794e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 8804e886c29SGreg Kroah-Hartman { 8814e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 8824e886c29SGreg Kroah-Hartman } 8834e886c29SGreg Kroah-Hartman #else 8844e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 8854e886c29SGreg Kroah-Hartman { 8864e886c29SGreg Kroah-Hartman return 1; 8874e886c29SGreg Kroah-Hartman } 8884e886c29SGreg Kroah-Hartman #endif 8891da177e4SLinus Torvalds 89007de0e86SHeikki Krogerus static int 89107de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 89207de0e86SHeikki Krogerus { 8937847a145SHeikki Krogerus int ret; 8947847a145SHeikki Krogerus 8957847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 8967847a145SHeikki Krogerus if (ret) 8977847a145SHeikki Krogerus return ret; 8987847a145SHeikki Krogerus 89959abd836SHeikki Krogerus ret = software_node_notify(dev, action); 90059abd836SHeikki Krogerus if (ret) 90159abd836SHeikki Krogerus return ret; 90259abd836SHeikki Krogerus 90307de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 90407de0e86SHeikki Krogerus platform_notify(dev); 90507de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 90607de0e86SHeikki Krogerus platform_notify_remove(dev); 90707de0e86SHeikki Krogerus return 0; 90807de0e86SHeikki Krogerus } 90907de0e86SHeikki Krogerus 9103e95637aSAlan Stern /** 9113e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 9123e95637aSAlan Stern * @dev: struct device to get the name of 9133e95637aSAlan Stern * 9143e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 9159169c012Syan * the device is not bound to a driver, it will return the name of the bus 9163e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 9173e95637aSAlan Stern * string will be returned. 9183e95637aSAlan Stern */ 919bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 9203e95637aSAlan Stern { 9213589972eSAlan Stern struct device_driver *drv; 9223589972eSAlan Stern 9233589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 9243589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 9253589972eSAlan Stern * never change once they are set, so they don't need special care. 9263589972eSAlan Stern */ 9276aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 9283589972eSAlan Stern return drv ? drv->name : 929a456b702SJean Delvare (dev->bus ? dev->bus->name : 930a456b702SJean Delvare (dev->class ? dev->class->name : "")); 9313e95637aSAlan Stern } 932310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 9333e95637aSAlan Stern 9341da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 9351da177e4SLinus Torvalds 9364a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 9374a3ad20cSGreg Kroah-Hartman char *buf) 9381da177e4SLinus Torvalds { 9391da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 940b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 9414a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds if (dev_attr->show) 94454b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 945815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 946a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 947a52668c6SSergey Senozhatsky dev_attr->show); 948815d2d50SAndrew Morton } 9491da177e4SLinus Torvalds return ret; 9501da177e4SLinus Torvalds } 9511da177e4SLinus Torvalds 9524a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 9531da177e4SLinus Torvalds const char *buf, size_t count) 9541da177e4SLinus Torvalds { 9551da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 956b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 9574a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds if (dev_attr->store) 96054b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 9611da177e4SLinus Torvalds return ret; 9621da177e4SLinus Torvalds } 9631da177e4SLinus Torvalds 96452cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 9651da177e4SLinus Torvalds .show = dev_attr_show, 9661da177e4SLinus Torvalds .store = dev_attr_store, 9671da177e4SLinus Torvalds }; 9681da177e4SLinus Torvalds 969ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 970ca22e56dSKay Sievers 971ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 972ca22e56dSKay Sievers struct device_attribute *attr, 973ca22e56dSKay Sievers const char *buf, size_t size) 974ca22e56dSKay Sievers { 975ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 976f88184bfSKaitao cheng int ret; 977f88184bfSKaitao cheng unsigned long new; 978f88184bfSKaitao cheng 979f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 980f88184bfSKaitao cheng if (ret) 981f88184bfSKaitao cheng return ret; 982ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 983ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 984ca22e56dSKay Sievers return size; 985ca22e56dSKay Sievers } 986ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 987ca22e56dSKay Sievers 988ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 989ca22e56dSKay Sievers struct device_attribute *attr, 990ca22e56dSKay Sievers char *buf) 991ca22e56dSKay Sievers { 992ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 993ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 994ca22e56dSKay Sievers } 995ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 996ca22e56dSKay Sievers 997ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 998ca22e56dSKay Sievers struct device_attribute *attr, 999ca22e56dSKay Sievers const char *buf, size_t size) 1000ca22e56dSKay Sievers { 1001ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1002f88184bfSKaitao cheng int ret; 1003f88184bfSKaitao cheng long new; 1004f88184bfSKaitao cheng 1005f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 1006f88184bfSKaitao cheng if (ret) 1007f88184bfSKaitao cheng return ret; 1008f88184bfSKaitao cheng 1009f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 1010ca22e56dSKay Sievers return -EINVAL; 1011ca22e56dSKay Sievers *(int *)(ea->var) = new; 1012ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1013ca22e56dSKay Sievers return size; 1014ca22e56dSKay Sievers } 1015ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 1016ca22e56dSKay Sievers 1017ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 1018ca22e56dSKay Sievers struct device_attribute *attr, 1019ca22e56dSKay Sievers char *buf) 1020ca22e56dSKay Sievers { 1021ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1022ca22e56dSKay Sievers 1023ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 1024ca22e56dSKay Sievers } 1025ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 10261da177e4SLinus Torvalds 102791872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 102891872392SBorislav Petkov const char *buf, size_t size) 102991872392SBorislav Petkov { 103091872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 103191872392SBorislav Petkov 103291872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 103391872392SBorislav Petkov return -EINVAL; 103491872392SBorislav Petkov 103591872392SBorislav Petkov return size; 103691872392SBorislav Petkov } 103791872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 103891872392SBorislav Petkov 103991872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 104091872392SBorislav Petkov char *buf) 104191872392SBorislav Petkov { 104291872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 104391872392SBorislav Petkov 104491872392SBorislav Petkov return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 104591872392SBorislav Petkov } 104691872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 104791872392SBorislav Petkov 10481da177e4SLinus Torvalds /** 10491da177e4SLinus Torvalds * device_release - free device structure. 10501da177e4SLinus Torvalds * @kobj: device's kobject. 10511da177e4SLinus Torvalds * 10521da177e4SLinus Torvalds * This is called once the reference count for the object 10531da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 10541da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 10551da177e4SLinus Torvalds */ 10561da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 10571da177e4SLinus Torvalds { 1058b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1059fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 10601da177e4SLinus Torvalds 1061a525a3ddSMing Lei /* 1062a525a3ddSMing Lei * Some platform devices are driven without driver attached 1063a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 1064a525a3ddSMing Lei * all resources are released. 1065a525a3ddSMing Lei * 1066a525a3ddSMing Lei * Drivers still can add resources into device after device 1067a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 1068a525a3ddSMing Lei * possible memory leak. 1069a525a3ddSMing Lei */ 1070a525a3ddSMing Lei devres_release_all(dev); 1071a525a3ddSMing Lei 10721da177e4SLinus Torvalds if (dev->release) 10731da177e4SLinus Torvalds dev->release(dev); 1074f9f852dfSKay Sievers else if (dev->type && dev->type->release) 1075f9f852dfSKay Sievers dev->type->release(dev); 10762620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 10772620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 1078f810a5cfSArjan van de Ven else 1079186bddb2SEzequiel Garcia WARN(1, KERN_ERR "Device '%s' does not have a release() function, it is broken and must be fixed. See Documentation/kobject.txt.\n", 10801e0b2cf9SKay Sievers dev_name(dev)); 1081fb069a5dSGreg Kroah-Hartman kfree(p); 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds 1084bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 1085bc451f20SEric W. Biederman { 1086b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1087bc451f20SEric W. Biederman const void *ns = NULL; 1088bc451f20SEric W. Biederman 1089bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 1090bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 1091bc451f20SEric W. Biederman 1092bc451f20SEric W. Biederman return ns; 1093bc451f20SEric W. Biederman } 1094bc451f20SEric W. Biederman 10959944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 10969944e894SDmitry Torokhov { 10979944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 10989944e894SDmitry Torokhov 10999944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 11009944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 11019944e894SDmitry Torokhov } 11029944e894SDmitry Torokhov 11038f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 11041da177e4SLinus Torvalds .release = device_release, 11051da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 1106bc451f20SEric W. Biederman .namespace = device_namespace, 11079944e894SDmitry Torokhov .get_ownership = device_get_ownership, 11081da177e4SLinus Torvalds }; 11091da177e4SLinus Torvalds 11101da177e4SLinus Torvalds 1111312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 11121da177e4SLinus Torvalds { 11131da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 11141da177e4SLinus Torvalds 11158f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 1116b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 11171da177e4SLinus Torvalds if (dev->bus) 11181da177e4SLinus Torvalds return 1; 111923681e47SGreg Kroah-Hartman if (dev->class) 112023681e47SGreg Kroah-Hartman return 1; 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds return 0; 11231da177e4SLinus Torvalds } 11241da177e4SLinus Torvalds 1125312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 11261da177e4SLinus Torvalds { 1127b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 11281da177e4SLinus Torvalds 112923681e47SGreg Kroah-Hartman if (dev->bus) 11301da177e4SLinus Torvalds return dev->bus->name; 113123681e47SGreg Kroah-Hartman if (dev->class) 113223681e47SGreg Kroah-Hartman return dev->class->name; 113323681e47SGreg Kroah-Hartman return NULL; 11341da177e4SLinus Torvalds } 11351da177e4SLinus Torvalds 11367eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 11377eff2e7aSKay Sievers struct kobj_uevent_env *env) 11381da177e4SLinus Torvalds { 1139b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 11401da177e4SLinus Torvalds int retval = 0; 11411da177e4SLinus Torvalds 11426fcf53acSKay Sievers /* add device node properties if present */ 114323681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 11446fcf53acSKay Sievers const char *tmp; 11456fcf53acSKay Sievers const char *name; 11462c9ede55SAl Viro umode_t mode = 0; 11474e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 11484e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 11496fcf53acSKay Sievers 11507eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 11517eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 11523c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 11536fcf53acSKay Sievers if (name) { 11546fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 1155e454cea2SKay Sievers if (mode) 1156e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 11574e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 11584e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 11594e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 11604e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 11613c2670e6SKay Sievers kfree(tmp); 11626fcf53acSKay Sievers } 116323681e47SGreg Kroah-Hartman } 116423681e47SGreg Kroah-Hartman 1165414264f9SKay Sievers if (dev->type && dev->type->name) 11667eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 1167414264f9SKay Sievers 1168239378f1SKay Sievers if (dev->driver) 11697eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 1170239378f1SKay Sievers 117107d57a32SGrant Likely /* Add common DT information about the device */ 117207d57a32SGrant Likely of_device_uevent(dev, env); 117307d57a32SGrant Likely 11741da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 11757eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 11767eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 1177f9f852dfSKay Sievers if (retval) 11787dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 11791e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 11801da177e4SLinus Torvalds } 11811da177e4SLinus Torvalds 11822620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 11837eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 11847eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 1185f9f852dfSKay Sievers if (retval) 11867dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 11871e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 11882b3a302aSHarvey Harrison __func__, retval); 11892620efefSGreg Kroah-Hartman } 1190f9f852dfSKay Sievers 1191eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 11927eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 11937eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 1194f9f852dfSKay Sievers if (retval) 11957dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 11961e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 11972b3a302aSHarvey Harrison __func__, retval); 11982620efefSGreg Kroah-Hartman } 11992620efefSGreg Kroah-Hartman 12001da177e4SLinus Torvalds return retval; 12011da177e4SLinus Torvalds } 12021da177e4SLinus Torvalds 12039cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 1204312c004dSKay Sievers .filter = dev_uevent_filter, 1205312c004dSKay Sievers .name = dev_uevent_name, 1206312c004dSKay Sievers .uevent = dev_uevent, 12071da177e4SLinus Torvalds }; 12081da177e4SLinus Torvalds 1209c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 121016574dccSKay Sievers char *buf) 121116574dccSKay Sievers { 121216574dccSKay Sievers struct kobject *top_kobj; 121316574dccSKay Sievers struct kset *kset; 12147eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 121516574dccSKay Sievers int i; 121616574dccSKay Sievers size_t count = 0; 121716574dccSKay Sievers int retval; 121816574dccSKay Sievers 121916574dccSKay Sievers /* search the kset, the device belongs to */ 122016574dccSKay Sievers top_kobj = &dev->kobj; 12215c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 122216574dccSKay Sievers top_kobj = top_kobj->parent; 122316574dccSKay Sievers if (!top_kobj->kset) 122416574dccSKay Sievers goto out; 12255c5daf65SKay Sievers 122616574dccSKay Sievers kset = top_kobj->kset; 122716574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 122816574dccSKay Sievers goto out; 122916574dccSKay Sievers 123016574dccSKay Sievers /* respect filter */ 123116574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 123216574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 123316574dccSKay Sievers goto out; 123416574dccSKay Sievers 12357eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 12367eff2e7aSKay Sievers if (!env) 1237c7308c81SGreg Kroah-Hartman return -ENOMEM; 1238c7308c81SGreg Kroah-Hartman 123916574dccSKay Sievers /* let the kset specific function add its keys */ 12407eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 124116574dccSKay Sievers if (retval) 124216574dccSKay Sievers goto out; 124316574dccSKay Sievers 124416574dccSKay Sievers /* copy keys to file */ 12457eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 12467eff2e7aSKay Sievers count += sprintf(&buf[count], "%s\n", env->envp[i]); 124716574dccSKay Sievers out: 12487eff2e7aSKay Sievers kfree(env); 124916574dccSKay Sievers return count; 125016574dccSKay Sievers } 125116574dccSKay Sievers 1252c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 1253a7fd6706SKay Sievers const char *buf, size_t count) 1254a7fd6706SKay Sievers { 1255df44b479SPeter Rajnoha int rc; 1256df44b479SPeter Rajnoha 1257df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 1258df44b479SPeter Rajnoha 1259df44b479SPeter Rajnoha if (rc) { 1260f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 1261df44b479SPeter Rajnoha return rc; 1262df44b479SPeter Rajnoha } 126360a96a59SKay Sievers 1264a7fd6706SKay Sievers return count; 1265a7fd6706SKay Sievers } 1266c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 1267a7fd6706SKay Sievers 1268c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 12694f3549d7SRafael J. Wysocki char *buf) 12704f3549d7SRafael J. Wysocki { 12714f3549d7SRafael J. Wysocki bool val; 12724f3549d7SRafael J. Wysocki 12735e33bc41SRafael J. Wysocki device_lock(dev); 12744f3549d7SRafael J. Wysocki val = !dev->offline; 12755e33bc41SRafael J. Wysocki device_unlock(dev); 12764f3549d7SRafael J. Wysocki return sprintf(buf, "%u\n", val); 12774f3549d7SRafael J. Wysocki } 12784f3549d7SRafael J. Wysocki 1279c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 12804f3549d7SRafael J. Wysocki const char *buf, size_t count) 12814f3549d7SRafael J. Wysocki { 12824f3549d7SRafael J. Wysocki bool val; 12834f3549d7SRafael J. Wysocki int ret; 12844f3549d7SRafael J. Wysocki 12854f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 12864f3549d7SRafael J. Wysocki if (ret < 0) 12874f3549d7SRafael J. Wysocki return ret; 12884f3549d7SRafael J. Wysocki 12895e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 12905e33bc41SRafael J. Wysocki if (ret) 12915e33bc41SRafael J. Wysocki return ret; 12925e33bc41SRafael J. Wysocki 12934f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 12944f3549d7SRafael J. Wysocki unlock_device_hotplug(); 12954f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 12964f3549d7SRafael J. Wysocki } 1297c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 12984f3549d7SRafael J. Wysocki 1299fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 1300621a1672SDmitry Torokhov { 13013e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 1302621a1672SDmitry Torokhov } 1303a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 1304621a1672SDmitry Torokhov 1305fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 1306a4dbd674SDavid Brownell const struct attribute_group **groups) 1307621a1672SDmitry Torokhov { 13083e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 1309621a1672SDmitry Torokhov } 1310a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 1311de0ff00dSGreg Kroah-Hartman 131257b8ff07SDmitry Torokhov union device_attr_group_devres { 131357b8ff07SDmitry Torokhov const struct attribute_group *group; 131457b8ff07SDmitry Torokhov const struct attribute_group **groups; 131557b8ff07SDmitry Torokhov }; 131657b8ff07SDmitry Torokhov 131757b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 131857b8ff07SDmitry Torokhov { 131957b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 132057b8ff07SDmitry Torokhov } 132157b8ff07SDmitry Torokhov 132257b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 132357b8ff07SDmitry Torokhov { 132457b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 132557b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 132657b8ff07SDmitry Torokhov 132757b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 132857b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 132957b8ff07SDmitry Torokhov } 133057b8ff07SDmitry Torokhov 133157b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 133257b8ff07SDmitry Torokhov { 133357b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 133457b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 133557b8ff07SDmitry Torokhov 133657b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 133757b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 133857b8ff07SDmitry Torokhov } 133957b8ff07SDmitry Torokhov 134057b8ff07SDmitry Torokhov /** 134157b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 134257b8ff07SDmitry Torokhov * @dev: The device to create the group for 134357b8ff07SDmitry Torokhov * @grp: The attribute group to create 134457b8ff07SDmitry Torokhov * 134557b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 134657b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 134757b8ff07SDmitry Torokhov * 134857b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 134957b8ff07SDmitry Torokhov */ 135057b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 135157b8ff07SDmitry Torokhov { 135257b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 135357b8ff07SDmitry Torokhov int error; 135457b8ff07SDmitry Torokhov 135557b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 135657b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 135757b8ff07SDmitry Torokhov if (!devres) 135857b8ff07SDmitry Torokhov return -ENOMEM; 135957b8ff07SDmitry Torokhov 136057b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 136157b8ff07SDmitry Torokhov if (error) { 136257b8ff07SDmitry Torokhov devres_free(devres); 136357b8ff07SDmitry Torokhov return error; 136457b8ff07SDmitry Torokhov } 136557b8ff07SDmitry Torokhov 136657b8ff07SDmitry Torokhov devres->group = grp; 136757b8ff07SDmitry Torokhov devres_add(dev, devres); 136857b8ff07SDmitry Torokhov return 0; 136957b8ff07SDmitry Torokhov } 137057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 137157b8ff07SDmitry Torokhov 137257b8ff07SDmitry Torokhov /** 137357b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 137457b8ff07SDmitry Torokhov * @dev: device to remove the group from 137557b8ff07SDmitry Torokhov * @grp: group to remove 137657b8ff07SDmitry Torokhov * 137757b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 137857b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 137957b8ff07SDmitry Torokhov */ 138057b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 138157b8ff07SDmitry Torokhov const struct attribute_group *grp) 138257b8ff07SDmitry Torokhov { 138357b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 138457b8ff07SDmitry Torokhov devm_attr_group_match, 138557b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 138657b8ff07SDmitry Torokhov } 138757b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 138857b8ff07SDmitry Torokhov 138957b8ff07SDmitry Torokhov /** 139057b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 139157b8ff07SDmitry Torokhov * @dev: The device to create the group for 139257b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 139357b8ff07SDmitry Torokhov * 139457b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 139557b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 139657b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 139757b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 139857b8ff07SDmitry Torokhov * attribute files being created already exist. 139957b8ff07SDmitry Torokhov * 140057b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 140157b8ff07SDmitry Torokhov */ 140257b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 140357b8ff07SDmitry Torokhov const struct attribute_group **groups) 140457b8ff07SDmitry Torokhov { 140557b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 140657b8ff07SDmitry Torokhov int error; 140757b8ff07SDmitry Torokhov 140857b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 140957b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 141057b8ff07SDmitry Torokhov if (!devres) 141157b8ff07SDmitry Torokhov return -ENOMEM; 141257b8ff07SDmitry Torokhov 141357b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 141457b8ff07SDmitry Torokhov if (error) { 141557b8ff07SDmitry Torokhov devres_free(devres); 141657b8ff07SDmitry Torokhov return error; 141757b8ff07SDmitry Torokhov } 141857b8ff07SDmitry Torokhov 141957b8ff07SDmitry Torokhov devres->groups = groups; 142057b8ff07SDmitry Torokhov devres_add(dev, devres); 142157b8ff07SDmitry Torokhov return 0; 142257b8ff07SDmitry Torokhov } 142357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 142457b8ff07SDmitry Torokhov 142557b8ff07SDmitry Torokhov /** 142657b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 142757b8ff07SDmitry Torokhov * 142857b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 142957b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 143057b8ff07SDmitry Torokhov * 143157b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 143257b8ff07SDmitry Torokhov */ 143357b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 143457b8ff07SDmitry Torokhov const struct attribute_group **groups) 143557b8ff07SDmitry Torokhov { 143657b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 143757b8ff07SDmitry Torokhov devm_attr_group_match, 143857b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 143957b8ff07SDmitry Torokhov } 144057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 14411da177e4SLinus Torvalds 14422620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 14432620efefSGreg Kroah-Hartman { 14442620efefSGreg Kroah-Hartman struct class *class = dev->class; 1445aed65af1SStephen Hemminger const struct device_type *type = dev->type; 1446621a1672SDmitry Torokhov int error; 14472620efefSGreg Kroah-Hartman 1448621a1672SDmitry Torokhov if (class) { 1449d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 14502620efefSGreg Kroah-Hartman if (error) 1451621a1672SDmitry Torokhov return error; 1452f9f852dfSKay Sievers } 1453f9f852dfSKay Sievers 1454621a1672SDmitry Torokhov if (type) { 1455621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 1456f9f852dfSKay Sievers if (error) 1457a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 1458f9f852dfSKay Sievers } 1459621a1672SDmitry Torokhov 1460621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 1461f9f852dfSKay Sievers if (error) 1462621a1672SDmitry Torokhov goto err_remove_type_groups; 1463621a1672SDmitry Torokhov 14644f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 1465c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 14664f3549d7SRafael J. Wysocki if (error) 1467ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 14684f3549d7SRafael J. Wysocki } 14694f3549d7SRafael J. Wysocki 1470621a1672SDmitry Torokhov return 0; 1471621a1672SDmitry Torokhov 1472ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 1473ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 1474621a1672SDmitry Torokhov err_remove_type_groups: 1475621a1672SDmitry Torokhov if (type) 1476621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1477d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 1478d05a6f96SGreg Kroah-Hartman if (class) 1479d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1480f9f852dfSKay Sievers 14812620efefSGreg Kroah-Hartman return error; 14822620efefSGreg Kroah-Hartman } 14832620efefSGreg Kroah-Hartman 14842620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 14852620efefSGreg Kroah-Hartman { 14862620efefSGreg Kroah-Hartman struct class *class = dev->class; 1487aed65af1SStephen Hemminger const struct device_type *type = dev->type; 14882620efefSGreg Kroah-Hartman 1489c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 1490621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 1491f9f852dfSKay Sievers 1492621a1672SDmitry Torokhov if (type) 1493621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1494621a1672SDmitry Torokhov 1495a6b01dedSGreg Kroah-Hartman if (class) 1496d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1497c97415a7SStefan Achatz } 14982620efefSGreg Kroah-Hartman 1499c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 150023681e47SGreg Kroah-Hartman char *buf) 150123681e47SGreg Kroah-Hartman { 150223681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 150323681e47SGreg Kroah-Hartman } 1504c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 1505ad6a1e1cSTejun Heo 1506ca22e56dSKay Sievers /* /sys/devices/ */ 1507881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds /** 151052cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 151152cdbdd4SGrygorii Strashko * @deva: Device to move. 151252cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 151352cdbdd4SGrygorii Strashko */ 151452cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 151552cdbdd4SGrygorii Strashko { 151652cdbdd4SGrygorii Strashko if (!devices_kset) 151752cdbdd4SGrygorii Strashko return; 151852cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 151952cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 152052cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 152152cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 152252cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 152352cdbdd4SGrygorii Strashko } 152452cdbdd4SGrygorii Strashko 152552cdbdd4SGrygorii Strashko /** 152652cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 152752cdbdd4SGrygorii Strashko * @deva: Device to move 152852cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 152952cdbdd4SGrygorii Strashko */ 153052cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 153152cdbdd4SGrygorii Strashko { 153252cdbdd4SGrygorii Strashko if (!devices_kset) 153352cdbdd4SGrygorii Strashko return; 153452cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 153552cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 153652cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 153752cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 153852cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 153952cdbdd4SGrygorii Strashko } 154052cdbdd4SGrygorii Strashko 154152cdbdd4SGrygorii Strashko /** 154252cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 154352cdbdd4SGrygorii Strashko * @dev: device to move 154452cdbdd4SGrygorii Strashko */ 154552cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 154652cdbdd4SGrygorii Strashko { 154752cdbdd4SGrygorii Strashko if (!devices_kset) 154852cdbdd4SGrygorii Strashko return; 154952cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 155052cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 155152cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 155252cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 155352cdbdd4SGrygorii Strashko } 155452cdbdd4SGrygorii Strashko 155552cdbdd4SGrygorii Strashko /** 15561da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 15571da177e4SLinus Torvalds * @dev: device. 15581da177e4SLinus Torvalds * @attr: device attribute descriptor. 15591da177e4SLinus Torvalds */ 156026579ab7SPhil Carmody int device_create_file(struct device *dev, 156126579ab7SPhil Carmody const struct device_attribute *attr) 15621da177e4SLinus Torvalds { 15631da177e4SLinus Torvalds int error = 0; 15648f46baaaSFelipe Balbi 15658f46baaaSFelipe Balbi if (dev) { 15668f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 156797521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 156897521978Sdyoung@redhat.com attr->attr.name); 15698f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 157097521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 157197521978Sdyoung@redhat.com attr->attr.name); 15721da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 15738f46baaaSFelipe Balbi } 15748f46baaaSFelipe Balbi 15751da177e4SLinus Torvalds return error; 15761da177e4SLinus Torvalds } 157786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 15781da177e4SLinus Torvalds 15791da177e4SLinus Torvalds /** 15801da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 15811da177e4SLinus Torvalds * @dev: device. 15821da177e4SLinus Torvalds * @attr: device attribute descriptor. 15831da177e4SLinus Torvalds */ 158426579ab7SPhil Carmody void device_remove_file(struct device *dev, 158526579ab7SPhil Carmody const struct device_attribute *attr) 15861da177e4SLinus Torvalds { 15870c98b19fSCornelia Huck if (dev) 15881da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 15891da177e4SLinus Torvalds } 159086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 15911da177e4SLinus Torvalds 15922589f188SGreg Kroah-Hartman /** 15936b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 15946b0afc2aSTejun Heo * @dev: device. 15956b0afc2aSTejun Heo * @attr: device attribute descriptor. 15966b0afc2aSTejun Heo * 15976b0afc2aSTejun Heo * See kernfs_remove_self() for details. 15986b0afc2aSTejun Heo */ 15996b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 16006b0afc2aSTejun Heo const struct device_attribute *attr) 16016b0afc2aSTejun Heo { 16026b0afc2aSTejun Heo if (dev) 16036b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 16046b0afc2aSTejun Heo else 16056b0afc2aSTejun Heo return false; 16066b0afc2aSTejun Heo } 16076b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 16086b0afc2aSTejun Heo 16096b0afc2aSTejun Heo /** 16102589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 16112589f188SGreg Kroah-Hartman * @dev: device. 16122589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 16132589f188SGreg Kroah-Hartman */ 161466ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 161566ecb92bSPhil Carmody const struct bin_attribute *attr) 16162589f188SGreg Kroah-Hartman { 16172589f188SGreg Kroah-Hartman int error = -EINVAL; 16182589f188SGreg Kroah-Hartman if (dev) 16192589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 16202589f188SGreg Kroah-Hartman return error; 16212589f188SGreg Kroah-Hartman } 16222589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 16232589f188SGreg Kroah-Hartman 16242589f188SGreg Kroah-Hartman /** 16252589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 16262589f188SGreg Kroah-Hartman * @dev: device. 16272589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 16282589f188SGreg Kroah-Hartman */ 162966ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 163066ecb92bSPhil Carmody const struct bin_attribute *attr) 16312589f188SGreg Kroah-Hartman { 16322589f188SGreg Kroah-Hartman if (dev) 16332589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 16342589f188SGreg Kroah-Hartman } 16352589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 16362589f188SGreg Kroah-Hartman 163734bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 163834bb61f9SJames Bottomley { 1639f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1640f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 164134bb61f9SJames Bottomley 164234bb61f9SJames Bottomley get_device(dev); 164334bb61f9SJames Bottomley } 164434bb61f9SJames Bottomley 164534bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 164634bb61f9SJames Bottomley { 1647f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1648f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 164934bb61f9SJames Bottomley 165034bb61f9SJames Bottomley put_device(dev); 165134bb61f9SJames Bottomley } 165234bb61f9SJames Bottomley 16531da177e4SLinus Torvalds /** 16541da177e4SLinus Torvalds * device_initialize - init device structure. 16551da177e4SLinus Torvalds * @dev: device. 16561da177e4SLinus Torvalds * 16575739411aSCornelia Huck * This prepares the device for use by other layers by initializing 16585739411aSCornelia Huck * its fields. 16591da177e4SLinus Torvalds * It is the first half of device_register(), if called by 16605739411aSCornelia Huck * that function, though it can also be called separately, so one 16615739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 16625739411aSCornelia Huck * may be used for reference counting of @dev after calling this 16635739411aSCornelia Huck * function. 16645739411aSCornelia Huck * 1665b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 1666b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 1667b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 1668b10d5efdSAlan Stern * @dev. 1669b10d5efdSAlan Stern * 16705739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 16715739411aSCornelia Huck * @dev directly once you have called this function. 16721da177e4SLinus Torvalds */ 16731da177e4SLinus Torvalds void device_initialize(struct device *dev) 16741da177e4SLinus Torvalds { 1675881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 1676f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 16771da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 16783142788bSThomas Gleixner mutex_init(&dev->mutex); 16791704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 16809ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 16819ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 16823b98aeafSAlan Stern device_pm_init(dev); 168387348136SChristoph Hellwig set_dev_node(dev, -1); 16844a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 16854a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 16864a7cc831SJiang Liu #endif 16879ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 16889ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 16899ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 16901da177e4SLinus Torvalds } 169186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 16921da177e4SLinus Torvalds 1693d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 1694f0ee61a6SGreg Kroah-Hartman { 1695f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 1696f0ee61a6SGreg Kroah-Hartman 1697f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 16984ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 1699881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 1700f0ee61a6SGreg Kroah-Hartman 170186406245SKay Sievers return virtual_dir; 1702f0ee61a6SGreg Kroah-Hartman } 1703f0ee61a6SGreg Kroah-Hartman 1704bc451f20SEric W. Biederman struct class_dir { 1705bc451f20SEric W. Biederman struct kobject kobj; 1706bc451f20SEric W. Biederman struct class *class; 1707bc451f20SEric W. Biederman }; 1708bc451f20SEric W. Biederman 1709bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 1710bc451f20SEric W. Biederman 1711bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 1712bc451f20SEric W. Biederman { 1713bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 1714bc451f20SEric W. Biederman kfree(dir); 1715bc451f20SEric W. Biederman } 1716bc451f20SEric W. Biederman 1717bc451f20SEric W. Biederman static const 1718bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 1719bc451f20SEric W. Biederman { 1720bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 1721bc451f20SEric W. Biederman return dir->class->ns_type; 1722bc451f20SEric W. Biederman } 1723bc451f20SEric W. Biederman 1724bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 1725bc451f20SEric W. Biederman .release = class_dir_release, 1726bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 1727bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 1728bc451f20SEric W. Biederman }; 1729bc451f20SEric W. Biederman 1730bc451f20SEric W. Biederman static struct kobject * 1731bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 1732bc451f20SEric W. Biederman { 1733bc451f20SEric W. Biederman struct class_dir *dir; 1734bc451f20SEric W. Biederman int retval; 1735bc451f20SEric W. Biederman 1736bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 1737bc451f20SEric W. Biederman if (!dir) 173884d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 1739bc451f20SEric W. Biederman 1740bc451f20SEric W. Biederman dir->class = class; 1741bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 1742bc451f20SEric W. Biederman 17436b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 1744bc451f20SEric W. Biederman 1745bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 1746bc451f20SEric W. Biederman if (retval < 0) { 1747bc451f20SEric W. Biederman kobject_put(&dir->kobj); 174884d0c27dSTetsuo Handa return ERR_PTR(retval); 1749bc451f20SEric W. Biederman } 1750bc451f20SEric W. Biederman return &dir->kobj; 1751bc451f20SEric W. Biederman } 1752bc451f20SEric W. Biederman 1753e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 1754bc451f20SEric W. Biederman 1755c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 1756c744aeaeSCornelia Huck struct device *parent) 175740fa5422SGreg Kroah-Hartman { 175886406245SKay Sievers if (dev->class) { 175986406245SKay Sievers struct kobject *kobj = NULL; 176086406245SKay Sievers struct kobject *parent_kobj; 176186406245SKay Sievers struct kobject *k; 176286406245SKay Sievers 1763ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 176439aba963SKay Sievers /* block disks show up in /sys/block */ 1765e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 176639aba963SKay Sievers if (parent && parent->class == &block_class) 176739aba963SKay Sievers return &parent->kobj; 17686b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 176939aba963SKay Sievers } 1770ead454feSRandy Dunlap #endif 1771e52eec13SAndi Kleen 177286406245SKay Sievers /* 177386406245SKay Sievers * If we have no parent, we live in "virtual". 17740f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 17750f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 177686406245SKay Sievers */ 177786406245SKay Sievers if (parent == NULL) 177886406245SKay Sievers parent_kobj = virtual_device_parent(dev); 177924b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 178086406245SKay Sievers return &parent->kobj; 178186406245SKay Sievers else 178286406245SKay Sievers parent_kobj = &parent->kobj; 178386406245SKay Sievers 178477d3d7c1STejun Heo mutex_lock(&gdp_mutex); 178577d3d7c1STejun Heo 178686406245SKay Sievers /* find our class-directory at the parent and reference it */ 17876b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 17886b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 178986406245SKay Sievers if (k->parent == parent_kobj) { 179086406245SKay Sievers kobj = kobject_get(k); 179186406245SKay Sievers break; 179286406245SKay Sievers } 17936b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 179477d3d7c1STejun Heo if (kobj) { 179577d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 179686406245SKay Sievers return kobj; 179777d3d7c1STejun Heo } 179886406245SKay Sievers 179986406245SKay Sievers /* or create a new class-directory at the parent device */ 1800bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 18010f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 180277d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 180343968d2fSGreg Kroah-Hartman return k; 180486406245SKay Sievers } 180586406245SKay Sievers 1806ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 1807ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 1808ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 1809ca22e56dSKay Sievers 181086406245SKay Sievers if (parent) 1811c744aeaeSCornelia Huck return &parent->kobj; 1812c744aeaeSCornelia Huck return NULL; 1813c744aeaeSCornelia Huck } 1814da231fd5SKay Sievers 1815cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 1816cebf8fd1SMing Lei struct device *dev) 1817cebf8fd1SMing Lei { 1818cebf8fd1SMing Lei if (!kobj || !dev->class || 1819cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 1820cebf8fd1SMing Lei return false; 1821cebf8fd1SMing Lei return true; 1822cebf8fd1SMing Lei } 1823cebf8fd1SMing Lei 1824cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 1825cebf8fd1SMing Lei { 1826cebf8fd1SMing Lei return dev->kobj.parent; 1827cebf8fd1SMing Lei } 1828cebf8fd1SMing Lei 1829cebf8fd1SMing Lei /* 1830cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 1831cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 1832cebf8fd1SMing Lei * global lock 1833cebf8fd1SMing Lei */ 183463b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 1835da231fd5SKay Sievers { 18360f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 1837cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 1838da231fd5SKay Sievers return; 1839da231fd5SKay Sievers 1840e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 1841726e4109SBenjamin Herrenschmidt if (!kobject_has_children(glue_dir)) 1842726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 18430f4dafc0SKay Sievers kobject_put(glue_dir); 1844e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 1845da231fd5SKay Sievers } 184663b6971aSCornelia Huck 18472ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 18482ee97cafSCornelia Huck { 18495590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 18502ee97cafSCornelia Huck int error; 18512ee97cafSCornelia Huck 18525590f319SBenjamin Herrenschmidt if (of_node) { 18530c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 18545590f319SBenjamin Herrenschmidt if (error) 18555590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 18565590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 18575590f319SBenjamin Herrenschmidt } 18585590f319SBenjamin Herrenschmidt 18592ee97cafSCornelia Huck if (!dev->class) 18602ee97cafSCornelia Huck return 0; 1861da231fd5SKay Sievers 18621fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 18636b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 18642ee97cafSCornelia Huck "subsystem"); 18652ee97cafSCornelia Huck if (error) 18665590f319SBenjamin Herrenschmidt goto out_devnode; 1867da231fd5SKay Sievers 18684e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 18694f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 18704f01a757SDmitry Torokhov "device"); 18714f01a757SDmitry Torokhov if (error) 187239aba963SKay Sievers goto out_subsys; 18732ee97cafSCornelia Huck } 187439aba963SKay Sievers 1875ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 187639aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 1877e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 187839aba963SKay Sievers return 0; 1879ead454feSRandy Dunlap #endif 188039aba963SKay Sievers 188139aba963SKay Sievers /* link in the class directory pointing to the device */ 18826b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 188339aba963SKay Sievers &dev->kobj, dev_name(dev)); 188439aba963SKay Sievers if (error) 188539aba963SKay Sievers goto out_device; 188639aba963SKay Sievers 18872ee97cafSCornelia Huck return 0; 18882ee97cafSCornelia Huck 188939aba963SKay Sievers out_device: 189039aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 1891da231fd5SKay Sievers 18922ee97cafSCornelia Huck out_subsys: 18932ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 18945590f319SBenjamin Herrenschmidt out_devnode: 18955590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 18962ee97cafSCornelia Huck return error; 18972ee97cafSCornelia Huck } 18982ee97cafSCornelia Huck 18992ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 19002ee97cafSCornelia Huck { 19015590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 19025590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 19035590f319SBenjamin Herrenschmidt 19042ee97cafSCornelia Huck if (!dev->class) 19052ee97cafSCornelia Huck return; 1906da231fd5SKay Sievers 19074e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 1908da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 19092ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 1910ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 1911e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 191239aba963SKay Sievers return; 1913ead454feSRandy Dunlap #endif 19146b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 19152ee97cafSCornelia Huck } 19162ee97cafSCornelia Huck 19171da177e4SLinus Torvalds /** 1918413c239fSStephen Rothwell * dev_set_name - set a device name 1919413c239fSStephen Rothwell * @dev: device 192046232366SRandy Dunlap * @fmt: format string for the device's name 1921413c239fSStephen Rothwell */ 1922413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 1923413c239fSStephen Rothwell { 1924413c239fSStephen Rothwell va_list vargs; 19251fa5ae85SKay Sievers int err; 1926413c239fSStephen Rothwell 1927413c239fSStephen Rothwell va_start(vargs, fmt); 19281fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 1929413c239fSStephen Rothwell va_end(vargs); 19301fa5ae85SKay Sievers return err; 1931413c239fSStephen Rothwell } 1932413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 1933413c239fSStephen Rothwell 1934413c239fSStephen Rothwell /** 1935e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 1936e105b8bfSDan Williams * @dev: device 1937e105b8bfSDan Williams * 1938e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 1939e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 1940e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 1941e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 19420d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 19430d4e293cSPeter Korsgaard * the link. 1944e105b8bfSDan Williams */ 1945e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 1946e105b8bfSDan Williams { 1947e105b8bfSDan Williams struct kobject *kobj; 1948e105b8bfSDan Williams 1949e105b8bfSDan Williams if (dev->class) 1950e105b8bfSDan Williams kobj = dev->class->dev_kobj; 1951e105b8bfSDan Williams else 1952e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 1953e105b8bfSDan Williams 1954e105b8bfSDan Williams return kobj; 1955e105b8bfSDan Williams } 1956e105b8bfSDan Williams 1957e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 1958e105b8bfSDan Williams { 1959e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 1960e105b8bfSDan Williams int error = 0; 1961e105b8bfSDan Williams char devt_str[15]; 1962e105b8bfSDan Williams 1963e105b8bfSDan Williams if (kobj) { 1964e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 1965e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 1966e105b8bfSDan Williams } 1967e105b8bfSDan Williams 1968e105b8bfSDan Williams return error; 1969e105b8bfSDan Williams } 1970e105b8bfSDan Williams 1971e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 1972e105b8bfSDan Williams { 1973e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 1974e105b8bfSDan Williams char devt_str[15]; 1975e105b8bfSDan Williams 1976e105b8bfSDan Williams if (kobj) { 1977e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 1978e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 1979e105b8bfSDan Williams } 1980e105b8bfSDan Williams } 1981e105b8bfSDan Williams 198246d3a037SShaokun Zhang static int device_private_init(struct device *dev) 1983b4028437SGreg Kroah-Hartman { 1984b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 1985b4028437SGreg Kroah-Hartman if (!dev->p) 1986b4028437SGreg Kroah-Hartman return -ENOMEM; 1987b4028437SGreg Kroah-Hartman dev->p->device = dev; 1988b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 1989b4028437SGreg Kroah-Hartman klist_children_put); 1990ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 1991b4028437SGreg Kroah-Hartman return 0; 1992b4028437SGreg Kroah-Hartman } 1993b4028437SGreg Kroah-Hartman 1994e105b8bfSDan Williams /** 19951da177e4SLinus Torvalds * device_add - add device to device hierarchy. 19961da177e4SLinus Torvalds * @dev: device. 19971da177e4SLinus Torvalds * 19981da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 19991da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 20001da177e4SLinus Torvalds * 20015739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 20021da177e4SLinus Torvalds * to the global and sibling lists for the device, then 20031da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 20045739411aSCornelia Huck * 2005b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 2006b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 2007b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 2008b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 2009b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 2010b10d5efdSAlan Stern * and register a fresh new struct device instead. 2011b10d5efdSAlan Stern * 20125739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 20135739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 20145739411aSCornelia Huck * reference instead. 20151da177e4SLinus Torvalds */ 20161da177e4SLinus Torvalds int device_add(struct device *dev) 20171da177e4SLinus Torvalds { 201835dbf4efSViresh Kumar struct device *parent; 2019ca22e56dSKay Sievers struct kobject *kobj; 2020c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 2021c906a48aSGreg Kroah-Hartman int error = -EINVAL; 2022cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2023775b64d2SRafael J. Wysocki 20241da177e4SLinus Torvalds dev = get_device(dev); 2025c906a48aSGreg Kroah-Hartman if (!dev) 2026c906a48aSGreg Kroah-Hartman goto done; 2027c906a48aSGreg Kroah-Hartman 2028fb069a5dSGreg Kroah-Hartman if (!dev->p) { 2029b4028437SGreg Kroah-Hartman error = device_private_init(dev); 2030b4028437SGreg Kroah-Hartman if (error) 2031fb069a5dSGreg Kroah-Hartman goto done; 2032fb069a5dSGreg Kroah-Hartman } 2033fb069a5dSGreg Kroah-Hartman 20341fa5ae85SKay Sievers /* 20351fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 20361fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 20371fa5ae85SKay Sievers * the name, and force the use of dev_name() 20381fa5ae85SKay Sievers */ 20391fa5ae85SKay Sievers if (dev->init_name) { 2040acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 20411fa5ae85SKay Sievers dev->init_name = NULL; 20421fa5ae85SKay Sievers } 2043c906a48aSGreg Kroah-Hartman 2044ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 2045ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 2046ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 2047ca22e56dSKay Sievers 2048e6309e75SThomas Gleixner if (!dev_name(dev)) { 2049e6309e75SThomas Gleixner error = -EINVAL; 20505c8563d7SKay Sievers goto name_error; 2051e6309e75SThomas Gleixner } 20521da177e4SLinus Torvalds 20531e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 2054c205ef48SGreg Kroah-Hartman 20551da177e4SLinus Torvalds parent = get_device(dev->parent); 2056ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 205784d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 205884d0c27dSTetsuo Handa error = PTR_ERR(kobj); 205984d0c27dSTetsuo Handa goto parent_error; 206084d0c27dSTetsuo Handa } 2061ca22e56dSKay Sievers if (kobj) 2062ca22e56dSKay Sievers dev->kobj.parent = kobj; 20631da177e4SLinus Torvalds 20640d358f22SYinghai Lu /* use parent numa_node */ 206556f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 20660d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 20670d358f22SYinghai Lu 20681da177e4SLinus Torvalds /* first, register with generic layer. */ 20698a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 20708a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 2071cebf8fd1SMing Lei if (error) { 2072cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 20731da177e4SLinus Torvalds goto Error; 2074cebf8fd1SMing Lei } 2075a7fd6706SKay Sievers 207637022644SBrian Walsh /* notify platform of device entry */ 207707de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 207807de0e86SHeikki Krogerus if (error) 207907de0e86SHeikki Krogerus goto platform_error; 208037022644SBrian Walsh 2081c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 2082a306eea4SCornelia Huck if (error) 2083a306eea4SCornelia Huck goto attrError; 2084a7fd6706SKay Sievers 20852ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 20862ee97cafSCornelia Huck if (error) 20872ee97cafSCornelia Huck goto SymlinkError; 2088dc0afa83SCornelia Huck error = device_add_attrs(dev); 2089dc0afa83SCornelia Huck if (error) 20902620efefSGreg Kroah-Hartman goto AttrsError; 2091dc0afa83SCornelia Huck error = bus_add_device(dev); 2092dc0afa83SCornelia Huck if (error) 20931da177e4SLinus Torvalds goto BusError; 20943b98aeafSAlan Stern error = dpm_sysfs_add(dev); 209557eee3d2SRafael J. Wysocki if (error) 20963b98aeafSAlan Stern goto DPMError; 20973b98aeafSAlan Stern device_pm_add(dev); 2098ec0676eeSAlan Stern 20990cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 21000cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 21010cd75047SSergey Klyaus if (error) 21020cd75047SSergey Klyaus goto DevAttrError; 21030cd75047SSergey Klyaus 21040cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 21050cd75047SSergey Klyaus if (error) 21060cd75047SSergey Klyaus goto SysEntryError; 21070cd75047SSergey Klyaus 21080cd75047SSergey Klyaus devtmpfs_create_node(dev); 21090cd75047SSergey Klyaus } 21100cd75047SSergey Klyaus 2111ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 2112268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 2113ec0676eeSAlan Stern */ 2114ec0676eeSAlan Stern if (dev->bus) 2115ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2116ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 2117ec0676eeSAlan Stern 211853877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 21192023c610SAlan Stern bus_probe_device(dev); 21201da177e4SLinus Torvalds if (parent) 2121f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2122f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 21231da177e4SLinus Torvalds 21245d9fd169SGreg Kroah-Hartman if (dev->class) { 2125ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2126c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 2127570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 21286b6e39a6SKay Sievers &dev->class->p->klist_devices); 2129c47ed219SGreg Kroah-Hartman 2130c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 2131184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2132ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2133c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 2134c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 2135ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 21365d9fd169SGreg Kroah-Hartman } 2137c906a48aSGreg Kroah-Hartman done: 21381da177e4SLinus Torvalds put_device(dev); 21391da177e4SLinus Torvalds return error; 21400cd75047SSergey Klyaus SysEntryError: 21410cd75047SSergey Klyaus if (MAJOR(dev->devt)) 21420cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 21430cd75047SSergey Klyaus DevAttrError: 21440cd75047SSergey Klyaus device_pm_remove(dev); 21450cd75047SSergey Klyaus dpm_sysfs_remove(dev); 21463b98aeafSAlan Stern DPMError: 214757eee3d2SRafael J. Wysocki bus_remove_device(dev); 214857eee3d2SRafael J. Wysocki BusError: 21492620efefSGreg Kroah-Hartman device_remove_attrs(dev); 21502620efefSGreg Kroah-Hartman AttrsError: 21512ee97cafSCornelia Huck device_remove_class_symlinks(dev); 21522ee97cafSCornelia Huck SymlinkError: 2153c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 215423681e47SGreg Kroah-Hartman attrError: 215507de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 215607de0e86SHeikki Krogerus platform_error: 2157312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2158cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 21591da177e4SLinus Torvalds kobject_del(&dev->kobj); 21601da177e4SLinus Torvalds Error: 2161cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 216284d0c27dSTetsuo Handa parent_error: 21631da177e4SLinus Torvalds put_device(parent); 21645c8563d7SKay Sievers name_error: 21655c8563d7SKay Sievers kfree(dev->p); 21665c8563d7SKay Sievers dev->p = NULL; 2167c906a48aSGreg Kroah-Hartman goto done; 21681da177e4SLinus Torvalds } 216986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 21701da177e4SLinus Torvalds 21711da177e4SLinus Torvalds /** 21721da177e4SLinus Torvalds * device_register - register a device with the system. 21731da177e4SLinus Torvalds * @dev: pointer to the device structure 21741da177e4SLinus Torvalds * 21751da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 21761da177e4SLinus Torvalds * and add it to the system. The two steps can be called 21771da177e4SLinus Torvalds * separately, but this is the easiest and most common. 21781da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 21791da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 21801da177e4SLinus Torvalds * before it is added to the hierarchy. 21815739411aSCornelia Huck * 2182b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 2183b10d5efdSAlan Stern * and device_add(). 2184b10d5efdSAlan Stern * 21855739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 21865739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 21875739411aSCornelia Huck * reference initialized in this function instead. 21881da177e4SLinus Torvalds */ 21891da177e4SLinus Torvalds int device_register(struct device *dev) 21901da177e4SLinus Torvalds { 21911da177e4SLinus Torvalds device_initialize(dev); 21921da177e4SLinus Torvalds return device_add(dev); 21931da177e4SLinus Torvalds } 219486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 21951da177e4SLinus Torvalds 21961da177e4SLinus Torvalds /** 21971da177e4SLinus Torvalds * get_device - increment reference count for device. 21981da177e4SLinus Torvalds * @dev: device. 21991da177e4SLinus Torvalds * 22001da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 22011da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 22021da177e4SLinus Torvalds * pointer passed in. 22031da177e4SLinus Torvalds */ 22041da177e4SLinus Torvalds struct device *get_device(struct device *dev) 22051da177e4SLinus Torvalds { 2206b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 22071da177e4SLinus Torvalds } 220886df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 22091da177e4SLinus Torvalds 22101da177e4SLinus Torvalds /** 22111da177e4SLinus Torvalds * put_device - decrement reference count. 22121da177e4SLinus Torvalds * @dev: device in question. 22131da177e4SLinus Torvalds */ 22141da177e4SLinus Torvalds void put_device(struct device *dev) 22151da177e4SLinus Torvalds { 2216edfaa7c3SKay Sievers /* might_sleep(); */ 22171da177e4SLinus Torvalds if (dev) 22181da177e4SLinus Torvalds kobject_put(&dev->kobj); 22191da177e4SLinus Torvalds } 222086df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 22211da177e4SLinus Torvalds 22221da177e4SLinus Torvalds /** 22231da177e4SLinus Torvalds * device_del - delete device from system. 22241da177e4SLinus Torvalds * @dev: device. 22251da177e4SLinus Torvalds * 22261da177e4SLinus Torvalds * This is the first part of the device unregistration 22271da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 22281da177e4SLinus Torvalds * from here, has it removed from the other driver model 22291da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 22301da177e4SLinus Torvalds * from the kobject hierarchy. 22311da177e4SLinus Torvalds * 22321da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 22331da177e4SLinus Torvalds * also called manually. 22341da177e4SLinus Torvalds */ 22351da177e4SLinus Torvalds void device_del(struct device *dev) 22361da177e4SLinus Torvalds { 22371da177e4SLinus Torvalds struct device *parent = dev->parent; 2238cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2239c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 22401da177e4SLinus Torvalds 22413451a495SAlexander Duyck /* 22423451a495SAlexander Duyck * Hold the device lock and set the "dead" flag to guarantee that 22433451a495SAlexander Duyck * the update behavior is consistent with the other bitfields near 22443451a495SAlexander Duyck * it and that we cannot have an asynchronous probe routine trying 22453451a495SAlexander Duyck * to run while we are tearing out the bus/class/sysfs from 22463451a495SAlexander Duyck * underneath the device. 22473451a495SAlexander Duyck */ 22483451a495SAlexander Duyck device_lock(dev); 22493451a495SAlexander Duyck dev->p->dead = true; 22503451a495SAlexander Duyck device_unlock(dev); 22513451a495SAlexander Duyck 2252ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 2253ec0676eeSAlan Stern * before dpm_sysfs_remove(). 2254ec0676eeSAlan Stern */ 2255ec0676eeSAlan Stern if (dev->bus) 2256ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2257ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 22589ed98953SRafael J. Wysocki 22593b98aeafSAlan Stern dpm_sysfs_remove(dev); 22601da177e4SLinus Torvalds if (parent) 2261f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 2262e105b8bfSDan Williams if (MAJOR(dev->devt)) { 22632b2af54aSKay Sievers devtmpfs_delete_node(dev); 2264e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 2265c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 2266e105b8bfSDan Williams } 2267b9d9c82bSKay Sievers if (dev->class) { 2268da231fd5SKay Sievers device_remove_class_symlinks(dev); 226999ef3ef8SKay Sievers 2270ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2271c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 2272184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2273ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2274c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 2275c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 2276c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 2277570d0200SWei Yang klist_del(&dev->p->knode_class); 2278ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 2279b9d9c82bSKay Sievers } 2280c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 22812620efefSGreg Kroah-Hartman device_remove_attrs(dev); 228228953533SBenjamin Herrenschmidt bus_remove_device(dev); 22834b6d1f12SLongX Zhang device_pm_remove(dev); 2284d1c3414cSGrant Likely driver_deferred_probe_del(dev); 228507de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 2286478573c9SLukas Wunner device_remove_properties(dev); 22872ec16150SJeffy Chen device_links_purge(dev); 22881da177e4SLinus Torvalds 2289599bad38SJoerg Roedel if (dev->bus) 2290599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2291599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 2292312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2293cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 22941da177e4SLinus Torvalds kobject_del(&dev->kobj); 2295cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 22961da177e4SLinus Torvalds put_device(parent); 22971da177e4SLinus Torvalds } 229886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 22991da177e4SLinus Torvalds 23001da177e4SLinus Torvalds /** 23011da177e4SLinus Torvalds * device_unregister - unregister device from system. 23021da177e4SLinus Torvalds * @dev: device going away. 23031da177e4SLinus Torvalds * 23041da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 23051da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 23061da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 23071da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 23081da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 23091da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 23101da177e4SLinus Torvalds */ 23111da177e4SLinus Torvalds void device_unregister(struct device *dev) 23121da177e4SLinus Torvalds { 23131e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 23141da177e4SLinus Torvalds device_del(dev); 23151da177e4SLinus Torvalds put_device(dev); 23161da177e4SLinus Torvalds } 231786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 23181da177e4SLinus Torvalds 23193d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 23203d060aebSAndy Shevchenko { 23213d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 23223d060aebSAndy Shevchenko struct device *dev = NULL; 23233d060aebSAndy Shevchenko struct device_private *p; 23243d060aebSAndy Shevchenko 23253d060aebSAndy Shevchenko if (n) { 23263d060aebSAndy Shevchenko p = to_device_private_parent(n); 23273d060aebSAndy Shevchenko dev = p->device; 23283d060aebSAndy Shevchenko } 23293d060aebSAndy Shevchenko return dev; 23303d060aebSAndy Shevchenko } 23313d060aebSAndy Shevchenko 233236239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 233336239577Smochel@digitalimplant.org { 233436239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 2335f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 2336f791b8c8SGreg Kroah-Hartman struct device_private *p; 2337f791b8c8SGreg Kroah-Hartman 2338f791b8c8SGreg Kroah-Hartman if (n) { 2339f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 2340f791b8c8SGreg Kroah-Hartman dev = p->device; 2341f791b8c8SGreg Kroah-Hartman } 2342f791b8c8SGreg Kroah-Hartman return dev; 234336239577Smochel@digitalimplant.org } 234436239577Smochel@digitalimplant.org 23451da177e4SLinus Torvalds /** 2346e454cea2SKay Sievers * device_get_devnode - path of device node file 23476fcf53acSKay Sievers * @dev: device 2348e454cea2SKay Sievers * @mode: returned file access mode 23493c2670e6SKay Sievers * @uid: returned file owner 23503c2670e6SKay Sievers * @gid: returned file group 23516fcf53acSKay Sievers * @tmp: possibly allocated string 23526fcf53acSKay Sievers * 23536fcf53acSKay Sievers * Return the relative path of a possible device node. 23546fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 23556fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 23566fcf53acSKay Sievers * freed by the caller. 23576fcf53acSKay Sievers */ 2358e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 23594e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 23603c2670e6SKay Sievers const char **tmp) 23616fcf53acSKay Sievers { 23626fcf53acSKay Sievers char *s; 23636fcf53acSKay Sievers 23646fcf53acSKay Sievers *tmp = NULL; 23656fcf53acSKay Sievers 23666fcf53acSKay Sievers /* the device type may provide a specific name */ 2367e454cea2SKay Sievers if (dev->type && dev->type->devnode) 23683c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 23696fcf53acSKay Sievers if (*tmp) 23706fcf53acSKay Sievers return *tmp; 23716fcf53acSKay Sievers 23726fcf53acSKay Sievers /* the class may provide a specific name */ 2373e454cea2SKay Sievers if (dev->class && dev->class->devnode) 2374e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 23756fcf53acSKay Sievers if (*tmp) 23766fcf53acSKay Sievers return *tmp; 23776fcf53acSKay Sievers 23786fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 23796fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 23806fcf53acSKay Sievers return dev_name(dev); 23816fcf53acSKay Sievers 23826fcf53acSKay Sievers /* replace '!' in the name with '/' */ 2383a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 2384a29fd614SRasmus Villemoes if (!s) 23856fcf53acSKay Sievers return NULL; 2386a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 2387a29fd614SRasmus Villemoes return *tmp = s; 23886fcf53acSKay Sievers } 23896fcf53acSKay Sievers 23906fcf53acSKay Sievers /** 23911da177e4SLinus Torvalds * device_for_each_child - device child iterator. 2392c41455fbSRandy Dunlap * @parent: parent struct device. 23931da177e4SLinus Torvalds * @fn: function to be called for each device. 2394f8878dcbSRobert P. J. Day * @data: data for the callback. 23951da177e4SLinus Torvalds * 2396c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 23971da177e4SLinus Torvalds * passing it @data. 23981da177e4SLinus Torvalds * 23991da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 24001da177e4SLinus Torvalds * other than 0, we break out and return that value. 24011da177e4SLinus Torvalds */ 240236239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 24034a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 24041da177e4SLinus Torvalds { 240536239577Smochel@digitalimplant.org struct klist_iter i; 24061da177e4SLinus Torvalds struct device *child; 24071da177e4SLinus Torvalds int error = 0; 24081da177e4SLinus Torvalds 2409014c90dbSGreg Kroah-Hartman if (!parent->p) 2410014c90dbSGreg Kroah-Hartman return 0; 2411014c90dbSGreg Kroah-Hartman 2412f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 241393ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 241436239577Smochel@digitalimplant.org error = fn(child, data); 241536239577Smochel@digitalimplant.org klist_iter_exit(&i); 24161da177e4SLinus Torvalds return error; 24171da177e4SLinus Torvalds } 241886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 24191da177e4SLinus Torvalds 24205ab69981SCornelia Huck /** 24213d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 24223d060aebSAndy Shevchenko * @parent: parent struct device. 24233d060aebSAndy Shevchenko * @fn: function to be called for each device. 24243d060aebSAndy Shevchenko * @data: data for the callback. 24253d060aebSAndy Shevchenko * 24263d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 24273d060aebSAndy Shevchenko * passing it @data. 24283d060aebSAndy Shevchenko * 24293d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 24303d060aebSAndy Shevchenko * other than 0, we break out and return that value. 24313d060aebSAndy Shevchenko */ 24323d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 24333d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 24343d060aebSAndy Shevchenko { 24353d060aebSAndy Shevchenko struct klist_iter i; 24363d060aebSAndy Shevchenko struct device *child; 24373d060aebSAndy Shevchenko int error = 0; 24383d060aebSAndy Shevchenko 24393d060aebSAndy Shevchenko if (!parent->p) 24403d060aebSAndy Shevchenko return 0; 24413d060aebSAndy Shevchenko 24423d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 24433d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 24443d060aebSAndy Shevchenko error = fn(child, data); 24453d060aebSAndy Shevchenko klist_iter_exit(&i); 24463d060aebSAndy Shevchenko return error; 24473d060aebSAndy Shevchenko } 24483d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 24493d060aebSAndy Shevchenko 24503d060aebSAndy Shevchenko /** 24515ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 24525ab69981SCornelia Huck * @parent: parent struct device 24535ab69981SCornelia Huck * @match: Callback function to check device 2454f8878dcbSRobert P. J. Day * @data: Data to pass to match function 24555ab69981SCornelia Huck * 24565ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 24575ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 24585ab69981SCornelia Huck * determined by the @match callback. 24595ab69981SCornelia Huck * 24605ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 24615ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 24625ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 24635ab69981SCornelia Huck * and not iterate over any more devices. 2464a4e2400aSFederico Vaga * 2465a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 24665ab69981SCornelia Huck */ 24675ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 24684a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 24695ab69981SCornelia Huck { 24705ab69981SCornelia Huck struct klist_iter i; 24715ab69981SCornelia Huck struct device *child; 24725ab69981SCornelia Huck 24735ab69981SCornelia Huck if (!parent) 24745ab69981SCornelia Huck return NULL; 24755ab69981SCornelia Huck 2476f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 24775ab69981SCornelia Huck while ((child = next_device(&i))) 24785ab69981SCornelia Huck if (match(child, data) && get_device(child)) 24795ab69981SCornelia Huck break; 24805ab69981SCornelia Huck klist_iter_exit(&i); 24815ab69981SCornelia Huck return child; 24825ab69981SCornelia Huck } 248386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 24845ab69981SCornelia Huck 24851da177e4SLinus Torvalds int __init devices_init(void) 24861da177e4SLinus Torvalds { 2487881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 2488881c6cfdSGreg Kroah-Hartman if (!devices_kset) 2489881c6cfdSGreg Kroah-Hartman return -ENOMEM; 2490e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 2491e105b8bfSDan Williams if (!dev_kobj) 2492e105b8bfSDan Williams goto dev_kobj_err; 2493e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 2494e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 2495e105b8bfSDan Williams goto block_kobj_err; 2496e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 2497e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 2498e105b8bfSDan Williams goto char_kobj_err; 2499e105b8bfSDan Williams 2500881c6cfdSGreg Kroah-Hartman return 0; 2501e105b8bfSDan Williams 2502e105b8bfSDan Williams char_kobj_err: 2503e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 2504e105b8bfSDan Williams block_kobj_err: 2505e105b8bfSDan Williams kobject_put(dev_kobj); 2506e105b8bfSDan Williams dev_kobj_err: 2507e105b8bfSDan Williams kset_unregister(devices_kset); 2508e105b8bfSDan Williams return -ENOMEM; 25091da177e4SLinus Torvalds } 25101da177e4SLinus Torvalds 25114f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 25124f3549d7SRafael J. Wysocki { 25134f3549d7SRafael J. Wysocki int ret; 25144f3549d7SRafael J. Wysocki 25154f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 25164f3549d7SRafael J. Wysocki if (ret) 25174f3549d7SRafael J. Wysocki return ret; 25184f3549d7SRafael J. Wysocki 25194f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 25204f3549d7SRafael J. Wysocki } 25214f3549d7SRafael J. Wysocki 25224f3549d7SRafael J. Wysocki /** 25234f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 25244f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 25254f3549d7SRafael J. Wysocki * 25264f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 25274f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 25284f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 25294f3549d7SRafael J. Wysocki * is executed. 25304f3549d7SRafael J. Wysocki * 25314f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 25324f3549d7SRafael J. Wysocki */ 25334f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 25344f3549d7SRafael J. Wysocki { 25354f3549d7SRafael J. Wysocki int ret; 25364f3549d7SRafael J. Wysocki 25374f3549d7SRafael J. Wysocki if (dev->offline_disabled) 25384f3549d7SRafael J. Wysocki return -EPERM; 25394f3549d7SRafael J. Wysocki 25404f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 25414f3549d7SRafael J. Wysocki if (ret) 25424f3549d7SRafael J. Wysocki return ret; 25434f3549d7SRafael J. Wysocki 25444f3549d7SRafael J. Wysocki device_lock(dev); 25454f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 25464f3549d7SRafael J. Wysocki if (dev->offline) { 25474f3549d7SRafael J. Wysocki ret = 1; 25484f3549d7SRafael J. Wysocki } else { 25494f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 25504f3549d7SRafael J. Wysocki if (!ret) { 25514f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 25524f3549d7SRafael J. Wysocki dev->offline = true; 25534f3549d7SRafael J. Wysocki } 25544f3549d7SRafael J. Wysocki } 25554f3549d7SRafael J. Wysocki } 25564f3549d7SRafael J. Wysocki device_unlock(dev); 25574f3549d7SRafael J. Wysocki 25584f3549d7SRafael J. Wysocki return ret; 25594f3549d7SRafael J. Wysocki } 25604f3549d7SRafael J. Wysocki 25614f3549d7SRafael J. Wysocki /** 25624f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 25634f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 25644f3549d7SRafael J. Wysocki * 25654f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 25664f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 25674f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 25684f3549d7SRafael J. Wysocki * 25694f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 25704f3549d7SRafael J. Wysocki */ 25714f3549d7SRafael J. Wysocki int device_online(struct device *dev) 25724f3549d7SRafael J. Wysocki { 25734f3549d7SRafael J. Wysocki int ret = 0; 25744f3549d7SRafael J. Wysocki 25754f3549d7SRafael J. Wysocki device_lock(dev); 25764f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 25774f3549d7SRafael J. Wysocki if (dev->offline) { 25784f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 25794f3549d7SRafael J. Wysocki if (!ret) { 25804f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 25814f3549d7SRafael J. Wysocki dev->offline = false; 25824f3549d7SRafael J. Wysocki } 25834f3549d7SRafael J. Wysocki } else { 25844f3549d7SRafael J. Wysocki ret = 1; 25854f3549d7SRafael J. Wysocki } 25864f3549d7SRafael J. Wysocki } 25874f3549d7SRafael J. Wysocki device_unlock(dev); 25884f3549d7SRafael J. Wysocki 25894f3549d7SRafael J. Wysocki return ret; 25904f3549d7SRafael J. Wysocki } 25914f3549d7SRafael J. Wysocki 25927f100d15SKarthigan Srinivasan struct root_device { 25930aa0dc41SMark McLoughlin struct device dev; 25940aa0dc41SMark McLoughlin struct module *owner; 25950aa0dc41SMark McLoughlin }; 25960aa0dc41SMark McLoughlin 259793058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 2598481e2079SFerenc Wagner { 2599481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 2600481e2079SFerenc Wagner } 26010aa0dc41SMark McLoughlin 26020aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 26030aa0dc41SMark McLoughlin { 26040aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 26050aa0dc41SMark McLoughlin } 26060aa0dc41SMark McLoughlin 26070aa0dc41SMark McLoughlin /** 26080aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 26090aa0dc41SMark McLoughlin * @name: root device name 26100aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 26110aa0dc41SMark McLoughlin * 26120aa0dc41SMark McLoughlin * This function allocates a root device and registers it 26130aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 26140aa0dc41SMark McLoughlin * device, use root_device_unregister(). 26150aa0dc41SMark McLoughlin * 26160aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 26170aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 26180aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 26190aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 26200aa0dc41SMark McLoughlin * 26210aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 26220aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 26230aa0dc41SMark McLoughlin * in sysfs. 26240aa0dc41SMark McLoughlin * 2625f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 2626f0eae0edSJani Nikula * 26270aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 26280aa0dc41SMark McLoughlin */ 26290aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 26300aa0dc41SMark McLoughlin { 26310aa0dc41SMark McLoughlin struct root_device *root; 26320aa0dc41SMark McLoughlin int err = -ENOMEM; 26330aa0dc41SMark McLoughlin 26340aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 26350aa0dc41SMark McLoughlin if (!root) 26360aa0dc41SMark McLoughlin return ERR_PTR(err); 26370aa0dc41SMark McLoughlin 2638acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 26390aa0dc41SMark McLoughlin if (err) { 26400aa0dc41SMark McLoughlin kfree(root); 26410aa0dc41SMark McLoughlin return ERR_PTR(err); 26420aa0dc41SMark McLoughlin } 26430aa0dc41SMark McLoughlin 26440aa0dc41SMark McLoughlin root->dev.release = root_device_release; 26450aa0dc41SMark McLoughlin 26460aa0dc41SMark McLoughlin err = device_register(&root->dev); 26470aa0dc41SMark McLoughlin if (err) { 26480aa0dc41SMark McLoughlin put_device(&root->dev); 26490aa0dc41SMark McLoughlin return ERR_PTR(err); 26500aa0dc41SMark McLoughlin } 26510aa0dc41SMark McLoughlin 26521d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 26530aa0dc41SMark McLoughlin if (owner) { 26540aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 26550aa0dc41SMark McLoughlin 26560aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 26570aa0dc41SMark McLoughlin if (err) { 26580aa0dc41SMark McLoughlin device_unregister(&root->dev); 26590aa0dc41SMark McLoughlin return ERR_PTR(err); 26600aa0dc41SMark McLoughlin } 26610aa0dc41SMark McLoughlin root->owner = owner; 26620aa0dc41SMark McLoughlin } 26630aa0dc41SMark McLoughlin #endif 26640aa0dc41SMark McLoughlin 26650aa0dc41SMark McLoughlin return &root->dev; 26660aa0dc41SMark McLoughlin } 26670aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 26680aa0dc41SMark McLoughlin 26690aa0dc41SMark McLoughlin /** 26700aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 26717cbcf225SRandy Dunlap * @dev: device going away 26720aa0dc41SMark McLoughlin * 26730aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 26740aa0dc41SMark McLoughlin * root_device_register(). 26750aa0dc41SMark McLoughlin */ 26760aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 26770aa0dc41SMark McLoughlin { 26780aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 26790aa0dc41SMark McLoughlin 26800aa0dc41SMark McLoughlin if (root->owner) 26810aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 26820aa0dc41SMark McLoughlin 26830aa0dc41SMark McLoughlin device_unregister(dev); 26840aa0dc41SMark McLoughlin } 26850aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 26860aa0dc41SMark McLoughlin 268723681e47SGreg Kroah-Hartman 268823681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 268923681e47SGreg Kroah-Hartman { 26901e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 269123681e47SGreg Kroah-Hartman kfree(dev); 269223681e47SGreg Kroah-Hartman } 269323681e47SGreg Kroah-Hartman 26946a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 269539ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 269639ef3112SGuenter Roeck dev_t devt, void *drvdata, 269739ef3112SGuenter Roeck const struct attribute_group **groups, 269839ef3112SGuenter Roeck const char *fmt, va_list args) 269939ef3112SGuenter Roeck { 270039ef3112SGuenter Roeck struct device *dev = NULL; 270139ef3112SGuenter Roeck int retval = -ENODEV; 270239ef3112SGuenter Roeck 270339ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 270439ef3112SGuenter Roeck goto error; 270539ef3112SGuenter Roeck 270639ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 270739ef3112SGuenter Roeck if (!dev) { 270839ef3112SGuenter Roeck retval = -ENOMEM; 270939ef3112SGuenter Roeck goto error; 271039ef3112SGuenter Roeck } 271139ef3112SGuenter Roeck 2712bbc780f8SDavid Herrmann device_initialize(dev); 271339ef3112SGuenter Roeck dev->devt = devt; 271439ef3112SGuenter Roeck dev->class = class; 271539ef3112SGuenter Roeck dev->parent = parent; 271639ef3112SGuenter Roeck dev->groups = groups; 271739ef3112SGuenter Roeck dev->release = device_create_release; 271839ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 271939ef3112SGuenter Roeck 272039ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 272139ef3112SGuenter Roeck if (retval) 272239ef3112SGuenter Roeck goto error; 272339ef3112SGuenter Roeck 2724bbc780f8SDavid Herrmann retval = device_add(dev); 272539ef3112SGuenter Roeck if (retval) 272639ef3112SGuenter Roeck goto error; 272739ef3112SGuenter Roeck 272839ef3112SGuenter Roeck return dev; 272939ef3112SGuenter Roeck 273039ef3112SGuenter Roeck error: 273139ef3112SGuenter Roeck put_device(dev); 273239ef3112SGuenter Roeck return ERR_PTR(retval); 273339ef3112SGuenter Roeck } 273439ef3112SGuenter Roeck 273523681e47SGreg Kroah-Hartman /** 27368882b394SGreg Kroah-Hartman * device_create_vargs - creates a device and registers it with sysfs 27378882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 27388882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 27398882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 27408882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 27418882b394SGreg Kroah-Hartman * @fmt: string for the device's name 27428882b394SGreg Kroah-Hartman * @args: va_list for the device's name 27438882b394SGreg Kroah-Hartman * 27448882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 27458882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 27468882b394SGreg Kroah-Hartman * 27478882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 27488882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 27498882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 27508882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 27518882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 27528882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 27538882b394SGreg Kroah-Hartman * pointer. 27548882b394SGreg Kroah-Hartman * 2755f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 2756f0eae0edSJani Nikula * 27578882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 27588882b394SGreg Kroah-Hartman * been created with a call to class_create(). 27598882b394SGreg Kroah-Hartman */ 27608882b394SGreg Kroah-Hartman struct device *device_create_vargs(struct class *class, struct device *parent, 27618882b394SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, 27628882b394SGreg Kroah-Hartman va_list args) 27638882b394SGreg Kroah-Hartman { 276439ef3112SGuenter Roeck return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 276539ef3112SGuenter Roeck fmt, args); 27668882b394SGreg Kroah-Hartman } 27678882b394SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_vargs); 27688882b394SGreg Kroah-Hartman 27698882b394SGreg Kroah-Hartman /** 27704e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 27718882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 27728882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 27738882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 27748882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 27758882b394SGreg Kroah-Hartman * @fmt: string for the device's name 27768882b394SGreg Kroah-Hartman * 27778882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 27788882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 27798882b394SGreg Kroah-Hartman * 27808882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 27818882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 27828882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 27838882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 27848882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 27858882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 27868882b394SGreg Kroah-Hartman * pointer. 27878882b394SGreg Kroah-Hartman * 2788f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 2789f0eae0edSJani Nikula * 27908882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 27918882b394SGreg Kroah-Hartman * been created with a call to class_create(). 27928882b394SGreg Kroah-Hartman */ 27934e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 27944e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 27958882b394SGreg Kroah-Hartman { 27968882b394SGreg Kroah-Hartman va_list vargs; 27978882b394SGreg Kroah-Hartman struct device *dev; 27988882b394SGreg Kroah-Hartman 27998882b394SGreg Kroah-Hartman va_start(vargs, fmt); 28008882b394SGreg Kroah-Hartman dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 28018882b394SGreg Kroah-Hartman va_end(vargs); 28028882b394SGreg Kroah-Hartman return dev; 28038882b394SGreg Kroah-Hartman } 28044e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 28058882b394SGreg Kroah-Hartman 280639ef3112SGuenter Roeck /** 280739ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 280839ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 280939ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 281039ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 281139ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 281239ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 281339ef3112SGuenter Roeck * @fmt: string for the device's name 281439ef3112SGuenter Roeck * 281539ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 281639ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 281739ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 281839ef3112SGuenter Roeck * be created automatically. 281939ef3112SGuenter Roeck * 282039ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 282139ef3112SGuenter Roeck * the dev_t is not 0,0. 282239ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 282339ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 282439ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 282539ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 282639ef3112SGuenter Roeck * pointer. 282739ef3112SGuenter Roeck * 282839ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 282939ef3112SGuenter Roeck * 283039ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 283139ef3112SGuenter Roeck * been created with a call to class_create(). 283239ef3112SGuenter Roeck */ 283339ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 283439ef3112SGuenter Roeck struct device *parent, dev_t devt, 283539ef3112SGuenter Roeck void *drvdata, 283639ef3112SGuenter Roeck const struct attribute_group **groups, 283739ef3112SGuenter Roeck const char *fmt, ...) 283839ef3112SGuenter Roeck { 283939ef3112SGuenter Roeck va_list vargs; 284039ef3112SGuenter Roeck struct device *dev; 284139ef3112SGuenter Roeck 284239ef3112SGuenter Roeck va_start(vargs, fmt); 284339ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 284439ef3112SGuenter Roeck fmt, vargs); 284539ef3112SGuenter Roeck va_end(vargs); 284639ef3112SGuenter Roeck return dev; 284739ef3112SGuenter Roeck } 284839ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 284939ef3112SGuenter Roeck 28509f3b795aSMichał Mirosław static int __match_devt(struct device *dev, const void *data) 285123681e47SGreg Kroah-Hartman { 28529f3b795aSMichał Mirosław const dev_t *devt = data; 285323681e47SGreg Kroah-Hartman 2854cd35449bSDave Young return dev->devt == *devt; 2855775b64d2SRafael J. Wysocki } 285623681e47SGreg Kroah-Hartman 2857775b64d2SRafael J. Wysocki /** 2858775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 2859775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 2860775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 2861775b64d2SRafael J. Wysocki * 2862775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 2863775b64d2SRafael J. Wysocki * call to device_create(). 2864775b64d2SRafael J. Wysocki */ 2865775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 2866775b64d2SRafael J. Wysocki { 2867775b64d2SRafael J. Wysocki struct device *dev; 2868775b64d2SRafael J. Wysocki 2869695794aeSGreg Kroah-Hartman dev = class_find_device(class, NULL, &devt, __match_devt); 2870cd35449bSDave Young if (dev) { 2871cd35449bSDave Young put_device(dev); 287223681e47SGreg Kroah-Hartman device_unregister(dev); 287323681e47SGreg Kroah-Hartman } 2874cd35449bSDave Young } 287523681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 2876a2de48caSGreg Kroah-Hartman 2877a2de48caSGreg Kroah-Hartman /** 2878a2de48caSGreg Kroah-Hartman * device_rename - renames a device 2879a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 2880a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 2881030c1d2bSEric W. Biederman * 2882030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 2883030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 2884030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 2885030c1d2bSEric W. Biederman * won't conflict with other devices. 2886c6c0ac66SMichael Ellerman * 2887a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 2888a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 2889a5462516STimur Tabi * some insight: 2890a5462516STimur Tabi * 2891a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 2892a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 2893a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 2894a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 2895a5462516STimur Tabi * 2896a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 2897a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 2898a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 2899a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 2900a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 2901a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 2902a5462516STimur Tabi * 2903a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 2904a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 2905a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 2906a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 2907a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 2908a5462516STimur Tabi * reasons. 2909a5462516STimur Tabi * 2910a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 2911a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 2912a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 2913a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 2914a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 2915a2de48caSGreg Kroah-Hartman */ 29166937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 2917a2de48caSGreg Kroah-Hartman { 29184b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 29192ee97cafSCornelia Huck char *old_device_name = NULL; 2920a2de48caSGreg Kroah-Hartman int error; 2921a2de48caSGreg Kroah-Hartman 2922a2de48caSGreg Kroah-Hartman dev = get_device(dev); 2923a2de48caSGreg Kroah-Hartman if (!dev) 2924a2de48caSGreg Kroah-Hartman return -EINVAL; 2925a2de48caSGreg Kroah-Hartman 292669df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 2927a2de48caSGreg Kroah-Hartman 29281fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 29292ee97cafSCornelia Huck if (!old_device_name) { 2930952ab431SJesper Juhl error = -ENOMEM; 29312ee97cafSCornelia Huck goto out; 2932952ab431SJesper Juhl } 2933a2de48caSGreg Kroah-Hartman 2934f349cf34SEric W. Biederman if (dev->class) { 29354b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 29364b30ee58STejun Heo kobj, old_device_name, 29374b30ee58STejun Heo new_name, kobject_namespace(kobj)); 2938f349cf34SEric W. Biederman if (error) 2939f349cf34SEric W. Biederman goto out; 2940f349cf34SEric W. Biederman } 294139aba963SKay Sievers 29424b30ee58STejun Heo error = kobject_rename(kobj, new_name); 29431fa5ae85SKay Sievers if (error) 29442ee97cafSCornelia Huck goto out; 2945a2de48caSGreg Kroah-Hartman 29462ee97cafSCornelia Huck out: 2947a2de48caSGreg Kroah-Hartman put_device(dev); 2948a2de48caSGreg Kroah-Hartman 29492ee97cafSCornelia Huck kfree(old_device_name); 2950a2de48caSGreg Kroah-Hartman 2951a2de48caSGreg Kroah-Hartman return error; 2952a2de48caSGreg Kroah-Hartman } 2953a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 29548a82472fSCornelia Huck 29558a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 29568a82472fSCornelia Huck struct device *old_parent, 29578a82472fSCornelia Huck struct device *new_parent) 29588a82472fSCornelia Huck { 2959f7f3461dSGreg Kroah-Hartman int error = 0; 29608a82472fSCornelia Huck 2961f7f3461dSGreg Kroah-Hartman if (old_parent) 2962f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 2963f7f3461dSGreg Kroah-Hartman if (new_parent) 2964f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 2965f7f3461dSGreg Kroah-Hartman "device"); 2966f7f3461dSGreg Kroah-Hartman return error; 29678a82472fSCornelia Huck } 29688a82472fSCornelia Huck 29698a82472fSCornelia Huck /** 29708a82472fSCornelia Huck * device_move - moves a device to a new parent 29718a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 297213509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 2973ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 29748a82472fSCornelia Huck */ 2975ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 2976ffa6a705SCornelia Huck enum dpm_order dpm_order) 29778a82472fSCornelia Huck { 29788a82472fSCornelia Huck int error; 29798a82472fSCornelia Huck struct device *old_parent; 2980c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 29818a82472fSCornelia Huck 29828a82472fSCornelia Huck dev = get_device(dev); 29838a82472fSCornelia Huck if (!dev) 29848a82472fSCornelia Huck return -EINVAL; 29858a82472fSCornelia Huck 2986ffa6a705SCornelia Huck device_pm_lock(); 29878a82472fSCornelia Huck new_parent = get_device(new_parent); 2988c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 298984d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 299084d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 299184d0c27dSTetsuo Handa put_device(new_parent); 299284d0c27dSTetsuo Handa goto out; 299384d0c27dSTetsuo Handa } 299463b6971aSCornelia Huck 29951e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 29961e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 2997c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 29988a82472fSCornelia Huck if (error) { 299963b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 30008a82472fSCornelia Huck put_device(new_parent); 30018a82472fSCornelia Huck goto out; 30028a82472fSCornelia Huck } 30038a82472fSCornelia Huck old_parent = dev->parent; 30048a82472fSCornelia Huck dev->parent = new_parent; 30058a82472fSCornelia Huck if (old_parent) 3006f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 30070d358f22SYinghai Lu if (new_parent) { 3008f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3009f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 30100d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 30110d358f22SYinghai Lu } 30120d358f22SYinghai Lu 3013bdd4034dSRabin Vincent if (dev->class) { 30148a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 30158a82472fSCornelia Huck if (error) { 30168a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 30178a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 30188a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 3019c744aeaeSCornelia Huck if (new_parent) 3020f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 30210d358f22SYinghai Lu dev->parent = old_parent; 30220d358f22SYinghai Lu if (old_parent) { 3023f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3024f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 30250d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 30260d358f22SYinghai Lu } 30278a82472fSCornelia Huck } 302863b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 30298a82472fSCornelia Huck put_device(new_parent); 30308a82472fSCornelia Huck goto out; 30318a82472fSCornelia Huck } 3032bdd4034dSRabin Vincent } 3033ffa6a705SCornelia Huck switch (dpm_order) { 3034ffa6a705SCornelia Huck case DPM_ORDER_NONE: 3035ffa6a705SCornelia Huck break; 3036ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 3037ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 303852cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 3039ffa6a705SCornelia Huck break; 3040ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 3041ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 304252cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 3043ffa6a705SCornelia Huck break; 3044ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 3045ffa6a705SCornelia Huck device_pm_move_last(dev); 304652cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 3047ffa6a705SCornelia Huck break; 3048ffa6a705SCornelia Huck } 3049bdd4034dSRabin Vincent 30508a82472fSCornelia Huck put_device(old_parent); 30518a82472fSCornelia Huck out: 3052ffa6a705SCornelia Huck device_pm_unlock(); 30538a82472fSCornelia Huck put_device(dev); 30548a82472fSCornelia Huck return error; 30558a82472fSCornelia Huck } 30568a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 305737b0c020SGreg Kroah-Hartman 305837b0c020SGreg Kroah-Hartman /** 305937b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 306037b0c020SGreg Kroah-Hartman */ 306137b0c020SGreg Kroah-Hartman void device_shutdown(void) 306237b0c020SGreg Kroah-Hartman { 3063f123db8eSBenson Leung struct device *dev, *parent; 306437b0c020SGreg Kroah-Hartman 30653297c8fcSPingfan Liu wait_for_device_probe(); 30663297c8fcSPingfan Liu device_block_probing(); 30673297c8fcSPingfan Liu 30686245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 30696245838fSHugh Daschbach /* 30706245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 30716245838fSHugh Daschbach * Beware that device unplug events may also start pulling 30726245838fSHugh Daschbach * devices offline, even as the system is shutting down. 30736245838fSHugh Daschbach */ 30746245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 30756245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 30766245838fSHugh Daschbach kobj.entry); 3077d1c6c030SMing Lei 3078d1c6c030SMing Lei /* 3079d1c6c030SMing Lei * hold reference count of device's parent to 3080d1c6c030SMing Lei * prevent it from being freed because parent's 3081d1c6c030SMing Lei * lock is to be held 3082d1c6c030SMing Lei */ 3083f123db8eSBenson Leung parent = get_device(dev->parent); 30846245838fSHugh Daschbach get_device(dev); 30856245838fSHugh Daschbach /* 30866245838fSHugh Daschbach * Make sure the device is off the kset list, in the 30876245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 30886245838fSHugh Daschbach */ 30896245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 30906245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 3091fe6b91f4SAlan Stern 3092d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 3093f123db8eSBenson Leung if (parent) 3094f123db8eSBenson Leung device_lock(parent); 3095d1c6c030SMing Lei device_lock(dev); 3096d1c6c030SMing Lei 3097fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 3098fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 3099fe6b91f4SAlan Stern pm_runtime_barrier(dev); 31006245838fSHugh Daschbach 31017521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 3102f77af151SJosh Zimmerman if (initcall_debug) 31037521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 31047521621eSMichal Suchanek dev->class->shutdown_pre(dev); 31057521621eSMichal Suchanek } 31067521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 31070246c4faSShuoX Liu if (initcall_debug) 31080246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 310937b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 311037b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 31110246c4faSShuoX Liu if (initcall_debug) 31120246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 311337b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 311437b0c020SGreg Kroah-Hartman } 3115d1c6c030SMing Lei 3116d1c6c030SMing Lei device_unlock(dev); 3117f123db8eSBenson Leung if (parent) 3118f123db8eSBenson Leung device_unlock(parent); 3119d1c6c030SMing Lei 31206245838fSHugh Daschbach put_device(dev); 3121f123db8eSBenson Leung put_device(parent); 31226245838fSHugh Daschbach 31236245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 312437b0c020SGreg Kroah-Hartman } 31256245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 312637b0c020SGreg Kroah-Hartman } 312799bcf217SJoe Perches 312899bcf217SJoe Perches /* 312999bcf217SJoe Perches * Device logging functions 313099bcf217SJoe Perches */ 313199bcf217SJoe Perches 313299bcf217SJoe Perches #ifdef CONFIG_PRINTK 3133666f355fSJoe Perches static int 3134666f355fSJoe Perches create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 313599bcf217SJoe Perches { 3136c4e00daaSKay Sievers const char *subsys; 3137798efc60SJoe Perches size_t pos = 0; 313899bcf217SJoe Perches 3139c4e00daaSKay Sievers if (dev->class) 3140c4e00daaSKay Sievers subsys = dev->class->name; 3141c4e00daaSKay Sievers else if (dev->bus) 3142c4e00daaSKay Sievers subsys = dev->bus->name; 3143c4e00daaSKay Sievers else 3144798efc60SJoe Perches return 0; 3145c4e00daaSKay Sievers 3146798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 3147655e5b7cSBen Hutchings if (pos >= hdrlen) 3148655e5b7cSBen Hutchings goto overflow; 3149c4e00daaSKay Sievers 3150c4e00daaSKay Sievers /* 3151c4e00daaSKay Sievers * Add device identifier DEVICE=: 3152c4e00daaSKay Sievers * b12:8 block dev_t 3153c4e00daaSKay Sievers * c127:3 char dev_t 3154c4e00daaSKay Sievers * n8 netdev ifindex 3155c4e00daaSKay Sievers * +sound:card0 subsystem:devname 3156c4e00daaSKay Sievers */ 3157c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 3158c4e00daaSKay Sievers char c; 3159c4e00daaSKay Sievers 3160c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 3161c4e00daaSKay Sievers c = 'b'; 3162c4e00daaSKay Sievers else 3163c4e00daaSKay Sievers c = 'c'; 3164798efc60SJoe Perches pos++; 3165798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3166c4e00daaSKay Sievers "DEVICE=%c%u:%u", 3167c4e00daaSKay Sievers c, MAJOR(dev->devt), MINOR(dev->devt)); 3168c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 3169c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 3170c4e00daaSKay Sievers 3171798efc60SJoe Perches pos++; 3172798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3173c4e00daaSKay Sievers "DEVICE=n%u", net->ifindex); 3174c4e00daaSKay Sievers } else { 3175798efc60SJoe Perches pos++; 3176798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3177c4e00daaSKay Sievers "DEVICE=+%s:%s", subsys, dev_name(dev)); 3178c4e00daaSKay Sievers } 3179af7f2158SJim Cromie 3180655e5b7cSBen Hutchings if (pos >= hdrlen) 3181655e5b7cSBen Hutchings goto overflow; 3182655e5b7cSBen Hutchings 3183798efc60SJoe Perches return pos; 3184655e5b7cSBen Hutchings 3185655e5b7cSBen Hutchings overflow: 3186655e5b7cSBen Hutchings dev_WARN(dev, "device/subsystem name too long"); 3187655e5b7cSBen Hutchings return 0; 318899bcf217SJoe Perches } 3189798efc60SJoe Perches 319005e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 319105e4e5b8SJoe Perches const char *fmt, va_list args) 319205e4e5b8SJoe Perches { 319305e4e5b8SJoe Perches char hdr[128]; 319405e4e5b8SJoe Perches size_t hdrlen; 319505e4e5b8SJoe Perches 319605e4e5b8SJoe Perches hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 319705e4e5b8SJoe Perches 319805e4e5b8SJoe Perches return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 319905e4e5b8SJoe Perches } 320005e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 320105e4e5b8SJoe Perches 320205e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 320305e4e5b8SJoe Perches { 320405e4e5b8SJoe Perches va_list args; 320505e4e5b8SJoe Perches int r; 320605e4e5b8SJoe Perches 320705e4e5b8SJoe Perches va_start(args, fmt); 320805e4e5b8SJoe Perches 320905e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 321005e4e5b8SJoe Perches 321105e4e5b8SJoe Perches va_end(args); 321205e4e5b8SJoe Perches 321305e4e5b8SJoe Perches return r; 321405e4e5b8SJoe Perches } 321505e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 321605e4e5b8SJoe Perches 3217d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 3218798efc60SJoe Perches struct va_format *vaf) 3219798efc60SJoe Perches { 3220d1f1052cSJoe Perches if (dev) 3221d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 3222798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 3223d1f1052cSJoe Perches else 3224d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 3225798efc60SJoe Perches } 322699bcf217SJoe Perches 3227d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 322899bcf217SJoe Perches const char *fmt, ...) 322999bcf217SJoe Perches { 323099bcf217SJoe Perches struct va_format vaf; 323199bcf217SJoe Perches va_list args; 323299bcf217SJoe Perches 323399bcf217SJoe Perches va_start(args, fmt); 323499bcf217SJoe Perches 323599bcf217SJoe Perches vaf.fmt = fmt; 323699bcf217SJoe Perches vaf.va = &args; 323799bcf217SJoe Perches 3238d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 3239798efc60SJoe Perches 324099bcf217SJoe Perches va_end(args); 324199bcf217SJoe Perches } 324299bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 324399bcf217SJoe Perches 324499bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 3245d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 324699bcf217SJoe Perches { \ 324799bcf217SJoe Perches struct va_format vaf; \ 324899bcf217SJoe Perches va_list args; \ 324999bcf217SJoe Perches \ 325099bcf217SJoe Perches va_start(args, fmt); \ 325199bcf217SJoe Perches \ 325299bcf217SJoe Perches vaf.fmt = fmt; \ 325399bcf217SJoe Perches vaf.va = &args; \ 325499bcf217SJoe Perches \ 3255d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 3256798efc60SJoe Perches \ 325799bcf217SJoe Perches va_end(args); \ 325899bcf217SJoe Perches } \ 325999bcf217SJoe Perches EXPORT_SYMBOL(func); 326099bcf217SJoe Perches 3261663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 3262663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 3263663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 3264663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 3265663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 3266663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 326799bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 326899bcf217SJoe Perches 326999bcf217SJoe Perches #endif 327097badf87SRafael J. Wysocki 327197badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 327297badf87SRafael J. Wysocki { 327397badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 327497badf87SRafael J. Wysocki } 327597badf87SRafael J. Wysocki 327697badf87SRafael J. Wysocki /** 327797badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 327897badf87SRafael J. Wysocki * @dev: Device to handle. 327997badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 328097badf87SRafael J. Wysocki * 328197badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 328297badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 328397badf87SRafael J. Wysocki */ 328497badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 328597badf87SRafael J. Wysocki { 328697badf87SRafael J. Wysocki if (fwnode) { 328797badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 328897badf87SRafael J. Wysocki 328997badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 329097badf87SRafael J. Wysocki fn = fn->secondary; 329197badf87SRafael J. Wysocki 329255f89a8aSMika Westerberg if (fn) { 329355f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 329497badf87SRafael J. Wysocki fwnode->secondary = fn; 329555f89a8aSMika Westerberg } 329697badf87SRafael J. Wysocki dev->fwnode = fwnode; 329797badf87SRafael J. Wysocki } else { 329897badf87SRafael J. Wysocki dev->fwnode = fwnode_is_primary(dev->fwnode) ? 329997badf87SRafael J. Wysocki dev->fwnode->secondary : NULL; 330097badf87SRafael J. Wysocki } 330197badf87SRafael J. Wysocki } 330297badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 330397badf87SRafael J. Wysocki 330497badf87SRafael J. Wysocki /** 330597badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 330697badf87SRafael J. Wysocki * @dev: Device to handle. 330797badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 330897badf87SRafael J. Wysocki * 330997badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 331097badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 331197badf87SRafael J. Wysocki * @fwnode. 331297badf87SRafael J. Wysocki */ 331397badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 331497badf87SRafael J. Wysocki { 331597badf87SRafael J. Wysocki if (fwnode) 331697badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 331797badf87SRafael J. Wysocki 331897badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 331997badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 332097badf87SRafael J. Wysocki else 332197badf87SRafael J. Wysocki dev->fwnode = fwnode; 332297badf87SRafael J. Wysocki } 33234e75e1d7SJohan Hovold 33244e75e1d7SJohan Hovold /** 33254e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 33264e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 33274e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 33284e75e1d7SJohan Hovold * 33294e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 33304e75e1d7SJohan Hovold * any reference held to the old node. 33314e75e1d7SJohan Hovold */ 33324e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 33334e75e1d7SJohan Hovold { 33344e75e1d7SJohan Hovold of_node_put(dev->of_node); 33354e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 33364e75e1d7SJohan Hovold dev->of_node_reused = true; 33374e75e1d7SJohan Hovold } 33384e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 3339