1989d42e8SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * drivers/base/core.c - core driver model code (device registration, etc) 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright (c) 2002-3 Patrick Mochel 61da177e4SLinus Torvalds * Copyright (c) 2002-3 Open Source Development Labs 764bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> 864bb5d2cSGreg Kroah-Hartman * Copyright (c) 2006 Novell, Inc. 91da177e4SLinus Torvalds */ 101da177e4SLinus Torvalds 117847a145SHeikki Krogerus #include <linux/acpi.h> 1265650b35SRafael J. Wysocki #include <linux/cpufreq.h> 131da177e4SLinus Torvalds #include <linux/device.h> 141da177e4SLinus Torvalds #include <linux/err.h> 1597badf87SRafael J. Wysocki #include <linux/fwnode.h> 161da177e4SLinus Torvalds #include <linux/init.h> 171da177e4SLinus Torvalds #include <linux/module.h> 181da177e4SLinus Torvalds #include <linux/slab.h> 191da177e4SLinus Torvalds #include <linux/string.h> 2023681e47SGreg Kroah-Hartman #include <linux/kdev_t.h> 21116af378SBenjamin Herrenschmidt #include <linux/notifier.h> 2207d57a32SGrant Likely #include <linux/of.h> 2307d57a32SGrant Likely #include <linux/of_device.h> 24da231fd5SKay Sievers #include <linux/genhd.h> 25f75b1c60SDave Young #include <linux/mutex.h> 26af8db150SPeter Chen #include <linux/pm_runtime.h> 27c4e00daaSKay Sievers #include <linux/netdevice.h> 28174cd4b1SIngo Molnar #include <linux/sched/signal.h> 2963967685SGreg Kroah-Hartman #include <linux/sysfs.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include "base.h" 321da177e4SLinus Torvalds #include "power/power.h" 331da177e4SLinus Torvalds 34e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED 35e52eec13SAndi Kleen #ifdef CONFIG_SYSFS_DEPRECATED_V2 36e52eec13SAndi Kleen long sysfs_deprecated = 1; 37e52eec13SAndi Kleen #else 38e52eec13SAndi Kleen long sysfs_deprecated = 0; 39e52eec13SAndi Kleen #endif 403454bf96SHanjun Guo static int __init sysfs_deprecated_setup(char *arg) 41e52eec13SAndi Kleen { 4234da5e67SJingoo Han return kstrtol(arg, 10, &sysfs_deprecated); 43e52eec13SAndi Kleen } 44e52eec13SAndi Kleen early_param("sysfs.deprecated", sysfs_deprecated_setup); 45e52eec13SAndi Kleen #endif 46e52eec13SAndi Kleen 479ed98953SRafael J. Wysocki /* Device links support. */ 48e2ae9bccSSaravana Kannan static LIST_HEAD(wait_for_suppliers); 49e2ae9bccSSaravana Kannan static DEFINE_MUTEX(wfs_lock); 50fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 51fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 52716a7a25SSaravana Kannan static unsigned int defer_fw_devlink_count; 53716a7a25SSaravana Kannan static DEFINE_MUTEX(defer_fw_devlink_lock); 54716a7a25SSaravana Kannan static bool fw_devlink_is_permissive(void); 559ed98953SRafael J. Wysocki 569ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 579ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 589ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 599ed98953SRafael J. Wysocki 609ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 619ed98953SRafael J. Wysocki { 629ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 639ed98953SRafael J. Wysocki } 649ed98953SRafael J. Wysocki 659ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 669ed98953SRafael J. Wysocki { 679ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 689ed98953SRafael J. Wysocki } 699ed98953SRafael J. Wysocki 7068464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 719ed98953SRafael J. Wysocki { 729ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 739ed98953SRafael J. Wysocki } 749ed98953SRafael J. Wysocki 75ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 769ed98953SRafael J. Wysocki { 779ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 789ed98953SRafael J. Wysocki } 79c2fa1e1bSJoel Fernandes (Google) 80c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 81c2fa1e1bSJoel Fernandes (Google) { 82c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 83c2fa1e1bSJoel Fernandes (Google) } 849ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 859ed98953SRafael J. Wysocki static DECLARE_RWSEM(device_links_lock); 869ed98953SRafael J. Wysocki 879ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 889ed98953SRafael J. Wysocki { 899ed98953SRafael J. Wysocki down_write(&device_links_lock); 909ed98953SRafael J. Wysocki } 919ed98953SRafael J. Wysocki 929ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 939ed98953SRafael J. Wysocki { 949ed98953SRafael J. Wysocki up_write(&device_links_lock); 959ed98953SRafael J. Wysocki } 969ed98953SRafael J. Wysocki 979ed98953SRafael J. Wysocki int device_links_read_lock(void) 989ed98953SRafael J. Wysocki { 999ed98953SRafael J. Wysocki down_read(&device_links_lock); 1009ed98953SRafael J. Wysocki return 0; 1019ed98953SRafael J. Wysocki } 1029ed98953SRafael J. Wysocki 1039ed98953SRafael J. Wysocki void device_links_read_unlock(int not_used) 1049ed98953SRafael J. Wysocki { 1059ed98953SRafael J. Wysocki up_read(&device_links_lock); 1069ed98953SRafael J. Wysocki } 107c2fa1e1bSJoel Fernandes (Google) 108c2fa1e1bSJoel Fernandes (Google) #ifdef CONFIG_DEBUG_LOCK_ALLOC 109c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 110c2fa1e1bSJoel Fernandes (Google) { 111c2fa1e1bSJoel Fernandes (Google) return lockdep_is_held(&device_links_lock); 112c2fa1e1bSJoel Fernandes (Google) } 113c2fa1e1bSJoel Fernandes (Google) #endif 1149ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 1159ed98953SRafael J. Wysocki 1169ed98953SRafael J. Wysocki /** 1179ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 1189ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 1199ed98953SRafael J. Wysocki * @target: Device to check against. 1209ed98953SRafael J. Wysocki * 1219ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 1229ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 1239ed98953SRafael J. Wysocki */ 1249ed98953SRafael J. Wysocki static int device_is_dependent(struct device *dev, void *target) 1259ed98953SRafael J. Wysocki { 1269ed98953SRafael J. Wysocki struct device_link *link; 1279ed98953SRafael J. Wysocki int ret; 1289ed98953SRafael J. Wysocki 129e16f4f3eSBenjamin Gaignard if (dev == target) 1309ed98953SRafael J. Wysocki return 1; 1319ed98953SRafael J. Wysocki 1329ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 1339ed98953SRafael J. Wysocki if (ret) 1349ed98953SRafael J. Wysocki return ret; 1359ed98953SRafael J. Wysocki 1369ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 13705ef983eSSaravana Kannan if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 13805ef983eSSaravana Kannan continue; 13905ef983eSSaravana Kannan 140e16f4f3eSBenjamin Gaignard if (link->consumer == target) 1419ed98953SRafael J. Wysocki return 1; 1429ed98953SRafael J. Wysocki 1439ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 1449ed98953SRafael J. Wysocki if (ret) 1459ed98953SRafael J. Wysocki break; 1469ed98953SRafael J. Wysocki } 1479ed98953SRafael J. Wysocki return ret; 1489ed98953SRafael J. Wysocki } 1499ed98953SRafael J. Wysocki 150515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 151515db266SRafael J. Wysocki struct device *consumer, 152515db266SRafael J. Wysocki struct device *supplier) 153515db266SRafael J. Wysocki { 154515db266SRafael J. Wysocki switch (supplier->links.status) { 155515db266SRafael J. Wysocki case DL_DEV_PROBING: 156515db266SRafael J. Wysocki switch (consumer->links.status) { 157515db266SRafael J. Wysocki case DL_DEV_PROBING: 158515db266SRafael J. Wysocki /* 159515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 160515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 161515db266SRafael J. Wysocki * knows that the supplier is already functional (for 162515db266SRafael J. Wysocki * example, it has just acquired some resources from the 163515db266SRafael J. Wysocki * supplier). 164515db266SRafael J. Wysocki */ 165515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 166515db266SRafael J. Wysocki break; 167515db266SRafael J. Wysocki default: 168515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 169515db266SRafael J. Wysocki break; 170515db266SRafael J. Wysocki } 171515db266SRafael J. Wysocki break; 172515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 173515db266SRafael J. Wysocki switch (consumer->links.status) { 174515db266SRafael J. Wysocki case DL_DEV_PROBING: 175515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 176515db266SRafael J. Wysocki break; 177515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 178515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 179515db266SRafael J. Wysocki break; 180515db266SRafael J. Wysocki default: 181515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 182515db266SRafael J. Wysocki break; 183515db266SRafael J. Wysocki } 184515db266SRafael J. Wysocki break; 185515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 186515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 187515db266SRafael J. Wysocki break; 188515db266SRafael J. Wysocki default: 189515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 190515db266SRafael J. Wysocki break; 191515db266SRafael J. Wysocki } 192515db266SRafael J. Wysocki } 193515db266SRafael J. Wysocki 1949ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 1959ed98953SRafael J. Wysocki { 1969ed98953SRafael J. Wysocki struct device_link *link; 1979ed98953SRafael J. Wysocki 1989ed98953SRafael J. Wysocki /* 1999ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 2009ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 2019ed98953SRafael J. Wysocki */ 2029ed98953SRafael J. Wysocki if (device_is_registered(dev)) 2039ed98953SRafael J. Wysocki devices_kset_move_last(dev); 2049ed98953SRafael J. Wysocki 2059ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 2069ed98953SRafael J. Wysocki device_pm_move_last(dev); 2079ed98953SRafael J. Wysocki 2089ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 20905ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 21005ef983eSSaravana Kannan if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED)) 21105ef983eSSaravana Kannan continue; 2129ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 21305ef983eSSaravana Kannan } 2149ed98953SRafael J. Wysocki 2159ed98953SRafael J. Wysocki return 0; 2169ed98953SRafael J. Wysocki } 2179ed98953SRafael J. Wysocki 2189ed98953SRafael J. Wysocki /** 219494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 220494fd7b7SFeng Kan * @dev: Device to move 221494fd7b7SFeng Kan * 222494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 223494fd7b7SFeng Kan * 224494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 225494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 226494fd7b7SFeng Kan */ 227494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 228494fd7b7SFeng Kan { 229494fd7b7SFeng Kan int idx; 230494fd7b7SFeng Kan 231494fd7b7SFeng Kan idx = device_links_read_lock(); 232494fd7b7SFeng Kan device_pm_lock(); 233494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 234494fd7b7SFeng Kan device_pm_unlock(); 235494fd7b7SFeng Kan device_links_read_unlock(idx); 236494fd7b7SFeng Kan } 237494fd7b7SFeng Kan 238287905e6SSaravana Kannan #define to_devlink(dev) container_of((dev), struct device_link, link_dev) 239287905e6SSaravana Kannan 240287905e6SSaravana Kannan static ssize_t status_show(struct device *dev, 241287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 242287905e6SSaravana Kannan { 243287905e6SSaravana Kannan char *status; 244287905e6SSaravana Kannan 245287905e6SSaravana Kannan switch (to_devlink(dev)->status) { 246287905e6SSaravana Kannan case DL_STATE_NONE: 247287905e6SSaravana Kannan status = "not tracked"; break; 248287905e6SSaravana Kannan case DL_STATE_DORMANT: 249287905e6SSaravana Kannan status = "dormant"; break; 250287905e6SSaravana Kannan case DL_STATE_AVAILABLE: 251287905e6SSaravana Kannan status = "available"; break; 252287905e6SSaravana Kannan case DL_STATE_CONSUMER_PROBE: 253287905e6SSaravana Kannan status = "consumer probing"; break; 254287905e6SSaravana Kannan case DL_STATE_ACTIVE: 255287905e6SSaravana Kannan status = "active"; break; 256287905e6SSaravana Kannan case DL_STATE_SUPPLIER_UNBIND: 257287905e6SSaravana Kannan status = "supplier unbinding"; break; 258287905e6SSaravana Kannan default: 259287905e6SSaravana Kannan status = "unknown"; break; 260287905e6SSaravana Kannan } 261287905e6SSaravana Kannan return sprintf(buf, "%s\n", status); 262287905e6SSaravana Kannan } 263287905e6SSaravana Kannan static DEVICE_ATTR_RO(status); 264287905e6SSaravana Kannan 265287905e6SSaravana Kannan static ssize_t auto_remove_on_show(struct device *dev, 266287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 267287905e6SSaravana Kannan { 268287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 269287905e6SSaravana Kannan char *str; 270287905e6SSaravana Kannan 271287905e6SSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 272287905e6SSaravana Kannan str = "supplier unbind"; 273287905e6SSaravana Kannan else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 274287905e6SSaravana Kannan str = "consumer unbind"; 275287905e6SSaravana Kannan else 276287905e6SSaravana Kannan str = "never"; 277287905e6SSaravana Kannan 278287905e6SSaravana Kannan return sprintf(buf, "%s\n", str); 279287905e6SSaravana Kannan } 280287905e6SSaravana Kannan static DEVICE_ATTR_RO(auto_remove_on); 281287905e6SSaravana Kannan 282287905e6SSaravana Kannan static ssize_t runtime_pm_show(struct device *dev, 283287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 284287905e6SSaravana Kannan { 285287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 286287905e6SSaravana Kannan 287287905e6SSaravana Kannan return sprintf(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); 288287905e6SSaravana Kannan } 289287905e6SSaravana Kannan static DEVICE_ATTR_RO(runtime_pm); 290287905e6SSaravana Kannan 291287905e6SSaravana Kannan static ssize_t sync_state_only_show(struct device *dev, 292287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 293287905e6SSaravana Kannan { 294287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 295287905e6SSaravana Kannan 296287905e6SSaravana Kannan return sprintf(buf, "%d\n", !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 297287905e6SSaravana Kannan } 298287905e6SSaravana Kannan static DEVICE_ATTR_RO(sync_state_only); 299287905e6SSaravana Kannan 300287905e6SSaravana Kannan static struct attribute *devlink_attrs[] = { 301287905e6SSaravana Kannan &dev_attr_status.attr, 302287905e6SSaravana Kannan &dev_attr_auto_remove_on.attr, 303287905e6SSaravana Kannan &dev_attr_runtime_pm.attr, 304287905e6SSaravana Kannan &dev_attr_sync_state_only.attr, 305287905e6SSaravana Kannan NULL, 306287905e6SSaravana Kannan }; 307287905e6SSaravana Kannan ATTRIBUTE_GROUPS(devlink); 308287905e6SSaravana Kannan 309287905e6SSaravana Kannan static void devlink_dev_release(struct device *dev) 310287905e6SSaravana Kannan { 311287905e6SSaravana Kannan kfree(to_devlink(dev)); 312287905e6SSaravana Kannan } 313287905e6SSaravana Kannan 314287905e6SSaravana Kannan static struct class devlink_class = { 315287905e6SSaravana Kannan .name = "devlink", 316287905e6SSaravana Kannan .owner = THIS_MODULE, 317287905e6SSaravana Kannan .dev_groups = devlink_groups, 318287905e6SSaravana Kannan .dev_release = devlink_dev_release, 319287905e6SSaravana Kannan }; 320287905e6SSaravana Kannan 321287905e6SSaravana Kannan static int devlink_add_symlinks(struct device *dev, 322287905e6SSaravana Kannan struct class_interface *class_intf) 323287905e6SSaravana Kannan { 324287905e6SSaravana Kannan int ret; 325287905e6SSaravana Kannan size_t len; 326287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 327287905e6SSaravana Kannan struct device *sup = link->supplier; 328287905e6SSaravana Kannan struct device *con = link->consumer; 329287905e6SSaravana Kannan char *buf; 330287905e6SSaravana Kannan 331287905e6SSaravana Kannan len = max(strlen(dev_name(sup)), strlen(dev_name(con))); 332287905e6SSaravana Kannan len += strlen("supplier:") + 1; 333287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 334287905e6SSaravana Kannan if (!buf) 335287905e6SSaravana Kannan return -ENOMEM; 336287905e6SSaravana Kannan 337287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); 338287905e6SSaravana Kannan if (ret) 339287905e6SSaravana Kannan goto out; 340287905e6SSaravana Kannan 341287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); 342287905e6SSaravana Kannan if (ret) 343287905e6SSaravana Kannan goto err_con; 344287905e6SSaravana Kannan 345287905e6SSaravana Kannan snprintf(buf, len, "consumer:%s", dev_name(con)); 346287905e6SSaravana Kannan ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); 347287905e6SSaravana Kannan if (ret) 348287905e6SSaravana Kannan goto err_con_dev; 349287905e6SSaravana Kannan 350287905e6SSaravana Kannan snprintf(buf, len, "supplier:%s", dev_name(sup)); 351287905e6SSaravana Kannan ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); 352287905e6SSaravana Kannan if (ret) 353287905e6SSaravana Kannan goto err_sup_dev; 354287905e6SSaravana Kannan 355287905e6SSaravana Kannan goto out; 356287905e6SSaravana Kannan 357287905e6SSaravana Kannan err_sup_dev: 358287905e6SSaravana Kannan snprintf(buf, len, "consumer:%s", dev_name(con)); 359287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 360287905e6SSaravana Kannan err_con_dev: 361287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 362287905e6SSaravana Kannan err_con: 363287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 364287905e6SSaravana Kannan out: 365287905e6SSaravana Kannan kfree(buf); 366287905e6SSaravana Kannan return ret; 367287905e6SSaravana Kannan } 368287905e6SSaravana Kannan 369287905e6SSaravana Kannan static void devlink_remove_symlinks(struct device *dev, 370287905e6SSaravana Kannan struct class_interface *class_intf) 371287905e6SSaravana Kannan { 372287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 373287905e6SSaravana Kannan size_t len; 374287905e6SSaravana Kannan struct device *sup = link->supplier; 375287905e6SSaravana Kannan struct device *con = link->consumer; 376287905e6SSaravana Kannan char *buf; 377287905e6SSaravana Kannan 378287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 379287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 380287905e6SSaravana Kannan 381287905e6SSaravana Kannan len = max(strlen(dev_name(sup)), strlen(dev_name(con))); 382287905e6SSaravana Kannan len += strlen("supplier:") + 1; 383287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 384287905e6SSaravana Kannan if (!buf) { 385287905e6SSaravana Kannan WARN(1, "Unable to properly free device link symlinks!\n"); 386287905e6SSaravana Kannan return; 387287905e6SSaravana Kannan } 388287905e6SSaravana Kannan 389287905e6SSaravana Kannan snprintf(buf, len, "supplier:%s", dev_name(sup)); 390287905e6SSaravana Kannan sysfs_remove_link(&con->kobj, buf); 391287905e6SSaravana Kannan snprintf(buf, len, "consumer:%s", dev_name(con)); 392287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 393287905e6SSaravana Kannan kfree(buf); 394287905e6SSaravana Kannan } 395287905e6SSaravana Kannan 396287905e6SSaravana Kannan static struct class_interface devlink_class_intf = { 397287905e6SSaravana Kannan .class = &devlink_class, 398287905e6SSaravana Kannan .add_dev = devlink_add_symlinks, 399287905e6SSaravana Kannan .remove_dev = devlink_remove_symlinks, 400287905e6SSaravana Kannan }; 401287905e6SSaravana Kannan 402287905e6SSaravana Kannan static int __init devlink_class_init(void) 403287905e6SSaravana Kannan { 404287905e6SSaravana Kannan int ret; 405287905e6SSaravana Kannan 406287905e6SSaravana Kannan ret = class_register(&devlink_class); 407287905e6SSaravana Kannan if (ret) 408287905e6SSaravana Kannan return ret; 409287905e6SSaravana Kannan 410287905e6SSaravana Kannan ret = class_interface_register(&devlink_class_intf); 411287905e6SSaravana Kannan if (ret) 412287905e6SSaravana Kannan class_unregister(&devlink_class); 413287905e6SSaravana Kannan 414287905e6SSaravana Kannan return ret; 415287905e6SSaravana Kannan } 416287905e6SSaravana Kannan postcore_initcall(devlink_class_init); 417287905e6SSaravana Kannan 418515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 419515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 42005ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 42105ef983eSSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 422515db266SRafael J. Wysocki 423fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 424fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 425fb583c8eSRafael J. Wysocki 426494fd7b7SFeng Kan /** 4279ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 4289ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 4299ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 4309ed98953SRafael J. Wysocki * @flags: Link flags. 4319ed98953SRafael J. Wysocki * 43221d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 43321d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 43421d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 43521d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 43621d5c57bSRafael J. Wysocki * be forced into the active metastate and reference-counted upon the creation 43721d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 43821d5c57bSRafael J. Wysocki * ignored. 43921d5c57bSRafael J. Wysocki * 440515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 441515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 442515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 44372175d4eSRafael J. Wysocki * 44472175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 44572175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 44672175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 44772175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 44872175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 44972175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 45072175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 45172175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 45272175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 45372175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 45472175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 455c8d50986SRafael J. Wysocki * 456e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 457e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 458e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 459e7dd4010SRafael J. Wysocki * be used to request the driver core to automaticall probe for a consmer 460e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 461e7dd4010SRafael J. Wysocki * 462515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 463515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 464515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 465515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 466515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 467515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 468515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 469515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 470515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 471515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 4729ed98953SRafael J. Wysocki * 4739ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 4749ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 4759ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 4769ed98953SRafael J. Wysocki * not been registered when this function is called). 4779ed98953SRafael J. Wysocki * 4789ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 4799ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 48064df1148SLukas Wunner * not be registered, however. 4819ed98953SRafael J. Wysocki */ 4829ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 4839ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 4849ed98953SRafael J. Wysocki { 4859ed98953SRafael J. Wysocki struct device_link *link; 4869ed98953SRafael J. Wysocki 487fb583c8eSRafael J. Wysocki if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || 488515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 48905ef983eSSaravana Kannan (flags & DL_FLAG_SYNC_STATE_ONLY && 49005ef983eSSaravana Kannan flags != DL_FLAG_SYNC_STATE_ONLY) || 491e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 492e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 493e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 4949ed98953SRafael J. Wysocki return NULL; 4959ed98953SRafael J. Wysocki 4965db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 4975db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 4985db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 4995db25c9eSRafael J. Wysocki return NULL; 5005db25c9eSRafael J. Wysocki } 5015db25c9eSRafael J. Wysocki } 5025db25c9eSRafael J. Wysocki 503515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 504515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 505515db266SRafael J. Wysocki 5069ed98953SRafael J. Wysocki device_links_write_lock(); 5079ed98953SRafael J. Wysocki device_pm_lock(); 5089ed98953SRafael J. Wysocki 5099ed98953SRafael J. Wysocki /* 5109ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 51105ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 51205ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 51305ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 51405ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 5159ed98953SRafael J. Wysocki */ 5169ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 51705ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 51805ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 5199ed98953SRafael J. Wysocki link = NULL; 5209ed98953SRafael J. Wysocki goto out; 5219ed98953SRafael J. Wysocki } 5229ed98953SRafael J. Wysocki 52372175d4eSRafael J. Wysocki /* 52472175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 52572175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 52672175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 52772175d4eSRafael J. Wysocki */ 52872175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 52972175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 53072175d4eSRafael J. Wysocki 531f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 532f265df55SRafael J. Wysocki if (link->consumer != consumer) 533f265df55SRafael J. Wysocki continue; 534f265df55SRafael J. Wysocki 535e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 536e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 5374c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 538e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 539e2f3cd83SRafael J. Wysocki } 540e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 54136003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 542e2f3cd83SRafael J. Wysocki } 543e2f3cd83SRafael J. Wysocki 54472175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 545ead18c23SLukas Wunner kref_get(&link->kref); 54621c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 54744e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 54844e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 54905ef983eSSaravana Kannan goto reorder; 55044e96049SSaravana Kannan } else { 55144e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 5529ed98953SRafael J. Wysocki goto out; 553ead18c23SLukas Wunner } 55444e96049SSaravana Kannan } 5559ed98953SRafael J. Wysocki 55672175d4eSRafael J. Wysocki /* 55772175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 55872175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 55972175d4eSRafael J. Wysocki * update the existing link to stay around longer. 56072175d4eSRafael J. Wysocki */ 56172175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 56272175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 56372175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 56472175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 56572175d4eSRafael J. Wysocki } 56672175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 56772175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 56872175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 56972175d4eSRafael J. Wysocki } 570515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 571515db266SRafael J. Wysocki kref_get(&link->kref); 572515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 573515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 574515db266SRafael J. Wysocki } 57505ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 57605ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 57705ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 57805ef983eSSaravana Kannan goto reorder; 57905ef983eSSaravana Kannan } 58005ef983eSSaravana Kannan 58172175d4eSRafael J. Wysocki goto out; 58272175d4eSRafael J. Wysocki } 58372175d4eSRafael J. Wysocki 58421d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 5859ed98953SRafael J. Wysocki if (!link) 5869ed98953SRafael J. Wysocki goto out; 5879ed98953SRafael J. Wysocki 588e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 589e2f3cd83SRafael J. Wysocki 5909ed98953SRafael J. Wysocki get_device(supplier); 5919ed98953SRafael J. Wysocki link->supplier = supplier; 5929ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 5939ed98953SRafael J. Wysocki get_device(consumer); 5949ed98953SRafael J. Wysocki link->consumer = consumer; 5959ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 5969ed98953SRafael J. Wysocki link->flags = flags; 597ead18c23SLukas Wunner kref_init(&link->kref); 5989ed98953SRafael J. Wysocki 599287905e6SSaravana Kannan link->link_dev.class = &devlink_class; 600287905e6SSaravana Kannan device_set_pm_not_required(&link->link_dev); 601287905e6SSaravana Kannan dev_set_name(&link->link_dev, "%s:%s", 602287905e6SSaravana Kannan dev_name(supplier), dev_name(consumer)); 603287905e6SSaravana Kannan if (device_register(&link->link_dev)) { 604287905e6SSaravana Kannan put_device(consumer); 605287905e6SSaravana Kannan put_device(supplier); 606287905e6SSaravana Kannan kfree(link); 607287905e6SSaravana Kannan link = NULL; 608287905e6SSaravana Kannan goto out; 609287905e6SSaravana Kannan } 610287905e6SSaravana Kannan 611287905e6SSaravana Kannan if (flags & DL_FLAG_PM_RUNTIME) { 612287905e6SSaravana Kannan if (flags & DL_FLAG_RPM_ACTIVE) 613287905e6SSaravana Kannan refcount_inc(&link->rpm_active); 614287905e6SSaravana Kannan 615287905e6SSaravana Kannan pm_runtime_new_link(consumer); 616287905e6SSaravana Kannan } 617287905e6SSaravana Kannan 61864df1148SLukas Wunner /* Determine the initial link state. */ 619515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 6209ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 621515db266SRafael J. Wysocki else 622515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 6239ed98953SRafael J. Wysocki 6249ed98953SRafael J. Wysocki /* 62515cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 62615cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 62715cfb094SRafael J. Wysocki */ 62815cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 62915cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 63015cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 63115cfb094SRafael J. Wysocki 63221c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 63321c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 63421c27f06SSaravana Kannan 63505ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 63605ef983eSSaravana Kannan dev_dbg(consumer, 63705ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 63805ef983eSSaravana Kannan dev_name(supplier)); 63905ef983eSSaravana Kannan goto out; 64005ef983eSSaravana Kannan } 64121c27f06SSaravana Kannan 64205ef983eSSaravana Kannan reorder: 64315cfb094SRafael J. Wysocki /* 6449ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 6459ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 6469ed98953SRafael J. Wysocki * 6479ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 6489ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 6499ed98953SRafael J. Wysocki */ 6509ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 6519ed98953SRafael J. Wysocki 6528a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 6539ed98953SRafael J. Wysocki 6549ed98953SRafael J. Wysocki out: 6559ed98953SRafael J. Wysocki device_pm_unlock(); 6569ed98953SRafael J. Wysocki device_links_write_unlock(); 6575db25c9eSRafael J. Wysocki 658e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 6595db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 6605db25c9eSRafael J. Wysocki 6619ed98953SRafael J. Wysocki return link; 6629ed98953SRafael J. Wysocki } 6639ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 6649ed98953SRafael J. Wysocki 665e2ae9bccSSaravana Kannan /** 666e2ae9bccSSaravana Kannan * device_link_wait_for_supplier - Add device to wait_for_suppliers list 667e2ae9bccSSaravana Kannan * @consumer: Consumer device 668e2ae9bccSSaravana Kannan * 669e2ae9bccSSaravana Kannan * Marks the @consumer device as waiting for suppliers to become available by 670e2ae9bccSSaravana Kannan * adding it to the wait_for_suppliers list. The consumer device will never be 671e2ae9bccSSaravana Kannan * probed until it's removed from the wait_for_suppliers list. 672e2ae9bccSSaravana Kannan * 673e2ae9bccSSaravana Kannan * The caller is responsible for adding the links to the supplier devices once 674e2ae9bccSSaravana Kannan * they are available and removing the @consumer device from the 675e2ae9bccSSaravana Kannan * wait_for_suppliers list once links to all the suppliers have been created. 676e2ae9bccSSaravana Kannan * 677e2ae9bccSSaravana Kannan * This function is NOT meant to be called from the probe function of the 678e2ae9bccSSaravana Kannan * consumer but rather from code that creates/adds the consumer device. 679e2ae9bccSSaravana Kannan */ 680bcbbcfd5SSaravana Kannan static void device_link_wait_for_supplier(struct device *consumer, 681bcbbcfd5SSaravana Kannan bool need_for_probe) 682e2ae9bccSSaravana Kannan { 683e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 684e2ae9bccSSaravana Kannan list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers); 685bcbbcfd5SSaravana Kannan consumer->links.need_for_probe = need_for_probe; 686e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 687e2ae9bccSSaravana Kannan } 688e2ae9bccSSaravana Kannan 689bcbbcfd5SSaravana Kannan static void device_link_wait_for_mandatory_supplier(struct device *consumer) 690bcbbcfd5SSaravana Kannan { 691bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, true); 692bcbbcfd5SSaravana Kannan } 693bcbbcfd5SSaravana Kannan 694bcbbcfd5SSaravana Kannan static void device_link_wait_for_optional_supplier(struct device *consumer) 695bcbbcfd5SSaravana Kannan { 696bcbbcfd5SSaravana Kannan device_link_wait_for_supplier(consumer, false); 697bcbbcfd5SSaravana Kannan } 698bcbbcfd5SSaravana Kannan 699e2ae9bccSSaravana Kannan /** 700e2ae9bccSSaravana Kannan * device_link_add_missing_supplier_links - Add links from consumer devices to 701e2ae9bccSSaravana Kannan * supplier devices, leaving any 702e2ae9bccSSaravana Kannan * consumer with inactive suppliers on 703e2ae9bccSSaravana Kannan * the wait_for_suppliers list 704e2ae9bccSSaravana Kannan * 705e2ae9bccSSaravana Kannan * Loops through all consumers waiting on suppliers and tries to add all their 706e2ae9bccSSaravana Kannan * supplier links. If that succeeds, the consumer device is removed from 707e2ae9bccSSaravana Kannan * wait_for_suppliers list. Otherwise, they are left in the wait_for_suppliers 708e2ae9bccSSaravana Kannan * list. Devices left on the wait_for_suppliers list will not be probed. 709e2ae9bccSSaravana Kannan * 710e2ae9bccSSaravana Kannan * The fwnode add_links callback is expected to return 0 if it has found and 711e2ae9bccSSaravana Kannan * added all the supplier links for the consumer device. It should return an 712e2ae9bccSSaravana Kannan * error if it isn't able to do so. 713e2ae9bccSSaravana Kannan * 714e2ae9bccSSaravana Kannan * The caller of device_link_wait_for_supplier() is expected to call this once 715e2ae9bccSSaravana Kannan * it's aware of potential suppliers becoming available. 716e2ae9bccSSaravana Kannan */ 717e2ae9bccSSaravana Kannan static void device_link_add_missing_supplier_links(void) 718e2ae9bccSSaravana Kannan { 719e2ae9bccSSaravana Kannan struct device *dev, *tmp; 720e2ae9bccSSaravana Kannan 721e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 722e2ae9bccSSaravana Kannan list_for_each_entry_safe(dev, tmp, &wait_for_suppliers, 7231745d299SSaravana Kannan links.needs_suppliers) { 7241745d299SSaravana Kannan int ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 7251745d299SSaravana Kannan if (!ret) 726e2ae9bccSSaravana Kannan list_del_init(&dev->links.needs_suppliers); 727716a7a25SSaravana Kannan else if (ret != -ENODEV || fw_devlink_is_permissive()) 7281745d299SSaravana Kannan dev->links.need_for_probe = false; 7291745d299SSaravana Kannan } 730e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 731e2ae9bccSSaravana Kannan } 732e2ae9bccSSaravana Kannan 7339ed98953SRafael J. Wysocki static void device_link_free(struct device_link *link) 7349ed98953SRafael J. Wysocki { 735a1fdbfbbSRafael J. Wysocki while (refcount_dec_not_one(&link->rpm_active)) 736a1fdbfbbSRafael J. Wysocki pm_runtime_put(link->supplier); 737a1fdbfbbSRafael J. Wysocki 7389ed98953SRafael J. Wysocki put_device(link->consumer); 7399ed98953SRafael J. Wysocki put_device(link->supplier); 740287905e6SSaravana Kannan device_unregister(&link->link_dev); 7419ed98953SRafael J. Wysocki } 7429ed98953SRafael J. Wysocki 7439ed98953SRafael J. Wysocki #ifdef CONFIG_SRCU 7449ed98953SRafael J. Wysocki static void __device_link_free_srcu(struct rcu_head *rhead) 7459ed98953SRafael J. Wysocki { 7469ed98953SRafael J. Wysocki device_link_free(container_of(rhead, struct device_link, rcu_head)); 7479ed98953SRafael J. Wysocki } 7489ed98953SRafael J. Wysocki 749ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 7509ed98953SRafael J. Wysocki { 751ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 752ead18c23SLukas Wunner 7538a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 7549ed98953SRafael J. Wysocki dev_name(link->supplier)); 7559ed98953SRafael J. Wysocki 756baa8809fSRafael J. Wysocki if (link->flags & DL_FLAG_PM_RUNTIME) 757baa8809fSRafael J. Wysocki pm_runtime_drop_link(link->consumer); 758baa8809fSRafael J. Wysocki 7599ed98953SRafael J. Wysocki list_del_rcu(&link->s_node); 7609ed98953SRafael J. Wysocki list_del_rcu(&link->c_node); 7619ed98953SRafael J. Wysocki call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu); 7629ed98953SRafael J. Wysocki } 7639ed98953SRafael J. Wysocki #else /* !CONFIG_SRCU */ 764ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 7659ed98953SRafael J. Wysocki { 766ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 767ead18c23SLukas Wunner 7689ed98953SRafael J. Wysocki dev_info(link->consumer, "Dropping the link to %s\n", 7699ed98953SRafael J. Wysocki dev_name(link->supplier)); 7709ed98953SRafael J. Wysocki 771433986c2SLukas Wunner if (link->flags & DL_FLAG_PM_RUNTIME) 772433986c2SLukas Wunner pm_runtime_drop_link(link->consumer); 773433986c2SLukas Wunner 7749ed98953SRafael J. Wysocki list_del(&link->s_node); 7759ed98953SRafael J. Wysocki list_del(&link->c_node); 7769ed98953SRafael J. Wysocki device_link_free(link); 7779ed98953SRafael J. Wysocki } 7789ed98953SRafael J. Wysocki #endif /* !CONFIG_SRCU */ 7799ed98953SRafael J. Wysocki 78072175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 78172175d4eSRafael J. Wysocki { 78272175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 78372175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 78472175d4eSRafael J. Wysocki else 78572175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 78672175d4eSRafael J. Wysocki } 78772175d4eSRafael J. Wysocki 7889ed98953SRafael J. Wysocki /** 78972175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 7909ed98953SRafael J. Wysocki * @link: Device link to delete. 7919ed98953SRafael J. Wysocki * 7929ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 793ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 794ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 795ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 7969ed98953SRafael J. Wysocki */ 7979ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 7989ed98953SRafael J. Wysocki { 7999ed98953SRafael J. Wysocki device_links_write_lock(); 8009ed98953SRafael J. Wysocki device_pm_lock(); 80172175d4eSRafael J. Wysocki device_link_put_kref(link); 8029ed98953SRafael J. Wysocki device_pm_unlock(); 8039ed98953SRafael J. Wysocki device_links_write_unlock(); 8049ed98953SRafael J. Wysocki } 8059ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 8069ed98953SRafael J. Wysocki 807d8842211Spascal paillet /** 80872175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 809d8842211Spascal paillet * @consumer: Consumer end of the link. 810d8842211Spascal paillet * @supplier: Supplier end of the link. 811d8842211Spascal paillet * 812d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 813d8842211Spascal paillet * PM. 814d8842211Spascal paillet */ 815d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 816d8842211Spascal paillet { 817d8842211Spascal paillet struct device_link *link; 818d8842211Spascal paillet 819d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 820d8842211Spascal paillet return; 821d8842211Spascal paillet 822d8842211Spascal paillet device_links_write_lock(); 823d8842211Spascal paillet device_pm_lock(); 824d8842211Spascal paillet 825d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 826d8842211Spascal paillet if (link->consumer == consumer) { 82772175d4eSRafael J. Wysocki device_link_put_kref(link); 828d8842211Spascal paillet break; 829d8842211Spascal paillet } 830d8842211Spascal paillet } 831d8842211Spascal paillet 832d8842211Spascal paillet device_pm_unlock(); 833d8842211Spascal paillet device_links_write_unlock(); 834d8842211Spascal paillet } 835d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 836d8842211Spascal paillet 8379ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 8389ed98953SRafael J. Wysocki { 8399ed98953SRafael J. Wysocki struct device_link *link; 8409ed98953SRafael J. Wysocki 8418c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) { 8428c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE) 8438c3e315dSSaravana Kannan continue; 8448c3e315dSSaravana Kannan 8458c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 8469ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 8478c3e315dSSaravana Kannan } else { 8488c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 8498c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 8508c3e315dSSaravana Kannan } 8518c3e315dSSaravana Kannan } 8529ed98953SRafael J. Wysocki } 8539ed98953SRafael J. Wysocki 8549ed98953SRafael J. Wysocki /** 8559ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 8569ed98953SRafael J. Wysocki * @dev: Consumer device. 8579ed98953SRafael J. Wysocki * 8589ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 8599ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 8609ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 8619ed98953SRafael J. Wysocki * 8629ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 8639ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 8649ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 8659ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 8669ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 8679ed98953SRafael J. Wysocki * 868515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 8699ed98953SRafael J. Wysocki */ 8709ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 8719ed98953SRafael J. Wysocki { 8729ed98953SRafael J. Wysocki struct device_link *link; 8739ed98953SRafael J. Wysocki int ret = 0; 8749ed98953SRafael J. Wysocki 875e2ae9bccSSaravana Kannan /* 876e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 877e2ae9bccSSaravana Kannan * probe. 878e2ae9bccSSaravana Kannan */ 879e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 880bcbbcfd5SSaravana Kannan if (!list_empty(&dev->links.needs_suppliers) && 881bcbbcfd5SSaravana Kannan dev->links.need_for_probe) { 882e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 883e2ae9bccSSaravana Kannan return -EPROBE_DEFER; 884e2ae9bccSSaravana Kannan } 885e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 886e2ae9bccSSaravana Kannan 8879ed98953SRafael J. Wysocki device_links_write_lock(); 8889ed98953SRafael J. Wysocki 8899ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 8908c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 8919ed98953SRafael J. Wysocki continue; 8929ed98953SRafael J. Wysocki 8938c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE && 8948c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { 8959ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 8969ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 8979ed98953SRafael J. Wysocki break; 8989ed98953SRafael J. Wysocki } 8999ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 9009ed98953SRafael J. Wysocki } 9019ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 9029ed98953SRafael J. Wysocki 9039ed98953SRafael J. Wysocki device_links_write_unlock(); 9049ed98953SRafael J. Wysocki return ret; 9059ed98953SRafael J. Wysocki } 9069ed98953SRafael J. Wysocki 90726e77708SSaravana Kannan /** 90826e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 90926e77708SSaravana Kannan * @dev: Device to call sync_state() on 91026e77708SSaravana Kannan * @list: List head to queue the @dev on 91126e77708SSaravana Kannan * 91226e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 91326e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 91426e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 91526e77708SSaravana Kannan * device_links_write_lock() held. 91626e77708SSaravana Kannan * 91726e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 91826e77708SSaravana Kannan * on this list. 91926e77708SSaravana Kannan * 92026e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 92126e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 92226e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 92326e77708SSaravana Kannan * put_device() is called on this device. 92426e77708SSaravana Kannan */ 92526e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 92626e77708SSaravana Kannan struct list_head *list) 927fc5a251dSSaravana Kannan { 928fc5a251dSSaravana Kannan struct device_link *link; 929fc5a251dSSaravana Kannan 93077036165SSaravana Kannan if (!dev_has_sync_state(dev)) 93177036165SSaravana Kannan return; 932fc5a251dSSaravana Kannan if (dev->state_synced) 933fc5a251dSSaravana Kannan return; 934fc5a251dSSaravana Kannan 935fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 936fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 937fc5a251dSSaravana Kannan continue; 938fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 939fc5a251dSSaravana Kannan return; 940fc5a251dSSaravana Kannan } 941fc5a251dSSaravana Kannan 94226e77708SSaravana Kannan /* 94326e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 94426e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 94526e77708SSaravana Kannan * and probed before the list is flushed. 94626e77708SSaravana Kannan */ 94726e77708SSaravana Kannan dev->state_synced = true; 94826e77708SSaravana Kannan 94926e77708SSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 95026e77708SSaravana Kannan return; 95126e77708SSaravana Kannan 95226e77708SSaravana Kannan get_device(dev); 95326e77708SSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 95426e77708SSaravana Kannan } 95526e77708SSaravana Kannan 95626e77708SSaravana Kannan /** 95726e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 95826e77708SSaravana Kannan * @list: List of devices to call sync_state() on 95921eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 96026e77708SSaravana Kannan * 96126e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 96221eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 96321eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 96421eb93f4SSaravana Kannan * context where a device lock is already held. 96526e77708SSaravana Kannan */ 96621eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 96721eb93f4SSaravana Kannan struct device *dont_lock_dev) 96826e77708SSaravana Kannan { 96926e77708SSaravana Kannan struct device *dev, *tmp; 97026e77708SSaravana Kannan 97126e77708SSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 97226e77708SSaravana Kannan list_del_init(&dev->links.defer_sync); 97326e77708SSaravana Kannan 97421eb93f4SSaravana Kannan if (dev != dont_lock_dev) 97526e77708SSaravana Kannan device_lock(dev); 97626e77708SSaravana Kannan 977fc5a251dSSaravana Kannan if (dev->bus->sync_state) 978fc5a251dSSaravana Kannan dev->bus->sync_state(dev); 979fc5a251dSSaravana Kannan else if (dev->driver && dev->driver->sync_state) 980fc5a251dSSaravana Kannan dev->driver->sync_state(dev); 981fc5a251dSSaravana Kannan 98221eb93f4SSaravana Kannan if (dev != dont_lock_dev) 98326e77708SSaravana Kannan device_unlock(dev); 98426e77708SSaravana Kannan 98526e77708SSaravana Kannan put_device(dev); 98626e77708SSaravana Kannan } 987fc5a251dSSaravana Kannan } 988fc5a251dSSaravana Kannan 989fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 990fc5a251dSSaravana Kannan { 991fc5a251dSSaravana Kannan device_links_write_lock(); 992fc5a251dSSaravana Kannan defer_sync_state_count++; 993fc5a251dSSaravana Kannan device_links_write_unlock(); 994fc5a251dSSaravana Kannan } 995fc5a251dSSaravana Kannan 996fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 997fc5a251dSSaravana Kannan { 998fc5a251dSSaravana Kannan struct device *dev, *tmp; 99926e77708SSaravana Kannan LIST_HEAD(sync_list); 1000fc5a251dSSaravana Kannan 1001fc5a251dSSaravana Kannan device_links_write_lock(); 1002fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 1003fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 1004fc5a251dSSaravana Kannan goto out; 1005fc5a251dSSaravana Kannan } 1006fc5a251dSSaravana Kannan defer_sync_state_count--; 1007fc5a251dSSaravana Kannan if (defer_sync_state_count) 1008fc5a251dSSaravana Kannan goto out; 1009fc5a251dSSaravana Kannan 1010fc5a251dSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 101126e77708SSaravana Kannan /* 101226e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 101326e77708SSaravana Kannan * sync_list because defer_sync is used for both lists. 101426e77708SSaravana Kannan */ 1015fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 101626e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 1017fc5a251dSSaravana Kannan } 1018fc5a251dSSaravana Kannan out: 1019fc5a251dSSaravana Kannan device_links_write_unlock(); 102026e77708SSaravana Kannan 102121eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 1022fc5a251dSSaravana Kannan } 1023fc5a251dSSaravana Kannan 1024fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 1025fc5a251dSSaravana Kannan { 1026fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 1027fc5a251dSSaravana Kannan return 0; 1028fc5a251dSSaravana Kannan } 1029fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 1030fc5a251dSSaravana Kannan 1031fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 1032fc5a251dSSaravana Kannan { 103377036165SSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 1034fc5a251dSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 1035fc5a251dSSaravana Kannan } 1036fc5a251dSSaravana Kannan 103721c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link) 103821c27f06SSaravana Kannan { 103921c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED; 104021c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE); 104121c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del); 104221c27f06SSaravana Kannan } 104321c27f06SSaravana Kannan 10449ed98953SRafael J. Wysocki /** 10459ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 10469ed98953SRafael J. Wysocki * @dev: Device to update the links for. 10479ed98953SRafael J. Wysocki * 10489ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 10499ed98953SRafael J. Wysocki * consumers by changing their status to "available". 10509ed98953SRafael J. Wysocki * 10519ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 10529ed98953SRafael J. Wysocki * 1053515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10549ed98953SRafael J. Wysocki */ 10559ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 10569ed98953SRafael J. Wysocki { 105721c27f06SSaravana Kannan struct device_link *link, *ln; 105826e77708SSaravana Kannan LIST_HEAD(sync_list); 10599ed98953SRafael J. Wysocki 1060bcbbcfd5SSaravana Kannan /* 1061bcbbcfd5SSaravana Kannan * If a device probes successfully, it's expected to have created all 1062bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 1063bcbbcfd5SSaravana Kannan * them. So, it no longer needs to wait on any suppliers. 1064bcbbcfd5SSaravana Kannan */ 1065bcbbcfd5SSaravana Kannan mutex_lock(&wfs_lock); 1066bcbbcfd5SSaravana Kannan list_del_init(&dev->links.needs_suppliers); 1067bcbbcfd5SSaravana Kannan mutex_unlock(&wfs_lock); 1068bcbbcfd5SSaravana Kannan 10699ed98953SRafael J. Wysocki device_links_write_lock(); 10709ed98953SRafael J. Wysocki 10719ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1072515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 10739ed98953SRafael J. Wysocki continue; 10749ed98953SRafael J. Wysocki 107515cfb094SRafael J. Wysocki /* 107615cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 107715cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 107815cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 107915cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 108015cfb094SRafael J. Wysocki */ 108115cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 108215cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 108315cfb094SRafael J. Wysocki continue; 108415cfb094SRafael J. Wysocki 10859ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 10869ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 1087e7dd4010SRafael J. Wysocki 1088e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 1089e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 10909ed98953SRafael J. Wysocki } 10919ed98953SRafael J. Wysocki 109221eb93f4SSaravana Kannan if (defer_sync_state_count) 109321eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 109421eb93f4SSaravana Kannan else 109521eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 109621eb93f4SSaravana Kannan 109721c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 109821c27f06SSaravana Kannan struct device *supplier; 109921c27f06SSaravana Kannan 1100515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 11019ed98953SRafael J. Wysocki continue; 11029ed98953SRafael J. Wysocki 110321c27f06SSaravana Kannan supplier = link->supplier; 110421c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { 110521c27f06SSaravana Kannan /* 110621c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no 110721c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's 110821c27f06SSaravana Kannan * save to drop the managed link completely. 110921c27f06SSaravana Kannan */ 111021c27f06SSaravana Kannan device_link_drop_managed(link); 111121c27f06SSaravana Kannan } else { 11129ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 11139ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 111421c27f06SSaravana Kannan } 1115fc5a251dSSaravana Kannan 111621c27f06SSaravana Kannan /* 111721c27f06SSaravana Kannan * This needs to be done even for the deleted 111821c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last 111921c27f06SSaravana Kannan * device link that was preventing the supplier from getting a 112021c27f06SSaravana Kannan * sync_state() call. 112121c27f06SSaravana Kannan */ 1122fc5a251dSSaravana Kannan if (defer_sync_state_count) 112321c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier); 1124fc5a251dSSaravana Kannan else 112521c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list); 11269ed98953SRafael J. Wysocki } 11279ed98953SRafael J. Wysocki 11289ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 11299ed98953SRafael J. Wysocki 11309ed98953SRafael J. Wysocki device_links_write_unlock(); 113126e77708SSaravana Kannan 113221eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 11339ed98953SRafael J. Wysocki } 11349ed98953SRafael J. Wysocki 11359ed98953SRafael J. Wysocki /** 11369ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 11379ed98953SRafael J. Wysocki * @dev: Device without a drvier. 11389ed98953SRafael J. Wysocki * 11399ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 11409ed98953SRafael J. Wysocki * 11419ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 11429ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 11439ed98953SRafael J. Wysocki * case they need not be updated. 11449ed98953SRafael J. Wysocki * 1145515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 11469ed98953SRafael J. Wysocki */ 11479ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 11489ed98953SRafael J. Wysocki { 11499ed98953SRafael J. Wysocki struct device_link *link, *ln; 11509ed98953SRafael J. Wysocki 11519ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 1152515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 11539ed98953SRafael J. Wysocki continue; 11549ed98953SRafael J. Wysocki 11558c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 1156515db266SRafael J. Wysocki device_link_drop_managed(link); 11578c3e315dSSaravana Kannan continue; 11588c3e315dSSaravana Kannan } 11598c3e315dSSaravana Kannan 11608c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE && 11618c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE) 11628c3e315dSSaravana Kannan continue; 11638c3e315dSSaravana Kannan 11648c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 11659ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 11668c3e315dSSaravana Kannan } else { 11678c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 11688c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 11698c3e315dSSaravana Kannan } 11709ed98953SRafael J. Wysocki } 11719ed98953SRafael J. Wysocki 11729ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 11739ed98953SRafael J. Wysocki } 11749ed98953SRafael J. Wysocki 117515cfb094SRafael J. Wysocki /** 117615cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 117715cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 117815cfb094SRafael J. Wysocki * 117915cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 118015cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 118115cfb094SRafael J. Wysocki * appropriate. 118215cfb094SRafael J. Wysocki * 1183515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 118415cfb094SRafael J. Wysocki */ 11859ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 11869ed98953SRafael J. Wysocki { 118715cfb094SRafael J. Wysocki struct device_link *link; 118815cfb094SRafael J. Wysocki 11899ed98953SRafael J. Wysocki device_links_write_lock(); 119015cfb094SRafael J. Wysocki 119115cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1192515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 119315cfb094SRafael J. Wysocki continue; 119415cfb094SRafael J. Wysocki 119515cfb094SRafael J. Wysocki /* 119615cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 119715cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 119815cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 119915cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 120015cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 120115cfb094SRafael J. Wysocki */ 120215cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 120315cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 120415cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 120515cfb094SRafael J. Wysocki } 120615cfb094SRafael J. Wysocki 12079ed98953SRafael J. Wysocki __device_links_no_driver(dev); 120815cfb094SRafael J. Wysocki 12099ed98953SRafael J. Wysocki device_links_write_unlock(); 12109ed98953SRafael J. Wysocki } 12119ed98953SRafael J. Wysocki 12129ed98953SRafael J. Wysocki /** 12139ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 12149ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 12159ed98953SRafael J. Wysocki * 12169ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 12179ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 12189ed98953SRafael J. Wysocki * appropriate. 12199ed98953SRafael J. Wysocki * 1220515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 12219ed98953SRafael J. Wysocki */ 12229ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 12239ed98953SRafael J. Wysocki { 1224c8d50986SRafael J. Wysocki struct device_link *link, *ln; 12259ed98953SRafael J. Wysocki 12269ed98953SRafael J. Wysocki device_links_write_lock(); 12279ed98953SRafael J. Wysocki 1228c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1229515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 12309ed98953SRafael J. Wysocki continue; 12319ed98953SRafael J. Wysocki 1232e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 12339ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 12341689cac5SVivek Gautam 12351689cac5SVivek Gautam /* 12361689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 12371689cac5SVivek Gautam * devices that are not active, i.e. where the link state 12381689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 12391689cac5SVivek Gautam */ 12401689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 12411689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1242515db266SRafael J. Wysocki device_link_drop_managed(link); 12431689cac5SVivek Gautam 12449ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 12459ed98953SRafael J. Wysocki } 12469ed98953SRafael J. Wysocki 1247fc5a251dSSaravana Kannan list_del_init(&dev->links.defer_sync); 12489ed98953SRafael J. Wysocki __device_links_no_driver(dev); 12499ed98953SRafael J. Wysocki 12509ed98953SRafael J. Wysocki device_links_write_unlock(); 12519ed98953SRafael J. Wysocki } 12529ed98953SRafael J. Wysocki 12539ed98953SRafael J. Wysocki /** 12549ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 12559ed98953SRafael J. Wysocki * @dev: Device to check. 12569ed98953SRafael J. Wysocki * 12579ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 12589ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 12599ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 12609ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 12619ed98953SRafael J. Wysocki * successfully going forward. 12629ed98953SRafael J. Wysocki * 12639ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 12649ed98953SRafael J. Wysocki * 1265515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 12669ed98953SRafael J. Wysocki */ 12679ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 12689ed98953SRafael J. Wysocki { 12699ed98953SRafael J. Wysocki struct device_link *link; 12709ed98953SRafael J. Wysocki bool ret = false; 12719ed98953SRafael J. Wysocki 12729ed98953SRafael J. Wysocki device_links_write_lock(); 12739ed98953SRafael J. Wysocki 12749ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1275515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 12769ed98953SRafael J. Wysocki continue; 12779ed98953SRafael J. Wysocki 12789ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 12799ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 12809ed98953SRafael J. Wysocki ret = true; 12819ed98953SRafael J. Wysocki break; 12829ed98953SRafael J. Wysocki } 12839ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 12849ed98953SRafael J. Wysocki } 12859ed98953SRafael J. Wysocki 12869ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 12879ed98953SRafael J. Wysocki 12889ed98953SRafael J. Wysocki device_links_write_unlock(); 12899ed98953SRafael J. Wysocki return ret; 12909ed98953SRafael J. Wysocki } 12919ed98953SRafael J. Wysocki 12929ed98953SRafael J. Wysocki /** 12939ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 12949ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 12959ed98953SRafael J. Wysocki * 12969ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 12979ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 12989ed98953SRafael J. Wysocki * and start over. 12999ed98953SRafael J. Wysocki * 13009ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 13019ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 13029ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 13039ed98953SRafael J. Wysocki * changed the state of the link already). 13049ed98953SRafael J. Wysocki * 1305515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 13069ed98953SRafael J. Wysocki */ 13079ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 13089ed98953SRafael J. Wysocki { 13099ed98953SRafael J. Wysocki struct device_link *link; 13109ed98953SRafael J. Wysocki 13119ed98953SRafael J. Wysocki start: 13129ed98953SRafael J. Wysocki device_links_write_lock(); 13139ed98953SRafael J. Wysocki 13149ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 13159ed98953SRafael J. Wysocki enum device_link_state status; 13169ed98953SRafael J. Wysocki 131705ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 131805ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 13199ed98953SRafael J. Wysocki continue; 13209ed98953SRafael J. Wysocki 13219ed98953SRafael J. Wysocki status = link->status; 13229ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 13239ed98953SRafael J. Wysocki device_links_write_unlock(); 13249ed98953SRafael J. Wysocki 13259ed98953SRafael J. Wysocki wait_for_device_probe(); 13269ed98953SRafael J. Wysocki goto start; 13279ed98953SRafael J. Wysocki } 13289ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 13299ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 13309ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 13319ed98953SRafael J. Wysocki 13329ed98953SRafael J. Wysocki get_device(consumer); 13339ed98953SRafael J. Wysocki 13349ed98953SRafael J. Wysocki device_links_write_unlock(); 13359ed98953SRafael J. Wysocki 13369ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 13379ed98953SRafael J. Wysocki consumer->parent); 13389ed98953SRafael J. Wysocki put_device(consumer); 13399ed98953SRafael J. Wysocki goto start; 13409ed98953SRafael J. Wysocki } 13419ed98953SRafael J. Wysocki } 13429ed98953SRafael J. Wysocki 13439ed98953SRafael J. Wysocki device_links_write_unlock(); 13449ed98953SRafael J. Wysocki } 13459ed98953SRafael J. Wysocki 13469ed98953SRafael J. Wysocki /** 13479ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 13489ed98953SRafael J. Wysocki * @dev: Target device. 13499ed98953SRafael J. Wysocki */ 13509ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 13519ed98953SRafael J. Wysocki { 13529ed98953SRafael J. Wysocki struct device_link *link, *ln; 13539ed98953SRafael J. Wysocki 1354287905e6SSaravana Kannan if (dev->class == &devlink_class) 1355287905e6SSaravana Kannan return; 1356287905e6SSaravana Kannan 1357e2ae9bccSSaravana Kannan mutex_lock(&wfs_lock); 1358e2ae9bccSSaravana Kannan list_del(&dev->links.needs_suppliers); 1359e2ae9bccSSaravana Kannan mutex_unlock(&wfs_lock); 1360e2ae9bccSSaravana Kannan 13619ed98953SRafael J. Wysocki /* 13629ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 13639ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 13649ed98953SRafael J. Wysocki */ 13659ed98953SRafael J. Wysocki device_links_write_lock(); 13669ed98953SRafael J. Wysocki 13679ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 13689ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1369ead18c23SLukas Wunner __device_link_del(&link->kref); 13709ed98953SRafael J. Wysocki } 13719ed98953SRafael J. Wysocki 13729ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 13739ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 13749ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1375ead18c23SLukas Wunner __device_link_del(&link->kref); 13769ed98953SRafael J. Wysocki } 13779ed98953SRafael J. Wysocki 13789ed98953SRafael J. Wysocki device_links_write_unlock(); 13799ed98953SRafael J. Wysocki } 13809ed98953SRafael J. Wysocki 138142926ac3SSaravana Kannan static u32 fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY; 138242926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 138342926ac3SSaravana Kannan { 138442926ac3SSaravana Kannan if (!arg) 138542926ac3SSaravana Kannan return -EINVAL; 138642926ac3SSaravana Kannan 138742926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 138842926ac3SSaravana Kannan fw_devlink_flags = 0; 138942926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 139042926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY; 139142926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 139242926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER; 139342926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 139442926ac3SSaravana Kannan fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER | 139542926ac3SSaravana Kannan DL_FLAG_PM_RUNTIME; 139642926ac3SSaravana Kannan } 139742926ac3SSaravana Kannan return 0; 139842926ac3SSaravana Kannan } 139942926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 140042926ac3SSaravana Kannan 140142926ac3SSaravana Kannan u32 fw_devlink_get_flags(void) 140242926ac3SSaravana Kannan { 140342926ac3SSaravana Kannan return fw_devlink_flags; 140442926ac3SSaravana Kannan } 140542926ac3SSaravana Kannan 140642926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 140742926ac3SSaravana Kannan { 140842926ac3SSaravana Kannan return fw_devlink_flags == DL_FLAG_SYNC_STATE_ONLY; 140942926ac3SSaravana Kannan } 141042926ac3SSaravana Kannan 14115f5377eaSSaravana Kannan static void fw_devlink_link_device(struct device *dev) 14125f5377eaSSaravana Kannan { 14135f5377eaSSaravana Kannan int fw_ret; 14145f5377eaSSaravana Kannan 1415716a7a25SSaravana Kannan if (!fw_devlink_flags) 1416716a7a25SSaravana Kannan return; 1417716a7a25SSaravana Kannan 1418716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1419716a7a25SSaravana Kannan if (!defer_fw_devlink_count) 14205f5377eaSSaravana Kannan device_link_add_missing_supplier_links(); 14215f5377eaSSaravana Kannan 1422716a7a25SSaravana Kannan /* 1423716a7a25SSaravana Kannan * The device's fwnode not having add_links() doesn't affect if other 1424716a7a25SSaravana Kannan * consumers can find this device as a supplier. So, this check is 1425716a7a25SSaravana Kannan * intentionally placed after device_link_add_missing_supplier_links(). 1426716a7a25SSaravana Kannan */ 1427716a7a25SSaravana Kannan if (!fwnode_has_op(dev->fwnode, add_links)) 1428716a7a25SSaravana Kannan goto out; 1429716a7a25SSaravana Kannan 1430716a7a25SSaravana Kannan /* 1431716a7a25SSaravana Kannan * If fw_devlink is being deferred, assume all devices have mandatory 1432716a7a25SSaravana Kannan * suppliers they need to link to later. Then, when the fw_devlink is 1433716a7a25SSaravana Kannan * resumed, all these devices will get a chance to try and link to any 1434716a7a25SSaravana Kannan * suppliers they have. 1435716a7a25SSaravana Kannan */ 1436716a7a25SSaravana Kannan if (!defer_fw_devlink_count) { 14375f5377eaSSaravana Kannan fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev); 1438716a7a25SSaravana Kannan if (fw_ret == -ENODEV && fw_devlink_is_permissive()) 1439716a7a25SSaravana Kannan fw_ret = -EAGAIN; 1440716a7a25SSaravana Kannan } else { 1441716a7a25SSaravana Kannan fw_ret = -ENODEV; 1442716a7a25SSaravana Kannan } 1443716a7a25SSaravana Kannan 1444716a7a25SSaravana Kannan if (fw_ret == -ENODEV) 14455f5377eaSSaravana Kannan device_link_wait_for_mandatory_supplier(dev); 14465f5377eaSSaravana Kannan else if (fw_ret) 14475f5377eaSSaravana Kannan device_link_wait_for_optional_supplier(dev); 1448716a7a25SSaravana Kannan 1449716a7a25SSaravana Kannan out: 1450716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 14515f5377eaSSaravana Kannan } 14525f5377eaSSaravana Kannan 1453716a7a25SSaravana Kannan /** 1454716a7a25SSaravana Kannan * fw_devlink_pause - Pause parsing of fwnode to create device links 1455716a7a25SSaravana Kannan * 1456716a7a25SSaravana Kannan * Calling this function defers any fwnode parsing to create device links until 1457716a7a25SSaravana Kannan * fw_devlink_resume() is called. Both these functions are ref counted and the 1458716a7a25SSaravana Kannan * caller needs to match the calls. 1459716a7a25SSaravana Kannan * 1460716a7a25SSaravana Kannan * While fw_devlink is paused: 1461716a7a25SSaravana Kannan * - Any device that is added won't have its fwnode parsed to create device 1462716a7a25SSaravana Kannan * links. 1463716a7a25SSaravana Kannan * - The probe of the device will also be deferred during this period. 1464716a7a25SSaravana Kannan * - Any devices that were already added, but waiting for suppliers won't be 1465716a7a25SSaravana Kannan * able to link to newly added devices. 1466716a7a25SSaravana Kannan * 1467716a7a25SSaravana Kannan * Once fw_devlink_resume(): 1468716a7a25SSaravana Kannan * - All the fwnodes that was not parsed will be parsed. 1469716a7a25SSaravana Kannan * - All the devices that were deferred probing will be reattempted if they 1470716a7a25SSaravana Kannan * aren't waiting for any more suppliers. 1471716a7a25SSaravana Kannan * 1472716a7a25SSaravana Kannan * This pair of functions, is mainly meant to optimize the parsing of fwnodes 1473716a7a25SSaravana Kannan * when a lot of devices that need to link to each other are added in a short 1474716a7a25SSaravana Kannan * interval of time. For example, adding all the top level devices in a system. 1475716a7a25SSaravana Kannan * 1476716a7a25SSaravana Kannan * For example, if N devices are added and: 1477716a7a25SSaravana Kannan * - All the consumers are added before their suppliers 1478716a7a25SSaravana Kannan * - All the suppliers of the N devices are part of the N devices 1479716a7a25SSaravana Kannan * 1480716a7a25SSaravana Kannan * Then: 1481716a7a25SSaravana Kannan * 1482716a7a25SSaravana Kannan * - With the use of fw_devlink_pause() and fw_devlink_resume(), each device 1483716a7a25SSaravana Kannan * will only need one parsing of its fwnode because it is guaranteed to find 1484716a7a25SSaravana Kannan * all the supplier devices already registered and ready to link to. It won't 1485716a7a25SSaravana Kannan * have to do another pass later to find one or more suppliers it couldn't 1486716a7a25SSaravana Kannan * find in the first parse of the fwnode. So, we'll only need O(N) fwnode 1487716a7a25SSaravana Kannan * parses. 1488716a7a25SSaravana Kannan * 1489716a7a25SSaravana Kannan * - Without the use of fw_devlink_pause() and fw_devlink_resume(), we would 1490716a7a25SSaravana Kannan * end up doing O(N^2) parses of fwnodes because every device that's added is 1491716a7a25SSaravana Kannan * guaranteed to trigger a parse of the fwnode of every device added before 1492716a7a25SSaravana Kannan * it. This O(N^2) parse is made worse by the fact that when a fwnode of a 1493716a7a25SSaravana Kannan * device is parsed, all it descendant devices might need to have their 1494716a7a25SSaravana Kannan * fwnodes parsed too (even if the devices themselves aren't added). 1495716a7a25SSaravana Kannan */ 1496716a7a25SSaravana Kannan void fw_devlink_pause(void) 1497716a7a25SSaravana Kannan { 1498716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1499716a7a25SSaravana Kannan defer_fw_devlink_count++; 1500716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 1501716a7a25SSaravana Kannan } 1502716a7a25SSaravana Kannan 1503716a7a25SSaravana Kannan /** fw_devlink_resume - Resume parsing of fwnode to create device links 1504716a7a25SSaravana Kannan * 1505716a7a25SSaravana Kannan * This function is used in conjunction with fw_devlink_pause() and is ref 1506716a7a25SSaravana Kannan * counted. See documentation for fw_devlink_pause() for more details. 1507716a7a25SSaravana Kannan */ 1508716a7a25SSaravana Kannan void fw_devlink_resume(void) 1509716a7a25SSaravana Kannan { 1510716a7a25SSaravana Kannan mutex_lock(&defer_fw_devlink_lock); 1511716a7a25SSaravana Kannan if (!defer_fw_devlink_count) { 1512716a7a25SSaravana Kannan WARN(true, "Unmatched fw_devlink pause/resume!"); 1513716a7a25SSaravana Kannan goto out; 1514716a7a25SSaravana Kannan } 1515716a7a25SSaravana Kannan 1516716a7a25SSaravana Kannan defer_fw_devlink_count--; 1517716a7a25SSaravana Kannan if (defer_fw_devlink_count) 1518716a7a25SSaravana Kannan goto out; 1519716a7a25SSaravana Kannan 1520716a7a25SSaravana Kannan device_link_add_missing_supplier_links(); 1521716a7a25SSaravana Kannan driver_deferred_probe_force_trigger(); 1522716a7a25SSaravana Kannan out: 1523716a7a25SSaravana Kannan mutex_unlock(&defer_fw_devlink_lock); 1524716a7a25SSaravana Kannan } 15259ed98953SRafael J. Wysocki /* Device links support end. */ 15269ed98953SRafael J. Wysocki 15271da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 15281da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 1529e105b8bfSDan Williams static struct kobject *dev_kobj; 1530e105b8bfSDan Williams struct kobject *sysfs_dev_char_kobj; 1531e105b8bfSDan Williams struct kobject *sysfs_dev_block_kobj; 15321da177e4SLinus Torvalds 15335e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 15345e33bc41SRafael J. Wysocki 15355e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 15365e33bc41SRafael J. Wysocki { 15375e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 15385e33bc41SRafael J. Wysocki } 15395e33bc41SRafael J. Wysocki 15405e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 15415e33bc41SRafael J. Wysocki { 15425e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 15435e33bc41SRafael J. Wysocki } 15445e33bc41SRafael J. Wysocki 15455e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 15465e33bc41SRafael J. Wysocki { 15475e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 15485e33bc41SRafael J. Wysocki return 0; 15495e33bc41SRafael J. Wysocki 15505e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 15515e33bc41SRafael J. Wysocki msleep(5); 15525e33bc41SRafael J. Wysocki return restart_syscall(); 15535e33bc41SRafael J. Wysocki } 15545e33bc41SRafael J. Wysocki 15554e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 15564e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 15574e886c29SGreg Kroah-Hartman { 15584e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 15594e886c29SGreg Kroah-Hartman } 15604e886c29SGreg Kroah-Hartman #else 15614e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 15624e886c29SGreg Kroah-Hartman { 15634e886c29SGreg Kroah-Hartman return 1; 15644e886c29SGreg Kroah-Hartman } 15654e886c29SGreg Kroah-Hartman #endif 15661da177e4SLinus Torvalds 156707de0e86SHeikki Krogerus static int 156807de0e86SHeikki Krogerus device_platform_notify(struct device *dev, enum kobject_action action) 156907de0e86SHeikki Krogerus { 15707847a145SHeikki Krogerus int ret; 15717847a145SHeikki Krogerus 15727847a145SHeikki Krogerus ret = acpi_platform_notify(dev, action); 15737847a145SHeikki Krogerus if (ret) 15747847a145SHeikki Krogerus return ret; 15757847a145SHeikki Krogerus 157659abd836SHeikki Krogerus ret = software_node_notify(dev, action); 157759abd836SHeikki Krogerus if (ret) 157859abd836SHeikki Krogerus return ret; 157959abd836SHeikki Krogerus 158007de0e86SHeikki Krogerus if (platform_notify && action == KOBJ_ADD) 158107de0e86SHeikki Krogerus platform_notify(dev); 158207de0e86SHeikki Krogerus else if (platform_notify_remove && action == KOBJ_REMOVE) 158307de0e86SHeikki Krogerus platform_notify_remove(dev); 158407de0e86SHeikki Krogerus return 0; 158507de0e86SHeikki Krogerus } 158607de0e86SHeikki Krogerus 15873e95637aSAlan Stern /** 15883e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 15893e95637aSAlan Stern * @dev: struct device to get the name of 15903e95637aSAlan Stern * 15913e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 15929169c012Syan * the device is not bound to a driver, it will return the name of the bus 15933e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 15943e95637aSAlan Stern * string will be returned. 15953e95637aSAlan Stern */ 1596bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 15973e95637aSAlan Stern { 15983589972eSAlan Stern struct device_driver *drv; 15993589972eSAlan Stern 16003589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 16013589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 16023589972eSAlan Stern * never change once they are set, so they don't need special care. 16033589972eSAlan Stern */ 16046aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 16053589972eSAlan Stern return drv ? drv->name : 1606a456b702SJean Delvare (dev->bus ? dev->bus->name : 1607a456b702SJean Delvare (dev->class ? dev->class->name : "")); 16083e95637aSAlan Stern } 1609310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 16103e95637aSAlan Stern 16111da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 16121da177e4SLinus Torvalds 16134a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 16144a3ad20cSGreg Kroah-Hartman char *buf) 16151da177e4SLinus Torvalds { 16161da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1617b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 16184a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 16191da177e4SLinus Torvalds 16201da177e4SLinus Torvalds if (dev_attr->show) 162154b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 1622815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 1623a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 1624a52668c6SSergey Senozhatsky dev_attr->show); 1625815d2d50SAndrew Morton } 16261da177e4SLinus Torvalds return ret; 16271da177e4SLinus Torvalds } 16281da177e4SLinus Torvalds 16294a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 16301da177e4SLinus Torvalds const char *buf, size_t count) 16311da177e4SLinus Torvalds { 16321da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 1633b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 16344a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 16351da177e4SLinus Torvalds 16361da177e4SLinus Torvalds if (dev_attr->store) 163754b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 16381da177e4SLinus Torvalds return ret; 16391da177e4SLinus Torvalds } 16401da177e4SLinus Torvalds 164152cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 16421da177e4SLinus Torvalds .show = dev_attr_show, 16431da177e4SLinus Torvalds .store = dev_attr_store, 16441da177e4SLinus Torvalds }; 16451da177e4SLinus Torvalds 1646ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 1647ca22e56dSKay Sievers 1648ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 1649ca22e56dSKay Sievers struct device_attribute *attr, 1650ca22e56dSKay Sievers const char *buf, size_t size) 1651ca22e56dSKay Sievers { 1652ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1653f88184bfSKaitao cheng int ret; 1654f88184bfSKaitao cheng unsigned long new; 1655f88184bfSKaitao cheng 1656f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 1657f88184bfSKaitao cheng if (ret) 1658f88184bfSKaitao cheng return ret; 1659ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 1660ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1661ca22e56dSKay Sievers return size; 1662ca22e56dSKay Sievers } 1663ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 1664ca22e56dSKay Sievers 1665ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 1666ca22e56dSKay Sievers struct device_attribute *attr, 1667ca22e56dSKay Sievers char *buf) 1668ca22e56dSKay Sievers { 1669ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1670ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var)); 1671ca22e56dSKay Sievers } 1672ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 1673ca22e56dSKay Sievers 1674ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 1675ca22e56dSKay Sievers struct device_attribute *attr, 1676ca22e56dSKay Sievers const char *buf, size_t size) 1677ca22e56dSKay Sievers { 1678ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1679f88184bfSKaitao cheng int ret; 1680f88184bfSKaitao cheng long new; 1681f88184bfSKaitao cheng 1682f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 1683f88184bfSKaitao cheng if (ret) 1684f88184bfSKaitao cheng return ret; 1685f88184bfSKaitao cheng 1686f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 1687ca22e56dSKay Sievers return -EINVAL; 1688ca22e56dSKay Sievers *(int *)(ea->var) = new; 1689ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 1690ca22e56dSKay Sievers return size; 1691ca22e56dSKay Sievers } 1692ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 1693ca22e56dSKay Sievers 1694ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 1695ca22e56dSKay Sievers struct device_attribute *attr, 1696ca22e56dSKay Sievers char *buf) 1697ca22e56dSKay Sievers { 1698ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 1699ca22e56dSKay Sievers 1700ca22e56dSKay Sievers return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var)); 1701ca22e56dSKay Sievers } 1702ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 17031da177e4SLinus Torvalds 170491872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 170591872392SBorislav Petkov const char *buf, size_t size) 170691872392SBorislav Petkov { 170791872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 170891872392SBorislav Petkov 170991872392SBorislav Petkov if (strtobool(buf, ea->var) < 0) 171091872392SBorislav Petkov return -EINVAL; 171191872392SBorislav Petkov 171291872392SBorislav Petkov return size; 171391872392SBorislav Petkov } 171491872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 171591872392SBorislav Petkov 171691872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 171791872392SBorislav Petkov char *buf) 171891872392SBorislav Petkov { 171991872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 172091872392SBorislav Petkov 172191872392SBorislav Petkov return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var)); 172291872392SBorislav Petkov } 172391872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 172491872392SBorislav Petkov 17251da177e4SLinus Torvalds /** 17261da177e4SLinus Torvalds * device_release - free device structure. 17271da177e4SLinus Torvalds * @kobj: device's kobject. 17281da177e4SLinus Torvalds * 17291da177e4SLinus Torvalds * This is called once the reference count for the object 17301da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 17311da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 17321da177e4SLinus Torvalds */ 17331da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 17341da177e4SLinus Torvalds { 1735b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1736fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 17371da177e4SLinus Torvalds 1738a525a3ddSMing Lei /* 1739a525a3ddSMing Lei * Some platform devices are driven without driver attached 1740a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 1741a525a3ddSMing Lei * all resources are released. 1742a525a3ddSMing Lei * 1743a525a3ddSMing Lei * Drivers still can add resources into device after device 1744a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 1745a525a3ddSMing Lei * possible memory leak. 1746a525a3ddSMing Lei */ 1747a525a3ddSMing Lei devres_release_all(dev); 1748a525a3ddSMing Lei 17491da177e4SLinus Torvalds if (dev->release) 17501da177e4SLinus Torvalds dev->release(dev); 1751f9f852dfSKay Sievers else if (dev->type && dev->type->release) 1752f9f852dfSKay Sievers dev->type->release(dev); 17532620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 17542620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 1755f810a5cfSArjan van de Ven else 17560c1bc6b8SMauro Carvalho Chehab WARN(1, KERN_ERR "Device '%s' does not have a release() function, it is broken and must be fixed. See Documentation/core-api/kobject.rst.\n", 17571e0b2cf9SKay Sievers dev_name(dev)); 1758fb069a5dSGreg Kroah-Hartman kfree(p); 17591da177e4SLinus Torvalds } 17601da177e4SLinus Torvalds 1761bc451f20SEric W. Biederman static const void *device_namespace(struct kobject *kobj) 1762bc451f20SEric W. Biederman { 1763b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 1764bc451f20SEric W. Biederman const void *ns = NULL; 1765bc451f20SEric W. Biederman 1766bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 1767bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 1768bc451f20SEric W. Biederman 1769bc451f20SEric W. Biederman return ns; 1770bc451f20SEric W. Biederman } 1771bc451f20SEric W. Biederman 17729944e894SDmitry Torokhov static void device_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid) 17739944e894SDmitry Torokhov { 17749944e894SDmitry Torokhov struct device *dev = kobj_to_dev(kobj); 17759944e894SDmitry Torokhov 17769944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 17779944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 17789944e894SDmitry Torokhov } 17799944e894SDmitry Torokhov 17808f4afc41SGreg Kroah-Hartman static struct kobj_type device_ktype = { 17811da177e4SLinus Torvalds .release = device_release, 17821da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 1783bc451f20SEric W. Biederman .namespace = device_namespace, 17849944e894SDmitry Torokhov .get_ownership = device_get_ownership, 17851da177e4SLinus Torvalds }; 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds 1788312c004dSKay Sievers static int dev_uevent_filter(struct kset *kset, struct kobject *kobj) 17891da177e4SLinus Torvalds { 17901da177e4SLinus Torvalds struct kobj_type *ktype = get_ktype(kobj); 17911da177e4SLinus Torvalds 17928f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 1793b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 17941da177e4SLinus Torvalds if (dev->bus) 17951da177e4SLinus Torvalds return 1; 179623681e47SGreg Kroah-Hartman if (dev->class) 179723681e47SGreg Kroah-Hartman return 1; 17981da177e4SLinus Torvalds } 17991da177e4SLinus Torvalds return 0; 18001da177e4SLinus Torvalds } 18011da177e4SLinus Torvalds 1802312c004dSKay Sievers static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj) 18031da177e4SLinus Torvalds { 1804b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 18051da177e4SLinus Torvalds 180623681e47SGreg Kroah-Hartman if (dev->bus) 18071da177e4SLinus Torvalds return dev->bus->name; 180823681e47SGreg Kroah-Hartman if (dev->class) 180923681e47SGreg Kroah-Hartman return dev->class->name; 181023681e47SGreg Kroah-Hartman return NULL; 18111da177e4SLinus Torvalds } 18121da177e4SLinus Torvalds 18137eff2e7aSKay Sievers static int dev_uevent(struct kset *kset, struct kobject *kobj, 18147eff2e7aSKay Sievers struct kobj_uevent_env *env) 18151da177e4SLinus Torvalds { 1816b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 18171da177e4SLinus Torvalds int retval = 0; 18181da177e4SLinus Torvalds 18196fcf53acSKay Sievers /* add device node properties if present */ 182023681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 18216fcf53acSKay Sievers const char *tmp; 18226fcf53acSKay Sievers const char *name; 18232c9ede55SAl Viro umode_t mode = 0; 18244e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 18254e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 18266fcf53acSKay Sievers 18277eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 18287eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 18293c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 18306fcf53acSKay Sievers if (name) { 18316fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 1832e454cea2SKay Sievers if (mode) 1833e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 18344e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 18354e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 18364e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 18374e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 18383c2670e6SKay Sievers kfree(tmp); 18396fcf53acSKay Sievers } 184023681e47SGreg Kroah-Hartman } 184123681e47SGreg Kroah-Hartman 1842414264f9SKay Sievers if (dev->type && dev->type->name) 18437eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 1844414264f9SKay Sievers 1845239378f1SKay Sievers if (dev->driver) 18467eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 1847239378f1SKay Sievers 184807d57a32SGrant Likely /* Add common DT information about the device */ 184907d57a32SGrant Likely of_device_uevent(dev, env); 185007d57a32SGrant Likely 18511da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 18527eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 18537eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 1854f9f852dfSKay Sievers if (retval) 18557dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 18561e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 18571da177e4SLinus Torvalds } 18581da177e4SLinus Torvalds 18592620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 18607eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 18617eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 1862f9f852dfSKay Sievers if (retval) 18637dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 18641e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 18652b3a302aSHarvey Harrison __func__, retval); 18662620efefSGreg Kroah-Hartman } 1867f9f852dfSKay Sievers 1868eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 18697eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 18707eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 1871f9f852dfSKay Sievers if (retval) 18727dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 18731e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 18742b3a302aSHarvey Harrison __func__, retval); 18752620efefSGreg Kroah-Hartman } 18762620efefSGreg Kroah-Hartman 18771da177e4SLinus Torvalds return retval; 18781da177e4SLinus Torvalds } 18791da177e4SLinus Torvalds 18809cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 1881312c004dSKay Sievers .filter = dev_uevent_filter, 1882312c004dSKay Sievers .name = dev_uevent_name, 1883312c004dSKay Sievers .uevent = dev_uevent, 18841da177e4SLinus Torvalds }; 18851da177e4SLinus Torvalds 1886c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 188716574dccSKay Sievers char *buf) 188816574dccSKay Sievers { 188916574dccSKay Sievers struct kobject *top_kobj; 189016574dccSKay Sievers struct kset *kset; 18917eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 189216574dccSKay Sievers int i; 189316574dccSKay Sievers size_t count = 0; 189416574dccSKay Sievers int retval; 189516574dccSKay Sievers 189616574dccSKay Sievers /* search the kset, the device belongs to */ 189716574dccSKay Sievers top_kobj = &dev->kobj; 18985c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 189916574dccSKay Sievers top_kobj = top_kobj->parent; 190016574dccSKay Sievers if (!top_kobj->kset) 190116574dccSKay Sievers goto out; 19025c5daf65SKay Sievers 190316574dccSKay Sievers kset = top_kobj->kset; 190416574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 190516574dccSKay Sievers goto out; 190616574dccSKay Sievers 190716574dccSKay Sievers /* respect filter */ 190816574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 190916574dccSKay Sievers if (!kset->uevent_ops->filter(kset, &dev->kobj)) 191016574dccSKay Sievers goto out; 191116574dccSKay Sievers 19127eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 19137eff2e7aSKay Sievers if (!env) 1914c7308c81SGreg Kroah-Hartman return -ENOMEM; 1915c7308c81SGreg Kroah-Hartman 191616574dccSKay Sievers /* let the kset specific function add its keys */ 19177eff2e7aSKay Sievers retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); 191816574dccSKay Sievers if (retval) 191916574dccSKay Sievers goto out; 192016574dccSKay Sievers 192116574dccSKay Sievers /* copy keys to file */ 19227eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 19237eff2e7aSKay Sievers count += sprintf(&buf[count], "%s\n", env->envp[i]); 192416574dccSKay Sievers out: 19257eff2e7aSKay Sievers kfree(env); 192616574dccSKay Sievers return count; 192716574dccSKay Sievers } 192816574dccSKay Sievers 1929c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 1930a7fd6706SKay Sievers const char *buf, size_t count) 1931a7fd6706SKay Sievers { 1932df44b479SPeter Rajnoha int rc; 1933df44b479SPeter Rajnoha 1934df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 1935df44b479SPeter Rajnoha 1936df44b479SPeter Rajnoha if (rc) { 1937f36776faSPeter Rajnoha dev_err(dev, "uevent: failed to send synthetic uevent\n"); 1938df44b479SPeter Rajnoha return rc; 1939df44b479SPeter Rajnoha } 194060a96a59SKay Sievers 1941a7fd6706SKay Sievers return count; 1942a7fd6706SKay Sievers } 1943c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 1944a7fd6706SKay Sievers 1945c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 19464f3549d7SRafael J. Wysocki char *buf) 19474f3549d7SRafael J. Wysocki { 19484f3549d7SRafael J. Wysocki bool val; 19494f3549d7SRafael J. Wysocki 19505e33bc41SRafael J. Wysocki device_lock(dev); 19514f3549d7SRafael J. Wysocki val = !dev->offline; 19525e33bc41SRafael J. Wysocki device_unlock(dev); 19534f3549d7SRafael J. Wysocki return sprintf(buf, "%u\n", val); 19544f3549d7SRafael J. Wysocki } 19554f3549d7SRafael J. Wysocki 1956c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 19574f3549d7SRafael J. Wysocki const char *buf, size_t count) 19584f3549d7SRafael J. Wysocki { 19594f3549d7SRafael J. Wysocki bool val; 19604f3549d7SRafael J. Wysocki int ret; 19614f3549d7SRafael J. Wysocki 19624f3549d7SRafael J. Wysocki ret = strtobool(buf, &val); 19634f3549d7SRafael J. Wysocki if (ret < 0) 19644f3549d7SRafael J. Wysocki return ret; 19654f3549d7SRafael J. Wysocki 19665e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 19675e33bc41SRafael J. Wysocki if (ret) 19685e33bc41SRafael J. Wysocki return ret; 19695e33bc41SRafael J. Wysocki 19704f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 19714f3549d7SRafael J. Wysocki unlock_device_hotplug(); 19724f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 19734f3549d7SRafael J. Wysocki } 1974c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 19754f3549d7SRafael J. Wysocki 1976fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 1977621a1672SDmitry Torokhov { 19783e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 1979621a1672SDmitry Torokhov } 1980a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 1981621a1672SDmitry Torokhov 1982fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 1983a4dbd674SDavid Brownell const struct attribute_group **groups) 1984621a1672SDmitry Torokhov { 19853e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 1986621a1672SDmitry Torokhov } 1987a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 1988de0ff00dSGreg Kroah-Hartman 198957b8ff07SDmitry Torokhov union device_attr_group_devres { 199057b8ff07SDmitry Torokhov const struct attribute_group *group; 199157b8ff07SDmitry Torokhov const struct attribute_group **groups; 199257b8ff07SDmitry Torokhov }; 199357b8ff07SDmitry Torokhov 199457b8ff07SDmitry Torokhov static int devm_attr_group_match(struct device *dev, void *res, void *data) 199557b8ff07SDmitry Torokhov { 199657b8ff07SDmitry Torokhov return ((union device_attr_group_devres *)res)->group == data; 199757b8ff07SDmitry Torokhov } 199857b8ff07SDmitry Torokhov 199957b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 200057b8ff07SDmitry Torokhov { 200157b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 200257b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 200357b8ff07SDmitry Torokhov 200457b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 200557b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 200657b8ff07SDmitry Torokhov } 200757b8ff07SDmitry Torokhov 200857b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 200957b8ff07SDmitry Torokhov { 201057b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 201157b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 201257b8ff07SDmitry Torokhov 201357b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 201457b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 201557b8ff07SDmitry Torokhov } 201657b8ff07SDmitry Torokhov 201757b8ff07SDmitry Torokhov /** 201857b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 201957b8ff07SDmitry Torokhov * @dev: The device to create the group for 202057b8ff07SDmitry Torokhov * @grp: The attribute group to create 202157b8ff07SDmitry Torokhov * 202257b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 202357b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 202457b8ff07SDmitry Torokhov * 202557b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 202657b8ff07SDmitry Torokhov */ 202757b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 202857b8ff07SDmitry Torokhov { 202957b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 203057b8ff07SDmitry Torokhov int error; 203157b8ff07SDmitry Torokhov 203257b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 203357b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 203457b8ff07SDmitry Torokhov if (!devres) 203557b8ff07SDmitry Torokhov return -ENOMEM; 203657b8ff07SDmitry Torokhov 203757b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 203857b8ff07SDmitry Torokhov if (error) { 203957b8ff07SDmitry Torokhov devres_free(devres); 204057b8ff07SDmitry Torokhov return error; 204157b8ff07SDmitry Torokhov } 204257b8ff07SDmitry Torokhov 204357b8ff07SDmitry Torokhov devres->group = grp; 204457b8ff07SDmitry Torokhov devres_add(dev, devres); 204557b8ff07SDmitry Torokhov return 0; 204657b8ff07SDmitry Torokhov } 204757b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 204857b8ff07SDmitry Torokhov 204957b8ff07SDmitry Torokhov /** 205057b8ff07SDmitry Torokhov * devm_device_remove_group: remove a managed group from a device 205157b8ff07SDmitry Torokhov * @dev: device to remove the group from 205257b8ff07SDmitry Torokhov * @grp: group to remove 205357b8ff07SDmitry Torokhov * 205457b8ff07SDmitry Torokhov * This function removes a group of attributes from a device. The attributes 205557b8ff07SDmitry Torokhov * previously have to have been created for this group, otherwise it will fail. 205657b8ff07SDmitry Torokhov */ 205757b8ff07SDmitry Torokhov void devm_device_remove_group(struct device *dev, 205857b8ff07SDmitry Torokhov const struct attribute_group *grp) 205957b8ff07SDmitry Torokhov { 206057b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_group_remove, 206157b8ff07SDmitry Torokhov devm_attr_group_match, 206257b8ff07SDmitry Torokhov /* cast away const */ (void *)grp)); 206357b8ff07SDmitry Torokhov } 206457b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_group); 206557b8ff07SDmitry Torokhov 206657b8ff07SDmitry Torokhov /** 206757b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 206857b8ff07SDmitry Torokhov * @dev: The device to create the group for 206957b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 207057b8ff07SDmitry Torokhov * 207157b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 207257b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 207357b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 207457b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 207557b8ff07SDmitry Torokhov * attribute files being created already exist. 207657b8ff07SDmitry Torokhov * 207757b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 207857b8ff07SDmitry Torokhov */ 207957b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 208057b8ff07SDmitry Torokhov const struct attribute_group **groups) 208157b8ff07SDmitry Torokhov { 208257b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 208357b8ff07SDmitry Torokhov int error; 208457b8ff07SDmitry Torokhov 208557b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 208657b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 208757b8ff07SDmitry Torokhov if (!devres) 208857b8ff07SDmitry Torokhov return -ENOMEM; 208957b8ff07SDmitry Torokhov 209057b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 209157b8ff07SDmitry Torokhov if (error) { 209257b8ff07SDmitry Torokhov devres_free(devres); 209357b8ff07SDmitry Torokhov return error; 209457b8ff07SDmitry Torokhov } 209557b8ff07SDmitry Torokhov 209657b8ff07SDmitry Torokhov devres->groups = groups; 209757b8ff07SDmitry Torokhov devres_add(dev, devres); 209857b8ff07SDmitry Torokhov return 0; 209957b8ff07SDmitry Torokhov } 210057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 210157b8ff07SDmitry Torokhov 210257b8ff07SDmitry Torokhov /** 210357b8ff07SDmitry Torokhov * devm_device_remove_groups - remove a list of managed groups 210457b8ff07SDmitry Torokhov * 210557b8ff07SDmitry Torokhov * @dev: The device for the groups to be removed from 210657b8ff07SDmitry Torokhov * @groups: NULL terminated list of groups to be removed 210757b8ff07SDmitry Torokhov * 210857b8ff07SDmitry Torokhov * If groups is not NULL, remove the specified groups from the device. 210957b8ff07SDmitry Torokhov */ 211057b8ff07SDmitry Torokhov void devm_device_remove_groups(struct device *dev, 211157b8ff07SDmitry Torokhov const struct attribute_group **groups) 211257b8ff07SDmitry Torokhov { 211357b8ff07SDmitry Torokhov WARN_ON(devres_release(dev, devm_attr_groups_remove, 211457b8ff07SDmitry Torokhov devm_attr_group_match, 211557b8ff07SDmitry Torokhov /* cast away const */ (void *)groups)); 211657b8ff07SDmitry Torokhov } 211757b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_remove_groups); 21181da177e4SLinus Torvalds 21192620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 21202620efefSGreg Kroah-Hartman { 21212620efefSGreg Kroah-Hartman struct class *class = dev->class; 2122aed65af1SStephen Hemminger const struct device_type *type = dev->type; 2123621a1672SDmitry Torokhov int error; 21242620efefSGreg Kroah-Hartman 2125621a1672SDmitry Torokhov if (class) { 2126d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 21272620efefSGreg Kroah-Hartman if (error) 2128621a1672SDmitry Torokhov return error; 2129f9f852dfSKay Sievers } 2130f9f852dfSKay Sievers 2131621a1672SDmitry Torokhov if (type) { 2132621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 2133f9f852dfSKay Sievers if (error) 2134a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 2135f9f852dfSKay Sievers } 2136621a1672SDmitry Torokhov 2137621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 2138f9f852dfSKay Sievers if (error) 2139621a1672SDmitry Torokhov goto err_remove_type_groups; 2140621a1672SDmitry Torokhov 21414f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 2142c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 21434f3549d7SRafael J. Wysocki if (error) 2144ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 21454f3549d7SRafael J. Wysocki } 21464f3549d7SRafael J. Wysocki 2147621a1672SDmitry Torokhov return 0; 2148621a1672SDmitry Torokhov 2149ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 2150ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 2151621a1672SDmitry Torokhov err_remove_type_groups: 2152621a1672SDmitry Torokhov if (type) 2153621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2154d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 2155d05a6f96SGreg Kroah-Hartman if (class) 2156d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2157f9f852dfSKay Sievers 21582620efefSGreg Kroah-Hartman return error; 21592620efefSGreg Kroah-Hartman } 21602620efefSGreg Kroah-Hartman 21612620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 21622620efefSGreg Kroah-Hartman { 21632620efefSGreg Kroah-Hartman struct class *class = dev->class; 2164aed65af1SStephen Hemminger const struct device_type *type = dev->type; 21652620efefSGreg Kroah-Hartman 2166c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 2167621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 2168f9f852dfSKay Sievers 2169621a1672SDmitry Torokhov if (type) 2170621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2171621a1672SDmitry Torokhov 2172a6b01dedSGreg Kroah-Hartman if (class) 2173d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2174c97415a7SStefan Achatz } 21752620efefSGreg Kroah-Hartman 2176c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 217723681e47SGreg Kroah-Hartman char *buf) 217823681e47SGreg Kroah-Hartman { 217923681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 218023681e47SGreg Kroah-Hartman } 2181c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 2182ad6a1e1cSTejun Heo 2183ca22e56dSKay Sievers /* /sys/devices/ */ 2184881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 21851da177e4SLinus Torvalds 21861da177e4SLinus Torvalds /** 218752cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 218852cdbdd4SGrygorii Strashko * @deva: Device to move. 218952cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 219052cdbdd4SGrygorii Strashko */ 219152cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 219252cdbdd4SGrygorii Strashko { 219352cdbdd4SGrygorii Strashko if (!devices_kset) 219452cdbdd4SGrygorii Strashko return; 219552cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 219652cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 219752cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 219852cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 219952cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 220052cdbdd4SGrygorii Strashko } 220152cdbdd4SGrygorii Strashko 220252cdbdd4SGrygorii Strashko /** 220352cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 220452cdbdd4SGrygorii Strashko * @deva: Device to move 220552cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 220652cdbdd4SGrygorii Strashko */ 220752cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 220852cdbdd4SGrygorii Strashko { 220952cdbdd4SGrygorii Strashko if (!devices_kset) 221052cdbdd4SGrygorii Strashko return; 221152cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 221252cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 221352cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 221452cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 221552cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 221652cdbdd4SGrygorii Strashko } 221752cdbdd4SGrygorii Strashko 221852cdbdd4SGrygorii Strashko /** 221952cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 222052cdbdd4SGrygorii Strashko * @dev: device to move 222152cdbdd4SGrygorii Strashko */ 222252cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 222352cdbdd4SGrygorii Strashko { 222452cdbdd4SGrygorii Strashko if (!devices_kset) 222552cdbdd4SGrygorii Strashko return; 222652cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 222752cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 222852cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 222952cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 223052cdbdd4SGrygorii Strashko } 223152cdbdd4SGrygorii Strashko 223252cdbdd4SGrygorii Strashko /** 22331da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 22341da177e4SLinus Torvalds * @dev: device. 22351da177e4SLinus Torvalds * @attr: device attribute descriptor. 22361da177e4SLinus Torvalds */ 223726579ab7SPhil Carmody int device_create_file(struct device *dev, 223826579ab7SPhil Carmody const struct device_attribute *attr) 22391da177e4SLinus Torvalds { 22401da177e4SLinus Torvalds int error = 0; 22418f46baaaSFelipe Balbi 22428f46baaaSFelipe Balbi if (dev) { 22438f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 224497521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 224597521978Sdyoung@redhat.com attr->attr.name); 22468f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 224797521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 224897521978Sdyoung@redhat.com attr->attr.name); 22491da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 22508f46baaaSFelipe Balbi } 22518f46baaaSFelipe Balbi 22521da177e4SLinus Torvalds return error; 22531da177e4SLinus Torvalds } 225486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 22551da177e4SLinus Torvalds 22561da177e4SLinus Torvalds /** 22571da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 22581da177e4SLinus Torvalds * @dev: device. 22591da177e4SLinus Torvalds * @attr: device attribute descriptor. 22601da177e4SLinus Torvalds */ 226126579ab7SPhil Carmody void device_remove_file(struct device *dev, 226226579ab7SPhil Carmody const struct device_attribute *attr) 22631da177e4SLinus Torvalds { 22640c98b19fSCornelia Huck if (dev) 22651da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 22661da177e4SLinus Torvalds } 226786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 22681da177e4SLinus Torvalds 22692589f188SGreg Kroah-Hartman /** 22706b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 22716b0afc2aSTejun Heo * @dev: device. 22726b0afc2aSTejun Heo * @attr: device attribute descriptor. 22736b0afc2aSTejun Heo * 22746b0afc2aSTejun Heo * See kernfs_remove_self() for details. 22756b0afc2aSTejun Heo */ 22766b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 22776b0afc2aSTejun Heo const struct device_attribute *attr) 22786b0afc2aSTejun Heo { 22796b0afc2aSTejun Heo if (dev) 22806b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 22816b0afc2aSTejun Heo else 22826b0afc2aSTejun Heo return false; 22836b0afc2aSTejun Heo } 22846b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 22856b0afc2aSTejun Heo 22866b0afc2aSTejun Heo /** 22872589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 22882589f188SGreg Kroah-Hartman * @dev: device. 22892589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 22902589f188SGreg Kroah-Hartman */ 229166ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 229266ecb92bSPhil Carmody const struct bin_attribute *attr) 22932589f188SGreg Kroah-Hartman { 22942589f188SGreg Kroah-Hartman int error = -EINVAL; 22952589f188SGreg Kroah-Hartman if (dev) 22962589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 22972589f188SGreg Kroah-Hartman return error; 22982589f188SGreg Kroah-Hartman } 22992589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 23002589f188SGreg Kroah-Hartman 23012589f188SGreg Kroah-Hartman /** 23022589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 23032589f188SGreg Kroah-Hartman * @dev: device. 23042589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 23052589f188SGreg Kroah-Hartman */ 230666ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 230766ecb92bSPhil Carmody const struct bin_attribute *attr) 23082589f188SGreg Kroah-Hartman { 23092589f188SGreg Kroah-Hartman if (dev) 23102589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 23112589f188SGreg Kroah-Hartman } 23122589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 23132589f188SGreg Kroah-Hartman 231434bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 231534bb61f9SJames Bottomley { 2316f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2317f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 231834bb61f9SJames Bottomley 231934bb61f9SJames Bottomley get_device(dev); 232034bb61f9SJames Bottomley } 232134bb61f9SJames Bottomley 232234bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 232334bb61f9SJames Bottomley { 2324f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 2325f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 232634bb61f9SJames Bottomley 232734bb61f9SJames Bottomley put_device(dev); 232834bb61f9SJames Bottomley } 232934bb61f9SJames Bottomley 23301da177e4SLinus Torvalds /** 23311da177e4SLinus Torvalds * device_initialize - init device structure. 23321da177e4SLinus Torvalds * @dev: device. 23331da177e4SLinus Torvalds * 23345739411aSCornelia Huck * This prepares the device for use by other layers by initializing 23355739411aSCornelia Huck * its fields. 23361da177e4SLinus Torvalds * It is the first half of device_register(), if called by 23375739411aSCornelia Huck * that function, though it can also be called separately, so one 23385739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 23395739411aSCornelia Huck * may be used for reference counting of @dev after calling this 23405739411aSCornelia Huck * function. 23415739411aSCornelia Huck * 2342b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 2343b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 2344b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 2345b10d5efdSAlan Stern * @dev. 2346b10d5efdSAlan Stern * 23475739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 23485739411aSCornelia Huck * @dev directly once you have called this function. 23491da177e4SLinus Torvalds */ 23501da177e4SLinus Torvalds void device_initialize(struct device *dev) 23511da177e4SLinus Torvalds { 2352881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 2353f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 23541da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 23553142788bSThomas Gleixner mutex_init(&dev->mutex); 235687a30e1fSDan Williams #ifdef CONFIG_PROVE_LOCKING 235787a30e1fSDan Williams mutex_init(&dev->lockdep_mutex); 235887a30e1fSDan Williams #endif 23591704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 23609ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 23619ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 23623b98aeafSAlan Stern device_pm_init(dev); 236387348136SChristoph Hellwig set_dev_node(dev, -1); 23644a7cc831SJiang Liu #ifdef CONFIG_GENERIC_MSI_IRQ 23654a7cc831SJiang Liu INIT_LIST_HEAD(&dev->msi_list); 23664a7cc831SJiang Liu #endif 23679ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 23689ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 2369e2ae9bccSSaravana Kannan INIT_LIST_HEAD(&dev->links.needs_suppliers); 2370fc5a251dSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 23719ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 23721da177e4SLinus Torvalds } 237386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 23741da177e4SLinus Torvalds 2375d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 2376f0ee61a6SGreg Kroah-Hartman { 2377f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 2378f0ee61a6SGreg Kroah-Hartman 2379f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 23804ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 2381881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 2382f0ee61a6SGreg Kroah-Hartman 238386406245SKay Sievers return virtual_dir; 2384f0ee61a6SGreg Kroah-Hartman } 2385f0ee61a6SGreg Kroah-Hartman 2386bc451f20SEric W. Biederman struct class_dir { 2387bc451f20SEric W. Biederman struct kobject kobj; 2388bc451f20SEric W. Biederman struct class *class; 2389bc451f20SEric W. Biederman }; 2390bc451f20SEric W. Biederman 2391bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 2392bc451f20SEric W. Biederman 2393bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 2394bc451f20SEric W. Biederman { 2395bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2396bc451f20SEric W. Biederman kfree(dir); 2397bc451f20SEric W. Biederman } 2398bc451f20SEric W. Biederman 2399bc451f20SEric W. Biederman static const 2400bc451f20SEric W. Biederman struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj) 2401bc451f20SEric W. Biederman { 2402bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 2403bc451f20SEric W. Biederman return dir->class->ns_type; 2404bc451f20SEric W. Biederman } 2405bc451f20SEric W. Biederman 2406bc451f20SEric W. Biederman static struct kobj_type class_dir_ktype = { 2407bc451f20SEric W. Biederman .release = class_dir_release, 2408bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 2409bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 2410bc451f20SEric W. Biederman }; 2411bc451f20SEric W. Biederman 2412bc451f20SEric W. Biederman static struct kobject * 2413bc451f20SEric W. Biederman class_dir_create_and_add(struct class *class, struct kobject *parent_kobj) 2414bc451f20SEric W. Biederman { 2415bc451f20SEric W. Biederman struct class_dir *dir; 2416bc451f20SEric W. Biederman int retval; 2417bc451f20SEric W. Biederman 2418bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 2419bc451f20SEric W. Biederman if (!dir) 242084d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 2421bc451f20SEric W. Biederman 2422bc451f20SEric W. Biederman dir->class = class; 2423bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 2424bc451f20SEric W. Biederman 24256b6e39a6SKay Sievers dir->kobj.kset = &class->p->glue_dirs; 2426bc451f20SEric W. Biederman 2427bc451f20SEric W. Biederman retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name); 2428bc451f20SEric W. Biederman if (retval < 0) { 2429bc451f20SEric W. Biederman kobject_put(&dir->kobj); 243084d0c27dSTetsuo Handa return ERR_PTR(retval); 2431bc451f20SEric W. Biederman } 2432bc451f20SEric W. Biederman return &dir->kobj; 2433bc451f20SEric W. Biederman } 2434bc451f20SEric W. Biederman 2435e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 2436bc451f20SEric W. Biederman 2437c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 2438c744aeaeSCornelia Huck struct device *parent) 243940fa5422SGreg Kroah-Hartman { 244086406245SKay Sievers if (dev->class) { 244186406245SKay Sievers struct kobject *kobj = NULL; 244286406245SKay Sievers struct kobject *parent_kobj; 244386406245SKay Sievers struct kobject *k; 244486406245SKay Sievers 2445ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 244639aba963SKay Sievers /* block disks show up in /sys/block */ 2447e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) { 244839aba963SKay Sievers if (parent && parent->class == &block_class) 244939aba963SKay Sievers return &parent->kobj; 24506b6e39a6SKay Sievers return &block_class.p->subsys.kobj; 245139aba963SKay Sievers } 2452ead454feSRandy Dunlap #endif 2453e52eec13SAndi Kleen 245486406245SKay Sievers /* 245586406245SKay Sievers * If we have no parent, we live in "virtual". 24560f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 24570f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 245886406245SKay Sievers */ 245986406245SKay Sievers if (parent == NULL) 246086406245SKay Sievers parent_kobj = virtual_device_parent(dev); 246124b1442dSEric W. Biederman else if (parent->class && !dev->class->ns_type) 246286406245SKay Sievers return &parent->kobj; 246386406245SKay Sievers else 246486406245SKay Sievers parent_kobj = &parent->kobj; 246586406245SKay Sievers 246677d3d7c1STejun Heo mutex_lock(&gdp_mutex); 246777d3d7c1STejun Heo 246886406245SKay Sievers /* find our class-directory at the parent and reference it */ 24696b6e39a6SKay Sievers spin_lock(&dev->class->p->glue_dirs.list_lock); 24706b6e39a6SKay Sievers list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry) 247186406245SKay Sievers if (k->parent == parent_kobj) { 247286406245SKay Sievers kobj = kobject_get(k); 247386406245SKay Sievers break; 247486406245SKay Sievers } 24756b6e39a6SKay Sievers spin_unlock(&dev->class->p->glue_dirs.list_lock); 247677d3d7c1STejun Heo if (kobj) { 247777d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 247886406245SKay Sievers return kobj; 247977d3d7c1STejun Heo } 248086406245SKay Sievers 248186406245SKay Sievers /* or create a new class-directory at the parent device */ 2482bc451f20SEric W. Biederman k = class_dir_create_and_add(dev->class, parent_kobj); 24830f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 248477d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 248543968d2fSGreg Kroah-Hartman return k; 248686406245SKay Sievers } 248786406245SKay Sievers 2488ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 2489ca22e56dSKay Sievers if (!parent && dev->bus && dev->bus->dev_root) 2490ca22e56dSKay Sievers return &dev->bus->dev_root->kobj; 2491ca22e56dSKay Sievers 249286406245SKay Sievers if (parent) 2493c744aeaeSCornelia Huck return &parent->kobj; 2494c744aeaeSCornelia Huck return NULL; 2495c744aeaeSCornelia Huck } 2496da231fd5SKay Sievers 2497cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 2498cebf8fd1SMing Lei struct device *dev) 2499cebf8fd1SMing Lei { 2500cebf8fd1SMing Lei if (!kobj || !dev->class || 2501cebf8fd1SMing Lei kobj->kset != &dev->class->p->glue_dirs) 2502cebf8fd1SMing Lei return false; 2503cebf8fd1SMing Lei return true; 2504cebf8fd1SMing Lei } 2505cebf8fd1SMing Lei 2506cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 2507cebf8fd1SMing Lei { 2508cebf8fd1SMing Lei return dev->kobj.parent; 2509cebf8fd1SMing Lei } 2510cebf8fd1SMing Lei 2511cebf8fd1SMing Lei /* 2512cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 2513cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 2514cebf8fd1SMing Lei * global lock 2515cebf8fd1SMing Lei */ 251663b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 2517da231fd5SKay Sievers { 2518ac43432cSMuchun Song unsigned int ref; 2519ac43432cSMuchun Song 25200f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 2521cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 2522da231fd5SKay Sievers return; 2523da231fd5SKay Sievers 2524e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 2525ac43432cSMuchun Song /** 2526ac43432cSMuchun Song * There is a race condition between removing glue directory 2527ac43432cSMuchun Song * and adding a new device under the glue directory. 2528ac43432cSMuchun Song * 2529ac43432cSMuchun Song * CPU1: CPU2: 2530ac43432cSMuchun Song * 2531ac43432cSMuchun Song * device_add() 2532ac43432cSMuchun Song * get_device_parent() 2533ac43432cSMuchun Song * class_dir_create_and_add() 2534ac43432cSMuchun Song * kobject_add_internal() 2535ac43432cSMuchun Song * create_dir() // create glue_dir 2536ac43432cSMuchun Song * 2537ac43432cSMuchun Song * device_add() 2538ac43432cSMuchun Song * get_device_parent() 2539ac43432cSMuchun Song * kobject_get() // get glue_dir 2540ac43432cSMuchun Song * 2541ac43432cSMuchun Song * device_del() 2542ac43432cSMuchun Song * cleanup_glue_dir() 2543ac43432cSMuchun Song * kobject_del(glue_dir) 2544ac43432cSMuchun Song * 2545ac43432cSMuchun Song * kobject_add() 2546ac43432cSMuchun Song * kobject_add_internal() 2547ac43432cSMuchun Song * create_dir() // in glue_dir 2548ac43432cSMuchun Song * sysfs_create_dir_ns() 2549ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 2550ac43432cSMuchun Song * 2551ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 2552ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 2553ac43432cSMuchun Song * 2554ac43432cSMuchun Song * // sd is freed 2555ac43432cSMuchun Song * kernfs_new_node(sd) 2556ac43432cSMuchun Song * kernfs_get(glue_dir) 2557ac43432cSMuchun Song * kernfs_add_one() 2558ac43432cSMuchun Song * kernfs_put() 2559ac43432cSMuchun Song * 2560ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 2561ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 2562ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 2563ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 2564ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 2565ac43432cSMuchun Song * 2566ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 2567ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 2568ac43432cSMuchun Song * 2569ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 2570ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 2571ac43432cSMuchun Song * for glue_dir kobj is 1. 2572ac43432cSMuchun Song */ 2573ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 2574ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 2575726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 25760f4dafc0SKay Sievers kobject_put(glue_dir); 2577e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 2578da231fd5SKay Sievers } 257963b6971aSCornelia Huck 25802ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 25812ee97cafSCornelia Huck { 25825590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 25832ee97cafSCornelia Huck int error; 25842ee97cafSCornelia Huck 25855590f319SBenjamin Herrenschmidt if (of_node) { 25860c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 25875590f319SBenjamin Herrenschmidt if (error) 25885590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 25895590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 25905590f319SBenjamin Herrenschmidt } 25915590f319SBenjamin Herrenschmidt 25922ee97cafSCornelia Huck if (!dev->class) 25932ee97cafSCornelia Huck return 0; 2594da231fd5SKay Sievers 25951fbfee6cSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, 25966b6e39a6SKay Sievers &dev->class->p->subsys.kobj, 25972ee97cafSCornelia Huck "subsystem"); 25982ee97cafSCornelia Huck if (error) 25995590f319SBenjamin Herrenschmidt goto out_devnode; 2600da231fd5SKay Sievers 26014e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 26024f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 26034f01a757SDmitry Torokhov "device"); 26044f01a757SDmitry Torokhov if (error) 260539aba963SKay Sievers goto out_subsys; 26062ee97cafSCornelia Huck } 260739aba963SKay Sievers 2608ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 260939aba963SKay Sievers /* /sys/block has directories and does not need symlinks */ 2610e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 261139aba963SKay Sievers return 0; 2612ead454feSRandy Dunlap #endif 261339aba963SKay Sievers 261439aba963SKay Sievers /* link in the class directory pointing to the device */ 26156b6e39a6SKay Sievers error = sysfs_create_link(&dev->class->p->subsys.kobj, 261639aba963SKay Sievers &dev->kobj, dev_name(dev)); 261739aba963SKay Sievers if (error) 261839aba963SKay Sievers goto out_device; 261939aba963SKay Sievers 26202ee97cafSCornelia Huck return 0; 26212ee97cafSCornelia Huck 262239aba963SKay Sievers out_device: 262339aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 2624da231fd5SKay Sievers 26252ee97cafSCornelia Huck out_subsys: 26262ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 26275590f319SBenjamin Herrenschmidt out_devnode: 26285590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 26292ee97cafSCornelia Huck return error; 26302ee97cafSCornelia Huck } 26312ee97cafSCornelia Huck 26322ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 26332ee97cafSCornelia Huck { 26345590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 26355590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 26365590f319SBenjamin Herrenschmidt 26372ee97cafSCornelia Huck if (!dev->class) 26382ee97cafSCornelia Huck return; 2639da231fd5SKay Sievers 26404e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 2641da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 26422ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 2643ead454feSRandy Dunlap #ifdef CONFIG_BLOCK 2644e52eec13SAndi Kleen if (sysfs_deprecated && dev->class == &block_class) 264539aba963SKay Sievers return; 2646ead454feSRandy Dunlap #endif 26476b6e39a6SKay Sievers sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev)); 26482ee97cafSCornelia Huck } 26492ee97cafSCornelia Huck 26501da177e4SLinus Torvalds /** 2651413c239fSStephen Rothwell * dev_set_name - set a device name 2652413c239fSStephen Rothwell * @dev: device 265346232366SRandy Dunlap * @fmt: format string for the device's name 2654413c239fSStephen Rothwell */ 2655413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 2656413c239fSStephen Rothwell { 2657413c239fSStephen Rothwell va_list vargs; 26581fa5ae85SKay Sievers int err; 2659413c239fSStephen Rothwell 2660413c239fSStephen Rothwell va_start(vargs, fmt); 26611fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 2662413c239fSStephen Rothwell va_end(vargs); 26631fa5ae85SKay Sievers return err; 2664413c239fSStephen Rothwell } 2665413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 2666413c239fSStephen Rothwell 2667413c239fSStephen Rothwell /** 2668e105b8bfSDan Williams * device_to_dev_kobj - select a /sys/dev/ directory for the device 2669e105b8bfSDan Williams * @dev: device 2670e105b8bfSDan Williams * 2671e105b8bfSDan Williams * By default we select char/ for new entries. Setting class->dev_obj 2672e105b8bfSDan Williams * to NULL prevents an entry from being created. class->dev_kobj must 2673e105b8bfSDan Williams * be set (or cleared) before any devices are registered to the class 2674e105b8bfSDan Williams * otherwise device_create_sys_dev_entry() and 26750d4e293cSPeter Korsgaard * device_remove_sys_dev_entry() will disagree about the presence of 26760d4e293cSPeter Korsgaard * the link. 2677e105b8bfSDan Williams */ 2678e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 2679e105b8bfSDan Williams { 2680e105b8bfSDan Williams struct kobject *kobj; 2681e105b8bfSDan Williams 2682e105b8bfSDan Williams if (dev->class) 2683e105b8bfSDan Williams kobj = dev->class->dev_kobj; 2684e105b8bfSDan Williams else 2685e105b8bfSDan Williams kobj = sysfs_dev_char_kobj; 2686e105b8bfSDan Williams 2687e105b8bfSDan Williams return kobj; 2688e105b8bfSDan Williams } 2689e105b8bfSDan Williams 2690e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 2691e105b8bfSDan Williams { 2692e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2693e105b8bfSDan Williams int error = 0; 2694e105b8bfSDan Williams char devt_str[15]; 2695e105b8bfSDan Williams 2696e105b8bfSDan Williams if (kobj) { 2697e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2698e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 2699e105b8bfSDan Williams } 2700e105b8bfSDan Williams 2701e105b8bfSDan Williams return error; 2702e105b8bfSDan Williams } 2703e105b8bfSDan Williams 2704e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 2705e105b8bfSDan Williams { 2706e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 2707e105b8bfSDan Williams char devt_str[15]; 2708e105b8bfSDan Williams 2709e105b8bfSDan Williams if (kobj) { 2710e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 2711e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 2712e105b8bfSDan Williams } 2713e105b8bfSDan Williams } 2714e105b8bfSDan Williams 271546d3a037SShaokun Zhang static int device_private_init(struct device *dev) 2716b4028437SGreg Kroah-Hartman { 2717b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 2718b4028437SGreg Kroah-Hartman if (!dev->p) 2719b4028437SGreg Kroah-Hartman return -ENOMEM; 2720b4028437SGreg Kroah-Hartman dev->p->device = dev; 2721b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 2722b4028437SGreg Kroah-Hartman klist_children_put); 2723ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 2724b4028437SGreg Kroah-Hartman return 0; 2725b4028437SGreg Kroah-Hartman } 2726b4028437SGreg Kroah-Hartman 2727e105b8bfSDan Williams /** 27281da177e4SLinus Torvalds * device_add - add device to device hierarchy. 27291da177e4SLinus Torvalds * @dev: device. 27301da177e4SLinus Torvalds * 27311da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 27321da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 27331da177e4SLinus Torvalds * 27345739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 27351da177e4SLinus Torvalds * to the global and sibling lists for the device, then 27361da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 27375739411aSCornelia Huck * 2738b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 2739b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 2740b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 2741b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 2742b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 2743b10d5efdSAlan Stern * and register a fresh new struct device instead. 2744b10d5efdSAlan Stern * 27455739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 27465739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 27475739411aSCornelia Huck * reference instead. 2748affada72SBorislav Petkov * 2749affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 2750affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 2751affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 2752affada72SBorislav Petkov * count. 27531da177e4SLinus Torvalds */ 27541da177e4SLinus Torvalds int device_add(struct device *dev) 27551da177e4SLinus Torvalds { 275635dbf4efSViresh Kumar struct device *parent; 2757ca22e56dSKay Sievers struct kobject *kobj; 2758c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 27595f5377eaSSaravana Kannan int error = -EINVAL; 2760cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 2761775b64d2SRafael J. Wysocki 27621da177e4SLinus Torvalds dev = get_device(dev); 2763c906a48aSGreg Kroah-Hartman if (!dev) 2764c906a48aSGreg Kroah-Hartman goto done; 2765c906a48aSGreg Kroah-Hartman 2766fb069a5dSGreg Kroah-Hartman if (!dev->p) { 2767b4028437SGreg Kroah-Hartman error = device_private_init(dev); 2768b4028437SGreg Kroah-Hartman if (error) 2769fb069a5dSGreg Kroah-Hartman goto done; 2770fb069a5dSGreg Kroah-Hartman } 2771fb069a5dSGreg Kroah-Hartman 27721fa5ae85SKay Sievers /* 27731fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 27741fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 27751fa5ae85SKay Sievers * the name, and force the use of dev_name() 27761fa5ae85SKay Sievers */ 27771fa5ae85SKay Sievers if (dev->init_name) { 2778acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 27791fa5ae85SKay Sievers dev->init_name = NULL; 27801fa5ae85SKay Sievers } 2781c906a48aSGreg Kroah-Hartman 2782ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 2783ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 2784ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 2785ca22e56dSKay Sievers 2786e6309e75SThomas Gleixner if (!dev_name(dev)) { 2787e6309e75SThomas Gleixner error = -EINVAL; 27885c8563d7SKay Sievers goto name_error; 2789e6309e75SThomas Gleixner } 27901da177e4SLinus Torvalds 27911e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 2792c205ef48SGreg Kroah-Hartman 27931da177e4SLinus Torvalds parent = get_device(dev->parent); 2794ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 279584d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 279684d0c27dSTetsuo Handa error = PTR_ERR(kobj); 279784d0c27dSTetsuo Handa goto parent_error; 279884d0c27dSTetsuo Handa } 2799ca22e56dSKay Sievers if (kobj) 2800ca22e56dSKay Sievers dev->kobj.parent = kobj; 28011da177e4SLinus Torvalds 28020d358f22SYinghai Lu /* use parent numa_node */ 280356f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 28040d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 28050d358f22SYinghai Lu 28061da177e4SLinus Torvalds /* first, register with generic layer. */ 28078a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 28088a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 2809cebf8fd1SMing Lei if (error) { 2810cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 28111da177e4SLinus Torvalds goto Error; 2812cebf8fd1SMing Lei } 2813a7fd6706SKay Sievers 281437022644SBrian Walsh /* notify platform of device entry */ 281507de0e86SHeikki Krogerus error = device_platform_notify(dev, KOBJ_ADD); 281607de0e86SHeikki Krogerus if (error) 281707de0e86SHeikki Krogerus goto platform_error; 281837022644SBrian Walsh 2819c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 2820a306eea4SCornelia Huck if (error) 2821a306eea4SCornelia Huck goto attrError; 2822a7fd6706SKay Sievers 28232ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 28242ee97cafSCornelia Huck if (error) 28252ee97cafSCornelia Huck goto SymlinkError; 2826dc0afa83SCornelia Huck error = device_add_attrs(dev); 2827dc0afa83SCornelia Huck if (error) 28282620efefSGreg Kroah-Hartman goto AttrsError; 2829dc0afa83SCornelia Huck error = bus_add_device(dev); 2830dc0afa83SCornelia Huck if (error) 28311da177e4SLinus Torvalds goto BusError; 28323b98aeafSAlan Stern error = dpm_sysfs_add(dev); 283357eee3d2SRafael J. Wysocki if (error) 28343b98aeafSAlan Stern goto DPMError; 28353b98aeafSAlan Stern device_pm_add(dev); 2836ec0676eeSAlan Stern 28370cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 28380cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 28390cd75047SSergey Klyaus if (error) 28400cd75047SSergey Klyaus goto DevAttrError; 28410cd75047SSergey Klyaus 28420cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 28430cd75047SSergey Klyaus if (error) 28440cd75047SSergey Klyaus goto SysEntryError; 28450cd75047SSergey Klyaus 28460cd75047SSergey Klyaus devtmpfs_create_node(dev); 28470cd75047SSergey Klyaus } 28480cd75047SSergey Klyaus 2849ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 2850268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 2851ec0676eeSAlan Stern */ 2852ec0676eeSAlan Stern if (dev->bus) 2853ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 2854ec0676eeSAlan Stern BUS_NOTIFY_ADD_DEVICE, dev); 2855ec0676eeSAlan Stern 285653877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 2857372a67c0SSaravana Kannan 2858e2ae9bccSSaravana Kannan /* 2859e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 2860e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 2861e2ae9bccSSaravana Kannan * link to it. 2862e2ae9bccSSaravana Kannan * 2863e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 2864e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 2865e2ae9bccSSaravana Kannan * 28662cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure 2867e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 2868e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 2869e2ae9bccSSaravana Kannan */ 28702cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 28712cd38fd1SSaravana Kannan dev->fwnode->dev = dev; 28725f5377eaSSaravana Kannan fw_devlink_link_device(dev); 287303324507SSaravana Kannan } 2874e2ae9bccSSaravana Kannan 28752023c610SAlan Stern bus_probe_device(dev); 28761da177e4SLinus Torvalds if (parent) 2877f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 2878f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 28791da177e4SLinus Torvalds 28805d9fd169SGreg Kroah-Hartman if (dev->class) { 2881ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 2882c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 2883570d0200SWei Yang klist_add_tail(&dev->p->knode_class, 28846b6e39a6SKay Sievers &dev->class->p->klist_devices); 2885c47ed219SGreg Kroah-Hartman 2886c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 2887184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 2888ca22e56dSKay Sievers &dev->class->p->interfaces, node) 2889c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 2890c47ed219SGreg Kroah-Hartman class_intf->add_dev(dev, class_intf); 2891ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 28925d9fd169SGreg Kroah-Hartman } 2893c906a48aSGreg Kroah-Hartman done: 28941da177e4SLinus Torvalds put_device(dev); 28951da177e4SLinus Torvalds return error; 28960cd75047SSergey Klyaus SysEntryError: 28970cd75047SSergey Klyaus if (MAJOR(dev->devt)) 28980cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 28990cd75047SSergey Klyaus DevAttrError: 29000cd75047SSergey Klyaus device_pm_remove(dev); 29010cd75047SSergey Klyaus dpm_sysfs_remove(dev); 29023b98aeafSAlan Stern DPMError: 290357eee3d2SRafael J. Wysocki bus_remove_device(dev); 290457eee3d2SRafael J. Wysocki BusError: 29052620efefSGreg Kroah-Hartman device_remove_attrs(dev); 29062620efefSGreg Kroah-Hartman AttrsError: 29072ee97cafSCornelia Huck device_remove_class_symlinks(dev); 29082ee97cafSCornelia Huck SymlinkError: 2909c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 291023681e47SGreg Kroah-Hartman attrError: 291107de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 291207de0e86SHeikki Krogerus platform_error: 2913312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 2914cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 29151da177e4SLinus Torvalds kobject_del(&dev->kobj); 29161da177e4SLinus Torvalds Error: 2917cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 291884d0c27dSTetsuo Handa parent_error: 29191da177e4SLinus Torvalds put_device(parent); 29205c8563d7SKay Sievers name_error: 29215c8563d7SKay Sievers kfree(dev->p); 29225c8563d7SKay Sievers dev->p = NULL; 2923c906a48aSGreg Kroah-Hartman goto done; 29241da177e4SLinus Torvalds } 292586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 29261da177e4SLinus Torvalds 29271da177e4SLinus Torvalds /** 29281da177e4SLinus Torvalds * device_register - register a device with the system. 29291da177e4SLinus Torvalds * @dev: pointer to the device structure 29301da177e4SLinus Torvalds * 29311da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 29321da177e4SLinus Torvalds * and add it to the system. The two steps can be called 29331da177e4SLinus Torvalds * separately, but this is the easiest and most common. 29341da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 29351da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 29361da177e4SLinus Torvalds * before it is added to the hierarchy. 29375739411aSCornelia Huck * 2938b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 2939b10d5efdSAlan Stern * and device_add(). 2940b10d5efdSAlan Stern * 29415739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 29425739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 29435739411aSCornelia Huck * reference initialized in this function instead. 29441da177e4SLinus Torvalds */ 29451da177e4SLinus Torvalds int device_register(struct device *dev) 29461da177e4SLinus Torvalds { 29471da177e4SLinus Torvalds device_initialize(dev); 29481da177e4SLinus Torvalds return device_add(dev); 29491da177e4SLinus Torvalds } 295086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 29511da177e4SLinus Torvalds 29521da177e4SLinus Torvalds /** 29531da177e4SLinus Torvalds * get_device - increment reference count for device. 29541da177e4SLinus Torvalds * @dev: device. 29551da177e4SLinus Torvalds * 29561da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 29571da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 29581da177e4SLinus Torvalds * pointer passed in. 29591da177e4SLinus Torvalds */ 29601da177e4SLinus Torvalds struct device *get_device(struct device *dev) 29611da177e4SLinus Torvalds { 2962b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 29631da177e4SLinus Torvalds } 296486df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 29651da177e4SLinus Torvalds 29661da177e4SLinus Torvalds /** 29671da177e4SLinus Torvalds * put_device - decrement reference count. 29681da177e4SLinus Torvalds * @dev: device in question. 29691da177e4SLinus Torvalds */ 29701da177e4SLinus Torvalds void put_device(struct device *dev) 29711da177e4SLinus Torvalds { 2972edfaa7c3SKay Sievers /* might_sleep(); */ 29731da177e4SLinus Torvalds if (dev) 29741da177e4SLinus Torvalds kobject_put(&dev->kobj); 29751da177e4SLinus Torvalds } 297686df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 29771da177e4SLinus Torvalds 297800289cd8SDan Williams bool kill_device(struct device *dev) 297900289cd8SDan Williams { 298000289cd8SDan Williams /* 298100289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 298200289cd8SDan Williams * the update behavior is consistent with the other bitfields near 298300289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 298400289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 298500289cd8SDan Williams * underneath the device. 298600289cd8SDan Williams */ 298700289cd8SDan Williams lockdep_assert_held(&dev->mutex); 298800289cd8SDan Williams 298900289cd8SDan Williams if (dev->p->dead) 299000289cd8SDan Williams return false; 299100289cd8SDan Williams dev->p->dead = true; 299200289cd8SDan Williams return true; 299300289cd8SDan Williams } 299400289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 299500289cd8SDan Williams 29961da177e4SLinus Torvalds /** 29971da177e4SLinus Torvalds * device_del - delete device from system. 29981da177e4SLinus Torvalds * @dev: device. 29991da177e4SLinus Torvalds * 30001da177e4SLinus Torvalds * This is the first part of the device unregistration 30011da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 30021da177e4SLinus Torvalds * from here, has it removed from the other driver model 30031da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 30041da177e4SLinus Torvalds * from the kobject hierarchy. 30051da177e4SLinus Torvalds * 30061da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 30071da177e4SLinus Torvalds * also called manually. 30081da177e4SLinus Torvalds */ 30091da177e4SLinus Torvalds void device_del(struct device *dev) 30101da177e4SLinus Torvalds { 30111da177e4SLinus Torvalds struct device *parent = dev->parent; 3012cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3013c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 30141da177e4SLinus Torvalds 30153451a495SAlexander Duyck device_lock(dev); 301600289cd8SDan Williams kill_device(dev); 30173451a495SAlexander Duyck device_unlock(dev); 30183451a495SAlexander Duyck 3019372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 3020372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 3021372a67c0SSaravana Kannan 3022ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 3023ec0676eeSAlan Stern * before dpm_sysfs_remove(). 3024ec0676eeSAlan Stern */ 3025ec0676eeSAlan Stern if (dev->bus) 3026ec0676eeSAlan Stern blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3027ec0676eeSAlan Stern BUS_NOTIFY_DEL_DEVICE, dev); 30289ed98953SRafael J. Wysocki 30293b98aeafSAlan Stern dpm_sysfs_remove(dev); 30301da177e4SLinus Torvalds if (parent) 3031f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 3032e105b8bfSDan Williams if (MAJOR(dev->devt)) { 30332b2af54aSKay Sievers devtmpfs_delete_node(dev); 3034e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 3035c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 3036e105b8bfSDan Williams } 3037b9d9c82bSKay Sievers if (dev->class) { 3038da231fd5SKay Sievers device_remove_class_symlinks(dev); 303999ef3ef8SKay Sievers 3040ca22e56dSKay Sievers mutex_lock(&dev->class->p->mutex); 3041c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 3042184f1f77SGreg Kroah-Hartman list_for_each_entry(class_intf, 3043ca22e56dSKay Sievers &dev->class->p->interfaces, node) 3044c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 3045c47ed219SGreg Kroah-Hartman class_intf->remove_dev(dev, class_intf); 3046c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 3047570d0200SWei Yang klist_del(&dev->p->knode_class); 3048ca22e56dSKay Sievers mutex_unlock(&dev->class->p->mutex); 3049b9d9c82bSKay Sievers } 3050c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 30512620efefSGreg Kroah-Hartman device_remove_attrs(dev); 305228953533SBenjamin Herrenschmidt bus_remove_device(dev); 30534b6d1f12SLongX Zhang device_pm_remove(dev); 3054d1c3414cSGrant Likely driver_deferred_probe_del(dev); 305507de0e86SHeikki Krogerus device_platform_notify(dev, KOBJ_REMOVE); 3056478573c9SLukas Wunner device_remove_properties(dev); 30572ec16150SJeffy Chen device_links_purge(dev); 30581da177e4SLinus Torvalds 3059599bad38SJoerg Roedel if (dev->bus) 3060599bad38SJoerg Roedel blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 3061599bad38SJoerg Roedel BUS_NOTIFY_REMOVED_DEVICE, dev); 3062312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3063cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 30641da177e4SLinus Torvalds kobject_del(&dev->kobj); 3065cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 30661da177e4SLinus Torvalds put_device(parent); 30671da177e4SLinus Torvalds } 306886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 30691da177e4SLinus Torvalds 30701da177e4SLinus Torvalds /** 30711da177e4SLinus Torvalds * device_unregister - unregister device from system. 30721da177e4SLinus Torvalds * @dev: device going away. 30731da177e4SLinus Torvalds * 30741da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 30751da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 30761da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 30771da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 30781da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 30791da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 30801da177e4SLinus Torvalds */ 30811da177e4SLinus Torvalds void device_unregister(struct device *dev) 30821da177e4SLinus Torvalds { 30831e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 30841da177e4SLinus Torvalds device_del(dev); 30851da177e4SLinus Torvalds put_device(dev); 30861da177e4SLinus Torvalds } 308786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 30881da177e4SLinus Torvalds 30893d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 30903d060aebSAndy Shevchenko { 30913d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 30923d060aebSAndy Shevchenko struct device *dev = NULL; 30933d060aebSAndy Shevchenko struct device_private *p; 30943d060aebSAndy Shevchenko 30953d060aebSAndy Shevchenko if (n) { 30963d060aebSAndy Shevchenko p = to_device_private_parent(n); 30973d060aebSAndy Shevchenko dev = p->device; 30983d060aebSAndy Shevchenko } 30993d060aebSAndy Shevchenko return dev; 31003d060aebSAndy Shevchenko } 31013d060aebSAndy Shevchenko 310236239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 310336239577Smochel@digitalimplant.org { 310436239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 3105f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 3106f791b8c8SGreg Kroah-Hartman struct device_private *p; 3107f791b8c8SGreg Kroah-Hartman 3108f791b8c8SGreg Kroah-Hartman if (n) { 3109f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 3110f791b8c8SGreg Kroah-Hartman dev = p->device; 3111f791b8c8SGreg Kroah-Hartman } 3112f791b8c8SGreg Kroah-Hartman return dev; 311336239577Smochel@digitalimplant.org } 311436239577Smochel@digitalimplant.org 31151da177e4SLinus Torvalds /** 3116e454cea2SKay Sievers * device_get_devnode - path of device node file 31176fcf53acSKay Sievers * @dev: device 3118e454cea2SKay Sievers * @mode: returned file access mode 31193c2670e6SKay Sievers * @uid: returned file owner 31203c2670e6SKay Sievers * @gid: returned file group 31216fcf53acSKay Sievers * @tmp: possibly allocated string 31226fcf53acSKay Sievers * 31236fcf53acSKay Sievers * Return the relative path of a possible device node. 31246fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 31256fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 31266fcf53acSKay Sievers * freed by the caller. 31276fcf53acSKay Sievers */ 3128e454cea2SKay Sievers const char *device_get_devnode(struct device *dev, 31294e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 31303c2670e6SKay Sievers const char **tmp) 31316fcf53acSKay Sievers { 31326fcf53acSKay Sievers char *s; 31336fcf53acSKay Sievers 31346fcf53acSKay Sievers *tmp = NULL; 31356fcf53acSKay Sievers 31366fcf53acSKay Sievers /* the device type may provide a specific name */ 3137e454cea2SKay Sievers if (dev->type && dev->type->devnode) 31383c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 31396fcf53acSKay Sievers if (*tmp) 31406fcf53acSKay Sievers return *tmp; 31416fcf53acSKay Sievers 31426fcf53acSKay Sievers /* the class may provide a specific name */ 3143e454cea2SKay Sievers if (dev->class && dev->class->devnode) 3144e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 31456fcf53acSKay Sievers if (*tmp) 31466fcf53acSKay Sievers return *tmp; 31476fcf53acSKay Sievers 31486fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 31496fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 31506fcf53acSKay Sievers return dev_name(dev); 31516fcf53acSKay Sievers 31526fcf53acSKay Sievers /* replace '!' in the name with '/' */ 3153a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 3154a29fd614SRasmus Villemoes if (!s) 31556fcf53acSKay Sievers return NULL; 3156a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 3157a29fd614SRasmus Villemoes return *tmp = s; 31586fcf53acSKay Sievers } 31596fcf53acSKay Sievers 31606fcf53acSKay Sievers /** 31611da177e4SLinus Torvalds * device_for_each_child - device child iterator. 3162c41455fbSRandy Dunlap * @parent: parent struct device. 31631da177e4SLinus Torvalds * @fn: function to be called for each device. 3164f8878dcbSRobert P. J. Day * @data: data for the callback. 31651da177e4SLinus Torvalds * 3166c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 31671da177e4SLinus Torvalds * passing it @data. 31681da177e4SLinus Torvalds * 31691da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 31701da177e4SLinus Torvalds * other than 0, we break out and return that value. 31711da177e4SLinus Torvalds */ 317236239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 31734a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 31741da177e4SLinus Torvalds { 317536239577Smochel@digitalimplant.org struct klist_iter i; 31761da177e4SLinus Torvalds struct device *child; 31771da177e4SLinus Torvalds int error = 0; 31781da177e4SLinus Torvalds 3179014c90dbSGreg Kroah-Hartman if (!parent->p) 3180014c90dbSGreg Kroah-Hartman return 0; 3181014c90dbSGreg Kroah-Hartman 3182f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 318393ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 318436239577Smochel@digitalimplant.org error = fn(child, data); 318536239577Smochel@digitalimplant.org klist_iter_exit(&i); 31861da177e4SLinus Torvalds return error; 31871da177e4SLinus Torvalds } 318886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 31891da177e4SLinus Torvalds 31905ab69981SCornelia Huck /** 31913d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 31923d060aebSAndy Shevchenko * @parent: parent struct device. 31933d060aebSAndy Shevchenko * @fn: function to be called for each device. 31943d060aebSAndy Shevchenko * @data: data for the callback. 31953d060aebSAndy Shevchenko * 31963d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 31973d060aebSAndy Shevchenko * passing it @data. 31983d060aebSAndy Shevchenko * 31993d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 32003d060aebSAndy Shevchenko * other than 0, we break out and return that value. 32013d060aebSAndy Shevchenko */ 32023d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 32033d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 32043d060aebSAndy Shevchenko { 32053d060aebSAndy Shevchenko struct klist_iter i; 32063d060aebSAndy Shevchenko struct device *child; 32073d060aebSAndy Shevchenko int error = 0; 32083d060aebSAndy Shevchenko 32093d060aebSAndy Shevchenko if (!parent->p) 32103d060aebSAndy Shevchenko return 0; 32113d060aebSAndy Shevchenko 32123d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 32133d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 32143d060aebSAndy Shevchenko error = fn(child, data); 32153d060aebSAndy Shevchenko klist_iter_exit(&i); 32163d060aebSAndy Shevchenko return error; 32173d060aebSAndy Shevchenko } 32183d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 32193d060aebSAndy Shevchenko 32203d060aebSAndy Shevchenko /** 32215ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 32225ab69981SCornelia Huck * @parent: parent struct device 32235ab69981SCornelia Huck * @match: Callback function to check device 3224f8878dcbSRobert P. J. Day * @data: Data to pass to match function 32255ab69981SCornelia Huck * 32265ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 32275ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 32285ab69981SCornelia Huck * determined by the @match callback. 32295ab69981SCornelia Huck * 32305ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 32315ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 32325ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 32335ab69981SCornelia Huck * and not iterate over any more devices. 3234a4e2400aSFederico Vaga * 3235a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 32365ab69981SCornelia Huck */ 32375ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 32384a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 32395ab69981SCornelia Huck { 32405ab69981SCornelia Huck struct klist_iter i; 32415ab69981SCornelia Huck struct device *child; 32425ab69981SCornelia Huck 32435ab69981SCornelia Huck if (!parent) 32445ab69981SCornelia Huck return NULL; 32455ab69981SCornelia Huck 3246f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 32475ab69981SCornelia Huck while ((child = next_device(&i))) 32485ab69981SCornelia Huck if (match(child, data) && get_device(child)) 32495ab69981SCornelia Huck break; 32505ab69981SCornelia Huck klist_iter_exit(&i); 32515ab69981SCornelia Huck return child; 32525ab69981SCornelia Huck } 325386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 32545ab69981SCornelia Huck 3255dad9bb01SHeikki Krogerus /** 3256dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 3257dad9bb01SHeikki Krogerus * @parent: parent struct device 3258dad9bb01SHeikki Krogerus * @name: name of the child device 3259dad9bb01SHeikki Krogerus * 3260dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 3261dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 3262dad9bb01SHeikki Krogerus * 3263dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 3264dad9bb01SHeikki Krogerus */ 3265dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 3266dad9bb01SHeikki Krogerus const char *name) 3267dad9bb01SHeikki Krogerus { 3268dad9bb01SHeikki Krogerus struct klist_iter i; 3269dad9bb01SHeikki Krogerus struct device *child; 3270dad9bb01SHeikki Krogerus 3271dad9bb01SHeikki Krogerus if (!parent) 3272dad9bb01SHeikki Krogerus return NULL; 3273dad9bb01SHeikki Krogerus 3274dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 3275dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 3276dad9bb01SHeikki Krogerus if (!strcmp(dev_name(child), name) && get_device(child)) 3277dad9bb01SHeikki Krogerus break; 3278dad9bb01SHeikki Krogerus klist_iter_exit(&i); 3279dad9bb01SHeikki Krogerus return child; 3280dad9bb01SHeikki Krogerus } 3281dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 3282dad9bb01SHeikki Krogerus 32831da177e4SLinus Torvalds int __init devices_init(void) 32841da177e4SLinus Torvalds { 3285881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 3286881c6cfdSGreg Kroah-Hartman if (!devices_kset) 3287881c6cfdSGreg Kroah-Hartman return -ENOMEM; 3288e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 3289e105b8bfSDan Williams if (!dev_kobj) 3290e105b8bfSDan Williams goto dev_kobj_err; 3291e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 3292e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 3293e105b8bfSDan Williams goto block_kobj_err; 3294e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 3295e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 3296e105b8bfSDan Williams goto char_kobj_err; 3297e105b8bfSDan Williams 3298881c6cfdSGreg Kroah-Hartman return 0; 3299e105b8bfSDan Williams 3300e105b8bfSDan Williams char_kobj_err: 3301e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 3302e105b8bfSDan Williams block_kobj_err: 3303e105b8bfSDan Williams kobject_put(dev_kobj); 3304e105b8bfSDan Williams dev_kobj_err: 3305e105b8bfSDan Williams kset_unregister(devices_kset); 3306e105b8bfSDan Williams return -ENOMEM; 33071da177e4SLinus Torvalds } 33081da177e4SLinus Torvalds 33094f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 33104f3549d7SRafael J. Wysocki { 33114f3549d7SRafael J. Wysocki int ret; 33124f3549d7SRafael J. Wysocki 33134f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 33144f3549d7SRafael J. Wysocki if (ret) 33154f3549d7SRafael J. Wysocki return ret; 33164f3549d7SRafael J. Wysocki 33174f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 33184f3549d7SRafael J. Wysocki } 33194f3549d7SRafael J. Wysocki 33204f3549d7SRafael J. Wysocki /** 33214f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 33224f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 33234f3549d7SRafael J. Wysocki * 33244f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 33254f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 33264f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 33274f3549d7SRafael J. Wysocki * is executed. 33284f3549d7SRafael J. Wysocki * 33294f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 33304f3549d7SRafael J. Wysocki */ 33314f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 33324f3549d7SRafael J. Wysocki { 33334f3549d7SRafael J. Wysocki int ret; 33344f3549d7SRafael J. Wysocki 33354f3549d7SRafael J. Wysocki if (dev->offline_disabled) 33364f3549d7SRafael J. Wysocki return -EPERM; 33374f3549d7SRafael J. Wysocki 33384f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 33394f3549d7SRafael J. Wysocki if (ret) 33404f3549d7SRafael J. Wysocki return ret; 33414f3549d7SRafael J. Wysocki 33424f3549d7SRafael J. Wysocki device_lock(dev); 33434f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 33444f3549d7SRafael J. Wysocki if (dev->offline) { 33454f3549d7SRafael J. Wysocki ret = 1; 33464f3549d7SRafael J. Wysocki } else { 33474f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 33484f3549d7SRafael J. Wysocki if (!ret) { 33494f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 33504f3549d7SRafael J. Wysocki dev->offline = true; 33514f3549d7SRafael J. Wysocki } 33524f3549d7SRafael J. Wysocki } 33534f3549d7SRafael J. Wysocki } 33544f3549d7SRafael J. Wysocki device_unlock(dev); 33554f3549d7SRafael J. Wysocki 33564f3549d7SRafael J. Wysocki return ret; 33574f3549d7SRafael J. Wysocki } 33584f3549d7SRafael J. Wysocki 33594f3549d7SRafael J. Wysocki /** 33604f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 33614f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 33624f3549d7SRafael J. Wysocki * 33634f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 33644f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 33654f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 33664f3549d7SRafael J. Wysocki * 33674f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 33684f3549d7SRafael J. Wysocki */ 33694f3549d7SRafael J. Wysocki int device_online(struct device *dev) 33704f3549d7SRafael J. Wysocki { 33714f3549d7SRafael J. Wysocki int ret = 0; 33724f3549d7SRafael J. Wysocki 33734f3549d7SRafael J. Wysocki device_lock(dev); 33744f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 33754f3549d7SRafael J. Wysocki if (dev->offline) { 33764f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 33774f3549d7SRafael J. Wysocki if (!ret) { 33784f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 33794f3549d7SRafael J. Wysocki dev->offline = false; 33804f3549d7SRafael J. Wysocki } 33814f3549d7SRafael J. Wysocki } else { 33824f3549d7SRafael J. Wysocki ret = 1; 33834f3549d7SRafael J. Wysocki } 33844f3549d7SRafael J. Wysocki } 33854f3549d7SRafael J. Wysocki device_unlock(dev); 33864f3549d7SRafael J. Wysocki 33874f3549d7SRafael J. Wysocki return ret; 33884f3549d7SRafael J. Wysocki } 33894f3549d7SRafael J. Wysocki 33907f100d15SKarthigan Srinivasan struct root_device { 33910aa0dc41SMark McLoughlin struct device dev; 33920aa0dc41SMark McLoughlin struct module *owner; 33930aa0dc41SMark McLoughlin }; 33940aa0dc41SMark McLoughlin 339593058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 3396481e2079SFerenc Wagner { 3397481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 3398481e2079SFerenc Wagner } 33990aa0dc41SMark McLoughlin 34000aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 34010aa0dc41SMark McLoughlin { 34020aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 34030aa0dc41SMark McLoughlin } 34040aa0dc41SMark McLoughlin 34050aa0dc41SMark McLoughlin /** 34060aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 34070aa0dc41SMark McLoughlin * @name: root device name 34080aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 34090aa0dc41SMark McLoughlin * 34100aa0dc41SMark McLoughlin * This function allocates a root device and registers it 34110aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 34120aa0dc41SMark McLoughlin * device, use root_device_unregister(). 34130aa0dc41SMark McLoughlin * 34140aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 34150aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 34160aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 34170aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 34180aa0dc41SMark McLoughlin * 34190aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 34200aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 34210aa0dc41SMark McLoughlin * in sysfs. 34220aa0dc41SMark McLoughlin * 3423f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3424f0eae0edSJani Nikula * 34250aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 34260aa0dc41SMark McLoughlin */ 34270aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 34280aa0dc41SMark McLoughlin { 34290aa0dc41SMark McLoughlin struct root_device *root; 34300aa0dc41SMark McLoughlin int err = -ENOMEM; 34310aa0dc41SMark McLoughlin 34320aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 34330aa0dc41SMark McLoughlin if (!root) 34340aa0dc41SMark McLoughlin return ERR_PTR(err); 34350aa0dc41SMark McLoughlin 3436acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 34370aa0dc41SMark McLoughlin if (err) { 34380aa0dc41SMark McLoughlin kfree(root); 34390aa0dc41SMark McLoughlin return ERR_PTR(err); 34400aa0dc41SMark McLoughlin } 34410aa0dc41SMark McLoughlin 34420aa0dc41SMark McLoughlin root->dev.release = root_device_release; 34430aa0dc41SMark McLoughlin 34440aa0dc41SMark McLoughlin err = device_register(&root->dev); 34450aa0dc41SMark McLoughlin if (err) { 34460aa0dc41SMark McLoughlin put_device(&root->dev); 34470aa0dc41SMark McLoughlin return ERR_PTR(err); 34480aa0dc41SMark McLoughlin } 34490aa0dc41SMark McLoughlin 34501d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 34510aa0dc41SMark McLoughlin if (owner) { 34520aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 34530aa0dc41SMark McLoughlin 34540aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 34550aa0dc41SMark McLoughlin if (err) { 34560aa0dc41SMark McLoughlin device_unregister(&root->dev); 34570aa0dc41SMark McLoughlin return ERR_PTR(err); 34580aa0dc41SMark McLoughlin } 34590aa0dc41SMark McLoughlin root->owner = owner; 34600aa0dc41SMark McLoughlin } 34610aa0dc41SMark McLoughlin #endif 34620aa0dc41SMark McLoughlin 34630aa0dc41SMark McLoughlin return &root->dev; 34640aa0dc41SMark McLoughlin } 34650aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 34660aa0dc41SMark McLoughlin 34670aa0dc41SMark McLoughlin /** 34680aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 34697cbcf225SRandy Dunlap * @dev: device going away 34700aa0dc41SMark McLoughlin * 34710aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 34720aa0dc41SMark McLoughlin * root_device_register(). 34730aa0dc41SMark McLoughlin */ 34740aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 34750aa0dc41SMark McLoughlin { 34760aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 34770aa0dc41SMark McLoughlin 34780aa0dc41SMark McLoughlin if (root->owner) 34790aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 34800aa0dc41SMark McLoughlin 34810aa0dc41SMark McLoughlin device_unregister(dev); 34820aa0dc41SMark McLoughlin } 34830aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 34840aa0dc41SMark McLoughlin 348523681e47SGreg Kroah-Hartman 348623681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 348723681e47SGreg Kroah-Hartman { 34881e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 348923681e47SGreg Kroah-Hartman kfree(dev); 349023681e47SGreg Kroah-Hartman } 349123681e47SGreg Kroah-Hartman 34926a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 349339ef3112SGuenter Roeck device_create_groups_vargs(struct class *class, struct device *parent, 349439ef3112SGuenter Roeck dev_t devt, void *drvdata, 349539ef3112SGuenter Roeck const struct attribute_group **groups, 349639ef3112SGuenter Roeck const char *fmt, va_list args) 349739ef3112SGuenter Roeck { 349839ef3112SGuenter Roeck struct device *dev = NULL; 349939ef3112SGuenter Roeck int retval = -ENODEV; 350039ef3112SGuenter Roeck 350139ef3112SGuenter Roeck if (class == NULL || IS_ERR(class)) 350239ef3112SGuenter Roeck goto error; 350339ef3112SGuenter Roeck 350439ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 350539ef3112SGuenter Roeck if (!dev) { 350639ef3112SGuenter Roeck retval = -ENOMEM; 350739ef3112SGuenter Roeck goto error; 350839ef3112SGuenter Roeck } 350939ef3112SGuenter Roeck 3510bbc780f8SDavid Herrmann device_initialize(dev); 351139ef3112SGuenter Roeck dev->devt = devt; 351239ef3112SGuenter Roeck dev->class = class; 351339ef3112SGuenter Roeck dev->parent = parent; 351439ef3112SGuenter Roeck dev->groups = groups; 351539ef3112SGuenter Roeck dev->release = device_create_release; 351639ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 351739ef3112SGuenter Roeck 351839ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 351939ef3112SGuenter Roeck if (retval) 352039ef3112SGuenter Roeck goto error; 352139ef3112SGuenter Roeck 3522bbc780f8SDavid Herrmann retval = device_add(dev); 352339ef3112SGuenter Roeck if (retval) 352439ef3112SGuenter Roeck goto error; 352539ef3112SGuenter Roeck 352639ef3112SGuenter Roeck return dev; 352739ef3112SGuenter Roeck 352839ef3112SGuenter Roeck error: 352939ef3112SGuenter Roeck put_device(dev); 353039ef3112SGuenter Roeck return ERR_PTR(retval); 353139ef3112SGuenter Roeck } 353239ef3112SGuenter Roeck 353323681e47SGreg Kroah-Hartman /** 35344e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 35358882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 35368882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 35378882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 35388882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 35398882b394SGreg Kroah-Hartman * @fmt: string for the device's name 35408882b394SGreg Kroah-Hartman * 35418882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 35428882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 35438882b394SGreg Kroah-Hartman * 35448882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 35458882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 35468882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 35478882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 35488882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 35498882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 35508882b394SGreg Kroah-Hartman * pointer. 35518882b394SGreg Kroah-Hartman * 3552f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 3553f0eae0edSJani Nikula * 35548882b394SGreg Kroah-Hartman * Note: the struct class passed to this function must have previously 35558882b394SGreg Kroah-Hartman * been created with a call to class_create(). 35568882b394SGreg Kroah-Hartman */ 35574e106739SGreg Kroah-Hartman struct device *device_create(struct class *class, struct device *parent, 35584e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 35598882b394SGreg Kroah-Hartman { 35608882b394SGreg Kroah-Hartman va_list vargs; 35618882b394SGreg Kroah-Hartman struct device *dev; 35628882b394SGreg Kroah-Hartman 35638882b394SGreg Kroah-Hartman va_start(vargs, fmt); 35644c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL, 35654c747466SChristoph Hellwig fmt, vargs); 35668882b394SGreg Kroah-Hartman va_end(vargs); 35678882b394SGreg Kroah-Hartman return dev; 35688882b394SGreg Kroah-Hartman } 35694e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 35708882b394SGreg Kroah-Hartman 357139ef3112SGuenter Roeck /** 357239ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 357339ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 357439ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 357539ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 357639ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 357739ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 357839ef3112SGuenter Roeck * @fmt: string for the device's name 357939ef3112SGuenter Roeck * 358039ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 358139ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 358239ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 358339ef3112SGuenter Roeck * be created automatically. 358439ef3112SGuenter Roeck * 358539ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 358639ef3112SGuenter Roeck * the dev_t is not 0,0. 358739ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 358839ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 358939ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 359039ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 359139ef3112SGuenter Roeck * pointer. 359239ef3112SGuenter Roeck * 359339ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 359439ef3112SGuenter Roeck * 359539ef3112SGuenter Roeck * Note: the struct class passed to this function must have previously 359639ef3112SGuenter Roeck * been created with a call to class_create(). 359739ef3112SGuenter Roeck */ 359839ef3112SGuenter Roeck struct device *device_create_with_groups(struct class *class, 359939ef3112SGuenter Roeck struct device *parent, dev_t devt, 360039ef3112SGuenter Roeck void *drvdata, 360139ef3112SGuenter Roeck const struct attribute_group **groups, 360239ef3112SGuenter Roeck const char *fmt, ...) 360339ef3112SGuenter Roeck { 360439ef3112SGuenter Roeck va_list vargs; 360539ef3112SGuenter Roeck struct device *dev; 360639ef3112SGuenter Roeck 360739ef3112SGuenter Roeck va_start(vargs, fmt); 360839ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 360939ef3112SGuenter Roeck fmt, vargs); 361039ef3112SGuenter Roeck va_end(vargs); 361139ef3112SGuenter Roeck return dev; 361239ef3112SGuenter Roeck } 361339ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 361439ef3112SGuenter Roeck 3615775b64d2SRafael J. Wysocki /** 3616775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 3617775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 3618775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 3619775b64d2SRafael J. Wysocki * 3620775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 3621775b64d2SRafael J. Wysocki * call to device_create(). 3622775b64d2SRafael J. Wysocki */ 3623775b64d2SRafael J. Wysocki void device_destroy(struct class *class, dev_t devt) 3624775b64d2SRafael J. Wysocki { 3625775b64d2SRafael J. Wysocki struct device *dev; 3626775b64d2SRafael J. Wysocki 36274495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 3628cd35449bSDave Young if (dev) { 3629cd35449bSDave Young put_device(dev); 363023681e47SGreg Kroah-Hartman device_unregister(dev); 363123681e47SGreg Kroah-Hartman } 3632cd35449bSDave Young } 363323681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 3634a2de48caSGreg Kroah-Hartman 3635a2de48caSGreg Kroah-Hartman /** 3636a2de48caSGreg Kroah-Hartman * device_rename - renames a device 3637a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 3638a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 3639030c1d2bSEric W. Biederman * 3640030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 3641030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 3642030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 3643030c1d2bSEric W. Biederman * won't conflict with other devices. 3644c6c0ac66SMichael Ellerman * 3645a5462516STimur Tabi * Note: Don't call this function. Currently, the networking layer calls this 3646a5462516STimur Tabi * function, but that will change. The following text from Kay Sievers offers 3647a5462516STimur Tabi * some insight: 3648a5462516STimur Tabi * 3649a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 3650a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 3651a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 3652a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 3653a5462516STimur Tabi * 3654a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 3655a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 3656a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 3657a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 3658a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 3659a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 3660a5462516STimur Tabi * 3661a5462516STimur Tabi * We are currently about to change network renaming in udev to completely 3662a5462516STimur Tabi * disallow renaming of devices in the same namespace as the kernel uses, 3663a5462516STimur Tabi * because we can't solve the problems properly, that arise with swapping names 3664a5462516STimur Tabi * of multiple interfaces without races. Means, renaming of eth[0-9]* will only 3665a5462516STimur Tabi * be allowed to some other name than eth[0-9]*, for the aforementioned 3666a5462516STimur Tabi * reasons. 3667a5462516STimur Tabi * 3668a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 3669a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 3670a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 3671a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 3672a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 3673a2de48caSGreg Kroah-Hartman */ 36746937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 3675a2de48caSGreg Kroah-Hartman { 36764b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 36772ee97cafSCornelia Huck char *old_device_name = NULL; 3678a2de48caSGreg Kroah-Hartman int error; 3679a2de48caSGreg Kroah-Hartman 3680a2de48caSGreg Kroah-Hartman dev = get_device(dev); 3681a2de48caSGreg Kroah-Hartman if (!dev) 3682a2de48caSGreg Kroah-Hartman return -EINVAL; 3683a2de48caSGreg Kroah-Hartman 368469df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 3685a2de48caSGreg Kroah-Hartman 36861fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 36872ee97cafSCornelia Huck if (!old_device_name) { 3688952ab431SJesper Juhl error = -ENOMEM; 36892ee97cafSCornelia Huck goto out; 3690952ab431SJesper Juhl } 3691a2de48caSGreg Kroah-Hartman 3692f349cf34SEric W. Biederman if (dev->class) { 36934b30ee58STejun Heo error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj, 36944b30ee58STejun Heo kobj, old_device_name, 36954b30ee58STejun Heo new_name, kobject_namespace(kobj)); 3696f349cf34SEric W. Biederman if (error) 3697f349cf34SEric W. Biederman goto out; 3698f349cf34SEric W. Biederman } 369939aba963SKay Sievers 37004b30ee58STejun Heo error = kobject_rename(kobj, new_name); 37011fa5ae85SKay Sievers if (error) 37022ee97cafSCornelia Huck goto out; 3703a2de48caSGreg Kroah-Hartman 37042ee97cafSCornelia Huck out: 3705a2de48caSGreg Kroah-Hartman put_device(dev); 3706a2de48caSGreg Kroah-Hartman 37072ee97cafSCornelia Huck kfree(old_device_name); 3708a2de48caSGreg Kroah-Hartman 3709a2de48caSGreg Kroah-Hartman return error; 3710a2de48caSGreg Kroah-Hartman } 3711a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 37128a82472fSCornelia Huck 37138a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 37148a82472fSCornelia Huck struct device *old_parent, 37158a82472fSCornelia Huck struct device *new_parent) 37168a82472fSCornelia Huck { 3717f7f3461dSGreg Kroah-Hartman int error = 0; 37188a82472fSCornelia Huck 3719f7f3461dSGreg Kroah-Hartman if (old_parent) 3720f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 3721f7f3461dSGreg Kroah-Hartman if (new_parent) 3722f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 3723f7f3461dSGreg Kroah-Hartman "device"); 3724f7f3461dSGreg Kroah-Hartman return error; 37258a82472fSCornelia Huck } 37268a82472fSCornelia Huck 37278a82472fSCornelia Huck /** 37288a82472fSCornelia Huck * device_move - moves a device to a new parent 37298a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 373013509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 3731ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 37328a82472fSCornelia Huck */ 3733ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 3734ffa6a705SCornelia Huck enum dpm_order dpm_order) 37358a82472fSCornelia Huck { 37368a82472fSCornelia Huck int error; 37378a82472fSCornelia Huck struct device *old_parent; 3738c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 37398a82472fSCornelia Huck 37408a82472fSCornelia Huck dev = get_device(dev); 37418a82472fSCornelia Huck if (!dev) 37428a82472fSCornelia Huck return -EINVAL; 37438a82472fSCornelia Huck 3744ffa6a705SCornelia Huck device_pm_lock(); 37458a82472fSCornelia Huck new_parent = get_device(new_parent); 3746c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 374784d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 374884d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 374984d0c27dSTetsuo Handa put_device(new_parent); 375084d0c27dSTetsuo Handa goto out; 375184d0c27dSTetsuo Handa } 375263b6971aSCornelia Huck 37531e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 37541e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 3755c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 37568a82472fSCornelia Huck if (error) { 375763b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 37588a82472fSCornelia Huck put_device(new_parent); 37598a82472fSCornelia Huck goto out; 37608a82472fSCornelia Huck } 37618a82472fSCornelia Huck old_parent = dev->parent; 37628a82472fSCornelia Huck dev->parent = new_parent; 37638a82472fSCornelia Huck if (old_parent) 3764f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 37650d358f22SYinghai Lu if (new_parent) { 3766f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3767f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 37680d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 37690d358f22SYinghai Lu } 37700d358f22SYinghai Lu 3771bdd4034dSRabin Vincent if (dev->class) { 37728a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 37738a82472fSCornelia Huck if (error) { 37748a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 37758a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 37768a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 3777c744aeaeSCornelia Huck if (new_parent) 3778f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 37790d358f22SYinghai Lu dev->parent = old_parent; 37800d358f22SYinghai Lu if (old_parent) { 3781f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3782f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 37830d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 37840d358f22SYinghai Lu } 37858a82472fSCornelia Huck } 378663b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 37878a82472fSCornelia Huck put_device(new_parent); 37888a82472fSCornelia Huck goto out; 37898a82472fSCornelia Huck } 3790bdd4034dSRabin Vincent } 3791ffa6a705SCornelia Huck switch (dpm_order) { 3792ffa6a705SCornelia Huck case DPM_ORDER_NONE: 3793ffa6a705SCornelia Huck break; 3794ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 3795ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 379652cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 3797ffa6a705SCornelia Huck break; 3798ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 3799ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 380052cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 3801ffa6a705SCornelia Huck break; 3802ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 3803ffa6a705SCornelia Huck device_pm_move_last(dev); 380452cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 3805ffa6a705SCornelia Huck break; 3806ffa6a705SCornelia Huck } 3807bdd4034dSRabin Vincent 38088a82472fSCornelia Huck put_device(old_parent); 38098a82472fSCornelia Huck out: 3810ffa6a705SCornelia Huck device_pm_unlock(); 38118a82472fSCornelia Huck put_device(dev); 38128a82472fSCornelia Huck return error; 38138a82472fSCornelia Huck } 38148a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 381537b0c020SGreg Kroah-Hartman 3816b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 3817b8f33e5dSChristian Brauner kgid_t kgid) 3818b8f33e5dSChristian Brauner { 3819b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3820b8f33e5dSChristian Brauner struct class *class = dev->class; 3821b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 3822b8f33e5dSChristian Brauner int error; 3823b8f33e5dSChristian Brauner 3824b8f33e5dSChristian Brauner if (class) { 3825b8f33e5dSChristian Brauner /* 3826b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 3827b8f33e5dSChristian Brauner * @kuid/@kgid. 3828b8f33e5dSChristian Brauner */ 3829b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 3830b8f33e5dSChristian Brauner kgid); 3831b8f33e5dSChristian Brauner if (error) 3832b8f33e5dSChristian Brauner return error; 3833b8f33e5dSChristian Brauner } 3834b8f33e5dSChristian Brauner 3835b8f33e5dSChristian Brauner if (type) { 3836b8f33e5dSChristian Brauner /* 3837b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 3838b8f33e5dSChristian Brauner * @kuid/@kgid. 3839b8f33e5dSChristian Brauner */ 3840b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 3841b8f33e5dSChristian Brauner kgid); 3842b8f33e5dSChristian Brauner if (error) 3843b8f33e5dSChristian Brauner return error; 3844b8f33e5dSChristian Brauner } 3845b8f33e5dSChristian Brauner 3846b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 3847b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 3848b8f33e5dSChristian Brauner if (error) 3849b8f33e5dSChristian Brauner return error; 3850b8f33e5dSChristian Brauner 3851b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 3852b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 3853b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 3854b8f33e5dSChristian Brauner kuid, kgid); 3855b8f33e5dSChristian Brauner if (error) 3856b8f33e5dSChristian Brauner return error; 3857b8f33e5dSChristian Brauner } 3858b8f33e5dSChristian Brauner 3859b8f33e5dSChristian Brauner return 0; 3860b8f33e5dSChristian Brauner } 3861b8f33e5dSChristian Brauner 3862b8f33e5dSChristian Brauner /** 3863b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 3864b8f33e5dSChristian Brauner * @dev: device. 3865b8f33e5dSChristian Brauner * @kuid: new owner's kuid 3866b8f33e5dSChristian Brauner * @kgid: new owner's kgid 3867b8f33e5dSChristian Brauner * 3868b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 3869b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 3870b8f33e5dSChristian Brauner * core. 3871b8f33e5dSChristian Brauner * 3872b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 3873b8f33e5dSChristian Brauner */ 3874b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 3875b8f33e5dSChristian Brauner { 3876b8f33e5dSChristian Brauner int error; 3877b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 3878b8f33e5dSChristian Brauner 3879b8f33e5dSChristian Brauner dev = get_device(dev); 3880b8f33e5dSChristian Brauner if (!dev) 3881b8f33e5dSChristian Brauner return -EINVAL; 3882b8f33e5dSChristian Brauner 3883b8f33e5dSChristian Brauner /* 3884b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 3885b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 3886b8f33e5dSChristian Brauner */ 3887b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 3888b8f33e5dSChristian Brauner if (error) 3889b8f33e5dSChristian Brauner goto out; 3890b8f33e5dSChristian Brauner 3891b8f33e5dSChristian Brauner /* 3892b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 3893b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 3894b8f33e5dSChristian Brauner * that step here. 3895b8f33e5dSChristian Brauner */ 3896b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 3897b8f33e5dSChristian Brauner kgid); 3898b8f33e5dSChristian Brauner if (error) 3899b8f33e5dSChristian Brauner goto out; 3900b8f33e5dSChristian Brauner 3901b8f33e5dSChristian Brauner /* 3902b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 3903b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 3904b8f33e5dSChristian Brauner * to @kuid/@kgid. 3905b8f33e5dSChristian Brauner */ 3906b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 3907b8f33e5dSChristian Brauner if (error) 3908b8f33e5dSChristian Brauner goto out; 3909b8f33e5dSChristian Brauner 39103b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 39113b52fc5dSChristian Brauner if (error) 39123b52fc5dSChristian Brauner goto out; 39133b52fc5dSChristian Brauner 3914b8f33e5dSChristian Brauner #ifdef CONFIG_BLOCK 3915b8f33e5dSChristian Brauner if (sysfs_deprecated && dev->class == &block_class) 3916b8f33e5dSChristian Brauner goto out; 3917b8f33e5dSChristian Brauner #endif 3918b8f33e5dSChristian Brauner 3919b8f33e5dSChristian Brauner /* 3920b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 3921b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 3922b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 3923b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 3924b8f33e5dSChristian Brauner */ 3925b8f33e5dSChristian Brauner error = sysfs_link_change_owner(&dev->class->p->subsys.kobj, &dev->kobj, 3926b8f33e5dSChristian Brauner dev_name(dev), kuid, kgid); 3927b8f33e5dSChristian Brauner if (error) 3928b8f33e5dSChristian Brauner goto out; 3929b8f33e5dSChristian Brauner 3930b8f33e5dSChristian Brauner out: 3931b8f33e5dSChristian Brauner put_device(dev); 3932b8f33e5dSChristian Brauner return error; 3933b8f33e5dSChristian Brauner } 3934b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 3935b8f33e5dSChristian Brauner 393637b0c020SGreg Kroah-Hartman /** 393737b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 393837b0c020SGreg Kroah-Hartman */ 393937b0c020SGreg Kroah-Hartman void device_shutdown(void) 394037b0c020SGreg Kroah-Hartman { 3941f123db8eSBenson Leung struct device *dev, *parent; 394237b0c020SGreg Kroah-Hartman 39433297c8fcSPingfan Liu wait_for_device_probe(); 39443297c8fcSPingfan Liu device_block_probing(); 39453297c8fcSPingfan Liu 394665650b35SRafael J. Wysocki cpufreq_suspend(); 394765650b35SRafael J. Wysocki 39486245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 39496245838fSHugh Daschbach /* 39506245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 39516245838fSHugh Daschbach * Beware that device unplug events may also start pulling 39526245838fSHugh Daschbach * devices offline, even as the system is shutting down. 39536245838fSHugh Daschbach */ 39546245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 39556245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 39566245838fSHugh Daschbach kobj.entry); 3957d1c6c030SMing Lei 3958d1c6c030SMing Lei /* 3959d1c6c030SMing Lei * hold reference count of device's parent to 3960d1c6c030SMing Lei * prevent it from being freed because parent's 3961d1c6c030SMing Lei * lock is to be held 3962d1c6c030SMing Lei */ 3963f123db8eSBenson Leung parent = get_device(dev->parent); 39646245838fSHugh Daschbach get_device(dev); 39656245838fSHugh Daschbach /* 39666245838fSHugh Daschbach * Make sure the device is off the kset list, in the 39676245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 39686245838fSHugh Daschbach */ 39696245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 39706245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 3971fe6b91f4SAlan Stern 3972d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 3973f123db8eSBenson Leung if (parent) 3974f123db8eSBenson Leung device_lock(parent); 3975d1c6c030SMing Lei device_lock(dev); 3976d1c6c030SMing Lei 3977fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 3978fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 3979fe6b91f4SAlan Stern pm_runtime_barrier(dev); 39806245838fSHugh Daschbach 39817521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 3982f77af151SJosh Zimmerman if (initcall_debug) 39837521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 39847521621eSMichal Suchanek dev->class->shutdown_pre(dev); 39857521621eSMichal Suchanek } 39867521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 39870246c4faSShuoX Liu if (initcall_debug) 39880246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 398937b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 399037b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 39910246c4faSShuoX Liu if (initcall_debug) 39920246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 399337b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 399437b0c020SGreg Kroah-Hartman } 3995d1c6c030SMing Lei 3996d1c6c030SMing Lei device_unlock(dev); 3997f123db8eSBenson Leung if (parent) 3998f123db8eSBenson Leung device_unlock(parent); 3999d1c6c030SMing Lei 40006245838fSHugh Daschbach put_device(dev); 4001f123db8eSBenson Leung put_device(parent); 40026245838fSHugh Daschbach 40036245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 400437b0c020SGreg Kroah-Hartman } 40056245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 400637b0c020SGreg Kroah-Hartman } 400799bcf217SJoe Perches 400899bcf217SJoe Perches /* 400999bcf217SJoe Perches * Device logging functions 401099bcf217SJoe Perches */ 401199bcf217SJoe Perches 401299bcf217SJoe Perches #ifdef CONFIG_PRINTK 4013666f355fSJoe Perches static int 4014666f355fSJoe Perches create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen) 401599bcf217SJoe Perches { 4016c4e00daaSKay Sievers const char *subsys; 4017798efc60SJoe Perches size_t pos = 0; 401899bcf217SJoe Perches 4019c4e00daaSKay Sievers if (dev->class) 4020c4e00daaSKay Sievers subsys = dev->class->name; 4021c4e00daaSKay Sievers else if (dev->bus) 4022c4e00daaSKay Sievers subsys = dev->bus->name; 4023c4e00daaSKay Sievers else 4024798efc60SJoe Perches return 0; 4025c4e00daaSKay Sievers 4026798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys); 4027655e5b7cSBen Hutchings if (pos >= hdrlen) 4028655e5b7cSBen Hutchings goto overflow; 4029c4e00daaSKay Sievers 4030c4e00daaSKay Sievers /* 4031c4e00daaSKay Sievers * Add device identifier DEVICE=: 4032c4e00daaSKay Sievers * b12:8 block dev_t 4033c4e00daaSKay Sievers * c127:3 char dev_t 4034c4e00daaSKay Sievers * n8 netdev ifindex 4035c4e00daaSKay Sievers * +sound:card0 subsystem:devname 4036c4e00daaSKay Sievers */ 4037c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 4038c4e00daaSKay Sievers char c; 4039c4e00daaSKay Sievers 4040c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 4041c4e00daaSKay Sievers c = 'b'; 4042c4e00daaSKay Sievers else 4043c4e00daaSKay Sievers c = 'c'; 4044798efc60SJoe Perches pos++; 4045798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 4046c4e00daaSKay Sievers "DEVICE=%c%u:%u", 4047c4e00daaSKay Sievers c, MAJOR(dev->devt), MINOR(dev->devt)); 4048c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 4049c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 4050c4e00daaSKay Sievers 4051798efc60SJoe Perches pos++; 4052798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 4053c4e00daaSKay Sievers "DEVICE=n%u", net->ifindex); 4054c4e00daaSKay Sievers } else { 4055798efc60SJoe Perches pos++; 4056798efc60SJoe Perches pos += snprintf(hdr + pos, hdrlen - pos, 4057c4e00daaSKay Sievers "DEVICE=+%s:%s", subsys, dev_name(dev)); 4058c4e00daaSKay Sievers } 4059af7f2158SJim Cromie 4060655e5b7cSBen Hutchings if (pos >= hdrlen) 4061655e5b7cSBen Hutchings goto overflow; 4062655e5b7cSBen Hutchings 4063798efc60SJoe Perches return pos; 4064655e5b7cSBen Hutchings 4065655e5b7cSBen Hutchings overflow: 4066655e5b7cSBen Hutchings dev_WARN(dev, "device/subsystem name too long"); 4067655e5b7cSBen Hutchings return 0; 406899bcf217SJoe Perches } 4069798efc60SJoe Perches 407005e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 407105e4e5b8SJoe Perches const char *fmt, va_list args) 407205e4e5b8SJoe Perches { 407305e4e5b8SJoe Perches char hdr[128]; 407405e4e5b8SJoe Perches size_t hdrlen; 407505e4e5b8SJoe Perches 407605e4e5b8SJoe Perches hdrlen = create_syslog_header(dev, hdr, sizeof(hdr)); 407705e4e5b8SJoe Perches 407805e4e5b8SJoe Perches return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args); 407905e4e5b8SJoe Perches } 408005e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 408105e4e5b8SJoe Perches 408205e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 408305e4e5b8SJoe Perches { 408405e4e5b8SJoe Perches va_list args; 408505e4e5b8SJoe Perches int r; 408605e4e5b8SJoe Perches 408705e4e5b8SJoe Perches va_start(args, fmt); 408805e4e5b8SJoe Perches 408905e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 409005e4e5b8SJoe Perches 409105e4e5b8SJoe Perches va_end(args); 409205e4e5b8SJoe Perches 409305e4e5b8SJoe Perches return r; 409405e4e5b8SJoe Perches } 409505e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 409605e4e5b8SJoe Perches 4097d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 4098798efc60SJoe Perches struct va_format *vaf) 4099798efc60SJoe Perches { 4100d1f1052cSJoe Perches if (dev) 4101d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 4102798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 4103d1f1052cSJoe Perches else 4104d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 4105798efc60SJoe Perches } 410699bcf217SJoe Perches 4107d1f1052cSJoe Perches void dev_printk(const char *level, const struct device *dev, 410899bcf217SJoe Perches const char *fmt, ...) 410999bcf217SJoe Perches { 411099bcf217SJoe Perches struct va_format vaf; 411199bcf217SJoe Perches va_list args; 411299bcf217SJoe Perches 411399bcf217SJoe Perches va_start(args, fmt); 411499bcf217SJoe Perches 411599bcf217SJoe Perches vaf.fmt = fmt; 411699bcf217SJoe Perches vaf.va = &args; 411799bcf217SJoe Perches 4118d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 4119798efc60SJoe Perches 412099bcf217SJoe Perches va_end(args); 412199bcf217SJoe Perches } 412299bcf217SJoe Perches EXPORT_SYMBOL(dev_printk); 412399bcf217SJoe Perches 412499bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 4125d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 412699bcf217SJoe Perches { \ 412799bcf217SJoe Perches struct va_format vaf; \ 412899bcf217SJoe Perches va_list args; \ 412999bcf217SJoe Perches \ 413099bcf217SJoe Perches va_start(args, fmt); \ 413199bcf217SJoe Perches \ 413299bcf217SJoe Perches vaf.fmt = fmt; \ 413399bcf217SJoe Perches vaf.va = &args; \ 413499bcf217SJoe Perches \ 4135d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 4136798efc60SJoe Perches \ 413799bcf217SJoe Perches va_end(args); \ 413899bcf217SJoe Perches } \ 413999bcf217SJoe Perches EXPORT_SYMBOL(func); 414099bcf217SJoe Perches 4141663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 4142663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 4143663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 4144663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 4145663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 4146663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 414799bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 414899bcf217SJoe Perches 414999bcf217SJoe Perches #endif 415097badf87SRafael J. Wysocki 415197badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 415297badf87SRafael J. Wysocki { 415397badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 415497badf87SRafael J. Wysocki } 415597badf87SRafael J. Wysocki 415697badf87SRafael J. Wysocki /** 415797badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 415897badf87SRafael J. Wysocki * @dev: Device to handle. 415997badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 416097badf87SRafael J. Wysocki * 416197badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 416297badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 416397badf87SRafael J. Wysocki */ 416497badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 416597badf87SRafael J. Wysocki { 416697badf87SRafael J. Wysocki if (fwnode) { 416797badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 416897badf87SRafael J. Wysocki 416997badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 417097badf87SRafael J. Wysocki fn = fn->secondary; 417197badf87SRafael J. Wysocki 417255f89a8aSMika Westerberg if (fn) { 417355f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 417497badf87SRafael J. Wysocki fwnode->secondary = fn; 417555f89a8aSMika Westerberg } 417697badf87SRafael J. Wysocki dev->fwnode = fwnode; 417797badf87SRafael J. Wysocki } else { 417897badf87SRafael J. Wysocki dev->fwnode = fwnode_is_primary(dev->fwnode) ? 417997badf87SRafael J. Wysocki dev->fwnode->secondary : NULL; 418097badf87SRafael J. Wysocki } 418197badf87SRafael J. Wysocki } 418297badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 418397badf87SRafael J. Wysocki 418497badf87SRafael J. Wysocki /** 418597badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 418697badf87SRafael J. Wysocki * @dev: Device to handle. 418797badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 418897badf87SRafael J. Wysocki * 418997badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 419097badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 419197badf87SRafael J. Wysocki * @fwnode. 419297badf87SRafael J. Wysocki */ 419397badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 419497badf87SRafael J. Wysocki { 419597badf87SRafael J. Wysocki if (fwnode) 419697badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 419797badf87SRafael J. Wysocki 419897badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 419997badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 420097badf87SRafael J. Wysocki else 420197badf87SRafael J. Wysocki dev->fwnode = fwnode; 420297badf87SRafael J. Wysocki } 420396489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 42044e75e1d7SJohan Hovold 42054e75e1d7SJohan Hovold /** 42064e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 42074e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 42084e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 42094e75e1d7SJohan Hovold * 42104e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 42114e75e1d7SJohan Hovold * any reference held to the old node. 42124e75e1d7SJohan Hovold */ 42134e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 42144e75e1d7SJohan Hovold { 42154e75e1d7SJohan Hovold of_node_put(dev->of_node); 42164e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 42174e75e1d7SJohan Hovold dev->of_node_reused = true; 42184e75e1d7SJohan Hovold } 42194e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 422065b66682SSuzuki K Poulose 42216cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 42226cda08a2SSuzuki K Poulose { 42236cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 42246cda08a2SSuzuki K Poulose } 42256cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 42266cda08a2SSuzuki K Poulose 422765b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 422865b66682SSuzuki K Poulose { 422965b66682SSuzuki K Poulose return dev->of_node == np; 423065b66682SSuzuki K Poulose } 423165b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 423267843bbaSSuzuki K Poulose 423367843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 423467843bbaSSuzuki K Poulose { 423567843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 423667843bbaSSuzuki K Poulose } 423767843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 42384495dfddSSuzuki K Poulose 42394495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 42404495dfddSSuzuki K Poulose { 42414495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 42424495dfddSSuzuki K Poulose } 42434495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 424400500147SSuzuki K Poulose 424500500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 424600500147SSuzuki K Poulose { 424700500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 424800500147SSuzuki K Poulose } 424900500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 42506bf85ba9SSuzuki K Poulose 42516bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 42526bf85ba9SSuzuki K Poulose { 42536bf85ba9SSuzuki K Poulose return 1; 42546bf85ba9SSuzuki K Poulose } 42556bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 4256