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 168494fd7b7SFeng Kan /** 1699ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 1709ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 1719ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 1729ed98953SRafael J. Wysocki * @flags: Link flags. 1739ed98953SRafael J. Wysocki * 17421d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 17521d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 17621d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 17721d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 17821d5c57bSRafael J. Wysocki * be forced into the active metastate and reference-counted upon the creation 17921d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 18021d5c57bSRafael J. Wysocki * ignored. 18121d5c57bSRafael J. Wysocki * 182c8d50986SRafael J. Wysocki * If the DL_FLAG_AUTOREMOVE_CONSUMER flag is set, the link will be removed 183c8d50986SRafael J. Wysocki * automatically when the consumer device driver unbinds from it. Analogously, 184c8d50986SRafael J. Wysocki * if DL_FLAG_AUTOREMOVE_SUPPLIER is set in @flags, the link will be removed 185c8d50986SRafael J. Wysocki * automatically when the supplier device driver unbinds from it. 186c8d50986SRafael J. Wysocki * 187c8d50986SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and either DL_FLAG_AUTOREMOVE_CONSUMER 188c8d50986SRafael J. Wysocki * or DL_FLAG_AUTOREMOVE_SUPPLIER set in @flags at the same time is invalid and 189c8d50986SRafael J. Wysocki * will cause NULL to be returned upfront. 1909ed98953SRafael J. Wysocki * 1919ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 1929ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 1939ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 1949ed98953SRafael J. Wysocki * not been registered when this function is called). 1959ed98953SRafael J. Wysocki * 1969ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 1979ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 19864df1148SLukas Wunner * not be registered, however. 1999ed98953SRafael J. Wysocki */ 2009ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 2019ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 2029ed98953SRafael J. Wysocki { 2039ed98953SRafael J. Wysocki struct device_link *link; 2049ed98953SRafael J. Wysocki 2059ed98953SRafael J. Wysocki if (!consumer || !supplier || 206c8d50986SRafael J. Wysocki (flags & DL_FLAG_STATELESS && 207c8d50986SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | DL_FLAG_AUTOREMOVE_SUPPLIER))) 2089ed98953SRafael J. Wysocki return NULL; 2099ed98953SRafael J. Wysocki 2109ed98953SRafael J. Wysocki device_links_write_lock(); 2119ed98953SRafael J. Wysocki device_pm_lock(); 2129ed98953SRafael J. Wysocki 2139ed98953SRafael J. Wysocki /* 2149ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 2159ed98953SRafael J. Wysocki * reverse dependency between the consumer and the supplier already in 2169ed98953SRafael J. Wysocki * the graph, return NULL. 2179ed98953SRafael J. Wysocki */ 2189ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 2199ed98953SRafael J. Wysocki || device_is_dependent(consumer, supplier)) { 2209ed98953SRafael J. Wysocki link = NULL; 2219ed98953SRafael J. Wysocki goto out; 2229ed98953SRafael J. Wysocki } 2239ed98953SRafael J. Wysocki 224f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 225f265df55SRafael J. Wysocki if (link->consumer != consumer) 226f265df55SRafael J. Wysocki continue; 227f265df55SRafael J. Wysocki 228f265df55SRafael J. Wysocki /* 229f265df55SRafael J. Wysocki * Don't return a stateless link if the caller wants a stateful 230f265df55SRafael J. Wysocki * one and vice versa. 231f265df55SRafael J. Wysocki */ 232f265df55SRafael J. Wysocki if (WARN_ON((flags & DL_FLAG_STATELESS) != (link->flags & DL_FLAG_STATELESS))) { 233f265df55SRafael J. Wysocki link = NULL; 234f265df55SRafael J. Wysocki goto out; 235f265df55SRafael J. Wysocki } 236f265df55SRafael J. Wysocki 237f265df55SRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_CONSUMER) 238f265df55SRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_CONSUMER; 239f265df55SRafael J. Wysocki 240f265df55SRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 241f265df55SRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 242f265df55SRafael J. Wysocki 243ead18c23SLukas Wunner kref_get(&link->kref); 2449ed98953SRafael J. Wysocki goto out; 245ead18c23SLukas Wunner } 2469ed98953SRafael J. Wysocki 24721d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 2489ed98953SRafael J. Wysocki if (!link) 2499ed98953SRafael J. Wysocki goto out; 2509ed98953SRafael J. Wysocki 251baa8809fSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 252baa8809fSRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) { 25321d5c57bSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 25421d5c57bSRafael J. Wysocki pm_runtime_put_noidle(supplier); 25521d5c57bSRafael J. Wysocki kfree(link); 25621d5c57bSRafael J. Wysocki link = NULL; 25721d5c57bSRafael J. Wysocki goto out; 25821d5c57bSRafael J. Wysocki } 25921d5c57bSRafael J. Wysocki link->rpm_active = true; 26021d5c57bSRafael J. Wysocki } 261baa8809fSRafael J. Wysocki pm_runtime_new_link(consumer); 26247e5abfbSRafael J. Wysocki /* 26347e5abfbSRafael J. Wysocki * If the link is being added by the consumer driver at probe 26447e5abfbSRafael J. Wysocki * time, balance the decrementation of the supplier's runtime PM 26547e5abfbSRafael J. Wysocki * usage counter after consumer probe in driver_probe_device(). 26647e5abfbSRafael J. Wysocki */ 26747e5abfbSRafael J. Wysocki if (consumer->links.status == DL_DEV_PROBING) 26847e5abfbSRafael J. Wysocki pm_runtime_get_noresume(supplier); 269baa8809fSRafael J. Wysocki } 2709ed98953SRafael J. Wysocki get_device(supplier); 2719ed98953SRafael J. Wysocki link->supplier = supplier; 2729ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 2739ed98953SRafael J. Wysocki get_device(consumer); 2749ed98953SRafael J. Wysocki link->consumer = consumer; 2759ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 2769ed98953SRafael J. Wysocki link->flags = flags; 277ead18c23SLukas Wunner kref_init(&link->kref); 2789ed98953SRafael J. Wysocki 27964df1148SLukas Wunner /* Determine the initial link state. */ 2809ed98953SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 2819ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 2829ed98953SRafael J. Wysocki } else { 2839ed98953SRafael J. Wysocki switch (supplier->links.status) { 2849ed98953SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 2859ed98953SRafael J. Wysocki switch (consumer->links.status) { 2869ed98953SRafael J. Wysocki case DL_DEV_PROBING: 28721d5c57bSRafael J. Wysocki /* 28847e5abfbSRafael J. Wysocki * Some callers expect the link creation during 28947e5abfbSRafael J. Wysocki * consumer driver probe to resume the supplier 29047e5abfbSRafael J. Wysocki * even without DL_FLAG_RPM_ACTIVE. 29121d5c57bSRafael J. Wysocki */ 29221d5c57bSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) 29347e5abfbSRafael J. Wysocki pm_runtime_resume(supplier); 29421d5c57bSRafael J. Wysocki 2959ed98953SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 2969ed98953SRafael J. Wysocki break; 2979ed98953SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 2989ed98953SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 2999ed98953SRafael J. Wysocki break; 3009ed98953SRafael J. Wysocki default: 3019ed98953SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 3029ed98953SRafael J. Wysocki break; 3039ed98953SRafael J. Wysocki } 3049ed98953SRafael J. Wysocki break; 3059ed98953SRafael J. Wysocki case DL_DEV_UNBINDING: 3069ed98953SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 3079ed98953SRafael J. Wysocki break; 3089ed98953SRafael J. Wysocki default: 3099ed98953SRafael J. Wysocki link->status = DL_STATE_DORMANT; 3109ed98953SRafael J. Wysocki break; 3119ed98953SRafael J. Wysocki } 3129ed98953SRafael J. Wysocki } 3139ed98953SRafael J. Wysocki 3149ed98953SRafael J. Wysocki /* 3159ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 3169ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 3179ed98953SRafael J. Wysocki * 3189ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 3199ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 3209ed98953SRafael J. Wysocki */ 3219ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 3229ed98953SRafael J. Wysocki 3239ed98953SRafael J. Wysocki list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 3249ed98953SRafael J. Wysocki list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 3259ed98953SRafael J. Wysocki 3268a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 3279ed98953SRafael J. Wysocki 3289ed98953SRafael J. Wysocki out: 3299ed98953SRafael J. Wysocki device_pm_unlock(); 3309ed98953SRafael J. Wysocki device_links_write_unlock(); 3319ed98953SRafael J. Wysocki return link; 3329ed98953SRafael J. Wysocki } 3339ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 3349ed98953SRafael J. Wysocki 3359ed98953SRafael J. Wysocki static void device_link_free(struct device_link *link) 3369ed98953SRafael J. Wysocki { 3379ed98953SRafael J. Wysocki put_device(link->consumer); 3389ed98953SRafael J. Wysocki put_device(link->supplier); 3399ed98953SRafael J. Wysocki kfree(link); 3409ed98953SRafael J. Wysocki } 3419ed98953SRafael J. Wysocki 3429ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 3439ed98953SRafael J. Wysocki static void __device_link_free_srcu(struct rcu_head *rhead) 3449ed98953SRafael J. Wysocki { 3459ed98953SRafael J. Wysocki device_link_free(container_of(rhead, struct device_link, rcu_head)); 3469ed98953SRafael J. Wysocki } 3479ed98953SRafael J. Wysocki 348ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 3499ed98953SRafael J. Wysocki { 350ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 351ead18c23SLukas Wunner 3528a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 3539ed98953SRafael J. Wysocki dev_name(link->supplier)); 3549ed98953SRafael J. Wysocki 355baa8809fSRafael J. Wysocki if (link->flags & DL_FLAG_PM_RUNTIME) 356baa8809fSRafael J. Wysocki pm_runtime_drop_link(link->consumer); 357baa8809fSRafael J. Wysocki 3589ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 3599ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 3609ed98953SRafael J. Wysocki call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 3619ed98953SRafael J. Wysocki } 3629ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 363ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 3649ed98953SRafael J. Wysocki { 365ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 366ead18c23SLukas Wunner 3679ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 3689ed98953SRafael J. Wysocki dev_name(link->supplier)); 3699ed98953SRafael J. Wysocki 370433986c2SLukas Wunner if (link->flags & DL_FLAG_PM_RUNTIME) 371433986c2SLukas Wunner pm_runtime_drop_link(link->consumer); 372433986c2SLukas Wunner 3739ed98953SRafael J. Wysocki list_del(&link->s_node); 3749ed98953SRafael J. Wysocki list_del(&link->c_node); 3759ed98953SRafael J. Wysocki device_link_free(link); 3769ed98953SRafael J. Wysocki } 3779ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 3789ed98953SRafael J. Wysocki 3799ed98953SRafael J. Wysocki /** 3809ed98953SRafael J. Wysocki * device_link_del - Delete a link between two devices. 3819ed98953SRafael J. Wysocki * @link: Device link to delete. 3829ed98953SRafael J. Wysocki * 3839ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 384ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 385ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 386ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 3879ed98953SRafael J. Wysocki */ 3889ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 3899ed98953SRafael J. Wysocki { 3909ed98953SRafael J. Wysocki device_links_write_lock(); 3919ed98953SRafael J. Wysocki device_pm_lock(); 392ead18c23SLukas Wunner kref_put(&link->kref, __device_link_del); 3939ed98953SRafael J. Wysocki device_pm_unlock(); 3949ed98953SRafael J. Wysocki device_links_write_unlock(); 3959ed98953SRafael J. Wysocki } 3969ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 3979ed98953SRafael J. Wysocki 398d8842211Spascal paillet /** 399d8842211Spascal paillet * device_link_remove - remove a link between two devices. 400d8842211Spascal paillet * @consumer: Consumer end of the link. 401d8842211Spascal paillet * @supplier: Supplier end of the link. 402d8842211Spascal paillet * 403d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 404d8842211Spascal paillet * PM. 405d8842211Spascal paillet */ 406d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 407d8842211Spascal paillet { 408d8842211Spascal paillet struct device_link *link; 409d8842211Spascal paillet 410d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 411d8842211Spascal paillet return; 412d8842211Spascal paillet 413d8842211Spascal paillet device_links_write_lock(); 414d8842211Spascal paillet device_pm_lock(); 415d8842211Spascal paillet 416d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 417d8842211Spascal paillet if (link->consumer == consumer) { 418d8842211Spascal paillet kref_put(&link->kref, __device_link_del); 419d8842211Spascal paillet break; 420d8842211Spascal paillet } 421d8842211Spascal paillet } 422d8842211Spascal paillet 423d8842211Spascal paillet device_pm_unlock(); 424d8842211Spascal paillet device_links_write_unlock(); 425d8842211Spascal paillet } 426d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 427d8842211Spascal paillet 4289ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 4299ed98953SRafael J. Wysocki { 4309ed98953SRafael J. Wysocki struct device_link *link; 4319ed98953SRafael J. Wysocki 4329ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) 4339ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE) 4349ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 4359ed98953SRafael J. Wysocki } 4369ed98953SRafael J. Wysocki 4379ed98953SRafael J. Wysocki /** 4389ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 4399ed98953SRafael J. Wysocki * @dev: Consumer device. 4409ed98953SRafael J. Wysocki * 4419ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 4429ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 4439ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 4449ed98953SRafael J. Wysocki * 4459ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 4469ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 4479ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 4489ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 4499ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 4509ed98953SRafael J. Wysocki * 4519ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 4529ed98953SRafael J. Wysocki */ 4539ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 4549ed98953SRafael J. Wysocki { 4559ed98953SRafael J. Wysocki struct device_link *link; 4569ed98953SRafael J. Wysocki int ret = 0; 4579ed98953SRafael J. Wysocki 4589ed98953SRafael J. Wysocki device_links_write_lock(); 4599ed98953SRafael J. Wysocki 4609ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 4619ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 4629ed98953SRafael J. Wysocki continue; 4639ed98953SRafael J. Wysocki 4649ed98953SRafael J. Wysocki if (link->status != DL_STATE_AVAILABLE) { 4659ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 4669ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 4679ed98953SRafael J. Wysocki break; 4689ed98953SRafael J. Wysocki } 4699ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 4709ed98953SRafael J. Wysocki } 4719ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 4729ed98953SRafael J. Wysocki 4739ed98953SRafael J. Wysocki device_links_write_unlock(); 4749ed98953SRafael J. Wysocki return ret; 4759ed98953SRafael J. Wysocki } 4769ed98953SRafael J. Wysocki 4779ed98953SRafael J. Wysocki /** 4789ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 4799ed98953SRafael J. Wysocki * @dev: Device to update the links for. 4809ed98953SRafael J. Wysocki * 4819ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 4829ed98953SRafael J. Wysocki * consumers by changing their status to "available". 4839ed98953SRafael J. Wysocki * 4849ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 4859ed98953SRafael J. Wysocki * 4869ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 4879ed98953SRafael J. Wysocki */ 4889ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 4899ed98953SRafael J. Wysocki { 4909ed98953SRafael J. Wysocki struct device_link *link; 4919ed98953SRafael J. Wysocki 4929ed98953SRafael J. Wysocki device_links_write_lock(); 4939ed98953SRafael J. Wysocki 4949ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 4959ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 4969ed98953SRafael J. Wysocki continue; 4979ed98953SRafael J. Wysocki 4989ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 4999ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 5009ed98953SRafael J. Wysocki } 5019ed98953SRafael J. Wysocki 5029ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 5039ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 5049ed98953SRafael J. Wysocki continue; 5059ed98953SRafael J. Wysocki 5069ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 5079ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 5089ed98953SRafael J. Wysocki } 5099ed98953SRafael J. Wysocki 5109ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 5119ed98953SRafael J. Wysocki 5129ed98953SRafael J. Wysocki device_links_write_unlock(); 5139ed98953SRafael J. Wysocki } 5149ed98953SRafael J. Wysocki 5159ed98953SRafael J. Wysocki /** 5169ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 5179ed98953SRafael J. Wysocki * @dev: Device without a drvier. 5189ed98953SRafael J. Wysocki * 5199ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 5209ed98953SRafael J. Wysocki * 5219ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 5229ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 5239ed98953SRafael J. Wysocki * case they need not be updated. 5249ed98953SRafael J. Wysocki * 5259ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 5269ed98953SRafael J. Wysocki */ 5279ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 5289ed98953SRafael J. Wysocki { 5299ed98953SRafael J. Wysocki struct device_link *link, *ln; 5309ed98953SRafael J. Wysocki 5319ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 5329ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 5339ed98953SRafael J. Wysocki continue; 5349ed98953SRafael J. Wysocki 535e88728f4SVivek Gautam if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 5360fe6f787SYong Wu __device_link_del(&link->kref); 5379ed98953SRafael J. Wysocki else if (link->status != DL_STATE_SUPPLIER_UNBIND) 5389ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 5399ed98953SRafael J. Wysocki } 5409ed98953SRafael J. Wysocki 5419ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 5429ed98953SRafael J. Wysocki } 5439ed98953SRafael J. Wysocki 5449ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 5459ed98953SRafael J. Wysocki { 5469ed98953SRafael J. Wysocki device_links_write_lock(); 5479ed98953SRafael J. Wysocki __device_links_no_driver(dev); 5489ed98953SRafael J. Wysocki device_links_write_unlock(); 5499ed98953SRafael J. Wysocki } 5509ed98953SRafael J. Wysocki 5519ed98953SRafael J. Wysocki /** 5529ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 5539ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 5549ed98953SRafael J. Wysocki * 5559ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 5569ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 5579ed98953SRafael J. Wysocki * appropriate. 5589ed98953SRafael J. Wysocki * 5599ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 5609ed98953SRafael J. Wysocki */ 5619ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 5629ed98953SRafael J. Wysocki { 563c8d50986SRafael J. Wysocki struct device_link *link, *ln; 5649ed98953SRafael J. Wysocki 5659ed98953SRafael J. Wysocki device_links_write_lock(); 5669ed98953SRafael J. Wysocki 567c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 5689ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 5699ed98953SRafael J. Wysocki continue; 5709ed98953SRafael J. Wysocki 571e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 5729ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 5731689cac5SVivek Gautam 5741689cac5SVivek Gautam /* 5751689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 5761689cac5SVivek Gautam * devices that are not active, i.e. where the link state 5771689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 5781689cac5SVivek Gautam */ 5791689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 5801689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 5810fe6f787SYong Wu __device_link_del(&link->kref); 5821689cac5SVivek Gautam 5839ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 5849ed98953SRafael J. Wysocki } 5859ed98953SRafael J. Wysocki 5869ed98953SRafael J. Wysocki __device_links_no_driver(dev); 5879ed98953SRafael J. Wysocki 5889ed98953SRafael J. Wysocki device_links_write_unlock(); 5899ed98953SRafael J. Wysocki } 5909ed98953SRafael J. Wysocki 5919ed98953SRafael J. Wysocki /** 5929ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 5939ed98953SRafael J. Wysocki * @dev: Device to check. 5949ed98953SRafael J. Wysocki * 5959ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 5969ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 5979ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 5989ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 5999ed98953SRafael J. Wysocki * successfully going forward. 6009ed98953SRafael J. Wysocki * 6019ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 6029ed98953SRafael J. Wysocki * 6039ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 6049ed98953SRafael J. Wysocki */ 6059ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 6069ed98953SRafael J. Wysocki { 6079ed98953SRafael J. Wysocki struct device_link *link; 6089ed98953SRafael J. Wysocki bool ret = false; 6099ed98953SRafael J. Wysocki 6109ed98953SRafael J. Wysocki device_links_write_lock(); 6119ed98953SRafael J. Wysocki 6129ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 6139ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 6149ed98953SRafael J. Wysocki continue; 6159ed98953SRafael J. Wysocki 6169ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 6179ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 6189ed98953SRafael J. Wysocki ret = true; 6199ed98953SRafael J. Wysocki break; 6209ed98953SRafael J. Wysocki } 6219ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 6229ed98953SRafael J. Wysocki } 6239ed98953SRafael J. Wysocki 6249ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 6259ed98953SRafael J. Wysocki 6269ed98953SRafael J. Wysocki device_links_write_unlock(); 6279ed98953SRafael J. Wysocki return ret; 6289ed98953SRafael J. Wysocki } 6299ed98953SRafael J. Wysocki 6309ed98953SRafael J. Wysocki /** 6319ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 6329ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 6339ed98953SRafael J. Wysocki * 6349ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 6359ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 6369ed98953SRafael J. Wysocki * and start over. 6379ed98953SRafael J. Wysocki * 6389ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 6399ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 6409ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 6419ed98953SRafael J. Wysocki * changed the state of the link already). 6429ed98953SRafael J. Wysocki * 6439ed98953SRafael J. Wysocki * Links with the DL_FLAG_STATELESS flag set are ignored. 6449ed98953SRafael J. Wysocki */ 6459ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 6469ed98953SRafael J. Wysocki { 6479ed98953SRafael J. Wysocki struct device_link *link; 6489ed98953SRafael J. Wysocki 6499ed98953SRafael J. Wysocki start: 6509ed98953SRafael J. Wysocki device_links_write_lock(); 6519ed98953SRafael J. Wysocki 6529ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 6539ed98953SRafael J. Wysocki enum device_link_state status; 6549ed98953SRafael J. Wysocki 6559ed98953SRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 6569ed98953SRafael J. Wysocki continue; 6579ed98953SRafael J. Wysocki 6589ed98953SRafael J. Wysocki status = link->status; 6599ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 6609ed98953SRafael J. Wysocki device_links_write_unlock(); 6619ed98953SRafael J. Wysocki 6629ed98953SRafael J. Wysocki wait_for_device_probe(); 6639ed98953SRafael J. Wysocki goto start; 6649ed98953SRafael J. Wysocki } 6659ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 6669ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 6679ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 6689ed98953SRafael J. Wysocki 6699ed98953SRafael J. Wysocki get_device(consumer); 6709ed98953SRafael J. Wysocki 6719ed98953SRafael J. Wysocki device_links_write_unlock(); 6729ed98953SRafael J. Wysocki 6739ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 6749ed98953SRafael J. Wysocki consumer->parent); 6759ed98953SRafael J. Wysocki put_device(consumer); 6769ed98953SRafael J. Wysocki goto start; 6779ed98953SRafael J. Wysocki } 6789ed98953SRafael J. Wysocki } 6799ed98953SRafael J. Wysocki 6809ed98953SRafael J. Wysocki device_links_write_unlock(); 6819ed98953SRafael J. Wysocki } 6829ed98953SRafael J. Wysocki 6839ed98953SRafael J. Wysocki /** 6849ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 6859ed98953SRafael J. Wysocki * @dev: Target device. 6869ed98953SRafael J. Wysocki */ 6879ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 6889ed98953SRafael J. Wysocki { 6899ed98953SRafael J. Wysocki struct device_link *link, *ln; 6909ed98953SRafael J. Wysocki 6919ed98953SRafael J. Wysocki /* 6929ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 6939ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 6949ed98953SRafael J. Wysocki */ 6959ed98953SRafael J. Wysocki device_links_write_lock(); 6969ed98953SRafael J. Wysocki 6979ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 6989ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 699ead18c23SLukas Wunner __device_link_del(&link->kref); 7009ed98953SRafael J. Wysocki } 7019ed98953SRafael J. Wysocki 7029ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 7039ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 7049ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 705ead18c23SLukas Wunner __device_link_del(&link->kref); 7069ed98953SRafael J. Wysocki } 7079ed98953SRafael J. Wysocki 7089ed98953SRafael J. Wysocki device_links_write_unlock(); 7099ed98953SRafael J. Wysocki } 7109ed98953SRafael J. Wysocki 7119ed98953SRafael J. Wysocki /* Device links support end. */ 7129ed98953SRafael J. Wysocki 7131da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 7141da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 715e105b8bfSDan Williams static struct kobject *dev_kobj; 716e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 717e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 7181da177e4SLinus Torvalds 7195e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 7205e33bc41SRafael J. Wysocki 7215e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 7225e33bc41SRafael J. Wysocki { 7235e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 7245e33bc41SRafael J. Wysocki } 7255e33bc41SRafael J. Wysocki 7265e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 7275e33bc41SRafael J. Wysocki { 7285e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 7295e33bc41SRafael J. Wysocki } 7305e33bc41SRafael J. Wysocki 7315e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 7325e33bc41SRafael J. Wysocki { 7335e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 7345e33bc41SRafael J. Wysocki return 0; 7355e33bc41SRafael J. Wysocki 7365e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 7375e33bc41SRafael J. Wysocki msleep(5); 7385e33bc41SRafael J. Wysocki return restart_syscall(); 7395e33bc41SRafael J. Wysocki } 7405e33bc41SRafael J. Wysocki 7414e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 7424e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 7434e886c29SGreg Kroah-Hartman { 7444e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 7454e886c29SGreg Kroah-Hartman } 7464e886c29SGreg Kroah-Hartman #else 7474e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 7484e886c29SGreg Kroah-Hartman { 7494e886c29SGreg Kroah-Hartman return 1; 7504e886c29SGreg Kroah-Hartman } 7514e886c29SGreg Kroah-Hartman #endif 7521da177e4SLinus Torvalds 75307de0e86SHeikki Krogerus static int 75407de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 75507de0e86SHeikki Krogerus { 7567847a145SHeikki Krogerus int ret; 7577847a145SHeikki Krogerus 7587847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 7597847a145SHeikki Krogerus if (ret) 7607847a145SHeikki Krogerus return ret; 7617847a145SHeikki Krogerus 76259abd836SHeikki Krogerus ret = software_node_notify(dev, action); 76359abd836SHeikki Krogerus if (ret) 76459abd836SHeikki Krogerus return ret; 76559abd836SHeikki Krogerus 76607de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 76707de0e86SHeikki Krogerus platform_notify(dev); 76807de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 76907de0e86SHeikki Krogerus platform_notify_remove(dev); 77007de0e86SHeikki Krogerus return 0; 77107de0e86SHeikki Krogerus } 77207de0e86SHeikki Krogerus 7733e95637aSAlan Stern /** 7743e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 7753e95637aSAlan Stern * @dev: struct device to get the name of 7763e95637aSAlan Stern * 7773e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 7789169c012Syan * the device is not bound to a driver, it will return the name of the bus 7793e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 7803e95637aSAlan Stern * string will be returned. 7813e95637aSAlan Stern */ 782bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 7833e95637aSAlan Stern { 7843589972eSAlan Stern struct device_driver *drv; 7853589972eSAlan Stern 7863589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 7873589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 7883589972eSAlan Stern * never change once they are set, so they don't need special care. 7893589972eSAlan Stern */ 7906aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 7913589972eSAlan Stern return drv ? drv->name : 792a456b702SJean Delvare (dev->bus ? dev->bus->name : 793a456b702SJean Delvare (dev->class ? dev->class->name : "")); 7943e95637aSAlan Stern } 795310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 7963e95637aSAlan Stern 7971da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 7981da177e4SLinus Torvalds 7994a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 8004a3ad20cSGreg Kroah-Hartman char *buf) 8011da177e4SLinus Torvalds { 8021da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 803b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 8044a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds if (dev_attr->show) 80754b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 808815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 809a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 810a52668c6SSergey Senozhatsky dev_attr->show); 811815d2d50SAndrew Morton } 8121da177e4SLinus Torvalds return ret; 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds 8154a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 8161da177e4SLinus Torvalds const char *buf, size_t count) 8171da177e4SLinus Torvalds { 8181da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 819b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 8204a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds if (dev_attr->store) 82354b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 8241da177e4SLinus Torvalds return ret; 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds 82752cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 8281da177e4SLinus Torvalds .show = dev_attr_show, 8291da177e4SLinus Torvalds .store = dev_attr_store, 8301da177e4SLinus Torvalds }; 8311da177e4SLinus Torvalds 832ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 833ca22e56dSKay Sievers 834ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 835ca22e56dSKay Sievers struct device_attribute *attr, 836ca22e56dSKay Sievers const char *buf, size_t size) 837ca22e56dSKay Sievers { 838ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 839f88184bfSKaitao cheng int ret; 840f88184bfSKaitao cheng unsigned long new; 841f88184bfSKaitao cheng 842f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 843f88184bfSKaitao cheng if (ret) 844f88184bfSKaitao cheng return ret; 845ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 846ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 847ca22e56dSKay Sievers return size; 848ca22e56dSKay Sievers } 849ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 850ca22e56dSKay Sievers 851ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 852ca22e56dSKay Sievers struct device_attribute *attr, 853ca22e56dSKay Sievers char *buf) 854ca22e56dSKay Sievers { 855ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 856ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 857ca22e56dSKay Sievers } 858ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 859ca22e56dSKay Sievers 860ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 861ca22e56dSKay Sievers struct device_attribute *attr, 862ca22e56dSKay Sievers const char *buf, size_t size) 863ca22e56dSKay Sievers { 864ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 865f88184bfSKaitao cheng int ret; 866f88184bfSKaitao cheng long new; 867f88184bfSKaitao cheng 868f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 869f88184bfSKaitao cheng if (ret) 870f88184bfSKaitao cheng return ret; 871f88184bfSKaitao cheng 872f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 873ca22e56dSKay Sievers return -EINVAL; 874ca22e56dSKay Sievers *(int *)(ea->var) = new; 875ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 876ca22e56dSKay Sievers return size; 877ca22e56dSKay Sievers } 878ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 879ca22e56dSKay Sievers 880ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 881ca22e56dSKay Sievers struct device_attribute *attr, 882ca22e56dSKay Sievers char *buf) 883ca22e56dSKay Sievers { 884ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 885ca22e56dSKay Sievers 886ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 887ca22e56dSKay Sievers } 888ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 8891da177e4SLinus Torvalds 89091872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 89191872392SBorislav Petkov const char *buf, size_t size) 89291872392SBorislav Petkov { 89391872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 89491872392SBorislav Petkov 89591872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 89691872392SBorislav Petkov return -EINVAL; 89791872392SBorislav Petkov 89891872392SBorislav Petkov return size; 89991872392SBorislav Petkov } 90091872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 90191872392SBorislav Petkov 90291872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 90391872392SBorislav Petkov char *buf) 90491872392SBorislav Petkov { 90591872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 90691872392SBorislav Petkov 90791872392SBorislav Petkov return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 90891872392SBorislav Petkov } 90991872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 91091872392SBorislav Petkov 9111da177e4SLinus Torvalds /** 9121da177e4SLinus Torvalds * device_release - free device structure. 9131da177e4SLinus Torvalds * @kobj: device's kobject. 9141da177e4SLinus Torvalds * 9151da177e4SLinus Torvalds * This is called once the reference count for the object 9161da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 9171da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 9181da177e4SLinus Torvalds */ 9191da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 9201da177e4SLinus Torvalds { 921b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 922fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 9231da177e4SLinus Torvalds 924a525a3ddSMing Lei /* 925a525a3ddSMing Lei * Some platform devices are driven without driver attached 926a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 927a525a3ddSMing Lei * all resources are released. 928a525a3ddSMing Lei * 929a525a3ddSMing Lei * Drivers still can add resources into device after device 930a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 931a525a3ddSMing Lei * possible memory leak. 932a525a3ddSMing Lei */ 933a525a3ddSMing Lei devres_release_all(dev); 934a525a3ddSMing Lei 9351da177e4SLinus Torvalds if (dev->release) 9361da177e4SLinus Torvalds dev->release(dev); 937f9f852dfSKay Sievers else if (dev->type && dev->type->release) 938f9f852dfSKay Sievers dev->type->release(dev); 9392620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 9402620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 941f810a5cfSArjan van de Ven else 942186bddb2SEzequiel 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", 9431e0b2cf9SKay Sievers dev_name(dev)); 944fb069a5dSGreg Kroah-Hartman kfree(p); 9451da177e4SLinus Torvalds } 9461da177e4SLinus Torvalds 947bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 948bc451f20SEric W. Biederman { 949b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 950bc451f20SEric W. Biederman const void *ns = NULL; 951bc451f20SEric W. Biederman 952bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 953bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 954bc451f20SEric W. Biederman 955bc451f20SEric W. Biederman return ns; 956bc451f20SEric W. Biederman } 957bc451f20SEric W. Biederman 9589944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 9599944e894SDmitry Torokhov { 9609944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 9619944e894SDmitry Torokhov 9629944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 9639944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 9649944e894SDmitry Torokhov } 9659944e894SDmitry Torokhov 9668f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 9671da177e4SLinus Torvalds .release = device_release, 9681da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 969bc451f20SEric W. Biederman .namespace = device_namespace, 9709944e894SDmitry Torokhov .get_ownership = device_get_ownership, 9711da177e4SLinus Torvalds }; 9721da177e4SLinus Torvalds 9731da177e4SLinus Torvalds 974312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 9751da177e4SLinus Torvalds { 9761da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 9771da177e4SLinus Torvalds 9788f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 979b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 9801da177e4SLinus Torvalds if (dev->bus) 9811da177e4SLinus Torvalds return 1; 98223681e47SGreg Kroah-Hartman if (dev->class) 98323681e47SGreg Kroah-Hartman return 1; 9841da177e4SLinus Torvalds } 9851da177e4SLinus Torvalds return 0; 9861da177e4SLinus Torvalds } 9871da177e4SLinus Torvalds 988312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 9891da177e4SLinus Torvalds { 990b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 9911da177e4SLinus Torvalds 99223681e47SGreg Kroah-Hartman if (dev->bus) 9931da177e4SLinus Torvalds return dev->bus->name; 99423681e47SGreg Kroah-Hartman if (dev->class) 99523681e47SGreg Kroah-Hartman return dev->class->name; 99623681e47SGreg Kroah-Hartman return NULL; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 9997eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 10007eff2e7aSKay Sievers struct kobj_uevent_env *env) 10011da177e4SLinus Torvalds { 1002b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 10031da177e4SLinus Torvalds int retval = 0; 10041da177e4SLinus Torvalds 10056fcf53acSKay Sievers /* add device node properties if present */ 100623681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 10076fcf53acSKay Sievers const char *tmp; 10086fcf53acSKay Sievers const char *name; 10092c9ede55SAl Viro umode_t mode = 0; 10104e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 10114e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 10126fcf53acSKay Sievers 10137eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 10147eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 10153c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 10166fcf53acSKay Sievers if (name) { 10176fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 1018e454cea2SKay Sievers if (mode) 1019e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 10204e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 10214e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 10224e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 10234e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 10243c2670e6SKay Sievers kfree(tmp); 10256fcf53acSKay Sievers } 102623681e47SGreg Kroah-Hartman } 102723681e47SGreg Kroah-Hartman 1028414264f9SKay Sievers if (dev->type && dev->type->name) 10297eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 1030414264f9SKay Sievers 1031239378f1SKay Sievers if (dev->driver) 10327eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 1033239378f1SKay Sievers 103407d57a32SGrant Likely /* Add common DT information about the device */ 103507d57a32SGrant Likely of_device_uevent(dev, env); 103607d57a32SGrant Likely 10371da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 10387eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 10397eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 1040f9f852dfSKay Sievers if (retval) 10417dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 10421e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 10431da177e4SLinus Torvalds } 10441da177e4SLinus Torvalds 10452620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 10467eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 10477eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 1048f9f852dfSKay Sievers if (retval) 10497dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 10501e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 10512b3a302aSHarvey Harrison __func__, retval); 10522620efefSGreg Kroah-Hartman } 1053f9f852dfSKay Sievers 1054eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 10557eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 10567eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 1057f9f852dfSKay Sievers if (retval) 10587dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 10591e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 10602b3a302aSHarvey Harrison __func__, retval); 10612620efefSGreg Kroah-Hartman } 10622620efefSGreg Kroah-Hartman 10631da177e4SLinus Torvalds return retval; 10641da177e4SLinus Torvalds } 10651da177e4SLinus Torvalds 10669cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 1067312c004dSKay Sievers .filter = dev_uevent_filter, 1068312c004dSKay Sievers .name = dev_uevent_name, 1069312c004dSKay Sievers .uevent = dev_uevent, 10701da177e4SLinus Torvalds }; 10711da177e4SLinus Torvalds 1072c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 107316574dccSKay Sievers char *buf) 107416574dccSKay Sievers { 107516574dccSKay Sievers struct kobject *top_kobj; 107616574dccSKay Sievers struct kset *kset; 10777eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 107816574dccSKay Sievers int i; 107916574dccSKay Sievers size_t count = 0; 108016574dccSKay Sievers int retval; 108116574dccSKay Sievers 108216574dccSKay Sievers /* search the kset, the device belongs to */ 108316574dccSKay Sievers top_kobj = &dev->kobj; 10845c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 108516574dccSKay Sievers top_kobj = top_kobj->parent; 108616574dccSKay Sievers if (!top_kobj->kset) 108716574dccSKay Sievers goto out; 10885c5daf65SKay Sievers 108916574dccSKay Sievers kset = top_kobj->kset; 109016574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 109116574dccSKay Sievers goto out; 109216574dccSKay Sievers 109316574dccSKay Sievers /* respect filter */ 109416574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 109516574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 109616574dccSKay Sievers goto out; 109716574dccSKay Sievers 10987eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 10997eff2e7aSKay Sievers if (!env) 1100c7308c81SGreg Kroah-Hartman return -ENOMEM; 1101c7308c81SGreg Kroah-Hartman 110216574dccSKay Sievers /* let the kset specific function add its keys */ 11037eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 110416574dccSKay Sievers if (retval) 110516574dccSKay Sievers goto out; 110616574dccSKay Sievers 110716574dccSKay Sievers /* copy keys to file */ 11087eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 11097eff2e7aSKay Sievers count += sprintf(&buf[count], "%s\n", env->envp[i]); 111016574dccSKay Sievers out: 11117eff2e7aSKay Sievers kfree(env); 111216574dccSKay Sievers return count; 111316574dccSKay Sievers } 111416574dccSKay Sievers 1115c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 1116a7fd6706SKay Sievers const char *buf, size_t count) 1117a7fd6706SKay Sievers { 1118df44b479SPeter Rajnoha int rc; 1119df44b479SPeter Rajnoha 1120df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 1121df44b479SPeter Rajnoha 1122df44b479SPeter Rajnoha if (rc) { 1123f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 1124df44b479SPeter Rajnoha return rc; 1125df44b479SPeter Rajnoha } 112660a96a59SKay Sievers 1127a7fd6706SKay Sievers return count; 1128a7fd6706SKay Sievers } 1129c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 1130a7fd6706SKay Sievers 1131c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 11324f3549d7SRafael J. Wysocki char *buf) 11334f3549d7SRafael J. Wysocki { 11344f3549d7SRafael J. Wysocki bool val; 11354f3549d7SRafael J. Wysocki 11365e33bc41SRafael J. Wysocki device_lock(dev); 11374f3549d7SRafael J. Wysocki val = !dev->offline; 11385e33bc41SRafael J. Wysocki device_unlock(dev); 11394f3549d7SRafael J. Wysocki return sprintf(buf, "%u\n", val); 11404f3549d7SRafael J. Wysocki } 11414f3549d7SRafael J. Wysocki 1142c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 11434f3549d7SRafael J. Wysocki const char *buf, size_t count) 11444f3549d7SRafael J. Wysocki { 11454f3549d7SRafael J. Wysocki bool val; 11464f3549d7SRafael J. Wysocki int ret; 11474f3549d7SRafael J. Wysocki 11484f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 11494f3549d7SRafael J. Wysocki if (ret < 0) 11504f3549d7SRafael J. Wysocki return ret; 11514f3549d7SRafael J. Wysocki 11525e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 11535e33bc41SRafael J. Wysocki if (ret) 11545e33bc41SRafael J. Wysocki return ret; 11555e33bc41SRafael J. Wysocki 11564f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 11574f3549d7SRafael J. Wysocki unlock_device_hotplug(); 11584f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 11594f3549d7SRafael J. Wysocki } 1160c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 11614f3549d7SRafael J. Wysocki 1162fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 1163621a1672SDmitry Torokhov { 11643e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 1165621a1672SDmitry Torokhov } 1166a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 1167621a1672SDmitry Torokhov 1168fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 1169a4dbd674SDavid Brownell const struct attribute_group **groups) 1170621a1672SDmitry Torokhov { 11713e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 1172621a1672SDmitry Torokhov } 1173a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 1174de0ff00dSGreg Kroah-Hartman 117557b8ff07SDmitry Torokhov union device_attr_group_devres { 117657b8ff07SDmitry Torokhov const struct attribute_group *group; 117757b8ff07SDmitry Torokhov const struct attribute_group **groups; 117857b8ff07SDmitry Torokhov }; 117957b8ff07SDmitry Torokhov 118057b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 118157b8ff07SDmitry Torokhov { 118257b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 118357b8ff07SDmitry Torokhov } 118457b8ff07SDmitry Torokhov 118557b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 118657b8ff07SDmitry Torokhov { 118757b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 118857b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 118957b8ff07SDmitry Torokhov 119057b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 119157b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 119257b8ff07SDmitry Torokhov } 119357b8ff07SDmitry Torokhov 119457b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 119557b8ff07SDmitry Torokhov { 119657b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 119757b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 119857b8ff07SDmitry Torokhov 119957b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 120057b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 120157b8ff07SDmitry Torokhov } 120257b8ff07SDmitry Torokhov 120357b8ff07SDmitry Torokhov /** 120457b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 120557b8ff07SDmitry Torokhov * @dev: The device to create the group for 120657b8ff07SDmitry Torokhov * @grp: The attribute group to create 120757b8ff07SDmitry Torokhov * 120857b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 120957b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 121057b8ff07SDmitry Torokhov * 121157b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 121257b8ff07SDmitry Torokhov */ 121357b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 121457b8ff07SDmitry Torokhov { 121557b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 121657b8ff07SDmitry Torokhov int error; 121757b8ff07SDmitry Torokhov 121857b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 121957b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 122057b8ff07SDmitry Torokhov if (!devres) 122157b8ff07SDmitry Torokhov return -ENOMEM; 122257b8ff07SDmitry Torokhov 122357b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 122457b8ff07SDmitry Torokhov if (error) { 122557b8ff07SDmitry Torokhov devres_free(devres); 122657b8ff07SDmitry Torokhov return error; 122757b8ff07SDmitry Torokhov } 122857b8ff07SDmitry Torokhov 122957b8ff07SDmitry Torokhov devres->group = grp; 123057b8ff07SDmitry Torokhov devres_add(dev, devres); 123157b8ff07SDmitry Torokhov return 0; 123257b8ff07SDmitry Torokhov } 123357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 123457b8ff07SDmitry Torokhov 123557b8ff07SDmitry Torokhov /** 123657b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 123757b8ff07SDmitry Torokhov * @dev: device to remove the group from 123857b8ff07SDmitry Torokhov * @grp: group to remove 123957b8ff07SDmitry Torokhov * 124057b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 124157b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 124257b8ff07SDmitry Torokhov */ 124357b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 124457b8ff07SDmitry Torokhov const struct attribute_group *grp) 124557b8ff07SDmitry Torokhov { 124657b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 124757b8ff07SDmitry Torokhov devm_attr_group_match, 124857b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 124957b8ff07SDmitry Torokhov } 125057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 125157b8ff07SDmitry Torokhov 125257b8ff07SDmitry Torokhov /** 125357b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 125457b8ff07SDmitry Torokhov * @dev: The device to create the group for 125557b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 125657b8ff07SDmitry Torokhov * 125757b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 125857b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 125957b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 126057b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 126157b8ff07SDmitry Torokhov * attribute files being created already exist. 126257b8ff07SDmitry Torokhov * 126357b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 126457b8ff07SDmitry Torokhov */ 126557b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 126657b8ff07SDmitry Torokhov const struct attribute_group **groups) 126757b8ff07SDmitry Torokhov { 126857b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 126957b8ff07SDmitry Torokhov int error; 127057b8ff07SDmitry Torokhov 127157b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 127257b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 127357b8ff07SDmitry Torokhov if (!devres) 127457b8ff07SDmitry Torokhov return -ENOMEM; 127557b8ff07SDmitry Torokhov 127657b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 127757b8ff07SDmitry Torokhov if (error) { 127857b8ff07SDmitry Torokhov devres_free(devres); 127957b8ff07SDmitry Torokhov return error; 128057b8ff07SDmitry Torokhov } 128157b8ff07SDmitry Torokhov 128257b8ff07SDmitry Torokhov devres->groups = groups; 128357b8ff07SDmitry Torokhov devres_add(dev, devres); 128457b8ff07SDmitry Torokhov return 0; 128557b8ff07SDmitry Torokhov } 128657b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 128757b8ff07SDmitry Torokhov 128857b8ff07SDmitry Torokhov /** 128957b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 129057b8ff07SDmitry Torokhov * 129157b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 129257b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 129357b8ff07SDmitry Torokhov * 129457b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 129557b8ff07SDmitry Torokhov */ 129657b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 129757b8ff07SDmitry Torokhov const struct attribute_group **groups) 129857b8ff07SDmitry Torokhov { 129957b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 130057b8ff07SDmitry Torokhov devm_attr_group_match, 130157b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 130257b8ff07SDmitry Torokhov } 130357b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 13041da177e4SLinus Torvalds 13052620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 13062620efefSGreg Kroah-Hartman { 13072620efefSGreg Kroah-Hartman struct class *class = dev->class; 1308aed65af1SStephen Hemminger const struct device_type *type = dev->type; 1309621a1672SDmitry Torokhov int error; 13102620efefSGreg Kroah-Hartman 1311621a1672SDmitry Torokhov if (class) { 1312d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 13132620efefSGreg Kroah-Hartman if (error) 1314621a1672SDmitry Torokhov return error; 1315f9f852dfSKay Sievers } 1316f9f852dfSKay Sievers 1317621a1672SDmitry Torokhov if (type) { 1318621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 1319f9f852dfSKay Sievers if (error) 1320a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 1321f9f852dfSKay Sievers } 1322621a1672SDmitry Torokhov 1323621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 1324f9f852dfSKay Sievers if (error) 1325621a1672SDmitry Torokhov goto err_remove_type_groups; 1326621a1672SDmitry Torokhov 13274f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 1328c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 13294f3549d7SRafael J. Wysocki if (error) 1330ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 13314f3549d7SRafael J. Wysocki } 13324f3549d7SRafael J. Wysocki 1333621a1672SDmitry Torokhov return 0; 1334621a1672SDmitry Torokhov 1335ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 1336ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 1337621a1672SDmitry Torokhov err_remove_type_groups: 1338621a1672SDmitry Torokhov if (type) 1339621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1340d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 1341d05a6f96SGreg Kroah-Hartman if (class) 1342d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1343f9f852dfSKay Sievers 13442620efefSGreg Kroah-Hartman return error; 13452620efefSGreg Kroah-Hartman } 13462620efefSGreg Kroah-Hartman 13472620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 13482620efefSGreg Kroah-Hartman { 13492620efefSGreg Kroah-Hartman struct class *class = dev->class; 1350aed65af1SStephen Hemminger const struct device_type *type = dev->type; 13512620efefSGreg Kroah-Hartman 1352c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 1353621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 1354f9f852dfSKay Sievers 1355621a1672SDmitry Torokhov if (type) 1356621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 1357621a1672SDmitry Torokhov 1358a6b01dedSGreg Kroah-Hartman if (class) 1359d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 1360c97415a7SStefan Achatz } 13612620efefSGreg Kroah-Hartman 1362c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 136323681e47SGreg Kroah-Hartman char *buf) 136423681e47SGreg Kroah-Hartman { 136523681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 136623681e47SGreg Kroah-Hartman } 1367c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 1368ad6a1e1cSTejun Heo 1369ca22e56dSKay Sievers /* /sys/devices/ */ 1370881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 13711da177e4SLinus Torvalds 13721da177e4SLinus Torvalds /** 137352cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 137452cdbdd4SGrygorii Strashko * @deva: Device to move. 137552cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 137652cdbdd4SGrygorii Strashko */ 137752cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 137852cdbdd4SGrygorii Strashko { 137952cdbdd4SGrygorii Strashko if (!devices_kset) 138052cdbdd4SGrygorii Strashko return; 138152cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 138252cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 138352cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 138452cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 138552cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 138652cdbdd4SGrygorii Strashko } 138752cdbdd4SGrygorii Strashko 138852cdbdd4SGrygorii Strashko /** 138952cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 139052cdbdd4SGrygorii Strashko * @deva: Device to move 139152cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 139252cdbdd4SGrygorii Strashko */ 139352cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 139452cdbdd4SGrygorii Strashko { 139552cdbdd4SGrygorii Strashko if (!devices_kset) 139652cdbdd4SGrygorii Strashko return; 139752cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 139852cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 139952cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 140052cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 140152cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 140252cdbdd4SGrygorii Strashko } 140352cdbdd4SGrygorii Strashko 140452cdbdd4SGrygorii Strashko /** 140552cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 140652cdbdd4SGrygorii Strashko * @dev: device to move 140752cdbdd4SGrygorii Strashko */ 140852cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 140952cdbdd4SGrygorii Strashko { 141052cdbdd4SGrygorii Strashko if (!devices_kset) 141152cdbdd4SGrygorii Strashko return; 141252cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 141352cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 141452cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 141552cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 141652cdbdd4SGrygorii Strashko } 141752cdbdd4SGrygorii Strashko 141852cdbdd4SGrygorii Strashko /** 14191da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 14201da177e4SLinus Torvalds * @dev: device. 14211da177e4SLinus Torvalds * @attr: device attribute descriptor. 14221da177e4SLinus Torvalds */ 142326579ab7SPhil Carmody int device_create_file(struct device *dev, 142426579ab7SPhil Carmody const struct device_attribute *attr) 14251da177e4SLinus Torvalds { 14261da177e4SLinus Torvalds int error = 0; 14278f46baaaSFelipe Balbi 14288f46baaaSFelipe Balbi if (dev) { 14298f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 143097521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 143197521978Sdyoung@redhat.com attr->attr.name); 14328f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 143397521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 143497521978Sdyoung@redhat.com attr->attr.name); 14351da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 14368f46baaaSFelipe Balbi } 14378f46baaaSFelipe Balbi 14381da177e4SLinus Torvalds return error; 14391da177e4SLinus Torvalds } 144086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds /** 14431da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 14441da177e4SLinus Torvalds * @dev: device. 14451da177e4SLinus Torvalds * @attr: device attribute descriptor. 14461da177e4SLinus Torvalds */ 144726579ab7SPhil Carmody void device_remove_file(struct device *dev, 144826579ab7SPhil Carmody const struct device_attribute *attr) 14491da177e4SLinus Torvalds { 14500c98b19fSCornelia Huck if (dev) 14511da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 14521da177e4SLinus Torvalds } 145386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 14541da177e4SLinus Torvalds 14552589f188SGreg Kroah-Hartman /** 14566b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 14576b0afc2aSTejun Heo * @dev: device. 14586b0afc2aSTejun Heo * @attr: device attribute descriptor. 14596b0afc2aSTejun Heo * 14606b0afc2aSTejun Heo * See kernfs_remove_self() for details. 14616b0afc2aSTejun Heo */ 14626b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 14636b0afc2aSTejun Heo const struct device_attribute *attr) 14646b0afc2aSTejun Heo { 14656b0afc2aSTejun Heo if (dev) 14666b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 14676b0afc2aSTejun Heo else 14686b0afc2aSTejun Heo return false; 14696b0afc2aSTejun Heo } 14706b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 14716b0afc2aSTejun Heo 14726b0afc2aSTejun Heo /** 14732589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 14742589f188SGreg Kroah-Hartman * @dev: device. 14752589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 14762589f188SGreg Kroah-Hartman */ 147766ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 147866ecb92bSPhil Carmody const struct bin_attribute *attr) 14792589f188SGreg Kroah-Hartman { 14802589f188SGreg Kroah-Hartman int error = -EINVAL; 14812589f188SGreg Kroah-Hartman if (dev) 14822589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 14832589f188SGreg Kroah-Hartman return error; 14842589f188SGreg Kroah-Hartman } 14852589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 14862589f188SGreg Kroah-Hartman 14872589f188SGreg Kroah-Hartman /** 14882589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 14892589f188SGreg Kroah-Hartman * @dev: device. 14902589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 14912589f188SGreg Kroah-Hartman */ 149266ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 149366ecb92bSPhil Carmody const struct bin_attribute *attr) 14942589f188SGreg Kroah-Hartman { 14952589f188SGreg Kroah-Hartman if (dev) 14962589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 14972589f188SGreg Kroah-Hartman } 14982589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 14992589f188SGreg Kroah-Hartman 150034bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 150134bb61f9SJames Bottomley { 1502f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1503f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 150434bb61f9SJames Bottomley 150534bb61f9SJames Bottomley get_device(dev); 150634bb61f9SJames Bottomley } 150734bb61f9SJames Bottomley 150834bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 150934bb61f9SJames Bottomley { 1510f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 1511f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 151234bb61f9SJames Bottomley 151334bb61f9SJames Bottomley put_device(dev); 151434bb61f9SJames Bottomley } 151534bb61f9SJames Bottomley 15161da177e4SLinus Torvalds /** 15171da177e4SLinus Torvalds * device_initialize - init device structure. 15181da177e4SLinus Torvalds * @dev: device. 15191da177e4SLinus Torvalds * 15205739411aSCornelia Huck * This prepares the device for use by other layers by initializing 15215739411aSCornelia Huck * its fields. 15221da177e4SLinus Torvalds * It is the first half of device_register(), if called by 15235739411aSCornelia Huck * that function, though it can also be called separately, so one 15245739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 15255739411aSCornelia Huck * may be used for reference counting of @dev after calling this 15265739411aSCornelia Huck * function. 15275739411aSCornelia Huck * 1528b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 1529b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 1530b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 1531b10d5efdSAlan Stern * @dev. 1532b10d5efdSAlan Stern * 15335739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 15345739411aSCornelia Huck * @dev directly once you have called this function. 15351da177e4SLinus Torvalds */ 15361da177e4SLinus Torvalds void device_initialize(struct device *dev) 15371da177e4SLinus Torvalds { 1538881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 1539f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 15401da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 15413142788bSThomas Gleixner mutex_init(&dev->mutex); 15421704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 15439ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 15449ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 15453b98aeafSAlan Stern device_pm_init(dev); 154687348136SChristoph Hellwig set_dev_node(dev, -1); 15474a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 15484a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 15494a7cc831SJiang Liu #endif 15509ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 15519ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 15529ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 15531da177e4SLinus Torvalds } 155486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 15551da177e4SLinus Torvalds 1556d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 1557f0ee61a6SGreg Kroah-Hartman { 1558f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 1559f0ee61a6SGreg Kroah-Hartman 1560f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 15614ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 1562881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 1563f0ee61a6SGreg Kroah-Hartman 156486406245SKay Sievers return virtual_dir; 1565f0ee61a6SGreg Kroah-Hartman } 1566f0ee61a6SGreg Kroah-Hartman 1567bc451f20SEric W. Biederman struct class_dir { 1568bc451f20SEric W. Biederman struct kobject kobj; 1569bc451f20SEric W. Biederman struct class *class; 1570bc451f20SEric W. Biederman }; 1571bc451f20SEric W. Biederman 1572bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 1573bc451f20SEric W. Biederman 1574bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 1575bc451f20SEric W. Biederman { 1576bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 1577bc451f20SEric W. Biederman kfree(dir); 1578bc451f20SEric W. Biederman } 1579bc451f20SEric W. Biederman 1580bc451f20SEric W. Biederman static const 1581bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 1582bc451f20SEric W. Biederman { 1583bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 1584bc451f20SEric W. Biederman return dir->class->ns_type; 1585bc451f20SEric W. Biederman } 1586bc451f20SEric W. Biederman 1587bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 1588bc451f20SEric W. Biederman .release = class_dir_release, 1589bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 1590bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 1591bc451f20SEric W. Biederman }; 1592bc451f20SEric W. Biederman 1593bc451f20SEric W. Biederman static struct kobject * 1594bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 1595bc451f20SEric W. Biederman { 1596bc451f20SEric W. Biederman struct class_dir *dir; 1597bc451f20SEric W. Biederman int retval; 1598bc451f20SEric W. Biederman 1599bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 1600bc451f20SEric W. Biederman if (!dir) 160184d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 1602bc451f20SEric W. Biederman 1603bc451f20SEric W. Biederman dir->class = class; 1604bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 1605bc451f20SEric W. Biederman 16066b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 1607bc451f20SEric W. Biederman 1608bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 1609bc451f20SEric W. Biederman if (retval < 0) { 1610bc451f20SEric W. Biederman kobject_put(&dir->kobj); 161184d0c27dSTetsuo Handa return ERR_PTR(retval); 1612bc451f20SEric W. Biederman } 1613bc451f20SEric W. Biederman return &dir->kobj; 1614bc451f20SEric W. Biederman } 1615bc451f20SEric W. Biederman 1616e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 1617bc451f20SEric W. Biederman 1618c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 1619c744aeaeSCornelia Huck struct device *parent) 162040fa5422SGreg Kroah-Hartman { 162186406245SKay Sievers if (dev->class) { 162286406245SKay Sievers struct kobject *kobj = NULL; 162386406245SKay Sievers struct kobject *parent_kobj; 162486406245SKay Sievers struct kobject *k; 162586406245SKay Sievers 1626ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 162739aba963SKay Sievers /* block disks show up in /sys/block */ 1628e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 162939aba963SKay Sievers if (parent && parent->class == &block_class) 163039aba963SKay Sievers return &parent->kobj; 16316b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 163239aba963SKay Sievers } 1633ead454feSRandy Dunlap #endif 1634e52eec13SAndi Kleen 163586406245SKay Sievers /* 163686406245SKay Sievers * If we have no parent, we live in "virtual". 16370f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 16380f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 163986406245SKay Sievers */ 164086406245SKay Sievers if (parent == NULL) 164186406245SKay Sievers parent_kobj = virtual_device_parent(dev); 164224b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 164386406245SKay Sievers return &parent->kobj; 164486406245SKay Sievers else 164586406245SKay Sievers parent_kobj = &parent->kobj; 164686406245SKay Sievers 164777d3d7c1STejun Heo mutex_lock(&gdp_mutex); 164877d3d7c1STejun Heo 164986406245SKay Sievers /* find our class-directory at the parent and reference it */ 16506b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 16516b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 165286406245SKay Sievers if (k->parent == parent_kobj) { 165386406245SKay Sievers kobj = kobject_get(k); 165486406245SKay Sievers break; 165586406245SKay Sievers } 16566b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 165777d3d7c1STejun Heo if (kobj) { 165877d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 165986406245SKay Sievers return kobj; 166077d3d7c1STejun Heo } 166186406245SKay Sievers 166286406245SKay Sievers /* or create a new class-directory at the parent device */ 1663bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 16640f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 166577d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 166643968d2fSGreg Kroah-Hartman return k; 166786406245SKay Sievers } 166886406245SKay Sievers 1669ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 1670ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 1671ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 1672ca22e56dSKay Sievers 167386406245SKay Sievers if (parent) 1674c744aeaeSCornelia Huck return &parent->kobj; 1675c744aeaeSCornelia Huck return NULL; 1676c744aeaeSCornelia Huck } 1677da231fd5SKay Sievers 1678cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 1679cebf8fd1SMing Lei struct device *dev) 1680cebf8fd1SMing Lei { 1681cebf8fd1SMing Lei if (!kobj || !dev->class || 1682cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 1683cebf8fd1SMing Lei return false; 1684cebf8fd1SMing Lei return true; 1685cebf8fd1SMing Lei } 1686cebf8fd1SMing Lei 1687cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 1688cebf8fd1SMing Lei { 1689cebf8fd1SMing Lei return dev->kobj.parent; 1690cebf8fd1SMing Lei } 1691cebf8fd1SMing Lei 1692cebf8fd1SMing Lei /* 1693cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 1694cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 1695cebf8fd1SMing Lei * global lock 1696cebf8fd1SMing Lei */ 169763b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 1698da231fd5SKay Sievers { 16990f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 1700cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 1701da231fd5SKay Sievers return; 1702da231fd5SKay Sievers 1703e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 1704726e4109SBenjamin Herrenschmidt if (!kobject_has_children(glue_dir)) 1705726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 17060f4dafc0SKay Sievers kobject_put(glue_dir); 1707e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 1708da231fd5SKay Sievers } 170963b6971aSCornelia Huck 17102ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 17112ee97cafSCornelia Huck { 17125590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 17132ee97cafSCornelia Huck int error; 17142ee97cafSCornelia Huck 17155590f319SBenjamin Herrenschmidt if (of_node) { 17160c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 17175590f319SBenjamin Herrenschmidt if (error) 17185590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 17195590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 17205590f319SBenjamin Herrenschmidt } 17215590f319SBenjamin Herrenschmidt 17222ee97cafSCornelia Huck if (!dev->class) 17232ee97cafSCornelia Huck return 0; 1724da231fd5SKay Sievers 17251fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 17266b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 17272ee97cafSCornelia Huck "subsystem"); 17282ee97cafSCornelia Huck if (error) 17295590f319SBenjamin Herrenschmidt goto out_devnode; 1730da231fd5SKay Sievers 17314e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 17324f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 17334f01a757SDmitry Torokhov "device"); 17344f01a757SDmitry Torokhov if (error) 173539aba963SKay Sievers goto out_subsys; 17362ee97cafSCornelia Huck } 173739aba963SKay Sievers 1738ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 173939aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 1740e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 174139aba963SKay Sievers return 0; 1742ead454feSRandy Dunlap #endif 174339aba963SKay Sievers 174439aba963SKay Sievers /* link in the class directory pointing to the device */ 17456b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 174639aba963SKay Sievers &dev->kobj, dev_name(dev)); 174739aba963SKay Sievers if (error) 174839aba963SKay Sievers goto out_device; 174939aba963SKay Sievers 17502ee97cafSCornelia Huck return 0; 17512ee97cafSCornelia Huck 175239aba963SKay Sievers out_device: 175339aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 1754da231fd5SKay Sievers 17552ee97cafSCornelia Huck out_subsys: 17562ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 17575590f319SBenjamin Herrenschmidt out_devnode: 17585590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 17592ee97cafSCornelia Huck return error; 17602ee97cafSCornelia Huck } 17612ee97cafSCornelia Huck 17622ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 17632ee97cafSCornelia Huck { 17645590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 17655590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 17665590f319SBenjamin Herrenschmidt 17672ee97cafSCornelia Huck if (!dev->class) 17682ee97cafSCornelia Huck return; 1769da231fd5SKay Sievers 17704e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 1771da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 17722ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 1773ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 1774e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 177539aba963SKay Sievers return; 1776ead454feSRandy Dunlap #endif 17776b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 17782ee97cafSCornelia Huck } 17792ee97cafSCornelia Huck 17801da177e4SLinus Torvalds /** 1781413c239fSStephen Rothwell * dev_set_name - set a device name 1782413c239fSStephen Rothwell * @dev: device 178346232366SRandy Dunlap * @fmt: format string for the device's name 1784413c239fSStephen Rothwell */ 1785413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 1786413c239fSStephen Rothwell { 1787413c239fSStephen Rothwell va_list vargs; 17881fa5ae85SKay Sievers int err; 1789413c239fSStephen Rothwell 1790413c239fSStephen Rothwell va_start(vargs, fmt); 17911fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 1792413c239fSStephen Rothwell va_end(vargs); 17931fa5ae85SKay Sievers return err; 1794413c239fSStephen Rothwell } 1795413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 1796413c239fSStephen Rothwell 1797413c239fSStephen Rothwell /** 1798e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 1799e105b8bfSDan Williams * @dev: device 1800e105b8bfSDan Williams * 1801e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 1802e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 1803e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 1804e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 18050d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 18060d4e293cSPeter Korsgaard * the link. 1807e105b8bfSDan Williams */ 1808e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 1809e105b8bfSDan Williams { 1810e105b8bfSDan Williams struct kobject *kobj; 1811e105b8bfSDan Williams 1812e105b8bfSDan Williams if (dev->class) 1813e105b8bfSDan Williams kobj = dev->class->dev_kobj; 1814e105b8bfSDan Williams else 1815e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 1816e105b8bfSDan Williams 1817e105b8bfSDan Williams return kobj; 1818e105b8bfSDan Williams } 1819e105b8bfSDan Williams 1820e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 1821e105b8bfSDan Williams { 1822e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 1823e105b8bfSDan Williams int error = 0; 1824e105b8bfSDan Williams char devt_str[15]; 1825e105b8bfSDan Williams 1826e105b8bfSDan Williams if (kobj) { 1827e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 1828e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 1829e105b8bfSDan Williams } 1830e105b8bfSDan Williams 1831e105b8bfSDan Williams return error; 1832e105b8bfSDan Williams } 1833e105b8bfSDan Williams 1834e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 1835e105b8bfSDan Williams { 1836e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 1837e105b8bfSDan Williams char devt_str[15]; 1838e105b8bfSDan Williams 1839e105b8bfSDan Williams if (kobj) { 1840e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 1841e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 1842e105b8bfSDan Williams } 1843e105b8bfSDan Williams } 1844e105b8bfSDan Williams 184546d3a037SShaokun Zhang static int device_private_init(struct device *dev) 1846b4028437SGreg Kroah-Hartman { 1847b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 1848b4028437SGreg Kroah-Hartman if (!dev->p) 1849b4028437SGreg Kroah-Hartman return -ENOMEM; 1850b4028437SGreg Kroah-Hartman dev->p->device = dev; 1851b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 1852b4028437SGreg Kroah-Hartman klist_children_put); 1853ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 1854b4028437SGreg Kroah-Hartman return 0; 1855b4028437SGreg Kroah-Hartman } 1856b4028437SGreg Kroah-Hartman 1857e105b8bfSDan Williams /** 18581da177e4SLinus Torvalds * device_add - add device to device hierarchy. 18591da177e4SLinus Torvalds * @dev: device. 18601da177e4SLinus Torvalds * 18611da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 18621da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 18631da177e4SLinus Torvalds * 18645739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 18651da177e4SLinus Torvalds * to the global and sibling lists for the device, then 18661da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 18675739411aSCornelia Huck * 1868b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 1869b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 1870b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 1871b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 1872b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 1873b10d5efdSAlan Stern * and register a fresh new struct device instead. 1874b10d5efdSAlan Stern * 18755739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 18765739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 18775739411aSCornelia Huck * reference instead. 18781da177e4SLinus Torvalds */ 18791da177e4SLinus Torvalds int device_add(struct device *dev) 18801da177e4SLinus Torvalds { 188135dbf4efSViresh Kumar struct device *parent; 1882ca22e56dSKay Sievers struct kobject *kobj; 1883c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 1884c906a48aSGreg Kroah-Hartman int error = -EINVAL; 1885cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 1886775b64d2SRafael J. Wysocki 18871da177e4SLinus Torvalds dev = get_device(dev); 1888c906a48aSGreg Kroah-Hartman if (!dev) 1889c906a48aSGreg Kroah-Hartman goto done; 1890c906a48aSGreg Kroah-Hartman 1891fb069a5dSGreg Kroah-Hartman if (!dev->p) { 1892b4028437SGreg Kroah-Hartman error = device_private_init(dev); 1893b4028437SGreg Kroah-Hartman if (error) 1894fb069a5dSGreg Kroah-Hartman goto done; 1895fb069a5dSGreg Kroah-Hartman } 1896fb069a5dSGreg Kroah-Hartman 18971fa5ae85SKay Sievers /* 18981fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 18991fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 19001fa5ae85SKay Sievers * the name, and force the use of dev_name() 19011fa5ae85SKay Sievers */ 19021fa5ae85SKay Sievers if (dev->init_name) { 1903acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 19041fa5ae85SKay Sievers dev->init_name = NULL; 19051fa5ae85SKay Sievers } 1906c906a48aSGreg Kroah-Hartman 1907ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 1908ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 1909ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 1910ca22e56dSKay Sievers 1911e6309e75SThomas Gleixner if (!dev_name(dev)) { 1912e6309e75SThomas Gleixner error = -EINVAL; 19135c8563d7SKay Sievers goto name_error; 1914e6309e75SThomas Gleixner } 19151da177e4SLinus Torvalds 19161e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 1917c205ef48SGreg Kroah-Hartman 19181da177e4SLinus Torvalds parent = get_device(dev->parent); 1919ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 192084d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 192184d0c27dSTetsuo Handa error = PTR_ERR(kobj); 192284d0c27dSTetsuo Handa goto parent_error; 192384d0c27dSTetsuo Handa } 1924ca22e56dSKay Sievers if (kobj) 1925ca22e56dSKay Sievers dev->kobj.parent = kobj; 19261da177e4SLinus Torvalds 19270d358f22SYinghai Lu /* use parent numa_node */ 192856f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 19290d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 19300d358f22SYinghai Lu 19311da177e4SLinus Torvalds /* first, register with generic layer. */ 19328a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 19338a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 1934cebf8fd1SMing Lei if (error) { 1935cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 19361da177e4SLinus Torvalds goto Error; 1937cebf8fd1SMing Lei } 1938a7fd6706SKay Sievers 193937022644SBrian Walsh /* notify platform of device entry */ 194007de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 194107de0e86SHeikki Krogerus if (error) 194207de0e86SHeikki Krogerus goto platform_error; 194337022644SBrian Walsh 1944c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 1945a306eea4SCornelia Huck if (error) 1946a306eea4SCornelia Huck goto attrError; 1947a7fd6706SKay Sievers 19482ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 19492ee97cafSCornelia Huck if (error) 19502ee97cafSCornelia Huck goto SymlinkError; 1951dc0afa83SCornelia Huck error = device_add_attrs(dev); 1952dc0afa83SCornelia Huck if (error) 19532620efefSGreg Kroah-Hartman goto AttrsError; 1954dc0afa83SCornelia Huck error = bus_add_device(dev); 1955dc0afa83SCornelia Huck if (error) 19561da177e4SLinus Torvalds goto BusError; 19573b98aeafSAlan Stern error = dpm_sysfs_add(dev); 195857eee3d2SRafael J. Wysocki if (error) 19593b98aeafSAlan Stern goto DPMError; 19603b98aeafSAlan Stern device_pm_add(dev); 1961ec0676eeSAlan Stern 19620cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 19630cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 19640cd75047SSergey Klyaus if (error) 19650cd75047SSergey Klyaus goto DevAttrError; 19660cd75047SSergey Klyaus 19670cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 19680cd75047SSergey Klyaus if (error) 19690cd75047SSergey Klyaus goto SysEntryError; 19700cd75047SSergey Klyaus 19710cd75047SSergey Klyaus devtmpfs_create_node(dev); 19720cd75047SSergey Klyaus } 19730cd75047SSergey Klyaus 1974ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 1975268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 1976ec0676eeSAlan Stern */ 1977ec0676eeSAlan Stern if (dev->bus) 1978ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 1979ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 1980ec0676eeSAlan Stern 198153877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 19822023c610SAlan Stern bus_probe_device(dev); 19831da177e4SLinus Torvalds if (parent) 1984f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 1985f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 19861da177e4SLinus Torvalds 19875d9fd169SGreg Kroah-Hartman if (dev->class) { 1988ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 1989c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 1990570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 19916b6e39a6SKay Sievers &dev->class->p->klist_devices); 1992c47ed219SGreg Kroah-Hartman 1993c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 1994184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 1995ca22e56dSKay Sievers &dev->class->p->interfaces, node) 1996c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 1997c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 1998ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 19995d9fd169SGreg Kroah-Hartman } 2000c906a48aSGreg Kroah-Hartman done: 20011da177e4SLinus Torvalds put_device(dev); 20021da177e4SLinus Torvalds return error; 20030cd75047SSergey Klyaus SysEntryError: 20040cd75047SSergey Klyaus if (MAJOR(dev->devt)) 20050cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 20060cd75047SSergey Klyaus DevAttrError: 20070cd75047SSergey Klyaus device_pm_remove(dev); 20080cd75047SSergey Klyaus dpm_sysfs_remove(dev); 20093b98aeafSAlan Stern DPMError: 201057eee3d2SRafael J. Wysocki bus_remove_device(dev); 201157eee3d2SRafael J. Wysocki BusError: 20122620efefSGreg Kroah-Hartman device_remove_attrs(dev); 20132620efefSGreg Kroah-Hartman AttrsError: 20142ee97cafSCornelia Huck device_remove_class_symlinks(dev); 20152ee97cafSCornelia Huck SymlinkError: 2016c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 201723681e47SGreg Kroah-Hartman attrError: 201807de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 201907de0e86SHeikki Krogerus platform_error: 2020312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2021cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 20221da177e4SLinus Torvalds kobject_del(&dev->kobj); 20231da177e4SLinus Torvalds Error: 2024cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 202584d0c27dSTetsuo Handa parent_error: 20261da177e4SLinus Torvalds put_device(parent); 20275c8563d7SKay Sievers name_error: 20285c8563d7SKay Sievers kfree(dev->p); 20295c8563d7SKay Sievers dev->p = NULL; 2030c906a48aSGreg Kroah-Hartman goto done; 20311da177e4SLinus Torvalds } 203286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds /** 20351da177e4SLinus Torvalds * device_register - register a device with the system. 20361da177e4SLinus Torvalds * @dev: pointer to the device structure 20371da177e4SLinus Torvalds * 20381da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 20391da177e4SLinus Torvalds * and add it to the system. The two steps can be called 20401da177e4SLinus Torvalds * separately, but this is the easiest and most common. 20411da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 20421da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 20431da177e4SLinus Torvalds * before it is added to the hierarchy. 20445739411aSCornelia Huck * 2045b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 2046b10d5efdSAlan Stern * and device_add(). 2047b10d5efdSAlan Stern * 20485739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 20495739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 20505739411aSCornelia Huck * reference initialized in this function instead. 20511da177e4SLinus Torvalds */ 20521da177e4SLinus Torvalds int device_register(struct device *dev) 20531da177e4SLinus Torvalds { 20541da177e4SLinus Torvalds device_initialize(dev); 20551da177e4SLinus Torvalds return device_add(dev); 20561da177e4SLinus Torvalds } 205786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 20581da177e4SLinus Torvalds 20591da177e4SLinus Torvalds /** 20601da177e4SLinus Torvalds * get_device - increment reference count for device. 20611da177e4SLinus Torvalds * @dev: device. 20621da177e4SLinus Torvalds * 20631da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 20641da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 20651da177e4SLinus Torvalds * pointer passed in. 20661da177e4SLinus Torvalds */ 20671da177e4SLinus Torvalds struct device *get_device(struct device *dev) 20681da177e4SLinus Torvalds { 2069b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 20701da177e4SLinus Torvalds } 207186df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 20721da177e4SLinus Torvalds 20731da177e4SLinus Torvalds /** 20741da177e4SLinus Torvalds * put_device - decrement reference count. 20751da177e4SLinus Torvalds * @dev: device in question. 20761da177e4SLinus Torvalds */ 20771da177e4SLinus Torvalds void put_device(struct device *dev) 20781da177e4SLinus Torvalds { 2079edfaa7c3SKay Sievers /* might_sleep(); */ 20801da177e4SLinus Torvalds if (dev) 20811da177e4SLinus Torvalds kobject_put(&dev->kobj); 20821da177e4SLinus Torvalds } 208386df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 20841da177e4SLinus Torvalds 20851da177e4SLinus Torvalds /** 20861da177e4SLinus Torvalds * device_del - delete device from system. 20871da177e4SLinus Torvalds * @dev: device. 20881da177e4SLinus Torvalds * 20891da177e4SLinus Torvalds * This is the first part of the device unregistration 20901da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 20911da177e4SLinus Torvalds * from here, has it removed from the other driver model 20921da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 20931da177e4SLinus Torvalds * from the kobject hierarchy. 20941da177e4SLinus Torvalds * 20951da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 20961da177e4SLinus Torvalds * also called manually. 20971da177e4SLinus Torvalds */ 20981da177e4SLinus Torvalds void device_del(struct device *dev) 20991da177e4SLinus Torvalds { 21001da177e4SLinus Torvalds struct device *parent = dev->parent; 2101cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2102c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 21031da177e4SLinus Torvalds 21043451a495SAlexander Duyck /* 21053451a495SAlexander Duyck * Hold the device lock and set the "dead" flag to guarantee that 21063451a495SAlexander Duyck * the update behavior is consistent with the other bitfields near 21073451a495SAlexander Duyck * it and that we cannot have an asynchronous probe routine trying 21083451a495SAlexander Duyck * to run while we are tearing out the bus/class/sysfs from 21093451a495SAlexander Duyck * underneath the device. 21103451a495SAlexander Duyck */ 21113451a495SAlexander Duyck device_lock(dev); 21123451a495SAlexander Duyck dev->p->dead = true; 21133451a495SAlexander Duyck device_unlock(dev); 21143451a495SAlexander Duyck 2115ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 2116ec0676eeSAlan Stern * before dpm_sysfs_remove(). 2117ec0676eeSAlan Stern */ 2118ec0676eeSAlan Stern if (dev->bus) 2119ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2120ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 21219ed98953SRafael J. Wysocki 21223b98aeafSAlan Stern dpm_sysfs_remove(dev); 21231da177e4SLinus Torvalds if (parent) 2124f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 2125e105b8bfSDan Williams if (MAJOR(dev->devt)) { 21262b2af54aSKay Sievers devtmpfs_delete_node(dev); 2127e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 2128c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 2129e105b8bfSDan Williams } 2130b9d9c82bSKay Sievers if (dev->class) { 2131da231fd5SKay Sievers device_remove_class_symlinks(dev); 213299ef3ef8SKay Sievers 2133ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2134c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 2135184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2136ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2137c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 2138c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 2139c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 2140570d0200SWei Yang klist_del(&dev->p->knode_class); 2141ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 2142b9d9c82bSKay Sievers } 2143c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 21442620efefSGreg Kroah-Hartman device_remove_attrs(dev); 214528953533SBenjamin Herrenschmidt bus_remove_device(dev); 21464b6d1f12SLongX Zhang device_pm_remove(dev); 2147d1c3414cSGrant Likely driver_deferred_probe_del(dev); 214807de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 2149478573c9SLukas Wunner device_remove_properties(dev); 21502ec16150SJeffy Chen device_links_purge(dev); 21511da177e4SLinus Torvalds 2152599bad38SJoerg Roedel if (dev->bus) 2153599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2154599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 2155312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2156cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 21571da177e4SLinus Torvalds kobject_del(&dev->kobj); 2158cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 21591da177e4SLinus Torvalds put_device(parent); 21601da177e4SLinus Torvalds } 216186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 21621da177e4SLinus Torvalds 21631da177e4SLinus Torvalds /** 21641da177e4SLinus Torvalds * device_unregister - unregister device from system. 21651da177e4SLinus Torvalds * @dev: device going away. 21661da177e4SLinus Torvalds * 21671da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 21681da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 21691da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 21701da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 21711da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 21721da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 21731da177e4SLinus Torvalds */ 21741da177e4SLinus Torvalds void device_unregister(struct device *dev) 21751da177e4SLinus Torvalds { 21761e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 21771da177e4SLinus Torvalds device_del(dev); 21781da177e4SLinus Torvalds put_device(dev); 21791da177e4SLinus Torvalds } 218086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 21811da177e4SLinus Torvalds 21823d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 21833d060aebSAndy Shevchenko { 21843d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 21853d060aebSAndy Shevchenko struct device *dev = NULL; 21863d060aebSAndy Shevchenko struct device_private *p; 21873d060aebSAndy Shevchenko 21883d060aebSAndy Shevchenko if (n) { 21893d060aebSAndy Shevchenko p = to_device_private_parent(n); 21903d060aebSAndy Shevchenko dev = p->device; 21913d060aebSAndy Shevchenko } 21923d060aebSAndy Shevchenko return dev; 21933d060aebSAndy Shevchenko } 21943d060aebSAndy Shevchenko 219536239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 219636239577Smochel@digitalimplant.org { 219736239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 2198f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 2199f791b8c8SGreg Kroah-Hartman struct device_private *p; 2200f791b8c8SGreg Kroah-Hartman 2201f791b8c8SGreg Kroah-Hartman if (n) { 2202f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 2203f791b8c8SGreg Kroah-Hartman dev = p->device; 2204f791b8c8SGreg Kroah-Hartman } 2205f791b8c8SGreg Kroah-Hartman return dev; 220636239577Smochel@digitalimplant.org } 220736239577Smochel@digitalimplant.org 22081da177e4SLinus Torvalds /** 2209e454cea2SKay Sievers * device_get_devnode - path of device node file 22106fcf53acSKay Sievers * @dev: device 2211e454cea2SKay Sievers * @mode: returned file access mode 22123c2670e6SKay Sievers * @uid: returned file owner 22133c2670e6SKay Sievers * @gid: returned file group 22146fcf53acSKay Sievers * @tmp: possibly allocated string 22156fcf53acSKay Sievers * 22166fcf53acSKay Sievers * Return the relative path of a possible device node. 22176fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 22186fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 22196fcf53acSKay Sievers * freed by the caller. 22206fcf53acSKay Sievers */ 2221e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 22224e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 22233c2670e6SKay Sievers const char **tmp) 22246fcf53acSKay Sievers { 22256fcf53acSKay Sievers char *s; 22266fcf53acSKay Sievers 22276fcf53acSKay Sievers *tmp = NULL; 22286fcf53acSKay Sievers 22296fcf53acSKay Sievers /* the device type may provide a specific name */ 2230e454cea2SKay Sievers if (dev->type && dev->type->devnode) 22313c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 22326fcf53acSKay Sievers if (*tmp) 22336fcf53acSKay Sievers return *tmp; 22346fcf53acSKay Sievers 22356fcf53acSKay Sievers /* the class may provide a specific name */ 2236e454cea2SKay Sievers if (dev->class && dev->class->devnode) 2237e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 22386fcf53acSKay Sievers if (*tmp) 22396fcf53acSKay Sievers return *tmp; 22406fcf53acSKay Sievers 22416fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 22426fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 22436fcf53acSKay Sievers return dev_name(dev); 22446fcf53acSKay Sievers 22456fcf53acSKay Sievers /* replace '!' in the name with '/' */ 2246a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 2247a29fd614SRasmus Villemoes if (!s) 22486fcf53acSKay Sievers return NULL; 2249a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 2250a29fd614SRasmus Villemoes return *tmp = s; 22516fcf53acSKay Sievers } 22526fcf53acSKay Sievers 22536fcf53acSKay Sievers /** 22541da177e4SLinus Torvalds * device_for_each_child - device child iterator. 2255c41455fbSRandy Dunlap * @parent: parent struct device. 22561da177e4SLinus Torvalds * @fn: function to be called for each device. 2257f8878dcbSRobert P. J. Day * @data: data for the callback. 22581da177e4SLinus Torvalds * 2259c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 22601da177e4SLinus Torvalds * passing it @data. 22611da177e4SLinus Torvalds * 22621da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 22631da177e4SLinus Torvalds * other than 0, we break out and return that value. 22641da177e4SLinus Torvalds */ 226536239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 22664a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 22671da177e4SLinus Torvalds { 226836239577Smochel@digitalimplant.org struct klist_iter i; 22691da177e4SLinus Torvalds struct device *child; 22701da177e4SLinus Torvalds int error = 0; 22711da177e4SLinus Torvalds 2272014c90dbSGreg Kroah-Hartman if (!parent->p) 2273014c90dbSGreg Kroah-Hartman return 0; 2274014c90dbSGreg Kroah-Hartman 2275f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 227693ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 227736239577Smochel@digitalimplant.org error = fn(child, data); 227836239577Smochel@digitalimplant.org klist_iter_exit(&i); 22791da177e4SLinus Torvalds return error; 22801da177e4SLinus Torvalds } 228186df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 22821da177e4SLinus Torvalds 22835ab69981SCornelia Huck /** 22843d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 22853d060aebSAndy Shevchenko * @parent: parent struct device. 22863d060aebSAndy Shevchenko * @fn: function to be called for each device. 22873d060aebSAndy Shevchenko * @data: data for the callback. 22883d060aebSAndy Shevchenko * 22893d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 22903d060aebSAndy Shevchenko * passing it @data. 22913d060aebSAndy Shevchenko * 22923d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 22933d060aebSAndy Shevchenko * other than 0, we break out and return that value. 22943d060aebSAndy Shevchenko */ 22953d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 22963d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 22973d060aebSAndy Shevchenko { 22983d060aebSAndy Shevchenko struct klist_iter i; 22993d060aebSAndy Shevchenko struct device *child; 23003d060aebSAndy Shevchenko int error = 0; 23013d060aebSAndy Shevchenko 23023d060aebSAndy Shevchenko if (!parent->p) 23033d060aebSAndy Shevchenko return 0; 23043d060aebSAndy Shevchenko 23053d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 23063d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 23073d060aebSAndy Shevchenko error = fn(child, data); 23083d060aebSAndy Shevchenko klist_iter_exit(&i); 23093d060aebSAndy Shevchenko return error; 23103d060aebSAndy Shevchenko } 23113d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 23123d060aebSAndy Shevchenko 23133d060aebSAndy Shevchenko /** 23145ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 23155ab69981SCornelia Huck * @parent: parent struct device 23165ab69981SCornelia Huck * @match: Callback function to check device 2317f8878dcbSRobert P. J. Day * @data: Data to pass to match function 23185ab69981SCornelia Huck * 23195ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 23205ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 23215ab69981SCornelia Huck * determined by the @match callback. 23225ab69981SCornelia Huck * 23235ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 23245ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 23255ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 23265ab69981SCornelia Huck * and not iterate over any more devices. 2327a4e2400aSFederico Vaga * 2328a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 23295ab69981SCornelia Huck */ 23305ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 23314a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 23325ab69981SCornelia Huck { 23335ab69981SCornelia Huck struct klist_iter i; 23345ab69981SCornelia Huck struct device *child; 23355ab69981SCornelia Huck 23365ab69981SCornelia Huck if (!parent) 23375ab69981SCornelia Huck return NULL; 23385ab69981SCornelia Huck 2339f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 23405ab69981SCornelia Huck while ((child = next_device(&i))) 23415ab69981SCornelia Huck if (match(child, data) && get_device(child)) 23425ab69981SCornelia Huck break; 23435ab69981SCornelia Huck klist_iter_exit(&i); 23445ab69981SCornelia Huck return child; 23455ab69981SCornelia Huck } 234686df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 23475ab69981SCornelia Huck 23481da177e4SLinus Torvalds int __init devices_init(void) 23491da177e4SLinus Torvalds { 2350881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 2351881c6cfdSGreg Kroah-Hartman if (!devices_kset) 2352881c6cfdSGreg Kroah-Hartman return -ENOMEM; 2353e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 2354e105b8bfSDan Williams if (!dev_kobj) 2355e105b8bfSDan Williams goto dev_kobj_err; 2356e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 2357e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 2358e105b8bfSDan Williams goto block_kobj_err; 2359e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 2360e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 2361e105b8bfSDan Williams goto char_kobj_err; 2362e105b8bfSDan Williams 2363881c6cfdSGreg Kroah-Hartman return 0; 2364e105b8bfSDan Williams 2365e105b8bfSDan Williams char_kobj_err: 2366e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 2367e105b8bfSDan Williams block_kobj_err: 2368e105b8bfSDan Williams kobject_put(dev_kobj); 2369e105b8bfSDan Williams dev_kobj_err: 2370e105b8bfSDan Williams kset_unregister(devices_kset); 2371e105b8bfSDan Williams return -ENOMEM; 23721da177e4SLinus Torvalds } 23731da177e4SLinus Torvalds 23744f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 23754f3549d7SRafael J. Wysocki { 23764f3549d7SRafael J. Wysocki int ret; 23774f3549d7SRafael J. Wysocki 23784f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 23794f3549d7SRafael J. Wysocki if (ret) 23804f3549d7SRafael J. Wysocki return ret; 23814f3549d7SRafael J. Wysocki 23824f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 23834f3549d7SRafael J. Wysocki } 23844f3549d7SRafael J. Wysocki 23854f3549d7SRafael J. Wysocki /** 23864f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 23874f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 23884f3549d7SRafael J. Wysocki * 23894f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 23904f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 23914f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 23924f3549d7SRafael J. Wysocki * is executed. 23934f3549d7SRafael J. Wysocki * 23944f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 23954f3549d7SRafael J. Wysocki */ 23964f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 23974f3549d7SRafael J. Wysocki { 23984f3549d7SRafael J. Wysocki int ret; 23994f3549d7SRafael J. Wysocki 24004f3549d7SRafael J. Wysocki if (dev->offline_disabled) 24014f3549d7SRafael J. Wysocki return -EPERM; 24024f3549d7SRafael J. Wysocki 24034f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 24044f3549d7SRafael J. Wysocki if (ret) 24054f3549d7SRafael J. Wysocki return ret; 24064f3549d7SRafael J. Wysocki 24074f3549d7SRafael J. Wysocki device_lock(dev); 24084f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 24094f3549d7SRafael J. Wysocki if (dev->offline) { 24104f3549d7SRafael J. Wysocki ret = 1; 24114f3549d7SRafael J. Wysocki } else { 24124f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 24134f3549d7SRafael J. Wysocki if (!ret) { 24144f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 24154f3549d7SRafael J. Wysocki dev->offline = true; 24164f3549d7SRafael J. Wysocki } 24174f3549d7SRafael J. Wysocki } 24184f3549d7SRafael J. Wysocki } 24194f3549d7SRafael J. Wysocki device_unlock(dev); 24204f3549d7SRafael J. Wysocki 24214f3549d7SRafael J. Wysocki return ret; 24224f3549d7SRafael J. Wysocki } 24234f3549d7SRafael J. Wysocki 24244f3549d7SRafael J. Wysocki /** 24254f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 24264f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 24274f3549d7SRafael J. Wysocki * 24284f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 24294f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 24304f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 24314f3549d7SRafael J. Wysocki * 24324f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 24334f3549d7SRafael J. Wysocki */ 24344f3549d7SRafael J. Wysocki int device_online(struct device *dev) 24354f3549d7SRafael J. Wysocki { 24364f3549d7SRafael J. Wysocki int ret = 0; 24374f3549d7SRafael J. Wysocki 24384f3549d7SRafael J. Wysocki device_lock(dev); 24394f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 24404f3549d7SRafael J. Wysocki if (dev->offline) { 24414f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 24424f3549d7SRafael J. Wysocki if (!ret) { 24434f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 24444f3549d7SRafael J. Wysocki dev->offline = false; 24454f3549d7SRafael J. Wysocki } 24464f3549d7SRafael J. Wysocki } else { 24474f3549d7SRafael J. Wysocki ret = 1; 24484f3549d7SRafael J. Wysocki } 24494f3549d7SRafael J. Wysocki } 24504f3549d7SRafael J. Wysocki device_unlock(dev); 24514f3549d7SRafael J. Wysocki 24524f3549d7SRafael J. Wysocki return ret; 24534f3549d7SRafael J. Wysocki } 24544f3549d7SRafael J. Wysocki 24557f100d15SKarthigan Srinivasan struct root_device { 24560aa0dc41SMark McLoughlin struct device dev; 24570aa0dc41SMark McLoughlin struct module *owner; 24580aa0dc41SMark McLoughlin }; 24590aa0dc41SMark McLoughlin 246093058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 2461481e2079SFerenc Wagner { 2462481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 2463481e2079SFerenc Wagner } 24640aa0dc41SMark McLoughlin 24650aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 24660aa0dc41SMark McLoughlin { 24670aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 24680aa0dc41SMark McLoughlin } 24690aa0dc41SMark McLoughlin 24700aa0dc41SMark McLoughlin /** 24710aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 24720aa0dc41SMark McLoughlin * @name: root device name 24730aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 24740aa0dc41SMark McLoughlin * 24750aa0dc41SMark McLoughlin * This function allocates a root device and registers it 24760aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 24770aa0dc41SMark McLoughlin * device, use root_device_unregister(). 24780aa0dc41SMark McLoughlin * 24790aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 24800aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 24810aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 24820aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 24830aa0dc41SMark McLoughlin * 24840aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 24850aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 24860aa0dc41SMark McLoughlin * in sysfs. 24870aa0dc41SMark McLoughlin * 2488f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 2489f0eae0edSJani Nikula * 24900aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 24910aa0dc41SMark McLoughlin */ 24920aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 24930aa0dc41SMark McLoughlin { 24940aa0dc41SMark McLoughlin struct root_device *root; 24950aa0dc41SMark McLoughlin int err = -ENOMEM; 24960aa0dc41SMark McLoughlin 24970aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 24980aa0dc41SMark McLoughlin if (!root) 24990aa0dc41SMark McLoughlin return ERR_PTR(err); 25000aa0dc41SMark McLoughlin 2501acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 25020aa0dc41SMark McLoughlin if (err) { 25030aa0dc41SMark McLoughlin kfree(root); 25040aa0dc41SMark McLoughlin return ERR_PTR(err); 25050aa0dc41SMark McLoughlin } 25060aa0dc41SMark McLoughlin 25070aa0dc41SMark McLoughlin root->dev.release = root_device_release; 25080aa0dc41SMark McLoughlin 25090aa0dc41SMark McLoughlin err = device_register(&root->dev); 25100aa0dc41SMark McLoughlin if (err) { 25110aa0dc41SMark McLoughlin put_device(&root->dev); 25120aa0dc41SMark McLoughlin return ERR_PTR(err); 25130aa0dc41SMark McLoughlin } 25140aa0dc41SMark McLoughlin 25151d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 25160aa0dc41SMark McLoughlin if (owner) { 25170aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 25180aa0dc41SMark McLoughlin 25190aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 25200aa0dc41SMark McLoughlin if (err) { 25210aa0dc41SMark McLoughlin device_unregister(&root->dev); 25220aa0dc41SMark McLoughlin return ERR_PTR(err); 25230aa0dc41SMark McLoughlin } 25240aa0dc41SMark McLoughlin root->owner = owner; 25250aa0dc41SMark McLoughlin } 25260aa0dc41SMark McLoughlin #endif 25270aa0dc41SMark McLoughlin 25280aa0dc41SMark McLoughlin return &root->dev; 25290aa0dc41SMark McLoughlin } 25300aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 25310aa0dc41SMark McLoughlin 25320aa0dc41SMark McLoughlin /** 25330aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 25347cbcf225SRandy Dunlap * @dev: device going away 25350aa0dc41SMark McLoughlin * 25360aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 25370aa0dc41SMark McLoughlin * root_device_register(). 25380aa0dc41SMark McLoughlin */ 25390aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 25400aa0dc41SMark McLoughlin { 25410aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 25420aa0dc41SMark McLoughlin 25430aa0dc41SMark McLoughlin if (root->owner) 25440aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 25450aa0dc41SMark McLoughlin 25460aa0dc41SMark McLoughlin device_unregister(dev); 25470aa0dc41SMark McLoughlin } 25480aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 25490aa0dc41SMark McLoughlin 255023681e47SGreg Kroah-Hartman 255123681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 255223681e47SGreg Kroah-Hartman { 25531e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 255423681e47SGreg Kroah-Hartman kfree(dev); 255523681e47SGreg Kroah-Hartman } 255623681e47SGreg Kroah-Hartman 25576a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 255839ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 255939ef3112SGuenter Roeck dev_t devt, void *drvdata, 256039ef3112SGuenter Roeck const struct attribute_group **groups, 256139ef3112SGuenter Roeck const char *fmt, va_list args) 256239ef3112SGuenter Roeck { 256339ef3112SGuenter Roeck struct device *dev = NULL; 256439ef3112SGuenter Roeck int retval = -ENODEV; 256539ef3112SGuenter Roeck 256639ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 256739ef3112SGuenter Roeck goto error; 256839ef3112SGuenter Roeck 256939ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 257039ef3112SGuenter Roeck if (!dev) { 257139ef3112SGuenter Roeck retval = -ENOMEM; 257239ef3112SGuenter Roeck goto error; 257339ef3112SGuenter Roeck } 257439ef3112SGuenter Roeck 2575bbc780f8SDavid Herrmann device_initialize(dev); 257639ef3112SGuenter Roeck dev->devt = devt; 257739ef3112SGuenter Roeck dev->class = class; 257839ef3112SGuenter Roeck dev->parent = parent; 257939ef3112SGuenter Roeck dev->groups = groups; 258039ef3112SGuenter Roeck dev->release = device_create_release; 258139ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 258239ef3112SGuenter Roeck 258339ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 258439ef3112SGuenter Roeck if (retval) 258539ef3112SGuenter Roeck goto error; 258639ef3112SGuenter Roeck 2587bbc780f8SDavid Herrmann retval = device_add(dev); 258839ef3112SGuenter Roeck if (retval) 258939ef3112SGuenter Roeck goto error; 259039ef3112SGuenter Roeck 259139ef3112SGuenter Roeck return dev; 259239ef3112SGuenter Roeck 259339ef3112SGuenter Roeck error: 259439ef3112SGuenter Roeck put_device(dev); 259539ef3112SGuenter Roeck return ERR_PTR(retval); 259639ef3112SGuenter Roeck } 259739ef3112SGuenter Roeck 259823681e47SGreg Kroah-Hartman /** 25998882b394SGreg Kroah-Hartman * device_create_vargs - creates a device and registers it with sysfs 26008882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 26018882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 26028882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 26038882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 26048882b394SGreg Kroah-Hartman * @fmt: string for the device's name 26058882b394SGreg Kroah-Hartman * @args: va_list for the device's name 26068882b394SGreg Kroah-Hartman * 26078882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 26088882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 26098882b394SGreg Kroah-Hartman * 26108882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 26118882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 26128882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 26138882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 26148882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 26158882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 26168882b394SGreg Kroah-Hartman * pointer. 26178882b394SGreg Kroah-Hartman * 2618f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 2619f0eae0edSJani Nikula * 26208882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 26218882b394SGreg Kroah-Hartman * been created with a call to class_create(). 26228882b394SGreg Kroah-Hartman */ 26238882b394SGreg Kroah-Hartman struct device *device_create_vargs(struct class *class, struct device *parent, 26248882b394SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, 26258882b394SGreg Kroah-Hartman va_list args) 26268882b394SGreg Kroah-Hartman { 262739ef3112SGuenter Roeck return device_create_groups_vargs(class, parent, devt, drvdata, NULL, 262839ef3112SGuenter Roeck fmt, args); 26298882b394SGreg Kroah-Hartman } 26308882b394SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_vargs); 26318882b394SGreg Kroah-Hartman 26328882b394SGreg Kroah-Hartman /** 26334e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 26348882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 26358882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 26368882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 26378882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 26388882b394SGreg Kroah-Hartman * @fmt: string for the device's name 26398882b394SGreg Kroah-Hartman * 26408882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 26418882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 26428882b394SGreg Kroah-Hartman * 26438882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 26448882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 26458882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 26468882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 26478882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 26488882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 26498882b394SGreg Kroah-Hartman * pointer. 26508882b394SGreg Kroah-Hartman * 2651f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 2652f0eae0edSJani Nikula * 26538882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 26548882b394SGreg Kroah-Hartman * been created with a call to class_create(). 26558882b394SGreg Kroah-Hartman */ 26564e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 26574e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 26588882b394SGreg Kroah-Hartman { 26598882b394SGreg Kroah-Hartman va_list vargs; 26608882b394SGreg Kroah-Hartman struct device *dev; 26618882b394SGreg Kroah-Hartman 26628882b394SGreg Kroah-Hartman va_start(vargs, fmt); 26638882b394SGreg Kroah-Hartman dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs); 26648882b394SGreg Kroah-Hartman va_end(vargs); 26658882b394SGreg Kroah-Hartman return dev; 26668882b394SGreg Kroah-Hartman } 26674e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 26688882b394SGreg Kroah-Hartman 266939ef3112SGuenter Roeck /** 267039ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 267139ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 267239ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 267339ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 267439ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 267539ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 267639ef3112SGuenter Roeck * @fmt: string for the device's name 267739ef3112SGuenter Roeck * 267839ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 267939ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 268039ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 268139ef3112SGuenter Roeck * be created automatically. 268239ef3112SGuenter Roeck * 268339ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 268439ef3112SGuenter Roeck * the dev_t is not 0,0. 268539ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 268639ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 268739ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 268839ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 268939ef3112SGuenter Roeck * pointer. 269039ef3112SGuenter Roeck * 269139ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 269239ef3112SGuenter Roeck * 269339ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 269439ef3112SGuenter Roeck * been created with a call to class_create(). 269539ef3112SGuenter Roeck */ 269639ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 269739ef3112SGuenter Roeck struct device *parent, dev_t devt, 269839ef3112SGuenter Roeck void *drvdata, 269939ef3112SGuenter Roeck const struct attribute_group **groups, 270039ef3112SGuenter Roeck const char *fmt, ...) 270139ef3112SGuenter Roeck { 270239ef3112SGuenter Roeck va_list vargs; 270339ef3112SGuenter Roeck struct device *dev; 270439ef3112SGuenter Roeck 270539ef3112SGuenter Roeck va_start(vargs, fmt); 270639ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 270739ef3112SGuenter Roeck fmt, vargs); 270839ef3112SGuenter Roeck va_end(vargs); 270939ef3112SGuenter Roeck return dev; 271039ef3112SGuenter Roeck } 271139ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 271239ef3112SGuenter Roeck 27139f3b795aSMichał Mirosław static int __match_devt(struct device *dev, const void *data) 271423681e47SGreg Kroah-Hartman { 27159f3b795aSMichał Mirosław const dev_t *devt = data; 271623681e47SGreg Kroah-Hartman 2717cd35449bSDave Young return dev->devt == *devt; 2718775b64d2SRafael J. Wysocki } 271923681e47SGreg Kroah-Hartman 2720775b64d2SRafael J. Wysocki /** 2721775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 2722775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 2723775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 2724775b64d2SRafael J. Wysocki * 2725775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 2726775b64d2SRafael J. Wysocki * call to device_create(). 2727775b64d2SRafael J. Wysocki */ 2728775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 2729775b64d2SRafael J. Wysocki { 2730775b64d2SRafael J. Wysocki struct device *dev; 2731775b64d2SRafael J. Wysocki 2732695794aeSGreg Kroah-Hartman dev = class_find_device(class, NULL, &devt, __match_devt); 2733cd35449bSDave Young if (dev) { 2734cd35449bSDave Young put_device(dev); 273523681e47SGreg Kroah-Hartman device_unregister(dev); 273623681e47SGreg Kroah-Hartman } 2737cd35449bSDave Young } 273823681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 2739a2de48caSGreg Kroah-Hartman 2740a2de48caSGreg Kroah-Hartman /** 2741a2de48caSGreg Kroah-Hartman * device_rename - renames a device 2742a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 2743a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 2744030c1d2bSEric W. Biederman * 2745030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 2746030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 2747030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 2748030c1d2bSEric W. Biederman * won't conflict with other devices. 2749c6c0ac66SMichael Ellerman * 2750a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 2751a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 2752a5462516STimur Tabi * some insight: 2753a5462516STimur Tabi * 2754a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 2755a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 2756a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 2757a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 2758a5462516STimur Tabi * 2759a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 2760a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 2761a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 2762a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 2763a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 2764a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 2765a5462516STimur Tabi * 2766a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 2767a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 2768a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 2769a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 2770a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 2771a5462516STimur Tabi * reasons. 2772a5462516STimur Tabi * 2773a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 2774a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 2775a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 2776a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 2777a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 2778a2de48caSGreg Kroah-Hartman */ 27796937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 2780a2de48caSGreg Kroah-Hartman { 27814b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 27822ee97cafSCornelia Huck char *old_device_name = NULL; 2783a2de48caSGreg Kroah-Hartman int error; 2784a2de48caSGreg Kroah-Hartman 2785a2de48caSGreg Kroah-Hartman dev = get_device(dev); 2786a2de48caSGreg Kroah-Hartman if (!dev) 2787a2de48caSGreg Kroah-Hartman return -EINVAL; 2788a2de48caSGreg Kroah-Hartman 278969df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 2790a2de48caSGreg Kroah-Hartman 27911fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 27922ee97cafSCornelia Huck if (!old_device_name) { 2793952ab431SJesper Juhl error = -ENOMEM; 27942ee97cafSCornelia Huck goto out; 2795952ab431SJesper Juhl } 2796a2de48caSGreg Kroah-Hartman 2797f349cf34SEric W. Biederman if (dev->class) { 27984b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 27994b30ee58STejun Heo kobj, old_device_name, 28004b30ee58STejun Heo new_name, kobject_namespace(kobj)); 2801f349cf34SEric W. Biederman if (error) 2802f349cf34SEric W. Biederman goto out; 2803f349cf34SEric W. Biederman } 280439aba963SKay Sievers 28054b30ee58STejun Heo error = kobject_rename(kobj, new_name); 28061fa5ae85SKay Sievers if (error) 28072ee97cafSCornelia Huck goto out; 2808a2de48caSGreg Kroah-Hartman 28092ee97cafSCornelia Huck out: 2810a2de48caSGreg Kroah-Hartman put_device(dev); 2811a2de48caSGreg Kroah-Hartman 28122ee97cafSCornelia Huck kfree(old_device_name); 2813a2de48caSGreg Kroah-Hartman 2814a2de48caSGreg Kroah-Hartman return error; 2815a2de48caSGreg Kroah-Hartman } 2816a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 28178a82472fSCornelia Huck 28188a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 28198a82472fSCornelia Huck struct device *old_parent, 28208a82472fSCornelia Huck struct device *new_parent) 28218a82472fSCornelia Huck { 2822f7f3461dSGreg Kroah-Hartman int error = 0; 28238a82472fSCornelia Huck 2824f7f3461dSGreg Kroah-Hartman if (old_parent) 2825f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 2826f7f3461dSGreg Kroah-Hartman if (new_parent) 2827f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 2828f7f3461dSGreg Kroah-Hartman "device"); 2829f7f3461dSGreg Kroah-Hartman return error; 28308a82472fSCornelia Huck } 28318a82472fSCornelia Huck 28328a82472fSCornelia Huck /** 28338a82472fSCornelia Huck * device_move - moves a device to a new parent 28348a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 283513509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 2836ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 28378a82472fSCornelia Huck */ 2838ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 2839ffa6a705SCornelia Huck enum dpm_order dpm_order) 28408a82472fSCornelia Huck { 28418a82472fSCornelia Huck int error; 28428a82472fSCornelia Huck struct device *old_parent; 2843c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 28448a82472fSCornelia Huck 28458a82472fSCornelia Huck dev = get_device(dev); 28468a82472fSCornelia Huck if (!dev) 28478a82472fSCornelia Huck return -EINVAL; 28488a82472fSCornelia Huck 2849ffa6a705SCornelia Huck device_pm_lock(); 28508a82472fSCornelia Huck new_parent = get_device(new_parent); 2851c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 285284d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 285384d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 285484d0c27dSTetsuo Handa put_device(new_parent); 285584d0c27dSTetsuo Handa goto out; 285684d0c27dSTetsuo Handa } 285763b6971aSCornelia Huck 28581e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 28591e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 2860c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 28618a82472fSCornelia Huck if (error) { 286263b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 28638a82472fSCornelia Huck put_device(new_parent); 28648a82472fSCornelia Huck goto out; 28658a82472fSCornelia Huck } 28668a82472fSCornelia Huck old_parent = dev->parent; 28678a82472fSCornelia Huck dev->parent = new_parent; 28688a82472fSCornelia Huck if (old_parent) 2869f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 28700d358f22SYinghai Lu if (new_parent) { 2871f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2872f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 28730d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 28740d358f22SYinghai Lu } 28750d358f22SYinghai Lu 2876bdd4034dSRabin Vincent if (dev->class) { 28778a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 28788a82472fSCornelia Huck if (error) { 28798a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 28808a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 28818a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 2882c744aeaeSCornelia Huck if (new_parent) 2883f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 28840d358f22SYinghai Lu dev->parent = old_parent; 28850d358f22SYinghai Lu if (old_parent) { 2886f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2887f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 28880d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 28890d358f22SYinghai Lu } 28908a82472fSCornelia Huck } 289163b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 28928a82472fSCornelia Huck put_device(new_parent); 28938a82472fSCornelia Huck goto out; 28948a82472fSCornelia Huck } 2895bdd4034dSRabin Vincent } 2896ffa6a705SCornelia Huck switch (dpm_order) { 2897ffa6a705SCornelia Huck case DPM_ORDER_NONE: 2898ffa6a705SCornelia Huck break; 2899ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 2900ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 290152cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 2902ffa6a705SCornelia Huck break; 2903ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 2904ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 290552cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 2906ffa6a705SCornelia Huck break; 2907ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 2908ffa6a705SCornelia Huck device_pm_move_last(dev); 290952cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 2910ffa6a705SCornelia Huck break; 2911ffa6a705SCornelia Huck } 2912bdd4034dSRabin Vincent 29138a82472fSCornelia Huck put_device(old_parent); 29148a82472fSCornelia Huck out: 2915ffa6a705SCornelia Huck device_pm_unlock(); 29168a82472fSCornelia Huck put_device(dev); 29178a82472fSCornelia Huck return error; 29188a82472fSCornelia Huck } 29198a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 292037b0c020SGreg Kroah-Hartman 292137b0c020SGreg Kroah-Hartman /** 292237b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 292337b0c020SGreg Kroah-Hartman */ 292437b0c020SGreg Kroah-Hartman void device_shutdown(void) 292537b0c020SGreg Kroah-Hartman { 2926f123db8eSBenson Leung struct device *dev, *parent; 292737b0c020SGreg Kroah-Hartman 29283297c8fcSPingfan Liu wait_for_device_probe(); 29293297c8fcSPingfan Liu device_block_probing(); 29303297c8fcSPingfan Liu 29316245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 29326245838fSHugh Daschbach /* 29336245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 29346245838fSHugh Daschbach * Beware that device unplug events may also start pulling 29356245838fSHugh Daschbach * devices offline, even as the system is shutting down. 29366245838fSHugh Daschbach */ 29376245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 29386245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 29396245838fSHugh Daschbach kobj.entry); 2940d1c6c030SMing Lei 2941d1c6c030SMing Lei /* 2942d1c6c030SMing Lei * hold reference count of device's parent to 2943d1c6c030SMing Lei * prevent it from being freed because parent's 2944d1c6c030SMing Lei * lock is to be held 2945d1c6c030SMing Lei */ 2946f123db8eSBenson Leung parent = get_device(dev->parent); 29476245838fSHugh Daschbach get_device(dev); 29486245838fSHugh Daschbach /* 29496245838fSHugh Daschbach * Make sure the device is off the kset list, in the 29506245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 29516245838fSHugh Daschbach */ 29526245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 29536245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 2954fe6b91f4SAlan Stern 2955d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 2956f123db8eSBenson Leung if (parent) 2957f123db8eSBenson Leung device_lock(parent); 2958d1c6c030SMing Lei device_lock(dev); 2959d1c6c030SMing Lei 2960fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 2961fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 2962fe6b91f4SAlan Stern pm_runtime_barrier(dev); 29636245838fSHugh Daschbach 29647521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 2965f77af151SJosh Zimmerman if (initcall_debug) 29667521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 29677521621eSMichal Suchanek dev->class->shutdown_pre(dev); 29687521621eSMichal Suchanek } 29697521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 29700246c4faSShuoX Liu if (initcall_debug) 29710246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 297237b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 297337b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 29740246c4faSShuoX Liu if (initcall_debug) 29750246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 297637b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 297737b0c020SGreg Kroah-Hartman } 2978d1c6c030SMing Lei 2979d1c6c030SMing Lei device_unlock(dev); 2980f123db8eSBenson Leung if (parent) 2981f123db8eSBenson Leung device_unlock(parent); 2982d1c6c030SMing Lei 29836245838fSHugh Daschbach put_device(dev); 2984f123db8eSBenson Leung put_device(parent); 29856245838fSHugh Daschbach 29866245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 298737b0c020SGreg Kroah-Hartman } 29886245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 298937b0c020SGreg Kroah-Hartman } 299099bcf217SJoe Perches 299199bcf217SJoe Perches /* 299299bcf217SJoe Perches * Device logging functions 299399bcf217SJoe Perches */ 299499bcf217SJoe Perches 299599bcf217SJoe Perches #ifdef CONFIG_PRINTK 2996666f355fSJoe Perches static int 2997666f355fSJoe Perches create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 299899bcf217SJoe Perches { 2999c4e00daaSKay Sievers const char *subsys; 3000798efc60SJoe Perches size_t pos = 0; 300199bcf217SJoe Perches 3002c4e00daaSKay Sievers if (dev->class) 3003c4e00daaSKay Sievers subsys = dev->class->name; 3004c4e00daaSKay Sievers else if (dev->bus) 3005c4e00daaSKay Sievers subsys = dev->bus->name; 3006c4e00daaSKay Sievers else 3007798efc60SJoe Perches return 0; 3008c4e00daaSKay Sievers 3009798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 3010655e5b7cSBen Hutchings if (pos >= hdrlen) 3011655e5b7cSBen Hutchings goto overflow; 3012c4e00daaSKay Sievers 3013c4e00daaSKay Sievers /* 3014c4e00daaSKay Sievers * Add device identifier DEVICE=: 3015c4e00daaSKay Sievers * b12:8 block dev_t 3016c4e00daaSKay Sievers * c127:3 char dev_t 3017c4e00daaSKay Sievers * n8 netdev ifindex 3018c4e00daaSKay Sievers * +sound:card0 subsystem:devname 3019c4e00daaSKay Sievers */ 3020c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 3021c4e00daaSKay Sievers char c; 3022c4e00daaSKay Sievers 3023c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 3024c4e00daaSKay Sievers c = 'b'; 3025c4e00daaSKay Sievers else 3026c4e00daaSKay Sievers c = 'c'; 3027798efc60SJoe Perches pos++; 3028798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3029c4e00daaSKay Sievers "DEVICE=%c%u:%u", 3030c4e00daaSKay Sievers c, MAJOR(dev->devt), MINOR(dev->devt)); 3031c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 3032c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 3033c4e00daaSKay Sievers 3034798efc60SJoe Perches pos++; 3035798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3036c4e00daaSKay Sievers "DEVICE=n%u", net->ifindex); 3037c4e00daaSKay Sievers } else { 3038798efc60SJoe Perches pos++; 3039798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 3040c4e00daaSKay Sievers "DEVICE=+%s:%s", subsys, dev_name(dev)); 3041c4e00daaSKay Sievers } 3042af7f2158SJim Cromie 3043655e5b7cSBen Hutchings if (pos >= hdrlen) 3044655e5b7cSBen Hutchings goto overflow; 3045655e5b7cSBen Hutchings 3046798efc60SJoe Perches return pos; 3047655e5b7cSBen Hutchings 3048655e5b7cSBen Hutchings overflow: 3049655e5b7cSBen Hutchings dev_WARN(dev, "device/subsystem name too long"); 3050655e5b7cSBen Hutchings return 0; 305199bcf217SJoe Perches } 3052798efc60SJoe Perches 305305e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 305405e4e5b8SJoe Perches const char *fmt, va_list args) 305505e4e5b8SJoe Perches { 305605e4e5b8SJoe Perches char hdr[128]; 305705e4e5b8SJoe Perches size_t hdrlen; 305805e4e5b8SJoe Perches 305905e4e5b8SJoe Perches hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 306005e4e5b8SJoe Perches 306105e4e5b8SJoe Perches return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 306205e4e5b8SJoe Perches } 306305e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 306405e4e5b8SJoe Perches 306505e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 306605e4e5b8SJoe Perches { 306705e4e5b8SJoe Perches va_list args; 306805e4e5b8SJoe Perches int r; 306905e4e5b8SJoe Perches 307005e4e5b8SJoe Perches va_start(args, fmt); 307105e4e5b8SJoe Perches 307205e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 307305e4e5b8SJoe Perches 307405e4e5b8SJoe Perches va_end(args); 307505e4e5b8SJoe Perches 307605e4e5b8SJoe Perches return r; 307705e4e5b8SJoe Perches } 307805e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 307905e4e5b8SJoe Perches 3080d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 3081798efc60SJoe Perches struct va_format *vaf) 3082798efc60SJoe Perches { 3083d1f1052cSJoe Perches if (dev) 3084d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 3085798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 3086d1f1052cSJoe Perches else 3087d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 3088798efc60SJoe Perches } 308999bcf217SJoe Perches 3090d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 309199bcf217SJoe Perches const char *fmt, ...) 309299bcf217SJoe Perches { 309399bcf217SJoe Perches struct va_format vaf; 309499bcf217SJoe Perches va_list args; 309599bcf217SJoe Perches 309699bcf217SJoe Perches va_start(args, fmt); 309799bcf217SJoe Perches 309899bcf217SJoe Perches vaf.fmt = fmt; 309999bcf217SJoe Perches vaf.va = &args; 310099bcf217SJoe Perches 3101d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 3102798efc60SJoe Perches 310399bcf217SJoe Perches va_end(args); 310499bcf217SJoe Perches } 310599bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 310699bcf217SJoe Perches 310799bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 3108d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 310999bcf217SJoe Perches { \ 311099bcf217SJoe Perches struct va_format vaf; \ 311199bcf217SJoe Perches va_list args; \ 311299bcf217SJoe Perches \ 311399bcf217SJoe Perches va_start(args, fmt); \ 311499bcf217SJoe Perches \ 311599bcf217SJoe Perches vaf.fmt = fmt; \ 311699bcf217SJoe Perches vaf.va = &args; \ 311799bcf217SJoe Perches \ 3118d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 3119798efc60SJoe Perches \ 312099bcf217SJoe Perches va_end(args); \ 312199bcf217SJoe Perches } \ 312299bcf217SJoe Perches EXPORT_SYMBOL(func); 312399bcf217SJoe Perches 3124663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 3125663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 3126663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 3127663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 3128663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 3129663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 313099bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 313199bcf217SJoe Perches 313299bcf217SJoe Perches #endif 313397badf87SRafael J. Wysocki 313497badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 313597badf87SRafael J. Wysocki { 313697badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 313797badf87SRafael J. Wysocki } 313897badf87SRafael J. Wysocki 313997badf87SRafael J. Wysocki /** 314097badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 314197badf87SRafael J. Wysocki * @dev: Device to handle. 314297badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 314397badf87SRafael J. Wysocki * 314497badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 314597badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 314697badf87SRafael J. Wysocki */ 314797badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 314897badf87SRafael J. Wysocki { 314997badf87SRafael J. Wysocki if (fwnode) { 315097badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 315197badf87SRafael J. Wysocki 315297badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 315397badf87SRafael J. Wysocki fn = fn->secondary; 315497badf87SRafael J. Wysocki 315555f89a8aSMika Westerberg if (fn) { 315655f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 315797badf87SRafael J. Wysocki fwnode->secondary = fn; 315855f89a8aSMika Westerberg } 315997badf87SRafael J. Wysocki dev->fwnode = fwnode; 316097badf87SRafael J. Wysocki } else { 316197badf87SRafael J. Wysocki dev->fwnode = fwnode_is_primary(dev->fwnode) ? 316297badf87SRafael J. Wysocki dev->fwnode->secondary : NULL; 316397badf87SRafael J. Wysocki } 316497badf87SRafael J. Wysocki } 316597badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 316697badf87SRafael J. Wysocki 316797badf87SRafael J. Wysocki /** 316897badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 316997badf87SRafael J. Wysocki * @dev: Device to handle. 317097badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 317197badf87SRafael J. Wysocki * 317297badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 317397badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 317497badf87SRafael J. Wysocki * @fwnode. 317597badf87SRafael J. Wysocki */ 317697badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 317797badf87SRafael J. Wysocki { 317897badf87SRafael J. Wysocki if (fwnode) 317997badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 318097badf87SRafael J. Wysocki 318197badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 318297badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 318397badf87SRafael J. Wysocki else 318497badf87SRafael J. Wysocki dev->fwnode = fwnode; 318597badf87SRafael J. Wysocki } 31864e75e1d7SJohan Hovold 31874e75e1d7SJohan Hovold /** 31884e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 31894e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 31904e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 31914e75e1d7SJohan Hovold * 31924e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 31934e75e1d7SJohan Hovold * any reference held to the old node. 31944e75e1d7SJohan Hovold */ 31954e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 31964e75e1d7SJohan Hovold { 31974e75e1d7SJohan Hovold of_node_put(dev->of_node); 31984e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 31994e75e1d7SJohan Hovold dev->of_node_reused = true; 32004e75e1d7SJohan Hovold } 32014e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 3202