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> 1773060022SChristophe JAILLET #include <linux/kstrtox.h> 181da177e4SLinus Torvalds #include <linux/module.h> 191da177e4SLinus Torvalds #include <linux/slab.h> 201da177e4SLinus Torvalds #include <linux/string.h> 2123681e47SGreg Kroah-Hartman #include <linux/kdev_t.h> 22116af378SBenjamin Herrenschmidt #include <linux/notifier.h> 2307d57a32SGrant Likely #include <linux/of.h> 2407d57a32SGrant Likely #include <linux/of_device.h> 25322cbb50SChristoph Hellwig #include <linux/blkdev.h> 26f75b1c60SDave Young #include <linux/mutex.h> 27af8db150SPeter Chen #include <linux/pm_runtime.h> 28c4e00daaSKay Sievers #include <linux/netdevice.h> 29174cd4b1SIngo Molnar #include <linux/sched/signal.h> 30b8530017SOliver Neukum #include <linux/sched/mm.h> 3169031f50SClaire Chang #include <linux/swiotlb.h> 3263967685SGreg Kroah-Hartman #include <linux/sysfs.h> 336d4e9a8eSChristoph Hellwig #include <linux/dma-map-ops.h> /* for dma_default_coherent */ 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include "base.h" 366423d295SWon Chung #include "physical_location.h" 371da177e4SLinus Torvalds #include "power/power.h" 381da177e4SLinus Torvalds 399ed98953SRafael J. Wysocki /* Device links support. */ 40fc5a251dSSaravana Kannan static LIST_HEAD(deferred_sync); 41fc5a251dSSaravana Kannan static unsigned int defer_sync_state_count = 1; 427b337cb3SSaravana Kannan static DEFINE_MUTEX(fwnode_link_lock); 4325ac86c6SSaravana Kannan static bool fw_devlink_is_permissive(void); 443a2dbc51SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev); 45d46f3e3eSSaravana Kannan static bool fw_devlink_drv_reg_done; 462f8c3ae8SSaravana Kannan static bool fw_devlink_best_effort; 477b337cb3SSaravana Kannan 487b337cb3SSaravana Kannan /** 493a2dbc51SSaravana Kannan * __fwnode_link_add - Create a link between two fwnode_handles. 507b337cb3SSaravana Kannan * @con: Consumer end of the link. 517b337cb3SSaravana Kannan * @sup: Supplier end of the link. 527b337cb3SSaravana Kannan * 537b337cb3SSaravana Kannan * Create a fwnode link between fwnode handles @con and @sup. The fwnode link 547b337cb3SSaravana Kannan * represents the detail that the firmware lists @sup fwnode as supplying a 557b337cb3SSaravana Kannan * resource to @con. 567b337cb3SSaravana Kannan * 577b337cb3SSaravana Kannan * The driver core will use the fwnode link to create a device link between the 587b337cb3SSaravana Kannan * two device objects corresponding to @con and @sup when they are created. The 597b337cb3SSaravana Kannan * driver core will automatically delete the fwnode link between @con and @sup 607b337cb3SSaravana Kannan * after doing that. 617b337cb3SSaravana Kannan * 627b337cb3SSaravana Kannan * Attempts to create duplicate links between the same pair of fwnode handles 637b337cb3SSaravana Kannan * are ignored and there is no reference counting. 647b337cb3SSaravana Kannan */ 653a2dbc51SSaravana Kannan static int __fwnode_link_add(struct fwnode_handle *con, 666a6dfdf8SSaravana Kannan struct fwnode_handle *sup, u8 flags) 677b337cb3SSaravana Kannan { 687b337cb3SSaravana Kannan struct fwnode_link *link; 697b337cb3SSaravana Kannan 707b337cb3SSaravana Kannan list_for_each_entry(link, &sup->consumers, s_hook) 716a6dfdf8SSaravana Kannan if (link->consumer == con) { 726a6dfdf8SSaravana Kannan link->flags |= flags; 733a2dbc51SSaravana Kannan return 0; 746a6dfdf8SSaravana Kannan } 757b337cb3SSaravana Kannan 767b337cb3SSaravana Kannan link = kzalloc(sizeof(*link), GFP_KERNEL); 773a2dbc51SSaravana Kannan if (!link) 783a2dbc51SSaravana Kannan return -ENOMEM; 797b337cb3SSaravana Kannan 807b337cb3SSaravana Kannan link->supplier = sup; 817b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->s_hook); 827b337cb3SSaravana Kannan link->consumer = con; 837b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->c_hook); 846a6dfdf8SSaravana Kannan link->flags = flags; 857b337cb3SSaravana Kannan 867b337cb3SSaravana Kannan list_add(&link->s_hook, &sup->consumers); 877b337cb3SSaravana Kannan list_add(&link->c_hook, &con->suppliers); 880c058fb9SSaravana Kannan pr_debug("%pfwf Linked as a fwnode consumer to %pfwf\n", 89ebd6823aSSaravana Kannan con, sup); 907b337cb3SSaravana Kannan 913a2dbc51SSaravana Kannan return 0; 923a2dbc51SSaravana Kannan } 933a2dbc51SSaravana Kannan 943a2dbc51SSaravana Kannan int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup) 953a2dbc51SSaravana Kannan { 963a2dbc51SSaravana Kannan int ret; 973a2dbc51SSaravana Kannan 983a2dbc51SSaravana Kannan mutex_lock(&fwnode_link_lock); 996a6dfdf8SSaravana Kannan ret = __fwnode_link_add(con, sup, 0); 1003a2dbc51SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1017b337cb3SSaravana Kannan return ret; 1027b337cb3SSaravana Kannan } 1037b337cb3SSaravana Kannan 1047b337cb3SSaravana Kannan /** 10576f13081SSaravana Kannan * __fwnode_link_del - Delete a link between two fwnode_handles. 10676f13081SSaravana Kannan * @link: the fwnode_link to be deleted 10776f13081SSaravana Kannan * 10876f13081SSaravana Kannan * The fwnode_link_lock needs to be held when this function is called. 10976f13081SSaravana Kannan */ 11076f13081SSaravana Kannan static void __fwnode_link_del(struct fwnode_link *link) 11176f13081SSaravana Kannan { 1120c058fb9SSaravana Kannan pr_debug("%pfwf Dropping the fwnode link to %pfwf\n", 113ebd6823aSSaravana Kannan link->consumer, link->supplier); 11476f13081SSaravana Kannan list_del(&link->s_hook); 11576f13081SSaravana Kannan list_del(&link->c_hook); 11676f13081SSaravana Kannan kfree(link); 11776f13081SSaravana Kannan } 11876f13081SSaravana Kannan 11976f13081SSaravana Kannan /** 1206a6dfdf8SSaravana Kannan * __fwnode_link_cycle - Mark a fwnode link as being part of a cycle. 1216a6dfdf8SSaravana Kannan * @link: the fwnode_link to be marked 1226a6dfdf8SSaravana Kannan * 1236a6dfdf8SSaravana Kannan * The fwnode_link_lock needs to be held when this function is called. 1246a6dfdf8SSaravana Kannan */ 1256a6dfdf8SSaravana Kannan static void __fwnode_link_cycle(struct fwnode_link *link) 1266a6dfdf8SSaravana Kannan { 1276a6dfdf8SSaravana Kannan pr_debug("%pfwf: Relaxing link with %pfwf\n", 1286a6dfdf8SSaravana Kannan link->consumer, link->supplier); 1296a6dfdf8SSaravana Kannan link->flags |= FWLINK_FLAG_CYCLE; 1306a6dfdf8SSaravana Kannan } 1316a6dfdf8SSaravana Kannan 1326a6dfdf8SSaravana Kannan /** 1337b337cb3SSaravana Kannan * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle. 1347b337cb3SSaravana Kannan * @fwnode: fwnode whose supplier links need to be deleted 1357b337cb3SSaravana Kannan * 1367b337cb3SSaravana Kannan * Deletes all supplier links connecting directly to @fwnode. 1377b337cb3SSaravana Kannan */ 1387b337cb3SSaravana Kannan static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode) 1397b337cb3SSaravana Kannan { 1407b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1417b337cb3SSaravana Kannan 1427b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 14376f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) 14476f13081SSaravana Kannan __fwnode_link_del(link); 1457b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1467b337cb3SSaravana Kannan } 1477b337cb3SSaravana Kannan 1487b337cb3SSaravana Kannan /** 1497b337cb3SSaravana Kannan * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle. 1507b337cb3SSaravana Kannan * @fwnode: fwnode whose consumer links need to be deleted 1517b337cb3SSaravana Kannan * 1527b337cb3SSaravana Kannan * Deletes all consumer links connecting directly to @fwnode. 1537b337cb3SSaravana Kannan */ 1547b337cb3SSaravana Kannan static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode) 1557b337cb3SSaravana Kannan { 1567b337cb3SSaravana Kannan struct fwnode_link *link, *tmp; 1577b337cb3SSaravana Kannan 1587b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock); 15976f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) 16076f13081SSaravana Kannan __fwnode_link_del(link); 1617b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1627b337cb3SSaravana Kannan } 1637b337cb3SSaravana Kannan 1647b337cb3SSaravana Kannan /** 1657b337cb3SSaravana Kannan * fwnode_links_purge - Delete all links connected to a fwnode_handle. 1667b337cb3SSaravana Kannan * @fwnode: fwnode whose links needs to be deleted 1677b337cb3SSaravana Kannan * 1687b337cb3SSaravana Kannan * Deletes all links connecting directly to a fwnode. 1697b337cb3SSaravana Kannan */ 1707b337cb3SSaravana Kannan void fwnode_links_purge(struct fwnode_handle *fwnode) 1717b337cb3SSaravana Kannan { 1727b337cb3SSaravana Kannan fwnode_links_purge_suppliers(fwnode); 1737b337cb3SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1747b337cb3SSaravana Kannan } 1759ed98953SRafael J. Wysocki 17628ec344bSSaravana Kannan void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode) 1779528e0d9SSaravana Kannan { 1789528e0d9SSaravana Kannan struct fwnode_handle *child; 1799528e0d9SSaravana Kannan 1809528e0d9SSaravana Kannan /* Don't purge consumer links of an added child */ 1819528e0d9SSaravana Kannan if (fwnode->dev) 1829528e0d9SSaravana Kannan return; 1839528e0d9SSaravana Kannan 1849528e0d9SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; 1859528e0d9SSaravana Kannan fwnode_links_purge_consumers(fwnode); 1869528e0d9SSaravana Kannan 1879528e0d9SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child) 1889528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child); 1899528e0d9SSaravana Kannan } 19028ec344bSSaravana Kannan EXPORT_SYMBOL_GPL(fw_devlink_purge_absent_suppliers); 1919528e0d9SSaravana Kannan 1923a2dbc51SSaravana Kannan /** 1933a2dbc51SSaravana Kannan * __fwnode_links_move_consumers - Move consumer from @from to @to fwnode_handle 1943a2dbc51SSaravana Kannan * @from: move consumers away from this fwnode 1953a2dbc51SSaravana Kannan * @to: move consumers to this fwnode 1963a2dbc51SSaravana Kannan * 1973a2dbc51SSaravana Kannan * Move all consumer links from @from fwnode to @to fwnode. 1983a2dbc51SSaravana Kannan */ 1993a2dbc51SSaravana Kannan static void __fwnode_links_move_consumers(struct fwnode_handle *from, 2003a2dbc51SSaravana Kannan struct fwnode_handle *to) 2013a2dbc51SSaravana Kannan { 2023a2dbc51SSaravana Kannan struct fwnode_link *link, *tmp; 2033a2dbc51SSaravana Kannan 2043a2dbc51SSaravana Kannan list_for_each_entry_safe(link, tmp, &from->consumers, s_hook) { 2056a6dfdf8SSaravana Kannan __fwnode_link_add(link->consumer, to, link->flags); 2063a2dbc51SSaravana Kannan __fwnode_link_del(link); 2073a2dbc51SSaravana Kannan } 2083a2dbc51SSaravana Kannan } 2093a2dbc51SSaravana Kannan 2103a2dbc51SSaravana Kannan /** 2113a2dbc51SSaravana Kannan * __fw_devlink_pickup_dangling_consumers - Pick up dangling consumers 2123a2dbc51SSaravana Kannan * @fwnode: fwnode from which to pick up dangling consumers 2133a2dbc51SSaravana Kannan * @new_sup: fwnode of new supplier 2143a2dbc51SSaravana Kannan * 2153a2dbc51SSaravana Kannan * If the @fwnode has a corresponding struct device and the device supports 2163a2dbc51SSaravana Kannan * probing (that is, added to a bus), then we want to let fw_devlink create 2173a2dbc51SSaravana Kannan * MANAGED device links to this device, so leave @fwnode and its descendant's 2183a2dbc51SSaravana Kannan * fwnode links alone. 2193a2dbc51SSaravana Kannan * 2203a2dbc51SSaravana Kannan * Otherwise, move its consumers to the new supplier @new_sup. 2213a2dbc51SSaravana Kannan */ 2223a2dbc51SSaravana Kannan static void __fw_devlink_pickup_dangling_consumers(struct fwnode_handle *fwnode, 2233a2dbc51SSaravana Kannan struct fwnode_handle *new_sup) 2243a2dbc51SSaravana Kannan { 2253a2dbc51SSaravana Kannan struct fwnode_handle *child; 2263a2dbc51SSaravana Kannan 2273a2dbc51SSaravana Kannan if (fwnode->dev && fwnode->dev->bus) 2283a2dbc51SSaravana Kannan return; 2293a2dbc51SSaravana Kannan 2303a2dbc51SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE; 2313a2dbc51SSaravana Kannan __fwnode_links_move_consumers(fwnode, new_sup); 2323a2dbc51SSaravana Kannan 2333a2dbc51SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child) 2343a2dbc51SSaravana Kannan __fw_devlink_pickup_dangling_consumers(child, new_sup); 2353a2dbc51SSaravana Kannan } 2363a2dbc51SSaravana Kannan 2379ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock); 2389ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu); 2399ed98953SRafael J. Wysocki 2409ed98953SRafael J. Wysocki static inline void device_links_write_lock(void) 2419ed98953SRafael J. Wysocki { 2429ed98953SRafael J. Wysocki mutex_lock(&device_links_lock); 2439ed98953SRafael J. Wysocki } 2449ed98953SRafael J. Wysocki 2459ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void) 2469ed98953SRafael J. Wysocki { 2479ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock); 2489ed98953SRafael J. Wysocki } 2499ed98953SRafael J. Wysocki 25068464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu) 2519ed98953SRafael J. Wysocki { 2529ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu); 2539ed98953SRafael J. Wysocki } 2549ed98953SRafael J. Wysocki 255ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu) 2569ed98953SRafael J. Wysocki { 2579ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx); 2589ed98953SRafael J. Wysocki } 259c2fa1e1bSJoel Fernandes (Google) 260c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void) 261c2fa1e1bSJoel Fernandes (Google) { 262c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu); 263c2fa1e1bSJoel Fernandes (Google) } 26480dd33cfSRafael J. Wysocki 26580dd33cfSRafael J. Wysocki static void device_link_synchronize_removal(void) 26680dd33cfSRafael J. Wysocki { 26780dd33cfSRafael J. Wysocki synchronize_srcu(&device_links_srcu); 26880dd33cfSRafael J. Wysocki } 2690c871315SRafael J. Wysocki 2700c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link) 2710c871315SRafael J. Wysocki { 2720c871315SRafael J. Wysocki list_del_rcu(&link->s_node); 2730c871315SRafael J. Wysocki list_del_rcu(&link->c_node); 2740c871315SRafael J. Wysocki } 2759ed98953SRafael J. Wysocki 2763d1cf435SRafael J. Wysocki static bool device_is_ancestor(struct device *dev, struct device *target) 2773d1cf435SRafael J. Wysocki { 2783d1cf435SRafael J. Wysocki while (target->parent) { 2793d1cf435SRafael J. Wysocki target = target->parent; 2803d1cf435SRafael J. Wysocki if (dev == target) 2813d1cf435SRafael J. Wysocki return true; 2823d1cf435SRafael J. Wysocki } 2833d1cf435SRafael J. Wysocki return false; 2843d1cf435SRafael J. Wysocki } 2853d1cf435SRafael J. Wysocki 28667cad5c6SSaravana Kannan static inline bool device_link_flag_is_sync_state_only(u32 flags) 28767cad5c6SSaravana Kannan { 28867cad5c6SSaravana Kannan return (flags & ~(DL_FLAG_INFERRED | DL_FLAG_CYCLE)) == 28967cad5c6SSaravana Kannan (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED); 29067cad5c6SSaravana Kannan } 29167cad5c6SSaravana Kannan 2929ed98953SRafael J. Wysocki /** 2939ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one 2949ed98953SRafael J. Wysocki * @dev: Device to check dependencies for. 2959ed98953SRafael J. Wysocki * @target: Device to check against. 2969ed98953SRafael J. Wysocki * 2979ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or 2989ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise. 2999ed98953SRafael J. Wysocki */ 3007d34ca38SSaravana Kannan int device_is_dependent(struct device *dev, void *target) 3019ed98953SRafael J. Wysocki { 3029ed98953SRafael J. Wysocki struct device_link *link; 3039ed98953SRafael J. Wysocki int ret; 3049ed98953SRafael J. Wysocki 3053d1cf435SRafael J. Wysocki /* 3063d1cf435SRafael J. Wysocki * The "ancestors" check is needed to catch the case when the target 3073d1cf435SRafael J. Wysocki * device has not been completely initialized yet and it is still 3083d1cf435SRafael J. Wysocki * missing from the list of children of its parent device. 3093d1cf435SRafael J. Wysocki */ 3103d1cf435SRafael J. Wysocki if (dev == target || device_is_ancestor(dev, target)) 3119ed98953SRafael J. Wysocki return 1; 3129ed98953SRafael J. Wysocki 3139ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent); 3149ed98953SRafael J. Wysocki if (ret) 3159ed98953SRafael J. Wysocki return ret; 3169ed98953SRafael J. Wysocki 3179ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 31867cad5c6SSaravana Kannan if (device_link_flag_is_sync_state_only(link->flags)) 31905ef983eSSaravana Kannan continue; 32005ef983eSSaravana Kannan 321e16f4f3eSBenjamin Gaignard if (link->consumer == target) 3229ed98953SRafael J. Wysocki return 1; 3239ed98953SRafael J. Wysocki 3249ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target); 3259ed98953SRafael J. Wysocki if (ret) 3269ed98953SRafael J. Wysocki break; 3279ed98953SRafael J. Wysocki } 3289ed98953SRafael J. Wysocki return ret; 3299ed98953SRafael J. Wysocki } 3309ed98953SRafael J. Wysocki 331515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link, 332515db266SRafael J. Wysocki struct device *consumer, 333515db266SRafael J. Wysocki struct device *supplier) 334515db266SRafael J. Wysocki { 335515db266SRafael J. Wysocki switch (supplier->links.status) { 336515db266SRafael J. Wysocki case DL_DEV_PROBING: 337515db266SRafael J. Wysocki switch (consumer->links.status) { 338515db266SRafael J. Wysocki case DL_DEV_PROBING: 339515db266SRafael J. Wysocki /* 340515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier 341515db266SRafael J. Wysocki * that has not completed its probing yet as long as it 342515db266SRafael J. Wysocki * knows that the supplier is already functional (for 343515db266SRafael J. Wysocki * example, it has just acquired some resources from the 344515db266SRafael J. Wysocki * supplier). 345515db266SRafael J. Wysocki */ 346515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 347515db266SRafael J. Wysocki break; 348515db266SRafael J. Wysocki default: 349515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 350515db266SRafael J. Wysocki break; 351515db266SRafael J. Wysocki } 352515db266SRafael J. Wysocki break; 353515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 354515db266SRafael J. Wysocki switch (consumer->links.status) { 355515db266SRafael J. Wysocki case DL_DEV_PROBING: 356515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE; 357515db266SRafael J. Wysocki break; 358515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND: 359515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE; 360515db266SRafael J. Wysocki break; 361515db266SRafael J. Wysocki default: 362515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE; 363515db266SRafael J. Wysocki break; 364515db266SRafael J. Wysocki } 365515db266SRafael J. Wysocki break; 366515db266SRafael J. Wysocki case DL_DEV_UNBINDING: 367515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND; 368515db266SRafael J. Wysocki break; 369515db266SRafael J. Wysocki default: 370515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT; 371515db266SRafael J. Wysocki break; 372515db266SRafael J. Wysocki } 373515db266SRafael J. Wysocki } 374515db266SRafael J. Wysocki 3759ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used) 3769ed98953SRafael J. Wysocki { 3779ed98953SRafael J. Wysocki struct device_link *link; 3789ed98953SRafael J. Wysocki 3799ed98953SRafael J. Wysocki /* 3809ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends 3819ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here. 3829ed98953SRafael J. Wysocki */ 3839ed98953SRafael J. Wysocki if (device_is_registered(dev)) 3849ed98953SRafael J. Wysocki devices_kset_move_last(dev); 3859ed98953SRafael J. Wysocki 3869ed98953SRafael J. Wysocki if (device_pm_initialized(dev)) 3879ed98953SRafael J. Wysocki device_pm_move_last(dev); 3889ed98953SRafael J. Wysocki 3899ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail); 39005ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 39167cad5c6SSaravana Kannan if (device_link_flag_is_sync_state_only(link->flags)) 39205ef983eSSaravana Kannan continue; 3939ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL); 39405ef983eSSaravana Kannan } 3959ed98953SRafael J. Wysocki 3969ed98953SRafael J. Wysocki return 0; 3979ed98953SRafael J. Wysocki } 3989ed98953SRafael J. Wysocki 3999ed98953SRafael J. Wysocki /** 400494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists 401494fd7b7SFeng Kan * @dev: Device to move 402494fd7b7SFeng Kan * 403494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks. 404494fd7b7SFeng Kan * 405494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers 406494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively. 407494fd7b7SFeng Kan */ 408494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev) 409494fd7b7SFeng Kan { 410494fd7b7SFeng Kan int idx; 411494fd7b7SFeng Kan 412494fd7b7SFeng Kan idx = device_links_read_lock(); 413494fd7b7SFeng Kan device_pm_lock(); 414494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL); 415494fd7b7SFeng Kan device_pm_unlock(); 416494fd7b7SFeng Kan device_links_read_unlock(idx); 417494fd7b7SFeng Kan } 418494fd7b7SFeng Kan 419287905e6SSaravana Kannan #define to_devlink(dev) container_of((dev), struct device_link, link_dev) 420287905e6SSaravana Kannan 421287905e6SSaravana Kannan static ssize_t status_show(struct device *dev, 422287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 423287905e6SSaravana Kannan { 424948b3edbSJoe Perches const char *output; 425287905e6SSaravana Kannan 426287905e6SSaravana Kannan switch (to_devlink(dev)->status) { 427287905e6SSaravana Kannan case DL_STATE_NONE: 428948b3edbSJoe Perches output = "not tracked"; 429948b3edbSJoe Perches break; 430287905e6SSaravana Kannan case DL_STATE_DORMANT: 431948b3edbSJoe Perches output = "dormant"; 432948b3edbSJoe Perches break; 433287905e6SSaravana Kannan case DL_STATE_AVAILABLE: 434948b3edbSJoe Perches output = "available"; 435948b3edbSJoe Perches break; 436287905e6SSaravana Kannan case DL_STATE_CONSUMER_PROBE: 437948b3edbSJoe Perches output = "consumer probing"; 438948b3edbSJoe Perches break; 439287905e6SSaravana Kannan case DL_STATE_ACTIVE: 440948b3edbSJoe Perches output = "active"; 441948b3edbSJoe Perches break; 442287905e6SSaravana Kannan case DL_STATE_SUPPLIER_UNBIND: 443948b3edbSJoe Perches output = "supplier unbinding"; 444948b3edbSJoe Perches break; 445287905e6SSaravana Kannan default: 446948b3edbSJoe Perches output = "unknown"; 447948b3edbSJoe Perches break; 448287905e6SSaravana Kannan } 449948b3edbSJoe Perches 450948b3edbSJoe Perches return sysfs_emit(buf, "%s\n", output); 451287905e6SSaravana Kannan } 452287905e6SSaravana Kannan static DEVICE_ATTR_RO(status); 453287905e6SSaravana Kannan 454287905e6SSaravana Kannan static ssize_t auto_remove_on_show(struct device *dev, 455287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 456287905e6SSaravana Kannan { 457287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 458973c3911SJoe Perches const char *output; 459287905e6SSaravana Kannan 460287905e6SSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 461973c3911SJoe Perches output = "supplier unbind"; 462287905e6SSaravana Kannan else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) 463973c3911SJoe Perches output = "consumer unbind"; 464287905e6SSaravana Kannan else 465973c3911SJoe Perches output = "never"; 466287905e6SSaravana Kannan 467973c3911SJoe Perches return sysfs_emit(buf, "%s\n", output); 468287905e6SSaravana Kannan } 469287905e6SSaravana Kannan static DEVICE_ATTR_RO(auto_remove_on); 470287905e6SSaravana Kannan 471287905e6SSaravana Kannan static ssize_t runtime_pm_show(struct device *dev, 472287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 473287905e6SSaravana Kannan { 474287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 475287905e6SSaravana Kannan 476aa838896SJoe Perches return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME)); 477287905e6SSaravana Kannan } 478287905e6SSaravana Kannan static DEVICE_ATTR_RO(runtime_pm); 479287905e6SSaravana Kannan 480287905e6SSaravana Kannan static ssize_t sync_state_only_show(struct device *dev, 481287905e6SSaravana Kannan struct device_attribute *attr, char *buf) 482287905e6SSaravana Kannan { 483287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 484287905e6SSaravana Kannan 485aa838896SJoe Perches return sysfs_emit(buf, "%d\n", 486aa838896SJoe Perches !!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 487287905e6SSaravana Kannan } 488287905e6SSaravana Kannan static DEVICE_ATTR_RO(sync_state_only); 489287905e6SSaravana Kannan 490287905e6SSaravana Kannan static struct attribute *devlink_attrs[] = { 491287905e6SSaravana Kannan &dev_attr_status.attr, 492287905e6SSaravana Kannan &dev_attr_auto_remove_on.attr, 493287905e6SSaravana Kannan &dev_attr_runtime_pm.attr, 494287905e6SSaravana Kannan &dev_attr_sync_state_only.attr, 495287905e6SSaravana Kannan NULL, 496287905e6SSaravana Kannan }; 497287905e6SSaravana Kannan ATTRIBUTE_GROUPS(devlink); 498287905e6SSaravana Kannan 49980dd33cfSRafael J. Wysocki static void device_link_release_fn(struct work_struct *work) 500843e600bSSaravana Kannan { 50180dd33cfSRafael J. Wysocki struct device_link *link = container_of(work, struct device_link, rm_work); 50280dd33cfSRafael J. Wysocki 50380dd33cfSRafael J. Wysocki /* Ensure that all references to the link object have been dropped. */ 50480dd33cfSRafael J. Wysocki device_link_synchronize_removal(); 50580dd33cfSRafael J. Wysocki 50607358194SRafael J. Wysocki pm_runtime_release_supplier(link); 50788737106SRafael J. Wysocki /* 50888737106SRafael J. Wysocki * If supplier_preactivated is set, the link has been dropped between 50988737106SRafael J. Wysocki * the pm_runtime_get_suppliers() and pm_runtime_put_suppliers() calls 51088737106SRafael J. Wysocki * in __driver_probe_device(). In that case, drop the supplier's 51188737106SRafael J. Wysocki * PM-runtime usage counter to remove the reference taken by 51288737106SRafael J. Wysocki * pm_runtime_get_suppliers(). 51388737106SRafael J. Wysocki */ 51488737106SRafael J. Wysocki if (link->supplier_preactivated) 51588737106SRafael J. Wysocki pm_runtime_put_noidle(link->supplier); 51688737106SRafael J. Wysocki 51707358194SRafael J. Wysocki pm_request_idle(link->supplier); 518843e600bSSaravana Kannan 519843e600bSSaravana Kannan put_device(link->consumer); 520843e600bSSaravana Kannan put_device(link->supplier); 521843e600bSSaravana Kannan kfree(link); 522843e600bSSaravana Kannan } 523843e600bSSaravana Kannan 524287905e6SSaravana Kannan static void devlink_dev_release(struct device *dev) 525287905e6SSaravana Kannan { 526843e600bSSaravana Kannan struct device_link *link = to_devlink(dev); 527843e600bSSaravana Kannan 52880dd33cfSRafael J. Wysocki INIT_WORK(&link->rm_work, device_link_release_fn); 52980dd33cfSRafael J. Wysocki /* 53080dd33cfSRafael J. Wysocki * It may take a while to complete this work because of the SRCU 53180dd33cfSRafael J. Wysocki * synchronization in device_link_release_fn() and if the consumer or 53280dd33cfSRafael J. Wysocki * supplier devices get deleted when it runs, so put it into the "long" 53380dd33cfSRafael J. Wysocki * workqueue. 53480dd33cfSRafael J. Wysocki */ 53580dd33cfSRafael J. Wysocki queue_work(system_long_wq, &link->rm_work); 536287905e6SSaravana Kannan } 537287905e6SSaravana Kannan 538287905e6SSaravana Kannan static struct class devlink_class = { 539287905e6SSaravana Kannan .name = "devlink", 540287905e6SSaravana Kannan .dev_groups = devlink_groups, 541287905e6SSaravana Kannan .dev_release = devlink_dev_release, 542287905e6SSaravana Kannan }; 543287905e6SSaravana Kannan 5442243acd5SGreg Kroah-Hartman static int devlink_add_symlinks(struct device *dev) 545287905e6SSaravana Kannan { 546287905e6SSaravana Kannan int ret; 547287905e6SSaravana Kannan size_t len; 548287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 549287905e6SSaravana Kannan struct device *sup = link->supplier; 550287905e6SSaravana Kannan struct device *con = link->consumer; 551287905e6SSaravana Kannan char *buf; 552287905e6SSaravana Kannan 553e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 554e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 555e020ff61SSaravana Kannan len += strlen(":"); 556287905e6SSaravana Kannan len += strlen("supplier:") + 1; 557287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 558287905e6SSaravana Kannan if (!buf) 559287905e6SSaravana Kannan return -ENOMEM; 560287905e6SSaravana Kannan 561287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier"); 562287905e6SSaravana Kannan if (ret) 563287905e6SSaravana Kannan goto out; 564287905e6SSaravana Kannan 565287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer"); 566287905e6SSaravana Kannan if (ret) 567287905e6SSaravana Kannan goto err_con; 568287905e6SSaravana Kannan 569e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 570287905e6SSaravana Kannan ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf); 571287905e6SSaravana Kannan if (ret) 572287905e6SSaravana Kannan goto err_con_dev; 573287905e6SSaravana Kannan 574e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 575287905e6SSaravana Kannan ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf); 576287905e6SSaravana Kannan if (ret) 577287905e6SSaravana Kannan goto err_sup_dev; 578287905e6SSaravana Kannan 579287905e6SSaravana Kannan goto out; 580287905e6SSaravana Kannan 581287905e6SSaravana Kannan err_sup_dev: 582e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 583287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 584287905e6SSaravana Kannan err_con_dev: 585287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 586287905e6SSaravana Kannan err_con: 587287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 588287905e6SSaravana Kannan out: 589287905e6SSaravana Kannan kfree(buf); 590287905e6SSaravana Kannan return ret; 591287905e6SSaravana Kannan } 592287905e6SSaravana Kannan 5932243acd5SGreg Kroah-Hartman static void devlink_remove_symlinks(struct device *dev) 594287905e6SSaravana Kannan { 595287905e6SSaravana Kannan struct device_link *link = to_devlink(dev); 596287905e6SSaravana Kannan size_t len; 597287905e6SSaravana Kannan struct device *sup = link->supplier; 598287905e6SSaravana Kannan struct device *con = link->consumer; 599287905e6SSaravana Kannan char *buf; 600287905e6SSaravana Kannan 601287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer"); 602287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier"); 603287905e6SSaravana Kannan 604e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)), 605e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con))); 606e020ff61SSaravana Kannan len += strlen(":"); 607287905e6SSaravana Kannan len += strlen("supplier:") + 1; 608287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL); 609287905e6SSaravana Kannan if (!buf) { 610287905e6SSaravana Kannan WARN(1, "Unable to properly free device link symlinks!\n"); 611287905e6SSaravana Kannan return; 612287905e6SSaravana Kannan } 613287905e6SSaravana Kannan 614e64daad6SAdrian Hunter if (device_is_registered(con)) { 615e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup)); 616287905e6SSaravana Kannan sysfs_remove_link(&con->kobj, buf); 617e64daad6SAdrian Hunter } 618e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con)); 619287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf); 620287905e6SSaravana Kannan kfree(buf); 621287905e6SSaravana Kannan } 622287905e6SSaravana Kannan 623287905e6SSaravana Kannan static struct class_interface devlink_class_intf = { 624287905e6SSaravana Kannan .class = &devlink_class, 625287905e6SSaravana Kannan .add_dev = devlink_add_symlinks, 626287905e6SSaravana Kannan .remove_dev = devlink_remove_symlinks, 627287905e6SSaravana Kannan }; 628287905e6SSaravana Kannan 629287905e6SSaravana Kannan static int __init devlink_class_init(void) 630287905e6SSaravana Kannan { 631287905e6SSaravana Kannan int ret; 632287905e6SSaravana Kannan 633287905e6SSaravana Kannan ret = class_register(&devlink_class); 634287905e6SSaravana Kannan if (ret) 635287905e6SSaravana Kannan return ret; 636287905e6SSaravana Kannan 637287905e6SSaravana Kannan ret = class_interface_register(&devlink_class_intf); 638287905e6SSaravana Kannan if (ret) 639287905e6SSaravana Kannan class_unregister(&devlink_class); 640287905e6SSaravana Kannan 641287905e6SSaravana Kannan return ret; 642287905e6SSaravana Kannan } 643287905e6SSaravana Kannan postcore_initcall(devlink_class_init); 644287905e6SSaravana Kannan 645515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \ 646515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \ 64705ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \ 6484b9bbb29SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY | \ 64967cad5c6SSaravana Kannan DL_FLAG_INFERRED | \ 65067cad5c6SSaravana Kannan DL_FLAG_CYCLE) 651515db266SRafael J. Wysocki 652fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \ 653fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) 654fb583c8eSRafael J. Wysocki 655494fd7b7SFeng Kan /** 6569ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices. 6579ed98953SRafael J. Wysocki * @consumer: Consumer end of the link. 6589ed98953SRafael J. Wysocki * @supplier: Supplier end of the link. 6599ed98953SRafael J. Wysocki * @flags: Link flags. 6609ed98953SRafael J. Wysocki * 66121d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation 66221d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the 66321d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the 66421d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will 66521d5c57bSRafael J. Wysocki * be forced into the active meta state and reference-counted upon the creation 66621d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be 66721d5c57bSRafael J. Wysocki * ignored. 66821d5c57bSRafael J. Wysocki * 669515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is 670515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either 671515db266SRafael J. Wysocki * device_link_del() or device_link_remove(). 67272175d4eSRafael J. Wysocki * 67372175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the 67472175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value 67572175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case, 67672175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link 67772175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely 67872175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core 67972175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function) 68072175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its 68172175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set, 68272175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either 68372175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered. 684c8d50986SRafael J. Wysocki * 685e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and 686e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent 687e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can 688d475f8eaSThierry Reding * be used to request the driver core to automatically probe for a consumer 689e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device. 690e7dd4010SRafael J. Wysocki * 691515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, 692515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at 693515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront. 694515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair 695515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will 696515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may 697515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat 698515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if 699515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released 700515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above). 7019ed98953SRafael J. Wysocki * 7029ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the 7039ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending 7049ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have 7059ed98953SRafael J. Wysocki * not been registered when this function is called). 7069ed98953SRafael J. Wysocki * 7079ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called 7089ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need 70964df1148SLukas Wunner * not be registered, however. 7109ed98953SRafael J. Wysocki */ 7119ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer, 7129ed98953SRafael J. Wysocki struct device *supplier, u32 flags) 7139ed98953SRafael J. Wysocki { 7149ed98953SRafael J. Wysocki struct device_link *link; 7159ed98953SRafael J. Wysocki 716f729a592SSaravana Kannan if (!consumer || !supplier || consumer == supplier || 717f729a592SSaravana Kannan flags & ~DL_ADD_VALID_FLAGS || 718515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || 719e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER && 720e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER | 721e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER))) 7229ed98953SRafael J. Wysocki return NULL; 7239ed98953SRafael J. Wysocki 7245db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) { 7255db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) { 7265db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier); 7275db25c9eSRafael J. Wysocki return NULL; 7285db25c9eSRafael J. Wysocki } 7295db25c9eSRafael J. Wysocki } 7305db25c9eSRafael J. Wysocki 731515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS)) 732515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED; 733515db266SRafael J. Wysocki 73467cad5c6SSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY && 73567cad5c6SSaravana Kannan !device_link_flag_is_sync_state_only(flags)) 73667cad5c6SSaravana Kannan return NULL; 73767cad5c6SSaravana Kannan 7389ed98953SRafael J. Wysocki device_links_write_lock(); 7399ed98953SRafael J. Wysocki device_pm_lock(); 7409ed98953SRafael J. Wysocki 7419ed98953SRafael J. Wysocki /* 7429ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a 74305ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and 74405ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a 74505ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies 74605ef983eSSaravana Kannan * because it only affects sync_state() callbacks. 7479ed98953SRafael J. Wysocki */ 7489ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier) 74905ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) && 75005ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) { 7519ed98953SRafael J. Wysocki link = NULL; 7529ed98953SRafael J. Wysocki goto out; 7539ed98953SRafael J. Wysocki } 7549ed98953SRafael J. Wysocki 75572175d4eSRafael J. Wysocki /* 756ac66c5bbSSaravana Kannan * SYNC_STATE_ONLY links are useless once a consumer device has probed. 757ac66c5bbSSaravana Kannan * So, only create it if the consumer hasn't probed yet. 758ac66c5bbSSaravana Kannan */ 759ac66c5bbSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY && 760ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_NO_DRIVER && 761ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_PROBING) { 762ac66c5bbSSaravana Kannan link = NULL; 763ac66c5bbSSaravana Kannan goto out; 764ac66c5bbSSaravana Kannan } 765ac66c5bbSSaravana Kannan 766ac66c5bbSSaravana Kannan /* 76772175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed 76872175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both 76972175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER. 77072175d4eSRafael J. Wysocki */ 77172175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 77272175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 77372175d4eSRafael J. Wysocki 774f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) { 775f265df55SRafael J. Wysocki if (link->consumer != consumer) 776f265df55SRafael J. Wysocki continue; 777f265df55SRafael J. Wysocki 7784b9bbb29SSaravana Kannan if (link->flags & DL_FLAG_INFERRED && 7794b9bbb29SSaravana Kannan !(flags & DL_FLAG_INFERRED)) 7804b9bbb29SSaravana Kannan link->flags &= ~DL_FLAG_INFERRED; 7814b9bbb29SSaravana Kannan 782e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) { 783e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) { 7844c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer); 785e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME; 786e2f3cd83SRafael J. Wysocki } 787e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE) 78836003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active); 789e2f3cd83SRafael J. Wysocki } 790e2f3cd83SRafael J. Wysocki 79172175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) { 792ead18c23SLukas Wunner kref_get(&link->kref); 79321c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 79444e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) { 79544e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 79605ef983eSSaravana Kannan goto reorder; 79744e96049SSaravana Kannan } else { 79844e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS; 7999ed98953SRafael J. Wysocki goto out; 800ead18c23SLukas Wunner } 80144e96049SSaravana Kannan } 8029ed98953SRafael J. Wysocki 80372175d4eSRafael J. Wysocki /* 80472175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is 80572175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link, 80672175d4eSRafael J. Wysocki * update the existing link to stay around longer. 80772175d4eSRafael J. Wysocki */ 80872175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) { 80972175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 81072175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 81172175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER; 81272175d4eSRafael J. Wysocki } 81372175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) { 81472175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER | 81572175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER); 81672175d4eSRafael J. Wysocki } 817515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) { 818515db266SRafael J. Wysocki kref_get(&link->kref); 819515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED; 820515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 821515db266SRafael J. Wysocki } 82205ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY && 82305ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) { 82405ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY; 82505ef983eSSaravana Kannan goto reorder; 82605ef983eSSaravana Kannan } 82705ef983eSSaravana Kannan 82872175d4eSRafael J. Wysocki goto out; 82972175d4eSRafael J. Wysocki } 83072175d4eSRafael J. Wysocki 83121d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL); 8329ed98953SRafael J. Wysocki if (!link) 8339ed98953SRafael J. Wysocki goto out; 8349ed98953SRafael J. Wysocki 835e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1); 836e2f3cd83SRafael J. Wysocki 8379ed98953SRafael J. Wysocki get_device(supplier); 8389ed98953SRafael J. Wysocki link->supplier = supplier; 8399ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node); 8409ed98953SRafael J. Wysocki get_device(consumer); 8419ed98953SRafael J. Wysocki link->consumer = consumer; 8429ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node); 8439ed98953SRafael J. Wysocki link->flags = flags; 844ead18c23SLukas Wunner kref_init(&link->kref); 8459ed98953SRafael J. Wysocki 846287905e6SSaravana Kannan link->link_dev.class = &devlink_class; 847287905e6SSaravana Kannan device_set_pm_not_required(&link->link_dev); 848e020ff61SSaravana Kannan dev_set_name(&link->link_dev, "%s:%s--%s:%s", 849e020ff61SSaravana Kannan dev_bus_name(supplier), dev_name(supplier), 850e020ff61SSaravana Kannan dev_bus_name(consumer), dev_name(consumer)); 851287905e6SSaravana Kannan if (device_register(&link->link_dev)) { 852df0a1814SYang Yingliang put_device(&link->link_dev); 853287905e6SSaravana Kannan link = NULL; 854287905e6SSaravana Kannan goto out; 855287905e6SSaravana Kannan } 856287905e6SSaravana Kannan 857287905e6SSaravana Kannan if (flags & DL_FLAG_PM_RUNTIME) { 858287905e6SSaravana Kannan if (flags & DL_FLAG_RPM_ACTIVE) 859287905e6SSaravana Kannan refcount_inc(&link->rpm_active); 860287905e6SSaravana Kannan 861287905e6SSaravana Kannan pm_runtime_new_link(consumer); 862287905e6SSaravana Kannan } 863287905e6SSaravana Kannan 86464df1148SLukas Wunner /* Determine the initial link state. */ 865515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS) 8669ed98953SRafael J. Wysocki link->status = DL_STATE_NONE; 867515db266SRafael J. Wysocki else 868515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier); 8699ed98953SRafael J. Wysocki 8709ed98953SRafael J. Wysocki /* 87115cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to 87215cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE. 87315cfb094SRafael J. Wysocki */ 87415cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE && 87515cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME) 87615cfb094SRafael J. Wysocki pm_runtime_resume(supplier); 87715cfb094SRafael J. Wysocki 87821c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers); 87921c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 88021c27f06SSaravana Kannan 88105ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) { 88205ef983eSSaravana Kannan dev_dbg(consumer, 88305ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n", 88405ef983eSSaravana Kannan dev_name(supplier)); 88505ef983eSSaravana Kannan goto out; 88605ef983eSSaravana Kannan } 88721c27f06SSaravana Kannan 88805ef983eSSaravana Kannan reorder: 88915cfb094SRafael J. Wysocki /* 8909ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end 8919ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list. 8929ed98953SRafael J. Wysocki * 8939ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else 8949ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it. 8959ed98953SRafael J. Wysocki */ 8969ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL); 8979ed98953SRafael J. Wysocki 8988a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); 8999ed98953SRafael J. Wysocki 9009ed98953SRafael J. Wysocki out: 9019ed98953SRafael J. Wysocki device_pm_unlock(); 9029ed98953SRafael J. Wysocki device_links_write_unlock(); 9035db25c9eSRafael J. Wysocki 904e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link) 9055db25c9eSRafael J. Wysocki pm_runtime_put(supplier); 9065db25c9eSRafael J. Wysocki 9079ed98953SRafael J. Wysocki return link; 9089ed98953SRafael J. Wysocki } 9099ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add); 9109ed98953SRafael J. Wysocki 911ead18c23SLukas Wunner static void __device_link_del(struct kref *kref) 9129ed98953SRafael J. Wysocki { 913ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref); 914ead18c23SLukas Wunner 9158a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n", 9169ed98953SRafael J. Wysocki dev_name(link->supplier)); 9179ed98953SRafael J. Wysocki 918e0e398e2SRafael J. Wysocki pm_runtime_drop_link(link); 919baa8809fSRafael J. Wysocki 9200c871315SRafael J. Wysocki device_link_remove_from_lists(link); 921843e600bSSaravana Kannan device_unregister(&link->link_dev); 9229ed98953SRafael J. Wysocki } 9239ed98953SRafael J. Wysocki 92472175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link) 92572175d4eSRafael J. Wysocki { 92672175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS) 92772175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del); 928bf25967aSAdrian Hunter else if (!device_is_registered(link->consumer)) 929bf25967aSAdrian Hunter __device_link_del(&link->kref); 93072175d4eSRafael J. Wysocki else 93172175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n"); 93272175d4eSRafael J. Wysocki } 93372175d4eSRafael J. Wysocki 9349ed98953SRafael J. Wysocki /** 93572175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices. 9369ed98953SRafael J. Wysocki * @link: Device link to delete. 9379ed98953SRafael J. Wysocki * 9389ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime 939ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often. 940ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal 941ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed. 9429ed98953SRafael J. Wysocki */ 9439ed98953SRafael J. Wysocki void device_link_del(struct device_link *link) 9449ed98953SRafael J. Wysocki { 9459ed98953SRafael J. Wysocki device_links_write_lock(); 94672175d4eSRafael J. Wysocki device_link_put_kref(link); 9479ed98953SRafael J. Wysocki device_links_write_unlock(); 9489ed98953SRafael J. Wysocki } 9499ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del); 9509ed98953SRafael J. Wysocki 951d8842211Spascal paillet /** 95272175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices. 953d8842211Spascal paillet * @consumer: Consumer end of the link. 954d8842211Spascal paillet * @supplier: Supplier end of the link. 955d8842211Spascal paillet * 956d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime 957d8842211Spascal paillet * PM. 958d8842211Spascal paillet */ 959d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier) 960d8842211Spascal paillet { 961d8842211Spascal paillet struct device_link *link; 962d8842211Spascal paillet 963d8842211Spascal paillet if (WARN_ON(consumer == supplier)) 964d8842211Spascal paillet return; 965d8842211Spascal paillet 966d8842211Spascal paillet device_links_write_lock(); 967d8842211Spascal paillet 968d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) { 969d8842211Spascal paillet if (link->consumer == consumer) { 97072175d4eSRafael J. Wysocki device_link_put_kref(link); 971d8842211Spascal paillet break; 972d8842211Spascal paillet } 973d8842211Spascal paillet } 974d8842211Spascal paillet 975d8842211Spascal paillet device_links_write_unlock(); 976d8842211Spascal paillet } 977d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove); 978d8842211Spascal paillet 9799ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev) 9809ed98953SRafael J. Wysocki { 9819ed98953SRafael J. Wysocki struct device_link *link; 9829ed98953SRafael J. Wysocki 9838c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) { 9848c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE) 9858c3e315dSSaravana Kannan continue; 9868c3e315dSSaravana Kannan 9878c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 9889ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 9898c3e315dSSaravana Kannan } else { 9908c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 9918c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 9928c3e315dSSaravana Kannan } 9938c3e315dSSaravana Kannan } 9949ed98953SRafael J. Wysocki } 9959ed98953SRafael J. Wysocki 9962f8c3ae8SSaravana Kannan static bool dev_is_best_effort(struct device *dev) 9972f8c3ae8SSaravana Kannan { 9988f486cabSSaravana Kannan return (fw_devlink_best_effort && dev->can_match) || 9998f486cabSSaravana Kannan (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT)); 10002f8c3ae8SSaravana Kannan } 10012f8c3ae8SSaravana Kannan 10026a6dfdf8SSaravana Kannan static struct fwnode_handle *fwnode_links_check_suppliers( 10036a6dfdf8SSaravana Kannan struct fwnode_handle *fwnode) 10046a6dfdf8SSaravana Kannan { 10056a6dfdf8SSaravana Kannan struct fwnode_link *link; 10066a6dfdf8SSaravana Kannan 10076a6dfdf8SSaravana Kannan if (!fwnode || fw_devlink_is_permissive()) 10086a6dfdf8SSaravana Kannan return NULL; 10096a6dfdf8SSaravana Kannan 10106a6dfdf8SSaravana Kannan list_for_each_entry(link, &fwnode->suppliers, c_hook) 10116a6dfdf8SSaravana Kannan if (!(link->flags & FWLINK_FLAG_CYCLE)) 10126a6dfdf8SSaravana Kannan return link->supplier; 10136a6dfdf8SSaravana Kannan 10146a6dfdf8SSaravana Kannan return NULL; 10156a6dfdf8SSaravana Kannan } 10166a6dfdf8SSaravana Kannan 10179ed98953SRafael J. Wysocki /** 10189ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers. 10199ed98953SRafael J. Wysocki * @dev: Consumer device. 10209ed98953SRafael J. Wysocki * 10219ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's 10229ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply 10239ed98953SRafael J. Wysocki * return -EPROBE_DEFER. 10249ed98953SRafael J. Wysocki * 10259ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has 10269ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and 10279ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to 10289ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal 10299ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen). 10309ed98953SRafael J. Wysocki * 1031515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 10329ed98953SRafael J. Wysocki */ 10339ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev) 10349ed98953SRafael J. Wysocki { 10359ed98953SRafael J. Wysocki struct device_link *link; 10362f8c3ae8SSaravana Kannan int ret = 0, fwnode_ret = 0; 103768223eeeSSaravana Kannan struct fwnode_handle *sup_fw; 10389ed98953SRafael J. Wysocki 1039e2ae9bccSSaravana Kannan /* 1040e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to 1041e2ae9bccSSaravana Kannan * probe. 1042e2ae9bccSSaravana Kannan */ 104325ac86c6SSaravana Kannan mutex_lock(&fwnode_link_lock); 10446a6dfdf8SSaravana Kannan sup_fw = fwnode_links_check_suppliers(dev->fwnode); 10456a6dfdf8SSaravana Kannan if (sup_fw) { 10462f8c3ae8SSaravana Kannan if (!dev_is_best_effort(dev)) { 10472f8c3ae8SSaravana Kannan fwnode_ret = -EPROBE_DEFER; 10482f8c3ae8SSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER, 10490c058fb9SSaravana Kannan "wait for supplier %pfwf\n", sup_fw); 10502f8c3ae8SSaravana Kannan } else { 10512f8c3ae8SSaravana Kannan fwnode_ret = -EAGAIN; 10522f8c3ae8SSaravana Kannan } 1053e2ae9bccSSaravana Kannan } 105425ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock); 10552f8c3ae8SSaravana Kannan if (fwnode_ret == -EPROBE_DEFER) 10562f8c3ae8SSaravana Kannan return fwnode_ret; 1057e2ae9bccSSaravana Kannan 10589ed98953SRafael J. Wysocki device_links_write_lock(); 10599ed98953SRafael J. Wysocki 10609ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) { 10618c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 10629ed98953SRafael J. Wysocki continue; 10639ed98953SRafael J. Wysocki 10648c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE && 10658c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) { 10662f8c3ae8SSaravana Kannan 10672f8c3ae8SSaravana Kannan if (dev_is_best_effort(dev) && 10682f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED && 10692f8c3ae8SSaravana Kannan !link->supplier->can_match) { 10702f8c3ae8SSaravana Kannan ret = -EAGAIN; 10712f8c3ae8SSaravana Kannan continue; 10722f8c3ae8SSaravana Kannan } 10732f8c3ae8SSaravana Kannan 10749ed98953SRafael J. Wysocki device_links_missing_supplier(dev); 107568223eeeSSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER, 107668223eeeSSaravana Kannan "supplier %s not ready\n", 10771f0dfa05SSaravana Kannan dev_name(link->supplier)); 10789ed98953SRafael J. Wysocki ret = -EPROBE_DEFER; 10799ed98953SRafael J. Wysocki break; 10809ed98953SRafael J. Wysocki } 10819ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 10829ed98953SRafael J. Wysocki } 10839ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING; 10849ed98953SRafael J. Wysocki 10859ed98953SRafael J. Wysocki device_links_write_unlock(); 10862f8c3ae8SSaravana Kannan 10872f8c3ae8SSaravana Kannan return ret ? ret : fwnode_ret; 10889ed98953SRafael J. Wysocki } 10899ed98953SRafael J. Wysocki 109026e77708SSaravana Kannan /** 109126e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback 109226e77708SSaravana Kannan * @dev: Device to call sync_state() on 109326e77708SSaravana Kannan * @list: List head to queue the @dev on 109426e77708SSaravana Kannan * 109526e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock 109626e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links 109726e77708SSaravana Kannan * APIs. The caller must ensure this function is called with 109826e77708SSaravana Kannan * device_links_write_lock() held. 109926e77708SSaravana Kannan * 110026e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while 110126e77708SSaravana Kannan * on this list. 110226e77708SSaravana Kannan * 110326e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called 110426e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary 110526e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the 110626e77708SSaravana Kannan * put_device() is called on this device. 110726e77708SSaravana Kannan */ 110826e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev, 110926e77708SSaravana Kannan struct list_head *list) 1110fc5a251dSSaravana Kannan { 1111fc5a251dSSaravana Kannan struct device_link *link; 1112fc5a251dSSaravana Kannan 111377036165SSaravana Kannan if (!dev_has_sync_state(dev)) 111477036165SSaravana Kannan return; 1115fc5a251dSSaravana Kannan if (dev->state_synced) 1116fc5a251dSSaravana Kannan return; 1117fc5a251dSSaravana Kannan 1118fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) { 1119fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1120fc5a251dSSaravana Kannan continue; 1121fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE) 1122fc5a251dSSaravana Kannan return; 1123fc5a251dSSaravana Kannan } 1124fc5a251dSSaravana Kannan 112526e77708SSaravana Kannan /* 112626e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more 112726e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device 112826e77708SSaravana Kannan * and probed before the list is flushed. 112926e77708SSaravana Kannan */ 113026e77708SSaravana Kannan dev->state_synced = true; 113126e77708SSaravana Kannan 11323b052a3eSSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync))) 113326e77708SSaravana Kannan return; 113426e77708SSaravana Kannan 113526e77708SSaravana Kannan get_device(dev); 11363b052a3eSSaravana Kannan list_add_tail(&dev->links.defer_sync, list); 113726e77708SSaravana Kannan } 113826e77708SSaravana Kannan 113926e77708SSaravana Kannan /** 114026e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices 114126e77708SSaravana Kannan * @list: List of devices to call sync_state() on 114221eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller 114326e77708SSaravana Kannan * 114426e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This 114521eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The 114621eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a 114721eb93f4SSaravana Kannan * context where a device lock is already held. 114826e77708SSaravana Kannan */ 114921eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list, 115021eb93f4SSaravana Kannan struct device *dont_lock_dev) 115126e77708SSaravana Kannan { 115226e77708SSaravana Kannan struct device *dev, *tmp; 115326e77708SSaravana Kannan 11543b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) { 11553b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 115626e77708SSaravana Kannan 115721eb93f4SSaravana Kannan if (dev != dont_lock_dev) 115826e77708SSaravana Kannan device_lock(dev); 115926e77708SSaravana Kannan 1160f8fb5766SSaravana Kannan dev_sync_state(dev); 1161fc5a251dSSaravana Kannan 116221eb93f4SSaravana Kannan if (dev != dont_lock_dev) 116326e77708SSaravana Kannan device_unlock(dev); 116426e77708SSaravana Kannan 116526e77708SSaravana Kannan put_device(dev); 116626e77708SSaravana Kannan } 1167fc5a251dSSaravana Kannan } 1168fc5a251dSSaravana Kannan 1169fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void) 1170fc5a251dSSaravana Kannan { 1171fc5a251dSSaravana Kannan device_links_write_lock(); 1172fc5a251dSSaravana Kannan defer_sync_state_count++; 1173fc5a251dSSaravana Kannan device_links_write_unlock(); 1174fc5a251dSSaravana Kannan } 1175fc5a251dSSaravana Kannan 1176fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void) 1177fc5a251dSSaravana Kannan { 1178fc5a251dSSaravana Kannan struct device *dev, *tmp; 117926e77708SSaravana Kannan LIST_HEAD(sync_list); 1180fc5a251dSSaravana Kannan 1181fc5a251dSSaravana Kannan device_links_write_lock(); 1182fc5a251dSSaravana Kannan if (!defer_sync_state_count) { 1183fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!"); 1184fc5a251dSSaravana Kannan goto out; 1185fc5a251dSSaravana Kannan } 1186fc5a251dSSaravana Kannan defer_sync_state_count--; 1187fc5a251dSSaravana Kannan if (defer_sync_state_count) 1188fc5a251dSSaravana Kannan goto out; 1189fc5a251dSSaravana Kannan 11903b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { 119126e77708SSaravana Kannan /* 119226e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to 11933b052a3eSSaravana Kannan * sync_list because defer_sync is used for both lists. 119426e77708SSaravana Kannan */ 11953b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 119626e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 1197fc5a251dSSaravana Kannan } 1198fc5a251dSSaravana Kannan out: 1199fc5a251dSSaravana Kannan device_links_write_unlock(); 120026e77708SSaravana Kannan 120121eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 1202fc5a251dSSaravana Kannan } 1203fc5a251dSSaravana Kannan 1204fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void) 1205fc5a251dSSaravana Kannan { 1206fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume(); 1207fc5a251dSSaravana Kannan return 0; 1208fc5a251dSSaravana Kannan } 1209fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall); 1210fc5a251dSSaravana Kannan 1211fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup) 1212fc5a251dSSaravana Kannan { 12133b052a3eSSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup)) 12143b052a3eSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync); 1215fc5a251dSSaravana Kannan } 1216fc5a251dSSaravana Kannan 121721c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link) 121821c27f06SSaravana Kannan { 121921c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED; 122021c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE); 122121c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del); 122221c27f06SSaravana Kannan } 122321c27f06SSaravana Kannan 1224da6d6475SSaravana Kannan static ssize_t waiting_for_supplier_show(struct device *dev, 1225da6d6475SSaravana Kannan struct device_attribute *attr, 1226da6d6475SSaravana Kannan char *buf) 1227da6d6475SSaravana Kannan { 1228da6d6475SSaravana Kannan bool val; 1229da6d6475SSaravana Kannan 1230da6d6475SSaravana Kannan device_lock(dev); 12316a6dfdf8SSaravana Kannan mutex_lock(&fwnode_link_lock); 12326a6dfdf8SSaravana Kannan val = !!fwnode_links_check_suppliers(dev->fwnode); 12336a6dfdf8SSaravana Kannan mutex_unlock(&fwnode_link_lock); 1234da6d6475SSaravana Kannan device_unlock(dev); 1235aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 1236da6d6475SSaravana Kannan } 1237da6d6475SSaravana Kannan static DEVICE_ATTR_RO(waiting_for_supplier); 1238da6d6475SSaravana Kannan 12399ed98953SRafael J. Wysocki /** 1240b6f617dfSSaravana Kannan * device_links_force_bind - Prepares device to be force bound 1241b6f617dfSSaravana Kannan * @dev: Consumer device. 1242b6f617dfSSaravana Kannan * 1243b6f617dfSSaravana Kannan * device_bind_driver() force binds a device to a driver without calling any 1244b6f617dfSSaravana Kannan * driver probe functions. So the consumer really isn't going to wait for any 1245b6f617dfSSaravana Kannan * supplier before it's bound to the driver. We still want the device link 1246b6f617dfSSaravana Kannan * states to be sensible when this happens. 1247b6f617dfSSaravana Kannan * 1248b6f617dfSSaravana Kannan * In preparation for device_bind_driver(), this function goes through each 1249b6f617dfSSaravana Kannan * supplier device links and checks if the supplier is bound. If it is, then 1250b6f617dfSSaravana Kannan * the device link status is set to CONSUMER_PROBE. Otherwise, the device link 1251b6f617dfSSaravana Kannan * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored. 1252b6f617dfSSaravana Kannan */ 1253b6f617dfSSaravana Kannan void device_links_force_bind(struct device *dev) 1254b6f617dfSSaravana Kannan { 1255b6f617dfSSaravana Kannan struct device_link *link, *ln; 1256b6f617dfSSaravana Kannan 1257b6f617dfSSaravana Kannan device_links_write_lock(); 1258b6f617dfSSaravana Kannan 1259b6f617dfSSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 1260b6f617dfSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED)) 1261b6f617dfSSaravana Kannan continue; 1262b6f617dfSSaravana Kannan 1263b6f617dfSSaravana Kannan if (link->status != DL_STATE_AVAILABLE) { 1264b6f617dfSSaravana Kannan device_link_drop_managed(link); 1265b6f617dfSSaravana Kannan continue; 1266b6f617dfSSaravana Kannan } 1267b6f617dfSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE); 1268b6f617dfSSaravana Kannan } 1269b6f617dfSSaravana Kannan dev->links.status = DL_DEV_PROBING; 1270b6f617dfSSaravana Kannan 1271b6f617dfSSaravana Kannan device_links_write_unlock(); 1272b6f617dfSSaravana Kannan } 1273b6f617dfSSaravana Kannan 1274b6f617dfSSaravana Kannan /** 12759ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver. 12769ed98953SRafael J. Wysocki * @dev: Device to update the links for. 12779ed98953SRafael J. Wysocki * 12789ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any 12799ed98953SRafael J. Wysocki * consumers by changing their status to "available". 12809ed98953SRafael J. Wysocki * 12819ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active". 12829ed98953SRafael J. Wysocki * 1283515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 12849ed98953SRafael J. Wysocki */ 12859ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev) 12869ed98953SRafael J. Wysocki { 128721c27f06SSaravana Kannan struct device_link *link, *ln; 128826e77708SSaravana Kannan LIST_HEAD(sync_list); 12899ed98953SRafael J. Wysocki 1290bcbbcfd5SSaravana Kannan /* 12919528e0d9SSaravana Kannan * If a device binds successfully, it's expected to have created all 1292bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs 12939528e0d9SSaravana Kannan * them. So, fw_devlink no longer needs to create device links to any 12949528e0d9SSaravana Kannan * of the device's suppliers. 12959528e0d9SSaravana Kannan * 12963a2dbc51SSaravana Kannan * Also, if a child firmware node of this bound device is not added as a 12973a2dbc51SSaravana Kannan * device by now, assume it is never going to be added. Make this bound 12983a2dbc51SSaravana Kannan * device the fallback supplier to the dangling consumers of the child 12993a2dbc51SSaravana Kannan * firmware node because this bound device is probably implementing the 13003a2dbc51SSaravana Kannan * child firmware node functionality and we don't want the dangling 13013a2dbc51SSaravana Kannan * consumers to defer probe indefinitely waiting for a device for the 13023a2dbc51SSaravana Kannan * child firmware node. 1303bcbbcfd5SSaravana Kannan */ 13049528e0d9SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) { 13059528e0d9SSaravana Kannan struct fwnode_handle *child; 1306f9aa4606SSaravana Kannan fwnode_links_purge_suppliers(dev->fwnode); 13073a2dbc51SSaravana Kannan mutex_lock(&fwnode_link_lock); 13089528e0d9SSaravana Kannan fwnode_for_each_available_child_node(dev->fwnode, child) 13093a2dbc51SSaravana Kannan __fw_devlink_pickup_dangling_consumers(child, 13103a2dbc51SSaravana Kannan dev->fwnode); 13113a2dbc51SSaravana Kannan __fw_devlink_link_to_consumers(dev); 13123a2dbc51SSaravana Kannan mutex_unlock(&fwnode_link_lock); 13139528e0d9SSaravana Kannan } 1314da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 1315bcbbcfd5SSaravana Kannan 13169ed98953SRafael J. Wysocki device_links_write_lock(); 13179ed98953SRafael J. Wysocki 13189ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1319515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13209ed98953SRafael J. Wysocki continue; 13219ed98953SRafael J. Wysocki 132215cfb094SRafael J. Wysocki /* 132315cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer 132415cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing 132515cfb094SRafael J. Wysocki * when they are created and they may become "active" if the 132615cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here. 132715cfb094SRafael J. Wysocki */ 132815cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 132915cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 133015cfb094SRafael J. Wysocki continue; 133115cfb094SRafael J. Wysocki 13329ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT); 13339ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 1334e7dd4010SRafael J. Wysocki 1335e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER) 1336e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer); 13379ed98953SRafael J. Wysocki } 13389ed98953SRafael J. Wysocki 133921eb93f4SSaravana Kannan if (defer_sync_state_count) 134021eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev); 134121eb93f4SSaravana Kannan else 134221eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list); 134321eb93f4SSaravana Kannan 134421c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) { 134521c27f06SSaravana Kannan struct device *supplier; 134621c27f06SSaravana Kannan 1347515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 13489ed98953SRafael J. Wysocki continue; 13499ed98953SRafael J. Wysocki 135021c27f06SSaravana Kannan supplier = link->supplier; 135121c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) { 135221c27f06SSaravana Kannan /* 135321c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no 135421c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's 135521c27f06SSaravana Kannan * save to drop the managed link completely. 135621c27f06SSaravana Kannan */ 135721c27f06SSaravana Kannan device_link_drop_managed(link); 13582f8c3ae8SSaravana Kannan } else if (dev_is_best_effort(dev) && 13592f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED && 13602f8c3ae8SSaravana Kannan link->status != DL_STATE_CONSUMER_PROBE && 13612f8c3ae8SSaravana Kannan !link->supplier->can_match) { 13622f8c3ae8SSaravana Kannan /* 13632f8c3ae8SSaravana Kannan * When dev_is_best_effort() is true, we ignore device 13642f8c3ae8SSaravana Kannan * links to suppliers that don't have a driver. If the 13652f8c3ae8SSaravana Kannan * consumer device still managed to probe, there's no 13662f8c3ae8SSaravana Kannan * point in maintaining a device link in a weird state 13672f8c3ae8SSaravana Kannan * (consumer probed before supplier). So delete it. 13682f8c3ae8SSaravana Kannan */ 13692f8c3ae8SSaravana Kannan device_link_drop_managed(link); 137021c27f06SSaravana Kannan } else { 13719ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); 13729ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE); 137321c27f06SSaravana Kannan } 1374fc5a251dSSaravana Kannan 137521c27f06SSaravana Kannan /* 137621c27f06SSaravana Kannan * This needs to be done even for the deleted 137721c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last 137821c27f06SSaravana Kannan * device link that was preventing the supplier from getting a 137921c27f06SSaravana Kannan * sync_state() call. 138021c27f06SSaravana Kannan */ 1381fc5a251dSSaravana Kannan if (defer_sync_state_count) 138221c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier); 1383fc5a251dSSaravana Kannan else 138421c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list); 13859ed98953SRafael J. Wysocki } 13869ed98953SRafael J. Wysocki 13879ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND; 13889ed98953SRafael J. Wysocki 13899ed98953SRafael J. Wysocki device_links_write_unlock(); 139026e77708SSaravana Kannan 139121eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev); 13929ed98953SRafael J. Wysocki } 13939ed98953SRafael J. Wysocki 13949ed98953SRafael J. Wysocki /** 13959ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver. 13969ed98953SRafael J. Wysocki * @dev: Device without a drvier. 13979ed98953SRafael J. Wysocki * 13989ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers. 13999ed98953SRafael J. Wysocki * 14009ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available", 14019ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which 14029ed98953SRafael J. Wysocki * case they need not be updated. 14039ed98953SRafael J. Wysocki * 1404515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14059ed98953SRafael J. Wysocki */ 14069ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev) 14079ed98953SRafael J. Wysocki { 14089ed98953SRafael J. Wysocki struct device_link *link, *ln; 14099ed98953SRafael J. Wysocki 14109ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 1411515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 14129ed98953SRafael J. Wysocki continue; 14139ed98953SRafael J. Wysocki 14148c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) { 1415515db266SRafael J. Wysocki device_link_drop_managed(link); 14168c3e315dSSaravana Kannan continue; 14178c3e315dSSaravana Kannan } 14188c3e315dSSaravana Kannan 14198c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE && 14208c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE) 14218c3e315dSSaravana Kannan continue; 14228c3e315dSSaravana Kannan 14238c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) { 14249ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE); 14258c3e315dSSaravana Kannan } else { 14268c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY)); 14278c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT); 14288c3e315dSSaravana Kannan } 14299ed98953SRafael J. Wysocki } 14309ed98953SRafael J. Wysocki 14319ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 14329ed98953SRafael J. Wysocki } 14339ed98953SRafael J. Wysocki 143415cfb094SRafael J. Wysocki /** 143515cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe. 143615cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe. 143715cfb094SRafael J. Wysocki * 143815cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke 143915cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as 144015cfb094SRafael J. Wysocki * appropriate. 144115cfb094SRafael J. Wysocki * 1442515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 144315cfb094SRafael J. Wysocki */ 14449ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev) 14459ed98953SRafael J. Wysocki { 144615cfb094SRafael J. Wysocki struct device_link *link; 144715cfb094SRafael J. Wysocki 14489ed98953SRafael J. Wysocki device_links_write_lock(); 144915cfb094SRafael J. Wysocki 145015cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1451515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 145215cfb094SRafael J. Wysocki continue; 145315cfb094SRafael J. Wysocki 145415cfb094SRafael J. Wysocki /* 145515cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is 145615cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by 145715cfb094SRafael J. Wysocki * a probing consumer while this device was still probing. 145815cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid 145915cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful. 146015cfb094SRafael J. Wysocki */ 146115cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE || 146215cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE) 146315cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 146415cfb094SRafael J. Wysocki } 146515cfb094SRafael J. Wysocki 14669ed98953SRafael J. Wysocki __device_links_no_driver(dev); 146715cfb094SRafael J. Wysocki 14689ed98953SRafael J. Wysocki device_links_write_unlock(); 14699ed98953SRafael J. Wysocki } 14709ed98953SRafael J. Wysocki 14719ed98953SRafael J. Wysocki /** 14729ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal. 14739ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away. 14749ed98953SRafael J. Wysocki * 14759ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and 14769ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as 14779ed98953SRafael J. Wysocki * appropriate. 14789ed98953SRafael J. Wysocki * 1479515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 14809ed98953SRafael J. Wysocki */ 14819ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev) 14829ed98953SRafael J. Wysocki { 1483c8d50986SRafael J. Wysocki struct device_link *link, *ln; 14849ed98953SRafael J. Wysocki 14859ed98953SRafael J. Wysocki device_links_write_lock(); 14869ed98953SRafael J. Wysocki 1487c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) { 1488515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 14899ed98953SRafael J. Wysocki continue; 14909ed98953SRafael J. Wysocki 1491e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER); 14929ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND); 14931689cac5SVivek Gautam 14941689cac5SVivek Gautam /* 14951689cac5SVivek Gautam * autoremove the links between this @dev and its consumer 14961689cac5SVivek Gautam * devices that are not active, i.e. where the link state 14971689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND. 14981689cac5SVivek Gautam */ 14991689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND && 15001689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER) 1501515db266SRafael J. Wysocki device_link_drop_managed(link); 15021689cac5SVivek Gautam 15039ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT); 15049ed98953SRafael J. Wysocki } 15059ed98953SRafael J. Wysocki 15063b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync); 15079ed98953SRafael J. Wysocki __device_links_no_driver(dev); 15089ed98953SRafael J. Wysocki 15099ed98953SRafael J. Wysocki device_links_write_unlock(); 15109ed98953SRafael J. Wysocki } 15119ed98953SRafael J. Wysocki 15129ed98953SRafael J. Wysocki /** 15139ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers. 15149ed98953SRafael J. Wysocki * @dev: Device to check. 15159ed98953SRafael J. Wysocki * 15169ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status 15179ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is 15189ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link 15199ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed 15209ed98953SRafael J. Wysocki * successfully going forward. 15219ed98953SRafael J. Wysocki * 15229ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers. 15239ed98953SRafael J. Wysocki * 1524515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 15259ed98953SRafael J. Wysocki */ 15269ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev) 15279ed98953SRafael J. Wysocki { 15289ed98953SRafael J. Wysocki struct device_link *link; 15299ed98953SRafael J. Wysocki bool ret = false; 15309ed98953SRafael J. Wysocki 15319ed98953SRafael J. Wysocki device_links_write_lock(); 15329ed98953SRafael J. Wysocki 15339ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 1534515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) 15359ed98953SRafael J. Wysocki continue; 15369ed98953SRafael J. Wysocki 15379ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE 15389ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) { 15399ed98953SRafael J. Wysocki ret = true; 15409ed98953SRafael J. Wysocki break; 15419ed98953SRafael J. Wysocki } 15429ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 15439ed98953SRafael J. Wysocki } 15449ed98953SRafael J. Wysocki 15459ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING; 15469ed98953SRafael J. Wysocki 15479ed98953SRafael J. Wysocki device_links_write_unlock(); 15489ed98953SRafael J. Wysocki return ret; 15499ed98953SRafael J. Wysocki } 15509ed98953SRafael J. Wysocki 15519ed98953SRafael J. Wysocki /** 15529ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device. 15539ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of. 15549ed98953SRafael J. Wysocki * 15559ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the 15569ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete 15579ed98953SRafael J. Wysocki * and start over. 15589ed98953SRafael J. Wysocki * 15599ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind" 15609ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer 15619ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have 15629ed98953SRafael J. Wysocki * changed the state of the link already). 15639ed98953SRafael J. Wysocki * 1564515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored. 15659ed98953SRafael J. Wysocki */ 15669ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev) 15679ed98953SRafael J. Wysocki { 15689ed98953SRafael J. Wysocki struct device_link *link; 15699ed98953SRafael J. Wysocki 15709ed98953SRafael J. Wysocki start: 15719ed98953SRafael J. Wysocki device_links_write_lock(); 15729ed98953SRafael J. Wysocki 15739ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) { 15749ed98953SRafael J. Wysocki enum device_link_state status; 15759ed98953SRafael J. Wysocki 157605ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 157705ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY) 15789ed98953SRafael J. Wysocki continue; 15799ed98953SRafael J. Wysocki 15809ed98953SRafael J. Wysocki status = link->status; 15819ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) { 15829ed98953SRafael J. Wysocki device_links_write_unlock(); 15839ed98953SRafael J. Wysocki 15849ed98953SRafael J. Wysocki wait_for_device_probe(); 15859ed98953SRafael J. Wysocki goto start; 15869ed98953SRafael J. Wysocki } 15879ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND); 15889ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) { 15899ed98953SRafael J. Wysocki struct device *consumer = link->consumer; 15909ed98953SRafael J. Wysocki 15919ed98953SRafael J. Wysocki get_device(consumer); 15929ed98953SRafael J. Wysocki 15939ed98953SRafael J. Wysocki device_links_write_unlock(); 15949ed98953SRafael J. Wysocki 15959ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL, 15969ed98953SRafael J. Wysocki consumer->parent); 15979ed98953SRafael J. Wysocki put_device(consumer); 15989ed98953SRafael J. Wysocki goto start; 15999ed98953SRafael J. Wysocki } 16009ed98953SRafael J. Wysocki } 16019ed98953SRafael J. Wysocki 16029ed98953SRafael J. Wysocki device_links_write_unlock(); 16039ed98953SRafael J. Wysocki } 16049ed98953SRafael J. Wysocki 16059ed98953SRafael J. Wysocki /** 16069ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices. 16079ed98953SRafael J. Wysocki * @dev: Target device. 16089ed98953SRafael J. Wysocki */ 16099ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev) 16109ed98953SRafael J. Wysocki { 16119ed98953SRafael J. Wysocki struct device_link *link, *ln; 16129ed98953SRafael J. Wysocki 1613287905e6SSaravana Kannan if (dev->class == &devlink_class) 1614287905e6SSaravana Kannan return; 1615287905e6SSaravana Kannan 16169ed98953SRafael J. Wysocki /* 16179ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other 16189ed98953SRafael J. Wysocki * devices (either consumers or suppliers). 16199ed98953SRafael J. Wysocki */ 16209ed98953SRafael J. Wysocki device_links_write_lock(); 16219ed98953SRafael J. Wysocki 16229ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) { 16239ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE); 1624ead18c23SLukas Wunner __device_link_del(&link->kref); 16259ed98953SRafael J. Wysocki } 16269ed98953SRafael J. Wysocki 16279ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) { 16289ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT && 16299ed98953SRafael J. Wysocki link->status != DL_STATE_NONE); 1630ead18c23SLukas Wunner __device_link_del(&link->kref); 16319ed98953SRafael J. Wysocki } 16329ed98953SRafael J. Wysocki 16339ed98953SRafael J. Wysocki device_links_write_unlock(); 16349ed98953SRafael J. Wysocki } 16359ed98953SRafael J. Wysocki 1636b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_PERMISSIVE (DL_FLAG_INFERRED | \ 1637b90fb8f6SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY) 1638b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_ON (DL_FLAG_INFERRED | \ 1639b90fb8f6SSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER) 1640b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_RPM (FW_DEVLINK_FLAGS_ON | \ 1641b90fb8f6SSaravana Kannan DL_FLAG_PM_RUNTIME) 1642b90fb8f6SSaravana Kannan 1643ea718c69SSaravana Kannan static u32 fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 164442926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg) 164542926ac3SSaravana Kannan { 164642926ac3SSaravana Kannan if (!arg) 164742926ac3SSaravana Kannan return -EINVAL; 164842926ac3SSaravana Kannan 164942926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) { 165042926ac3SSaravana Kannan fw_devlink_flags = 0; 165142926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) { 1652b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_PERMISSIVE; 165342926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) { 1654b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_ON; 165542926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) { 1656b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_RPM; 165742926ac3SSaravana Kannan } 165842926ac3SSaravana Kannan return 0; 165942926ac3SSaravana Kannan } 166042926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup); 166142926ac3SSaravana Kannan 1662d8ab4685SGreg Kroah-Hartman static bool fw_devlink_strict; 166319d0f5f6SSaravana Kannan static int __init fw_devlink_strict_setup(char *arg) 166419d0f5f6SSaravana Kannan { 166573060022SChristophe JAILLET return kstrtobool(arg, &fw_devlink_strict); 166619d0f5f6SSaravana Kannan } 166719d0f5f6SSaravana Kannan early_param("fw_devlink.strict", fw_devlink_strict_setup); 166819d0f5f6SSaravana Kannan 1669ffbe08a8SSaravana Kannan #define FW_DEVLINK_SYNC_STATE_STRICT 0 1670ffbe08a8SSaravana Kannan #define FW_DEVLINK_SYNC_STATE_TIMEOUT 1 1671ffbe08a8SSaravana Kannan 16728ad266d1SSaravana Kannan #ifndef CONFIG_FW_DEVLINK_SYNC_STATE_TIMEOUT 1673ffbe08a8SSaravana Kannan static int fw_devlink_sync_state; 16748ad266d1SSaravana Kannan #else 16758ad266d1SSaravana Kannan static int fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_TIMEOUT; 16768ad266d1SSaravana Kannan #endif 16778ad266d1SSaravana Kannan 1678ffbe08a8SSaravana Kannan static int __init fw_devlink_sync_state_setup(char *arg) 1679ffbe08a8SSaravana Kannan { 1680ffbe08a8SSaravana Kannan if (!arg) 1681ffbe08a8SSaravana Kannan return -EINVAL; 1682ffbe08a8SSaravana Kannan 1683ffbe08a8SSaravana Kannan if (strcmp(arg, "strict") == 0) { 1684ffbe08a8SSaravana Kannan fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_STRICT; 1685ffbe08a8SSaravana Kannan return 0; 1686ffbe08a8SSaravana Kannan } else if (strcmp(arg, "timeout") == 0) { 1687ffbe08a8SSaravana Kannan fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_TIMEOUT; 1688ffbe08a8SSaravana Kannan return 0; 1689ffbe08a8SSaravana Kannan } 1690ffbe08a8SSaravana Kannan return -EINVAL; 1691ffbe08a8SSaravana Kannan } 1692ffbe08a8SSaravana Kannan early_param("fw_devlink.sync_state", fw_devlink_sync_state_setup); 1693ffbe08a8SSaravana Kannan 1694cd115c04SSaravana Kannan static inline u32 fw_devlink_get_flags(u8 fwlink_flags) 169542926ac3SSaravana Kannan { 1696cd115c04SSaravana Kannan if (fwlink_flags & FWLINK_FLAG_CYCLE) 1697cd115c04SSaravana Kannan return FW_DEVLINK_FLAGS_PERMISSIVE | DL_FLAG_CYCLE; 1698cd115c04SSaravana Kannan 169942926ac3SSaravana Kannan return fw_devlink_flags; 170042926ac3SSaravana Kannan } 170142926ac3SSaravana Kannan 170242926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void) 170342926ac3SSaravana Kannan { 1704b90fb8f6SSaravana Kannan return fw_devlink_flags == FW_DEVLINK_FLAGS_PERMISSIVE; 170542926ac3SSaravana Kannan } 170642926ac3SSaravana Kannan 170719d0f5f6SSaravana Kannan bool fw_devlink_is_strict(void) 170819d0f5f6SSaravana Kannan { 170919d0f5f6SSaravana Kannan return fw_devlink_strict && !fw_devlink_is_permissive(); 17109ed98953SRafael J. Wysocki } 17119ed98953SRafael J. Wysocki 1712c2c724c8SSaravana Kannan static void fw_devlink_parse_fwnode(struct fwnode_handle *fwnode) 1713c2c724c8SSaravana Kannan { 1714c2c724c8SSaravana Kannan if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED) 1715c2c724c8SSaravana Kannan return; 1716c2c724c8SSaravana Kannan 17172d09e6ebSSaravana Kannan fwnode_call_int_op(fwnode, add_links); 1718c2c724c8SSaravana Kannan fwnode->flags |= FWNODE_FLAG_LINKS_ADDED; 1719c2c724c8SSaravana Kannan } 1720c2c724c8SSaravana Kannan 1721c2c724c8SSaravana Kannan static void fw_devlink_parse_fwtree(struct fwnode_handle *fwnode) 1722c2c724c8SSaravana Kannan { 1723c2c724c8SSaravana Kannan struct fwnode_handle *child = NULL; 1724c2c724c8SSaravana Kannan 1725c2c724c8SSaravana Kannan fw_devlink_parse_fwnode(fwnode); 1726c2c724c8SSaravana Kannan 1727c2c724c8SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 1728c2c724c8SSaravana Kannan fw_devlink_parse_fwtree(child); 1729c2c724c8SSaravana Kannan } 1730c2c724c8SSaravana Kannan 1731d46f3e3eSSaravana Kannan static void fw_devlink_relax_link(struct device_link *link) 1732d46f3e3eSSaravana Kannan { 1733d46f3e3eSSaravana Kannan if (!(link->flags & DL_FLAG_INFERRED)) 1734d46f3e3eSSaravana Kannan return; 1735d46f3e3eSSaravana Kannan 173667cad5c6SSaravana Kannan if (device_link_flag_is_sync_state_only(link->flags)) 1737d46f3e3eSSaravana Kannan return; 1738d46f3e3eSSaravana Kannan 1739d46f3e3eSSaravana Kannan pm_runtime_drop_link(link); 1740d46f3e3eSSaravana Kannan link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE; 1741d46f3e3eSSaravana Kannan dev_dbg(link->consumer, "Relaxing link with %s\n", 1742d46f3e3eSSaravana Kannan dev_name(link->supplier)); 1743d46f3e3eSSaravana Kannan } 1744d46f3e3eSSaravana Kannan 1745d46f3e3eSSaravana Kannan static int fw_devlink_no_driver(struct device *dev, void *data) 1746d46f3e3eSSaravana Kannan { 1747d46f3e3eSSaravana Kannan struct device_link *link = to_devlink(dev); 1748d46f3e3eSSaravana Kannan 1749d46f3e3eSSaravana Kannan if (!link->supplier->can_match) 1750d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1751d46f3e3eSSaravana Kannan 1752d46f3e3eSSaravana Kannan return 0; 1753d46f3e3eSSaravana Kannan } 1754d46f3e3eSSaravana Kannan 1755d46f3e3eSSaravana Kannan void fw_devlink_drivers_done(void) 1756d46f3e3eSSaravana Kannan { 1757d46f3e3eSSaravana Kannan fw_devlink_drv_reg_done = true; 1758d46f3e3eSSaravana Kannan device_links_write_lock(); 1759d46f3e3eSSaravana Kannan class_for_each_device(&devlink_class, NULL, NULL, 1760d46f3e3eSSaravana Kannan fw_devlink_no_driver); 1761d46f3e3eSSaravana Kannan device_links_write_unlock(); 1762d46f3e3eSSaravana Kannan } 1763d46f3e3eSSaravana Kannan 1764ffbe08a8SSaravana Kannan static int fw_devlink_dev_sync_state(struct device *dev, void *data) 1765ffbe08a8SSaravana Kannan { 1766ffbe08a8SSaravana Kannan struct device_link *link = to_devlink(dev); 1767ffbe08a8SSaravana Kannan struct device *sup = link->supplier; 1768ffbe08a8SSaravana Kannan 1769ffbe08a8SSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) || 1770ffbe08a8SSaravana Kannan link->status == DL_STATE_ACTIVE || sup->state_synced || 1771ffbe08a8SSaravana Kannan !dev_has_sync_state(sup)) 1772ffbe08a8SSaravana Kannan return 0; 1773ffbe08a8SSaravana Kannan 1774ffbe08a8SSaravana Kannan if (fw_devlink_sync_state == FW_DEVLINK_SYNC_STATE_STRICT) { 1775ffbe08a8SSaravana Kannan dev_warn(sup, "sync_state() pending due to %s\n", 1776ffbe08a8SSaravana Kannan dev_name(link->consumer)); 1777ffbe08a8SSaravana Kannan return 0; 1778ffbe08a8SSaravana Kannan } 1779ffbe08a8SSaravana Kannan 1780ffbe08a8SSaravana Kannan if (!list_empty(&sup->links.defer_sync)) 1781ffbe08a8SSaravana Kannan return 0; 1782ffbe08a8SSaravana Kannan 1783ffbe08a8SSaravana Kannan dev_warn(sup, "Timed out. Forcing sync_state()\n"); 1784ffbe08a8SSaravana Kannan sup->state_synced = true; 1785ffbe08a8SSaravana Kannan get_device(sup); 1786ffbe08a8SSaravana Kannan list_add_tail(&sup->links.defer_sync, data); 1787ffbe08a8SSaravana Kannan 1788ffbe08a8SSaravana Kannan return 0; 1789ffbe08a8SSaravana Kannan } 1790ffbe08a8SSaravana Kannan 1791ffbe08a8SSaravana Kannan void fw_devlink_probing_done(void) 1792ffbe08a8SSaravana Kannan { 1793ffbe08a8SSaravana Kannan LIST_HEAD(sync_list); 1794ffbe08a8SSaravana Kannan 1795ffbe08a8SSaravana Kannan device_links_write_lock(); 1796ffbe08a8SSaravana Kannan class_for_each_device(&devlink_class, NULL, &sync_list, 1797ffbe08a8SSaravana Kannan fw_devlink_dev_sync_state); 1798ffbe08a8SSaravana Kannan device_links_write_unlock(); 1799ffbe08a8SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL); 1800ffbe08a8SSaravana Kannan } 1801ffbe08a8SSaravana Kannan 18022f8c3ae8SSaravana Kannan /** 18032f8c3ae8SSaravana Kannan * wait_for_init_devices_probe - Try to probe any device needed for init 18042f8c3ae8SSaravana Kannan * 18052f8c3ae8SSaravana Kannan * Some devices might need to be probed and bound successfully before the kernel 18062f8c3ae8SSaravana Kannan * boot sequence can finish and move on to init/userspace. For example, a 18072f8c3ae8SSaravana Kannan * network interface might need to be bound to be able to mount a NFS rootfs. 18082f8c3ae8SSaravana Kannan * 18092f8c3ae8SSaravana Kannan * With fw_devlink=on by default, some of these devices might be blocked from 18102f8c3ae8SSaravana Kannan * probing because they are waiting on a optional supplier that doesn't have a 18112f8c3ae8SSaravana Kannan * driver. While fw_devlink will eventually identify such devices and unblock 18122f8c3ae8SSaravana Kannan * the probing automatically, it might be too late by the time it unblocks the 18132f8c3ae8SSaravana Kannan * probing of devices. For example, the IP4 autoconfig might timeout before 18142f8c3ae8SSaravana Kannan * fw_devlink unblocks probing of the network interface. 18152f8c3ae8SSaravana Kannan * 18162f8c3ae8SSaravana Kannan * This function is available to temporarily try and probe all devices that have 18172f8c3ae8SSaravana Kannan * a driver even if some of their suppliers haven't been added or don't have 18182f8c3ae8SSaravana Kannan * drivers. 18192f8c3ae8SSaravana Kannan * 18202f8c3ae8SSaravana Kannan * The drivers can then decide which of the suppliers are optional vs mandatory 18212f8c3ae8SSaravana Kannan * and probe the device if possible. By the time this function returns, all such 18222f8c3ae8SSaravana Kannan * "best effort" probes are guaranteed to be completed. If a device successfully 18232f8c3ae8SSaravana Kannan * probes in this mode, we delete all fw_devlink discovered dependencies of that 18242f8c3ae8SSaravana Kannan * device where the supplier hasn't yet probed successfully because they have to 18252f8c3ae8SSaravana Kannan * be optional dependencies. 18262f8c3ae8SSaravana Kannan * 18272f8c3ae8SSaravana Kannan * Any devices that didn't successfully probe go back to being treated as if 18282f8c3ae8SSaravana Kannan * this function was never called. 18292f8c3ae8SSaravana Kannan * 18302f8c3ae8SSaravana Kannan * This also means that some devices that aren't needed for init and could have 18312f8c3ae8SSaravana Kannan * waited for their optional supplier to probe (when the supplier's module is 18322f8c3ae8SSaravana Kannan * loaded later on) would end up probing prematurely with limited functionality. 18332f8c3ae8SSaravana Kannan * So call this function only when boot would fail without it. 18342f8c3ae8SSaravana Kannan */ 18352f8c3ae8SSaravana Kannan void __init wait_for_init_devices_probe(void) 18362f8c3ae8SSaravana Kannan { 18372f8c3ae8SSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive()) 18382f8c3ae8SSaravana Kannan return; 18392f8c3ae8SSaravana Kannan 18402f8c3ae8SSaravana Kannan /* 18412f8c3ae8SSaravana Kannan * Wait for all ongoing probes to finish so that the "best effort" is 18422f8c3ae8SSaravana Kannan * only applied to devices that can't probe otherwise. 18432f8c3ae8SSaravana Kannan */ 18442f8c3ae8SSaravana Kannan wait_for_device_probe(); 18452f8c3ae8SSaravana Kannan 18462f8c3ae8SSaravana Kannan pr_info("Trying to probe devices needed for running init ...\n"); 18472f8c3ae8SSaravana Kannan fw_devlink_best_effort = true; 18482f8c3ae8SSaravana Kannan driver_deferred_probe_trigger(); 18492f8c3ae8SSaravana Kannan 18502f8c3ae8SSaravana Kannan /* 18512f8c3ae8SSaravana Kannan * Wait for all "best effort" probes to finish before going back to 18522f8c3ae8SSaravana Kannan * normal enforcement. 18532f8c3ae8SSaravana Kannan */ 18542f8c3ae8SSaravana Kannan wait_for_device_probe(); 18552f8c3ae8SSaravana Kannan fw_devlink_best_effort = false; 18562f8c3ae8SSaravana Kannan } 18572f8c3ae8SSaravana Kannan 1858d46f3e3eSSaravana Kannan static void fw_devlink_unblock_consumers(struct device *dev) 1859d46f3e3eSSaravana Kannan { 1860d46f3e3eSSaravana Kannan struct device_link *link; 1861d46f3e3eSSaravana Kannan 1862d46f3e3eSSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive()) 1863d46f3e3eSSaravana Kannan return; 1864d46f3e3eSSaravana Kannan 1865d46f3e3eSSaravana Kannan device_links_write_lock(); 1866d46f3e3eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) 1867d46f3e3eSSaravana Kannan fw_devlink_relax_link(link); 1868d46f3e3eSSaravana Kannan device_links_write_unlock(); 1869d46f3e3eSSaravana Kannan } 1870d46f3e3eSSaravana Kannan 1871b0e2fa4fSSaravana Kannan 1872411c0d58SSaravana Kannan static bool fwnode_init_without_drv(struct fwnode_handle *fwnode) 1873b0e2fa4fSSaravana Kannan { 1874411c0d58SSaravana Kannan struct device *dev; 1875411c0d58SSaravana Kannan bool ret; 1876b0e2fa4fSSaravana Kannan 1877411c0d58SSaravana Kannan if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED)) 1878411c0d58SSaravana Kannan return false; 1879b0e2fa4fSSaravana Kannan 1880411c0d58SSaravana Kannan dev = get_dev_from_fwnode(fwnode); 1881411c0d58SSaravana Kannan ret = !dev || dev->links.status == DL_DEV_NO_DRIVER; 1882411c0d58SSaravana Kannan put_device(dev); 1883411c0d58SSaravana Kannan 1884b0e2fa4fSSaravana Kannan return ret; 1885b0e2fa4fSSaravana Kannan } 1886411c0d58SSaravana Kannan 1887411c0d58SSaravana Kannan static bool fwnode_ancestor_init_without_drv(struct fwnode_handle *fwnode) 1888411c0d58SSaravana Kannan { 1889411c0d58SSaravana Kannan struct fwnode_handle *parent; 1890411c0d58SSaravana Kannan 1891411c0d58SSaravana Kannan fwnode_for_each_parent_node(fwnode, parent) { 1892411c0d58SSaravana Kannan if (fwnode_init_without_drv(parent)) { 1893411c0d58SSaravana Kannan fwnode_handle_put(parent); 1894411c0d58SSaravana Kannan return true; 1895411c0d58SSaravana Kannan } 1896411c0d58SSaravana Kannan } 1897411c0d58SSaravana Kannan 1898411c0d58SSaravana Kannan return false; 1899411c0d58SSaravana Kannan } 1900411c0d58SSaravana Kannan 1901b0e2fa4fSSaravana Kannan /** 19023fb16866SSaravana Kannan * __fw_devlink_relax_cycles - Relax and mark dependency cycles. 19033fb16866SSaravana Kannan * @con: Potential consumer device. 19043fb16866SSaravana Kannan * @sup_handle: Potential supplier's fwnode. 19053fb16866SSaravana Kannan * 19063fb16866SSaravana Kannan * Needs to be called with fwnode_lock and device link lock held. 19073fb16866SSaravana Kannan * 19083fb16866SSaravana Kannan * Check if @sup_handle or any of its ancestors or suppliers direct/indirectly 19093fb16866SSaravana Kannan * depend on @con. This function can detect multiple cyles between @sup_handle 19103fb16866SSaravana Kannan * and @con. When such dependency cycles are found, convert all device links 19113fb16866SSaravana Kannan * created solely by fw_devlink into SYNC_STATE_ONLY device links. Also, mark 19123fb16866SSaravana Kannan * all fwnode links in the cycle with FWLINK_FLAG_CYCLE so that when they are 19133fb16866SSaravana Kannan * converted into a device link in the future, they are created as 19143fb16866SSaravana Kannan * SYNC_STATE_ONLY device links. This is the equivalent of doing 19153fb16866SSaravana Kannan * fw_devlink=permissive just between the devices in the cycle. We need to do 19163fb16866SSaravana Kannan * this because, at this point, fw_devlink can't tell which of these 19173fb16866SSaravana Kannan * dependencies is not a real dependency. 19183fb16866SSaravana Kannan * 19193fb16866SSaravana Kannan * Return true if one or more cycles were found. Otherwise, return false. 19203fb16866SSaravana Kannan */ 19213fb16866SSaravana Kannan static bool __fw_devlink_relax_cycles(struct device *con, 19223fb16866SSaravana Kannan struct fwnode_handle *sup_handle) 19233fb16866SSaravana Kannan { 19243fb16866SSaravana Kannan struct device *sup_dev = NULL, *par_dev = NULL; 19253fb16866SSaravana Kannan struct fwnode_link *link; 19263fb16866SSaravana Kannan struct device_link *dev_link; 19273fb16866SSaravana Kannan bool ret = false; 19283fb16866SSaravana Kannan 19293fb16866SSaravana Kannan if (!sup_handle) 19303fb16866SSaravana Kannan return false; 19313fb16866SSaravana Kannan 19323fb16866SSaravana Kannan /* 19333fb16866SSaravana Kannan * We aren't trying to find all cycles. Just a cycle between con and 19343fb16866SSaravana Kannan * sup_handle. 19353fb16866SSaravana Kannan */ 19363fb16866SSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_VISITED) 19373fb16866SSaravana Kannan return false; 19383fb16866SSaravana Kannan 19393fb16866SSaravana Kannan sup_handle->flags |= FWNODE_FLAG_VISITED; 19403fb16866SSaravana Kannan 19413fb16866SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle); 19423fb16866SSaravana Kannan 19433fb16866SSaravana Kannan /* Termination condition. */ 19443fb16866SSaravana Kannan if (sup_dev == con) { 19453fb16866SSaravana Kannan ret = true; 19463fb16866SSaravana Kannan goto out; 19473fb16866SSaravana Kannan } 19483fb16866SSaravana Kannan 19493fb16866SSaravana Kannan /* 19503fb16866SSaravana Kannan * If sup_dev is bound to a driver and @con hasn't started binding to a 19513fb16866SSaravana Kannan * driver, sup_dev can't be a consumer of @con. So, no need to check 19523fb16866SSaravana Kannan * further. 19533fb16866SSaravana Kannan */ 19543fb16866SSaravana Kannan if (sup_dev && sup_dev->links.status == DL_DEV_DRIVER_BOUND && 19553fb16866SSaravana Kannan con->links.status == DL_DEV_NO_DRIVER) { 19563fb16866SSaravana Kannan ret = false; 19573fb16866SSaravana Kannan goto out; 19583fb16866SSaravana Kannan } 19593fb16866SSaravana Kannan 19603fb16866SSaravana Kannan list_for_each_entry(link, &sup_handle->suppliers, c_hook) { 19613fb16866SSaravana Kannan if (__fw_devlink_relax_cycles(con, link->supplier)) { 19623fb16866SSaravana Kannan __fwnode_link_cycle(link); 19633fb16866SSaravana Kannan ret = true; 19643fb16866SSaravana Kannan } 19653fb16866SSaravana Kannan } 19663fb16866SSaravana Kannan 19673fb16866SSaravana Kannan /* 19683fb16866SSaravana Kannan * Give priority to device parent over fwnode parent to account for any 19693fb16866SSaravana Kannan * quirks in how fwnodes are converted to devices. 19703fb16866SSaravana Kannan */ 19713fb16866SSaravana Kannan if (sup_dev) 19723fb16866SSaravana Kannan par_dev = get_device(sup_dev->parent); 19733fb16866SSaravana Kannan else 19743fb16866SSaravana Kannan par_dev = fwnode_get_next_parent_dev(sup_handle); 19753fb16866SSaravana Kannan 19763fb16866SSaravana Kannan if (par_dev && __fw_devlink_relax_cycles(con, par_dev->fwnode)) 19773fb16866SSaravana Kannan ret = true; 19783fb16866SSaravana Kannan 19793fb16866SSaravana Kannan if (!sup_dev) 19803fb16866SSaravana Kannan goto out; 19813fb16866SSaravana Kannan 19823fb16866SSaravana Kannan list_for_each_entry(dev_link, &sup_dev->links.suppliers, c_node) { 19833fb16866SSaravana Kannan /* 19843fb16866SSaravana Kannan * Ignore a SYNC_STATE_ONLY flag only if it wasn't marked as 19853fb16866SSaravana Kannan * such due to a cycle. 19863fb16866SSaravana Kannan */ 19873fb16866SSaravana Kannan if (device_link_flag_is_sync_state_only(dev_link->flags) && 19883fb16866SSaravana Kannan !(dev_link->flags & DL_FLAG_CYCLE)) 19893fb16866SSaravana Kannan continue; 19903fb16866SSaravana Kannan 19913fb16866SSaravana Kannan if (__fw_devlink_relax_cycles(con, 19923fb16866SSaravana Kannan dev_link->supplier->fwnode)) { 19933fb16866SSaravana Kannan fw_devlink_relax_link(dev_link); 19943fb16866SSaravana Kannan dev_link->flags |= DL_FLAG_CYCLE; 19953fb16866SSaravana Kannan ret = true; 19963fb16866SSaravana Kannan } 19973fb16866SSaravana Kannan } 19983fb16866SSaravana Kannan 19993fb16866SSaravana Kannan out: 20003fb16866SSaravana Kannan sup_handle->flags &= ~FWNODE_FLAG_VISITED; 20013fb16866SSaravana Kannan put_device(sup_dev); 20023fb16866SSaravana Kannan put_device(par_dev); 20039ed98953SRafael J. Wysocki return ret; 20041da177e4SLinus Torvalds } 20051da177e4SLinus Torvalds 2006f9aa4606SSaravana Kannan /** 2007f9aa4606SSaravana Kannan * fw_devlink_create_devlink - Create a device link from a consumer to fwnode 200837c52f74SPierre-Louis Bossart * @con: consumer device for the device link 200937c52f74SPierre-Louis Bossart * @sup_handle: fwnode handle of supplier 2010cd115c04SSaravana Kannan * @link: fwnode link that's being converted to a device link 2011f9aa4606SSaravana Kannan * 2012f9aa4606SSaravana Kannan * This function will try to create a device link between the consumer device 2013f9aa4606SSaravana Kannan * @con and the supplier device represented by @sup_handle. 2014f9aa4606SSaravana Kannan * 2015f9aa4606SSaravana Kannan * The supplier has to be provided as a fwnode because incorrect cycles in 2016f9aa4606SSaravana Kannan * fwnode links can sometimes cause the supplier device to never be created. 2017f9aa4606SSaravana Kannan * This function detects such cases and returns an error if it cannot create a 2018f9aa4606SSaravana Kannan * device link from the consumer to a missing supplier. 2019f9aa4606SSaravana Kannan * 2020f9aa4606SSaravana Kannan * Returns, 2021f9aa4606SSaravana Kannan * 0 on successfully creating a device link 2022f9aa4606SSaravana Kannan * -EINVAL if the device link cannot be created as expected 2023f9aa4606SSaravana Kannan * -EAGAIN if the device link cannot be created right now, but it may be 2024f9aa4606SSaravana Kannan * possible to do that in the future 2025f9aa4606SSaravana Kannan */ 2026f9aa4606SSaravana Kannan static int fw_devlink_create_devlink(struct device *con, 2027cd115c04SSaravana Kannan struct fwnode_handle *sup_handle, 2028cd115c04SSaravana Kannan struct fwnode_link *link) 2029f9aa4606SSaravana Kannan { 2030f9aa4606SSaravana Kannan struct device *sup_dev; 2031f9aa4606SSaravana Kannan int ret = 0; 2032cd115c04SSaravana Kannan u32 flags; 2033cd115c04SSaravana Kannan 2034cd115c04SSaravana Kannan if (con->fwnode == link->consumer) 2035cd115c04SSaravana Kannan flags = fw_devlink_get_flags(link->flags); 2036cd115c04SSaravana Kannan else 2037cd115c04SSaravana Kannan flags = FW_DEVLINK_FLAGS_PERMISSIVE; 2038f9aa4606SSaravana Kannan 20395501765aSSaravana Kannan /* 20405501765aSSaravana Kannan * In some cases, a device P might also be a supplier to its child node 20415501765aSSaravana Kannan * C. However, this would defer the probe of C until the probe of P 20425501765aSSaravana Kannan * completes successfully. This is perfectly fine in the device driver 20435501765aSSaravana Kannan * model. device_add() doesn't guarantee probe completion of the device 20445501765aSSaravana Kannan * by the time it returns. 20455501765aSSaravana Kannan * 20465501765aSSaravana Kannan * However, there are a few drivers that assume C will finish probing 20475501765aSSaravana Kannan * as soon as it's added and before P finishes probing. So, we provide 20485501765aSSaravana Kannan * a flag to let fw_devlink know not to delay the probe of C until the 20495501765aSSaravana Kannan * probe of P completes successfully. 20505501765aSSaravana Kannan * 20515501765aSSaravana Kannan * When such a flag is set, we can't create device links where P is the 20525501765aSSaravana Kannan * supplier of C as that would delay the probe of C. 20535501765aSSaravana Kannan */ 20545501765aSSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD && 20555501765aSSaravana Kannan fwnode_is_ancestor_of(sup_handle, con->fwnode)) 20565501765aSSaravana Kannan return -EINVAL; 20575501765aSSaravana Kannan 20583fb16866SSaravana Kannan /* 20593fb16866SSaravana Kannan * SYNC_STATE_ONLY device links don't block probing and supports cycles. 20603fb16866SSaravana Kannan * So cycle detection isn't necessary and shouldn't be done. 20613fb16866SSaravana Kannan */ 20623fb16866SSaravana Kannan if (!(flags & DL_FLAG_SYNC_STATE_ONLY)) { 20633fb16866SSaravana Kannan device_links_write_lock(); 20643fb16866SSaravana Kannan if (__fw_devlink_relax_cycles(con, sup_handle)) { 20653fb16866SSaravana Kannan __fwnode_link_cycle(link); 20663fb16866SSaravana Kannan flags = fw_devlink_get_flags(link->flags); 20673fb16866SSaravana Kannan dev_info(con, "Fixed dependency cycle(s) with %pfwf\n", 20683fb16866SSaravana Kannan sup_handle); 20693fb16866SSaravana Kannan } 20703fb16866SSaravana Kannan device_links_write_unlock(); 20713fb16866SSaravana Kannan } 20723fb16866SSaravana Kannan 20733a2dbc51SSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE) 20743a2dbc51SSaravana Kannan sup_dev = fwnode_get_next_parent_dev(sup_handle); 20753a2dbc51SSaravana Kannan else 2076f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle); 20773a2dbc51SSaravana Kannan 2078f9aa4606SSaravana Kannan if (sup_dev) { 2079f9aa4606SSaravana Kannan /* 208074c782cfSSaravana Kannan * If it's one of those drivers that don't actually bind to 208174c782cfSSaravana Kannan * their device using driver core, then don't wait on this 208274c782cfSSaravana Kannan * supplier device indefinitely. 208374c782cfSSaravana Kannan */ 208474c782cfSSaravana Kannan if (sup_dev->links.status == DL_DEV_NO_DRIVER && 208574c782cfSSaravana Kannan sup_handle->flags & FWNODE_FLAG_INITIALIZED) { 20863fb16866SSaravana Kannan dev_dbg(con, 20873fb16866SSaravana Kannan "Not linking %pfwf - dev might never probe\n", 20883fb16866SSaravana Kannan sup_handle); 208974c782cfSSaravana Kannan ret = -EINVAL; 209074c782cfSSaravana Kannan goto out; 209174c782cfSSaravana Kannan } 209274c782cfSSaravana Kannan 209363098724SSaravana Kannan if (con != sup_dev && !device_link_add(con, sup_dev, flags)) { 209463098724SSaravana Kannan dev_err(con, "Failed to create device link (0x%x) with %s\n", 209563098724SSaravana Kannan flags, dev_name(sup_dev)); 2096f9aa4606SSaravana Kannan ret = -EINVAL; 2097b0e2fa4fSSaravana Kannan } 2098f9aa4606SSaravana Kannan 2099f9aa4606SSaravana Kannan goto out; 2100f9aa4606SSaravana Kannan } 2101f9aa4606SSaravana Kannan 2102411c0d58SSaravana Kannan /* 2103411c0d58SSaravana Kannan * Supplier or supplier's ancestor already initialized without a struct 2104411c0d58SSaravana Kannan * device or being probed by a driver. 2105411c0d58SSaravana Kannan */ 2106411c0d58SSaravana Kannan if (fwnode_init_without_drv(sup_handle) || 2107411c0d58SSaravana Kannan fwnode_ancestor_init_without_drv(sup_handle)) { 21083fb16866SSaravana Kannan dev_dbg(con, "Not linking %pfwf - might never become dev\n", 2109411c0d58SSaravana Kannan sup_handle); 211074c782cfSSaravana Kannan return -EINVAL; 2111f9aa4606SSaravana Kannan } 2112f9aa4606SSaravana Kannan 2113f9aa4606SSaravana Kannan ret = -EAGAIN; 2114f9aa4606SSaravana Kannan out: 2115f9aa4606SSaravana Kannan put_device(sup_dev); 2116f9aa4606SSaravana Kannan return ret; 2117f9aa4606SSaravana Kannan } 2118f9aa4606SSaravana Kannan 2119f9aa4606SSaravana Kannan /** 2120f9aa4606SSaravana Kannan * __fw_devlink_link_to_consumers - Create device links to consumers of a device 212137c52f74SPierre-Louis Bossart * @dev: Device that needs to be linked to its consumers 2122f9aa4606SSaravana Kannan * 2123f9aa4606SSaravana Kannan * This function looks at all the consumer fwnodes of @dev and creates device 2124f9aa4606SSaravana Kannan * links between the consumer device and @dev (supplier). 2125f9aa4606SSaravana Kannan * 2126f9aa4606SSaravana Kannan * If the consumer device has not been added yet, then this function creates a 2127f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link between @dev (supplier) and the closest ancestor device 2128f9aa4606SSaravana Kannan * of the consumer fwnode. This is necessary to make sure @dev doesn't get a 2129f9aa4606SSaravana Kannan * sync_state() callback before the real consumer device gets to be added and 2130f9aa4606SSaravana Kannan * then probed. 2131f9aa4606SSaravana Kannan * 2132f9aa4606SSaravana Kannan * Once device links are created from the real consumer to @dev (supplier), the 2133f9aa4606SSaravana Kannan * fwnode links are deleted. 2134f9aa4606SSaravana Kannan */ 2135f9aa4606SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev) 2136f9aa4606SSaravana Kannan { 2137f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 2138f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 2139f9aa4606SSaravana Kannan 2140f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) { 2141f9aa4606SSaravana Kannan struct device *con_dev; 2142f9aa4606SSaravana Kannan bool own_link = true; 2143f9aa4606SSaravana Kannan int ret; 2144f9aa4606SSaravana Kannan 2145f9aa4606SSaravana Kannan con_dev = get_dev_from_fwnode(link->consumer); 2146f9aa4606SSaravana Kannan /* 2147f9aa4606SSaravana Kannan * If consumer device is not available yet, make a "proxy" 2148f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link from the consumer's parent device to 2149f9aa4606SSaravana Kannan * the supplier device. This is necessary to make sure the 2150f9aa4606SSaravana Kannan * supplier doesn't get a sync_state() callback before the real 2151f9aa4606SSaravana Kannan * consumer can create a device link to the supplier. 2152f9aa4606SSaravana Kannan * 2153f9aa4606SSaravana Kannan * This proxy link step is needed to handle the case where the 2154f9aa4606SSaravana Kannan * consumer's parent device is added before the supplier. 2155f9aa4606SSaravana Kannan */ 2156f9aa4606SSaravana Kannan if (!con_dev) { 2157f9aa4606SSaravana Kannan con_dev = fwnode_get_next_parent_dev(link->consumer); 2158f9aa4606SSaravana Kannan /* 2159f9aa4606SSaravana Kannan * However, if the consumer's parent device is also the 2160f9aa4606SSaravana Kannan * parent of the supplier, don't create a 2161f9aa4606SSaravana Kannan * consumer-supplier link from the parent to its child 2162f9aa4606SSaravana Kannan * device. Such a dependency is impossible. 2163f9aa4606SSaravana Kannan */ 2164f9aa4606SSaravana Kannan if (con_dev && 2165f9aa4606SSaravana Kannan fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) { 2166f9aa4606SSaravana Kannan put_device(con_dev); 2167f9aa4606SSaravana Kannan con_dev = NULL; 2168f9aa4606SSaravana Kannan } else { 2169f9aa4606SSaravana Kannan own_link = false; 2170f9aa4606SSaravana Kannan } 2171f9aa4606SSaravana Kannan } 2172f9aa4606SSaravana Kannan 2173f9aa4606SSaravana Kannan if (!con_dev) 2174f9aa4606SSaravana Kannan continue; 2175f9aa4606SSaravana Kannan 2176cd115c04SSaravana Kannan ret = fw_devlink_create_devlink(con_dev, fwnode, link); 2177f9aa4606SSaravana Kannan put_device(con_dev); 2178f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 2179f9aa4606SSaravana Kannan continue; 2180f9aa4606SSaravana Kannan 218176f13081SSaravana Kannan __fwnode_link_del(link); 2182f9aa4606SSaravana Kannan } 2183f9aa4606SSaravana Kannan } 2184f9aa4606SSaravana Kannan 2185f9aa4606SSaravana Kannan /** 2186f9aa4606SSaravana Kannan * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device 218737c52f74SPierre-Louis Bossart * @dev: The consumer device that needs to be linked to its suppliers 218837c52f74SPierre-Louis Bossart * @fwnode: Root of the fwnode tree that is used to create device links 2189f9aa4606SSaravana Kannan * 2190f9aa4606SSaravana Kannan * This function looks at all the supplier fwnodes of fwnode tree rooted at 2191f9aa4606SSaravana Kannan * @fwnode and creates device links between @dev (consumer) and all the 2192f9aa4606SSaravana Kannan * supplier devices of the entire fwnode tree at @fwnode. 2193f9aa4606SSaravana Kannan * 2194f9aa4606SSaravana Kannan * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev 2195f9aa4606SSaravana Kannan * and the real suppliers of @dev. Once these device links are created, the 21963fb16866SSaravana Kannan * fwnode links are deleted. 2197f9aa4606SSaravana Kannan * 2198f9aa4606SSaravana Kannan * In addition, it also looks at all the suppliers of the entire fwnode tree 2199f9aa4606SSaravana Kannan * because some of the child devices of @dev that have not been added yet 2200f9aa4606SSaravana Kannan * (because @dev hasn't probed) might already have their suppliers added to 2201f9aa4606SSaravana Kannan * driver core. So, this function creates SYNC_STATE_ONLY device links between 2202f9aa4606SSaravana Kannan * @dev (consumer) and these suppliers to make sure they don't execute their 2203f9aa4606SSaravana Kannan * sync_state() callbacks before these child devices have a chance to create 2204f9aa4606SSaravana Kannan * their device links. The fwnode links that correspond to the child devices 2205f9aa4606SSaravana Kannan * aren't delete because they are needed later to create the device links 2206f9aa4606SSaravana Kannan * between the real consumer and supplier devices. 2207f9aa4606SSaravana Kannan */ 2208f9aa4606SSaravana Kannan static void __fw_devlink_link_to_suppliers(struct device *dev, 2209f9aa4606SSaravana Kannan struct fwnode_handle *fwnode) 2210f9aa4606SSaravana Kannan { 2211f9aa4606SSaravana Kannan bool own_link = (dev->fwnode == fwnode); 2212f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp; 2213f9aa4606SSaravana Kannan struct fwnode_handle *child = NULL; 2214f9aa4606SSaravana Kannan 2215f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) { 2216f9aa4606SSaravana Kannan int ret; 2217f9aa4606SSaravana Kannan struct fwnode_handle *sup = link->supplier; 2218f9aa4606SSaravana Kannan 2219cd115c04SSaravana Kannan ret = fw_devlink_create_devlink(dev, sup, link); 2220f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN) 2221f9aa4606SSaravana Kannan continue; 2222f9aa4606SSaravana Kannan 222376f13081SSaravana Kannan __fwnode_link_del(link); 2224f9aa4606SSaravana Kannan } 2225f9aa4606SSaravana Kannan 2226f9aa4606SSaravana Kannan /* 2227f9aa4606SSaravana Kannan * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of 2228f9aa4606SSaravana Kannan * all the descendants. This proxy link step is needed to handle the 2229f9aa4606SSaravana Kannan * case where the supplier is added before the consumer's parent device 2230f9aa4606SSaravana Kannan * (@dev). 2231f9aa4606SSaravana Kannan */ 2232f9aa4606SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child))) 2233f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, child); 2234f9aa4606SSaravana Kannan } 2235f9aa4606SSaravana Kannan 22361da177e4SLinus Torvalds static void fw_devlink_link_device(struct device *dev) 22371da177e4SLinus Torvalds { 2238f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode; 22391da177e4SLinus Torvalds 2240f9aa4606SSaravana Kannan if (!fw_devlink_flags) 2241f9aa4606SSaravana Kannan return; 22421da177e4SLinus Torvalds 2243f9aa4606SSaravana Kannan fw_devlink_parse_fwtree(fwnode); 2244f9aa4606SSaravana Kannan 2245f9aa4606SSaravana Kannan mutex_lock(&fwnode_link_lock); 2246f9aa4606SSaravana Kannan __fw_devlink_link_to_consumers(dev); 2247f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, fwnode); 2248f9aa4606SSaravana Kannan mutex_unlock(&fwnode_link_lock); 22491da177e4SLinus Torvalds } 22501da177e4SLinus Torvalds 22511da177e4SLinus Torvalds /* Device links support end. */ 22521da177e4SLinus Torvalds 22531da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL; 22541da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL; 22551da177e4SLinus Torvalds static struct kobject *dev_kobj; 2256980c0561SGreg Kroah-Hartman 2257980c0561SGreg Kroah-Hartman /* /sys/dev/char */ 2258980c0561SGreg Kroah-Hartman static struct kobject *sysfs_dev_char_kobj; 2259575ab414SGreg Kroah-Hartman 2260575ab414SGreg Kroah-Hartman /* /sys/dev/block */ 2261575ab414SGreg Kroah-Hartman static struct kobject *sysfs_dev_block_kobj; 22621da177e4SLinus Torvalds 22635e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock); 22645e33bc41SRafael J. Wysocki 22655e33bc41SRafael J. Wysocki void lock_device_hotplug(void) 22665e33bc41SRafael J. Wysocki { 22675e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock); 22685e33bc41SRafael J. Wysocki } 22695e33bc41SRafael J. Wysocki 22705e33bc41SRafael J. Wysocki void unlock_device_hotplug(void) 22715e33bc41SRafael J. Wysocki { 22725e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock); 22735e33bc41SRafael J. Wysocki } 22745e33bc41SRafael J. Wysocki 22755e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void) 22765e33bc41SRafael J. Wysocki { 22775e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock)) 22785e33bc41SRafael J. Wysocki return 0; 22795e33bc41SRafael J. Wysocki 22805e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */ 22815e33bc41SRafael J. Wysocki msleep(5); 22825e33bc41SRafael J. Wysocki return restart_syscall(); 22835e33bc41SRafael J. Wysocki } 22845e33bc41SRafael J. Wysocki 22854e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK 22864e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 22874e886c29SGreg Kroah-Hartman { 22884e886c29SGreg Kroah-Hartman return !(dev->type == &part_type); 22894e886c29SGreg Kroah-Hartman } 22904e886c29SGreg Kroah-Hartman #else 22914e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev) 22924e886c29SGreg Kroah-Hartman { 22934e886c29SGreg Kroah-Hartman return 1; 22944e886c29SGreg Kroah-Hartman } 22954e886c29SGreg Kroah-Hartman #endif 22961da177e4SLinus Torvalds 2297b2ebd9ddSRafael J. Wysocki static void device_platform_notify(struct device *dev) 229807de0e86SHeikki Krogerus { 2299d0b8e398SRafael J. Wysocki acpi_device_notify(dev); 23007847a145SHeikki Krogerus 2301b2ebd9ddSRafael J. Wysocki software_node_notify(dev); 23027847a145SHeikki Krogerus 2303b2ebd9ddSRafael J. Wysocki if (platform_notify) 230407de0e86SHeikki Krogerus platform_notify(dev); 2305b2ebd9ddSRafael J. Wysocki } 2306b2ebd9ddSRafael J. Wysocki 2307b2ebd9ddSRafael J. Wysocki static void device_platform_notify_remove(struct device *dev) 2308b2ebd9ddSRafael J. Wysocki { 2309d0b8e398SRafael J. Wysocki acpi_device_notify_remove(dev); 231007de0e86SHeikki Krogerus 2311384f5a85SRafael J. Wysocki software_node_notify_remove(dev); 23121da177e4SLinus Torvalds 2313b2ebd9ddSRafael J. Wysocki if (platform_notify_remove) 23141da177e4SLinus Torvalds platform_notify_remove(dev); 23151da177e4SLinus Torvalds } 23161da177e4SLinus Torvalds 23173e95637aSAlan Stern /** 23183e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible 23193e95637aSAlan Stern * @dev: struct device to get the name of 23203e95637aSAlan Stern * 23213e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If 23229169c012Syan * the device is not bound to a driver, it will return the name of the bus 23233e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty 23243e95637aSAlan Stern * string will be returned. 23253e95637aSAlan Stern */ 2326bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev) 23273e95637aSAlan Stern { 23283589972eSAlan Stern struct device_driver *drv; 23293589972eSAlan Stern 23303589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding, 23313589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should 23323589972eSAlan Stern * never change once they are set, so they don't need special care. 23333589972eSAlan Stern */ 23346aa7de05SMark Rutland drv = READ_ONCE(dev->driver); 2335e020ff61SSaravana Kannan return drv ? drv->name : dev_bus_name(dev); 23363e95637aSAlan Stern } 2337310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string); 23383e95637aSAlan Stern 23391da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) 23401da177e4SLinus Torvalds 23414a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr, 23424a3ad20cSGreg Kroah-Hartman char *buf) 23431da177e4SLinus Torvalds { 23441da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2345b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 23464a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 23471da177e4SLinus Torvalds 23481da177e4SLinus Torvalds if (dev_attr->show) 234954b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf); 2350815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) { 2351a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n", 2352a52668c6SSergey Senozhatsky dev_attr->show); 2353815d2d50SAndrew Morton } 23541da177e4SLinus Torvalds return ret; 23551da177e4SLinus Torvalds } 23561da177e4SLinus Torvalds 23574a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr, 23581da177e4SLinus Torvalds const char *buf, size_t count) 23591da177e4SLinus Torvalds { 23601da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr); 2361b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 23624a0c20bfSDmitry Torokhov ssize_t ret = -EIO; 23631da177e4SLinus Torvalds 23641da177e4SLinus Torvalds if (dev_attr->store) 236554b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count); 23661da177e4SLinus Torvalds return ret; 23671da177e4SLinus Torvalds } 23681da177e4SLinus Torvalds 236952cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = { 23701da177e4SLinus Torvalds .show = dev_attr_show, 23711da177e4SLinus Torvalds .store = dev_attr_store, 23721da177e4SLinus Torvalds }; 23731da177e4SLinus Torvalds 2374ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr) 2375ca22e56dSKay Sievers 2376ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev, 2377ca22e56dSKay Sievers struct device_attribute *attr, 2378ca22e56dSKay Sievers const char *buf, size_t size) 2379ca22e56dSKay Sievers { 2380ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2381f88184bfSKaitao cheng int ret; 2382f88184bfSKaitao cheng unsigned long new; 2383f88184bfSKaitao cheng 2384f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new); 2385f88184bfSKaitao cheng if (ret) 2386f88184bfSKaitao cheng return ret; 2387ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new; 2388ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2389ca22e56dSKay Sievers return size; 2390ca22e56dSKay Sievers } 2391ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong); 2392ca22e56dSKay Sievers 2393ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev, 2394ca22e56dSKay Sievers struct device_attribute *attr, 2395ca22e56dSKay Sievers char *buf) 2396ca22e56dSKay Sievers { 2397ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2398aa838896SJoe Perches return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var)); 2399ca22e56dSKay Sievers } 2400ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong); 2401ca22e56dSKay Sievers 2402ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev, 2403ca22e56dSKay Sievers struct device_attribute *attr, 2404ca22e56dSKay Sievers const char *buf, size_t size) 2405ca22e56dSKay Sievers { 2406ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2407f88184bfSKaitao cheng int ret; 2408f88184bfSKaitao cheng long new; 2409f88184bfSKaitao cheng 2410f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new); 2411f88184bfSKaitao cheng if (ret) 2412f88184bfSKaitao cheng return ret; 2413f88184bfSKaitao cheng 2414f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN) 2415ca22e56dSKay Sievers return -EINVAL; 2416ca22e56dSKay Sievers *(int *)(ea->var) = new; 2417ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */ 2418ca22e56dSKay Sievers return size; 2419ca22e56dSKay Sievers } 2420ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int); 2421ca22e56dSKay Sievers 2422ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev, 2423ca22e56dSKay Sievers struct device_attribute *attr, 2424ca22e56dSKay Sievers char *buf) 2425ca22e56dSKay Sievers { 2426ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr); 2427ca22e56dSKay Sievers 2428aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(int *)(ea->var)); 2429ca22e56dSKay Sievers } 2430ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int); 24311da177e4SLinus Torvalds 243291872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 243391872392SBorislav Petkov const char *buf, size_t size) 243491872392SBorislav Petkov { 243591872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 243691872392SBorislav Petkov 243773060022SChristophe JAILLET if (kstrtobool(buf, ea->var) < 0) 243891872392SBorislav Petkov return -EINVAL; 243991872392SBorislav Petkov 244091872392SBorislav Petkov return size; 244191872392SBorislav Petkov } 244291872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool); 244391872392SBorislav Petkov 244491872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 244591872392SBorislav Petkov char *buf) 244691872392SBorislav Petkov { 244791872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr); 244891872392SBorislav Petkov 2449aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(bool *)(ea->var)); 245091872392SBorislav Petkov } 245191872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool); 245291872392SBorislav Petkov 24531da177e4SLinus Torvalds /** 24541da177e4SLinus Torvalds * device_release - free device structure. 24551da177e4SLinus Torvalds * @kobj: device's kobject. 24561da177e4SLinus Torvalds * 24571da177e4SLinus Torvalds * This is called once the reference count for the object 24581da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release 24591da177e4SLinus Torvalds * method, which should handle actually freeing the structure. 24601da177e4SLinus Torvalds */ 24611da177e4SLinus Torvalds static void device_release(struct kobject *kobj) 24621da177e4SLinus Torvalds { 2463b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj); 2464fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p; 24651da177e4SLinus Torvalds 2466a525a3ddSMing Lei /* 2467a525a3ddSMing Lei * Some platform devices are driven without driver attached 2468a525a3ddSMing Lei * and managed resources may have been acquired. Make sure 2469a525a3ddSMing Lei * all resources are released. 2470a525a3ddSMing Lei * 2471a525a3ddSMing Lei * Drivers still can add resources into device after device 2472a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid 2473a525a3ddSMing Lei * possible memory leak. 2474a525a3ddSMing Lei */ 2475a525a3ddSMing Lei devres_release_all(dev); 2476a525a3ddSMing Lei 2477e0d07278SJim Quinlan kfree(dev->dma_range_map); 2478e0d07278SJim Quinlan 24791da177e4SLinus Torvalds if (dev->release) 24801da177e4SLinus Torvalds dev->release(dev); 2481f9f852dfSKay Sievers else if (dev->type && dev->type->release) 2482f9f852dfSKay Sievers dev->type->release(dev); 24832620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release) 24842620efefSGreg Kroah-Hartman dev->class->dev_release(dev); 2485f810a5cfSArjan van de Ven else 24860c1bc6b8SMauro 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", 24871e0b2cf9SKay Sievers dev_name(dev)); 2488fb069a5dSGreg Kroah-Hartman kfree(p); 24891da177e4SLinus Torvalds } 24901da177e4SLinus Torvalds 249102a476d9SGreg Kroah-Hartman static const void *device_namespace(const struct kobject *kobj) 2492bc451f20SEric W. Biederman { 2493fa627348SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 2494bc451f20SEric W. Biederman const void *ns = NULL; 2495bc451f20SEric W. Biederman 2496bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type) 2497bc451f20SEric W. Biederman ns = dev->class->namespace(dev); 2498bc451f20SEric W. Biederman 2499bc451f20SEric W. Biederman return ns; 2500bc451f20SEric W. Biederman } 2501bc451f20SEric W. Biederman 250202a476d9SGreg Kroah-Hartman static void device_get_ownership(const struct kobject *kobj, kuid_t *uid, kgid_t *gid) 25039944e894SDmitry Torokhov { 2504fa627348SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 25059944e894SDmitry Torokhov 25069944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership) 25079944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid); 25089944e894SDmitry Torokhov } 25099944e894SDmitry Torokhov 2510c83d9ab4SThomas Weißschuh static const struct kobj_type device_ktype = { 25111da177e4SLinus Torvalds .release = device_release, 25121da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops, 2513bc451f20SEric W. Biederman .namespace = device_namespace, 25149944e894SDmitry Torokhov .get_ownership = device_get_ownership, 25151da177e4SLinus Torvalds }; 25161da177e4SLinus Torvalds 25171da177e4SLinus Torvalds 2518c45a88bbSGreg Kroah-Hartman static int dev_uevent_filter(const struct kobject *kobj) 25191da177e4SLinus Torvalds { 2520ee6d3dd4SWedson Almeida Filho const struct kobj_type *ktype = get_ktype(kobj); 25211da177e4SLinus Torvalds 25228f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) { 2523c45a88bbSGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 25241da177e4SLinus Torvalds if (dev->bus) 25251da177e4SLinus Torvalds return 1; 252623681e47SGreg Kroah-Hartman if (dev->class) 252723681e47SGreg Kroah-Hartman return 1; 25281da177e4SLinus Torvalds } 25291da177e4SLinus Torvalds return 0; 25301da177e4SLinus Torvalds } 25311da177e4SLinus Torvalds 2532a53d1accSGreg Kroah-Hartman static const char *dev_uevent_name(const struct kobject *kobj) 25331da177e4SLinus Torvalds { 2534a53d1accSGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 25351da177e4SLinus Torvalds 253623681e47SGreg Kroah-Hartman if (dev->bus) 25371da177e4SLinus Torvalds return dev->bus->name; 253823681e47SGreg Kroah-Hartman if (dev->class) 253923681e47SGreg Kroah-Hartman return dev->class->name; 254023681e47SGreg Kroah-Hartman return NULL; 25411da177e4SLinus Torvalds } 25421da177e4SLinus Torvalds 254356d5f362SGreg Kroah-Hartman static int dev_uevent(const struct kobject *kobj, struct kobj_uevent_env *env) 25441da177e4SLinus Torvalds { 254556d5f362SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj); 25461da177e4SLinus Torvalds int retval = 0; 25471da177e4SLinus Torvalds 25486fcf53acSKay Sievers /* add device node properties if present */ 254923681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) { 25506fcf53acSKay Sievers const char *tmp; 25516fcf53acSKay Sievers const char *name; 25522c9ede55SAl Viro umode_t mode = 0; 25534e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID; 25544e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID; 25556fcf53acSKay Sievers 25567eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); 25577eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); 25583c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp); 25596fcf53acSKay Sievers if (name) { 25606fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name); 2561e454cea2SKay Sievers if (mode) 2562e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777); 25634e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID)) 25644e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); 25654e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID)) 25664e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); 25673c2670e6SKay Sievers kfree(tmp); 25686fcf53acSKay Sievers } 256923681e47SGreg Kroah-Hartman } 257023681e47SGreg Kroah-Hartman 2571414264f9SKay Sievers if (dev->type && dev->type->name) 25727eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name); 2573414264f9SKay Sievers 2574239378f1SKay Sievers if (dev->driver) 25757eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name); 2576239378f1SKay Sievers 257707d57a32SGrant Likely /* Add common DT information about the device */ 257807d57a32SGrant Likely of_device_uevent(dev, env); 257907d57a32SGrant Likely 25801da177e4SLinus Torvalds /* have the bus specific function add its stuff */ 25817eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) { 25827eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env); 2583f9f852dfSKay Sievers if (retval) 25847dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n", 25851e0b2cf9SKay Sievers dev_name(dev), __func__, retval); 25861da177e4SLinus Torvalds } 25871da177e4SLinus Torvalds 25882620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */ 25897eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) { 25907eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env); 2591f9f852dfSKay Sievers if (retval) 25927dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() " 25931e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 25942b3a302aSHarvey Harrison __func__, retval); 25952620efefSGreg Kroah-Hartman } 2596f9f852dfSKay Sievers 2597eef35c2dSStefan Weil /* have the device type specific function add its stuff */ 25987eff2e7aSKay Sievers if (dev->type && dev->type->uevent) { 25997eff2e7aSKay Sievers retval = dev->type->uevent(dev, env); 2600f9f852dfSKay Sievers if (retval) 26017dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() " 26021e0b2cf9SKay Sievers "returned %d\n", dev_name(dev), 26032b3a302aSHarvey Harrison __func__, retval); 26042620efefSGreg Kroah-Hartman } 26052620efefSGreg Kroah-Hartman 26061da177e4SLinus Torvalds return retval; 26071da177e4SLinus Torvalds } 26081da177e4SLinus Torvalds 26099cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = { 2610312c004dSKay Sievers .filter = dev_uevent_filter, 2611312c004dSKay Sievers .name = dev_uevent_name, 2612312c004dSKay Sievers .uevent = dev_uevent, 26131da177e4SLinus Torvalds }; 26141da177e4SLinus Torvalds 2615c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr, 261616574dccSKay Sievers char *buf) 261716574dccSKay Sievers { 261816574dccSKay Sievers struct kobject *top_kobj; 261916574dccSKay Sievers struct kset *kset; 26207eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL; 262116574dccSKay Sievers int i; 2622948b3edbSJoe Perches int len = 0; 262316574dccSKay Sievers int retval; 262416574dccSKay Sievers 262516574dccSKay Sievers /* search the kset, the device belongs to */ 262616574dccSKay Sievers top_kobj = &dev->kobj; 26275c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent) 262816574dccSKay Sievers top_kobj = top_kobj->parent; 262916574dccSKay Sievers if (!top_kobj->kset) 263016574dccSKay Sievers goto out; 26315c5daf65SKay Sievers 263216574dccSKay Sievers kset = top_kobj->kset; 263316574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent) 263416574dccSKay Sievers goto out; 263516574dccSKay Sievers 263616574dccSKay Sievers /* respect filter */ 263716574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter) 2638cf6299b6SGreg Kroah-Hartman if (!kset->uevent_ops->filter(&dev->kobj)) 263916574dccSKay Sievers goto out; 264016574dccSKay Sievers 26417eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 26427eff2e7aSKay Sievers if (!env) 2643c7308c81SGreg Kroah-Hartman return -ENOMEM; 2644c7308c81SGreg Kroah-Hartman 264516574dccSKay Sievers /* let the kset specific function add its keys */ 2646cf6299b6SGreg Kroah-Hartman retval = kset->uevent_ops->uevent(&dev->kobj, env); 264716574dccSKay Sievers if (retval) 264816574dccSKay Sievers goto out; 264916574dccSKay Sievers 265016574dccSKay Sievers /* copy keys to file */ 26517eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++) 2652948b3edbSJoe Perches len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]); 265316574dccSKay Sievers out: 26547eff2e7aSKay Sievers kfree(env); 2655948b3edbSJoe Perches return len; 265616574dccSKay Sievers } 265716574dccSKay Sievers 2658c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr, 2659a7fd6706SKay Sievers const char *buf, size_t count) 2660a7fd6706SKay Sievers { 2661df44b479SPeter Rajnoha int rc; 2662df44b479SPeter Rajnoha 2663df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count); 2664df44b479SPeter Rajnoha 2665df44b479SPeter Rajnoha if (rc) { 26666bb7ea3aSBrian Norris dev_err(dev, "uevent: failed to send synthetic uevent: %d\n", rc); 2667df44b479SPeter Rajnoha return rc; 2668df44b479SPeter Rajnoha } 266960a96a59SKay Sievers 2670a7fd6706SKay Sievers return count; 2671a7fd6706SKay Sievers } 2672c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent); 2673a7fd6706SKay Sievers 2674c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr, 26754f3549d7SRafael J. Wysocki char *buf) 26764f3549d7SRafael J. Wysocki { 26774f3549d7SRafael J. Wysocki bool val; 26784f3549d7SRafael J. Wysocki 26795e33bc41SRafael J. Wysocki device_lock(dev); 26804f3549d7SRafael J. Wysocki val = !dev->offline; 26815e33bc41SRafael J. Wysocki device_unlock(dev); 2682aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val); 26834f3549d7SRafael J. Wysocki } 26844f3549d7SRafael J. Wysocki 2685c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr, 26864f3549d7SRafael J. Wysocki const char *buf, size_t count) 26874f3549d7SRafael J. Wysocki { 26884f3549d7SRafael J. Wysocki bool val; 26894f3549d7SRafael J. Wysocki int ret; 26904f3549d7SRafael J. Wysocki 269173060022SChristophe JAILLET ret = kstrtobool(buf, &val); 26924f3549d7SRafael J. Wysocki if (ret < 0) 26934f3549d7SRafael J. Wysocki return ret; 26944f3549d7SRafael J. Wysocki 26955e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs(); 26965e33bc41SRafael J. Wysocki if (ret) 26975e33bc41SRafael J. Wysocki return ret; 26985e33bc41SRafael J. Wysocki 26994f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev); 27004f3549d7SRafael J. Wysocki unlock_device_hotplug(); 27014f3549d7SRafael J. Wysocki return ret < 0 ? ret : count; 27024f3549d7SRafael J. Wysocki } 2703c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online); 27044f3549d7SRafael J. Wysocki 270570f400d4SRajat Jain static ssize_t removable_show(struct device *dev, struct device_attribute *attr, 270670f400d4SRajat Jain char *buf) 270770f400d4SRajat Jain { 270870f400d4SRajat Jain const char *loc; 270970f400d4SRajat Jain 271070f400d4SRajat Jain switch (dev->removable) { 271170f400d4SRajat Jain case DEVICE_REMOVABLE: 271270f400d4SRajat Jain loc = "removable"; 271370f400d4SRajat Jain break; 271470f400d4SRajat Jain case DEVICE_FIXED: 271570f400d4SRajat Jain loc = "fixed"; 271670f400d4SRajat Jain break; 271770f400d4SRajat Jain default: 271870f400d4SRajat Jain loc = "unknown"; 271970f400d4SRajat Jain } 272070f400d4SRajat Jain return sysfs_emit(buf, "%s\n", loc); 272170f400d4SRajat Jain } 272270f400d4SRajat Jain static DEVICE_ATTR_RO(removable); 272370f400d4SRajat Jain 2724fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups) 2725621a1672SDmitry Torokhov { 27263e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups); 2727621a1672SDmitry Torokhov } 2728a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups); 2729621a1672SDmitry Torokhov 2730fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev, 2731a4dbd674SDavid Brownell const struct attribute_group **groups) 2732621a1672SDmitry Torokhov { 27333e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups); 2734621a1672SDmitry Torokhov } 2735a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups); 2736de0ff00dSGreg Kroah-Hartman 273757b8ff07SDmitry Torokhov union device_attr_group_devres { 273857b8ff07SDmitry Torokhov const struct attribute_group *group; 273957b8ff07SDmitry Torokhov const struct attribute_group **groups; 274057b8ff07SDmitry Torokhov }; 274157b8ff07SDmitry Torokhov 274257b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res) 274357b8ff07SDmitry Torokhov { 274457b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 274557b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group; 274657b8ff07SDmitry Torokhov 274757b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group); 274857b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group); 274957b8ff07SDmitry Torokhov } 275057b8ff07SDmitry Torokhov 275157b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res) 275257b8ff07SDmitry Torokhov { 275357b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res; 275457b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups; 275557b8ff07SDmitry Torokhov 275657b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups); 275757b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups); 275857b8ff07SDmitry Torokhov } 275957b8ff07SDmitry Torokhov 276057b8ff07SDmitry Torokhov /** 276157b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group 276257b8ff07SDmitry Torokhov * @dev: The device to create the group for 276357b8ff07SDmitry Torokhov * @grp: The attribute group to create 276457b8ff07SDmitry Torokhov * 276557b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly 276657b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist. 276757b8ff07SDmitry Torokhov * 276857b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure. 276957b8ff07SDmitry Torokhov */ 277057b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp) 277157b8ff07SDmitry Torokhov { 277257b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 277357b8ff07SDmitry Torokhov int error; 277457b8ff07SDmitry Torokhov 277557b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove, 277657b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 277757b8ff07SDmitry Torokhov if (!devres) 277857b8ff07SDmitry Torokhov return -ENOMEM; 277957b8ff07SDmitry Torokhov 278057b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp); 278157b8ff07SDmitry Torokhov if (error) { 278257b8ff07SDmitry Torokhov devres_free(devres); 278357b8ff07SDmitry Torokhov return error; 278457b8ff07SDmitry Torokhov } 278557b8ff07SDmitry Torokhov 278657b8ff07SDmitry Torokhov devres->group = grp; 278757b8ff07SDmitry Torokhov devres_add(dev, devres); 278857b8ff07SDmitry Torokhov return 0; 278957b8ff07SDmitry Torokhov } 279057b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group); 279157b8ff07SDmitry Torokhov 279257b8ff07SDmitry Torokhov /** 279357b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups 279457b8ff07SDmitry Torokhov * @dev: The device to create the group for 279557b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated 279657b8ff07SDmitry Torokhov * 279757b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error 279857b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be 279957b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this 280057b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the 280157b8ff07SDmitry Torokhov * attribute files being created already exist. 280257b8ff07SDmitry Torokhov * 280357b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure. 280457b8ff07SDmitry Torokhov */ 280557b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev, 280657b8ff07SDmitry Torokhov const struct attribute_group **groups) 280757b8ff07SDmitry Torokhov { 280857b8ff07SDmitry Torokhov union device_attr_group_devres *devres; 280957b8ff07SDmitry Torokhov int error; 281057b8ff07SDmitry Torokhov 281157b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove, 281257b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL); 281357b8ff07SDmitry Torokhov if (!devres) 281457b8ff07SDmitry Torokhov return -ENOMEM; 281557b8ff07SDmitry Torokhov 281657b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups); 281757b8ff07SDmitry Torokhov if (error) { 281857b8ff07SDmitry Torokhov devres_free(devres); 281957b8ff07SDmitry Torokhov return error; 282057b8ff07SDmitry Torokhov } 282157b8ff07SDmitry Torokhov 282257b8ff07SDmitry Torokhov devres->groups = groups; 282357b8ff07SDmitry Torokhov devres_add(dev, devres); 282457b8ff07SDmitry Torokhov return 0; 282557b8ff07SDmitry Torokhov } 282657b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups); 282757b8ff07SDmitry Torokhov 28282620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev) 28292620efefSGreg Kroah-Hartman { 28309fa120fbSGreg Kroah-Hartman const struct class *class = dev->class; 2831aed65af1SStephen Hemminger const struct device_type *type = dev->type; 2832621a1672SDmitry Torokhov int error; 28332620efefSGreg Kroah-Hartman 2834621a1672SDmitry Torokhov if (class) { 2835d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups); 28362620efefSGreg Kroah-Hartman if (error) 2837621a1672SDmitry Torokhov return error; 2838f9f852dfSKay Sievers } 2839f9f852dfSKay Sievers 2840621a1672SDmitry Torokhov if (type) { 2841621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups); 2842f9f852dfSKay Sievers if (error) 2843a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups; 2844f9f852dfSKay Sievers } 2845621a1672SDmitry Torokhov 2846621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups); 2847f9f852dfSKay Sievers if (error) 2848621a1672SDmitry Torokhov goto err_remove_type_groups; 2849621a1672SDmitry Torokhov 28504f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) { 2851c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online); 28524f3549d7SRafael J. Wysocki if (error) 2853ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups; 28544f3549d7SRafael J. Wysocki } 28554f3549d7SRafael J. Wysocki 285625ac86c6SSaravana Kannan if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) { 2857da6d6475SSaravana Kannan error = device_create_file(dev, &dev_attr_waiting_for_supplier); 2858da6d6475SSaravana Kannan if (error) 2859da6d6475SSaravana Kannan goto err_remove_dev_online; 2860da6d6475SSaravana Kannan } 2861da6d6475SSaravana Kannan 286270f400d4SRajat Jain if (dev_removable_is_valid(dev)) { 286370f400d4SRajat Jain error = device_create_file(dev, &dev_attr_removable); 286470f400d4SRajat Jain if (error) 286570f400d4SRajat Jain goto err_remove_dev_waiting_for_supplier; 286670f400d4SRajat Jain } 286770f400d4SRajat Jain 28686423d295SWon Chung if (dev_add_physical_location(dev)) { 28696423d295SWon Chung error = device_add_group(dev, 28706423d295SWon Chung &dev_attr_physical_location_group); 28716423d295SWon Chung if (error) 28726423d295SWon Chung goto err_remove_dev_removable; 28736423d295SWon Chung } 28746423d295SWon Chung 2875621a1672SDmitry Torokhov return 0; 2876621a1672SDmitry Torokhov 28776423d295SWon Chung err_remove_dev_removable: 28786423d295SWon Chung device_remove_file(dev, &dev_attr_removable); 287970f400d4SRajat Jain err_remove_dev_waiting_for_supplier: 288070f400d4SRajat Jain device_remove_file(dev, &dev_attr_waiting_for_supplier); 2881da6d6475SSaravana Kannan err_remove_dev_online: 2882da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_online); 2883ecfbf6fdSRafael J. Wysocki err_remove_dev_groups: 2884ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups); 2885621a1672SDmitry Torokhov err_remove_type_groups: 2886621a1672SDmitry Torokhov if (type) 2887621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2888d05a6f96SGreg Kroah-Hartman err_remove_class_groups: 2889d05a6f96SGreg Kroah-Hartman if (class) 2890d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2891f9f852dfSKay Sievers 28922620efefSGreg Kroah-Hartman return error; 28932620efefSGreg Kroah-Hartman } 28942620efefSGreg Kroah-Hartman 28952620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev) 28962620efefSGreg Kroah-Hartman { 28979fa120fbSGreg Kroah-Hartman const struct class *class = dev->class; 2898aed65af1SStephen Hemminger const struct device_type *type = dev->type; 28992620efefSGreg Kroah-Hartman 29006423d295SWon Chung if (dev->physical_location) { 29016423d295SWon Chung device_remove_group(dev, &dev_attr_physical_location_group); 29026423d295SWon Chung kfree(dev->physical_location); 29036423d295SWon Chung } 29046423d295SWon Chung 290570f400d4SRajat Jain device_remove_file(dev, &dev_attr_removable); 2906da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier); 2907c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online); 2908621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups); 2909f9f852dfSKay Sievers 2910621a1672SDmitry Torokhov if (type) 2911621a1672SDmitry Torokhov device_remove_groups(dev, type->groups); 2912621a1672SDmitry Torokhov 2913a6b01dedSGreg Kroah-Hartman if (class) 2914d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups); 2915c97415a7SStefan Achatz } 29162620efefSGreg Kroah-Hartman 2917c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr, 291823681e47SGreg Kroah-Hartman char *buf) 291923681e47SGreg Kroah-Hartman { 292023681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt); 292123681e47SGreg Kroah-Hartman } 2922c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev); 2923ad6a1e1cSTejun Heo 2924ca22e56dSKay Sievers /* /sys/devices/ */ 2925881c6cfdSGreg Kroah-Hartman struct kset *devices_kset; 29261da177e4SLinus Torvalds 29271da177e4SLinus Torvalds /** 292852cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list. 292952cdbdd4SGrygorii Strashko * @deva: Device to move. 293052cdbdd4SGrygorii Strashko * @devb: Device @deva should come before. 293152cdbdd4SGrygorii Strashko */ 293252cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb) 293352cdbdd4SGrygorii Strashko { 293452cdbdd4SGrygorii Strashko if (!devices_kset) 293552cdbdd4SGrygorii Strashko return; 293652cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n", 293752cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 293852cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 293952cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry); 294052cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 294152cdbdd4SGrygorii Strashko } 294252cdbdd4SGrygorii Strashko 294352cdbdd4SGrygorii Strashko /** 294452cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list. 294552cdbdd4SGrygorii Strashko * @deva: Device to move 294652cdbdd4SGrygorii Strashko * @devb: Device @deva should come after. 294752cdbdd4SGrygorii Strashko */ 294852cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb) 294952cdbdd4SGrygorii Strashko { 295052cdbdd4SGrygorii Strashko if (!devices_kset) 295152cdbdd4SGrygorii Strashko return; 295252cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n", 295352cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb)); 295452cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 295552cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry); 295652cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 295752cdbdd4SGrygorii Strashko } 295852cdbdd4SGrygorii Strashko 295952cdbdd4SGrygorii Strashko /** 296052cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list. 296152cdbdd4SGrygorii Strashko * @dev: device to move 296252cdbdd4SGrygorii Strashko */ 296352cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev) 296452cdbdd4SGrygorii Strashko { 296552cdbdd4SGrygorii Strashko if (!devices_kset) 296652cdbdd4SGrygorii Strashko return; 296752cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev)); 296852cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock); 296952cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list); 297052cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock); 297152cdbdd4SGrygorii Strashko } 297252cdbdd4SGrygorii Strashko 297352cdbdd4SGrygorii Strashko /** 29741da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device. 29751da177e4SLinus Torvalds * @dev: device. 29761da177e4SLinus Torvalds * @attr: device attribute descriptor. 29771da177e4SLinus Torvalds */ 297826579ab7SPhil Carmody int device_create_file(struct device *dev, 297926579ab7SPhil Carmody const struct device_attribute *attr) 29801da177e4SLinus Torvalds { 29811da177e4SLinus Torvalds int error = 0; 29828f46baaaSFelipe Balbi 29838f46baaaSFelipe Balbi if (dev) { 29848f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store), 298597521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n", 298697521978Sdyoung@redhat.com attr->attr.name); 29878f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show), 298897521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n", 298997521978Sdyoung@redhat.com attr->attr.name); 29901da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr); 29918f46baaaSFelipe Balbi } 29928f46baaaSFelipe Balbi 29931da177e4SLinus Torvalds return error; 29941da177e4SLinus Torvalds } 299586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file); 29961da177e4SLinus Torvalds 29971da177e4SLinus Torvalds /** 29981da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file. 29991da177e4SLinus Torvalds * @dev: device. 30001da177e4SLinus Torvalds * @attr: device attribute descriptor. 30011da177e4SLinus Torvalds */ 300226579ab7SPhil Carmody void device_remove_file(struct device *dev, 300326579ab7SPhil Carmody const struct device_attribute *attr) 30041da177e4SLinus Torvalds { 30050c98b19fSCornelia Huck if (dev) 30061da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr); 30071da177e4SLinus Torvalds } 300886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file); 30091da177e4SLinus Torvalds 30102589f188SGreg Kroah-Hartman /** 30116b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method. 30126b0afc2aSTejun Heo * @dev: device. 30136b0afc2aSTejun Heo * @attr: device attribute descriptor. 30146b0afc2aSTejun Heo * 30156b0afc2aSTejun Heo * See kernfs_remove_self() for details. 30166b0afc2aSTejun Heo */ 30176b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev, 30186b0afc2aSTejun Heo const struct device_attribute *attr) 30196b0afc2aSTejun Heo { 30206b0afc2aSTejun Heo if (dev) 30216b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr); 30226b0afc2aSTejun Heo else 30236b0afc2aSTejun Heo return false; 30246b0afc2aSTejun Heo } 30256b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self); 30266b0afc2aSTejun Heo 30276b0afc2aSTejun Heo /** 30282589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device. 30292589f188SGreg Kroah-Hartman * @dev: device. 30302589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 30312589f188SGreg Kroah-Hartman */ 303266ecb92bSPhil Carmody int device_create_bin_file(struct device *dev, 303366ecb92bSPhil Carmody const struct bin_attribute *attr) 30342589f188SGreg Kroah-Hartman { 30352589f188SGreg Kroah-Hartman int error = -EINVAL; 30362589f188SGreg Kroah-Hartman if (dev) 30372589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr); 30382589f188SGreg Kroah-Hartman return error; 30392589f188SGreg Kroah-Hartman } 30402589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file); 30412589f188SGreg Kroah-Hartman 30422589f188SGreg Kroah-Hartman /** 30432589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file 30442589f188SGreg Kroah-Hartman * @dev: device. 30452589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor. 30462589f188SGreg Kroah-Hartman */ 304766ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev, 304866ecb92bSPhil Carmody const struct bin_attribute *attr) 30492589f188SGreg Kroah-Hartman { 30502589f188SGreg Kroah-Hartman if (dev) 30512589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr); 30522589f188SGreg Kroah-Hartman } 30532589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file); 30542589f188SGreg Kroah-Hartman 305534bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n) 305634bb61f9SJames Bottomley { 3057f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 3058f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 305934bb61f9SJames Bottomley 306034bb61f9SJames Bottomley get_device(dev); 306134bb61f9SJames Bottomley } 306234bb61f9SJames Bottomley 306334bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n) 306434bb61f9SJames Bottomley { 3065f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n); 3066f791b8c8SGreg Kroah-Hartman struct device *dev = p->device; 306734bb61f9SJames Bottomley 306834bb61f9SJames Bottomley put_device(dev); 306934bb61f9SJames Bottomley } 307034bb61f9SJames Bottomley 30711da177e4SLinus Torvalds /** 30721da177e4SLinus Torvalds * device_initialize - init device structure. 30731da177e4SLinus Torvalds * @dev: device. 30741da177e4SLinus Torvalds * 30755739411aSCornelia Huck * This prepares the device for use by other layers by initializing 30765739411aSCornelia Huck * its fields. 30771da177e4SLinus Torvalds * It is the first half of device_register(), if called by 30785739411aSCornelia Huck * that function, though it can also be called separately, so one 30795739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device() 30805739411aSCornelia Huck * may be used for reference counting of @dev after calling this 30815739411aSCornelia Huck * function. 30825739411aSCornelia Huck * 3083b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except 3084b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest 3085b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing 3086b10d5efdSAlan Stern * @dev. 3087b10d5efdSAlan Stern * 30885739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing 30895739411aSCornelia Huck * @dev directly once you have called this function. 30901da177e4SLinus Torvalds */ 30911da177e4SLinus Torvalds void device_initialize(struct device *dev) 30921da177e4SLinus Torvalds { 3093881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset; 3094f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype); 30951da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools); 30963142788bSThomas Gleixner mutex_init(&dev->mutex); 30971704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex); 30989ac7849eSTejun Heo spin_lock_init(&dev->devres_lock); 30999ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head); 31003b98aeafSAlan Stern device_pm_init(dev); 3101d460d7f7SMax Gurtovoy set_dev_node(dev, NUMA_NO_NODE); 31029ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers); 31039ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers); 31043b052a3eSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync); 31059ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER; 31066d4e9a8eSChristoph Hellwig #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \ 31076d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \ 31086d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) 31096d4e9a8eSChristoph Hellwig dev->dma_coherent = dma_default_coherent; 31106d4e9a8eSChristoph Hellwig #endif 311169031f50SClaire Chang #ifdef CONFIG_SWIOTLB 3112463e862aSWill Deacon dev->dma_io_tlb_mem = &io_tlb_default_mem; 311369031f50SClaire Chang #endif 31141da177e4SLinus Torvalds } 311586df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize); 31161da177e4SLinus Torvalds 3117d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev) 3118f0ee61a6SGreg Kroah-Hartman { 3119f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL; 3120f0ee61a6SGreg Kroah-Hartman 3121f0ee61a6SGreg Kroah-Hartman if (!virtual_dir) 31224ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual", 3123881c6cfdSGreg Kroah-Hartman &devices_kset->kobj); 3124f0ee61a6SGreg Kroah-Hartman 312586406245SKay Sievers return virtual_dir; 3126f0ee61a6SGreg Kroah-Hartman } 3127f0ee61a6SGreg Kroah-Hartman 3128bc451f20SEric W. Biederman struct class_dir { 3129bc451f20SEric W. Biederman struct kobject kobj; 31309fa120fbSGreg Kroah-Hartman const struct class *class; 3131bc451f20SEric W. Biederman }; 3132bc451f20SEric W. Biederman 3133bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj) 3134bc451f20SEric W. Biederman 3135bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj) 3136bc451f20SEric W. Biederman { 3137bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj); 3138bc451f20SEric W. Biederman kfree(dir); 3139bc451f20SEric W. Biederman } 3140bc451f20SEric W. Biederman 3141bc451f20SEric W. Biederman static const 314202a476d9SGreg Kroah-Hartman struct kobj_ns_type_operations *class_dir_child_ns_type(const struct kobject *kobj) 3143bc451f20SEric W. Biederman { 314402a476d9SGreg Kroah-Hartman const struct class_dir *dir = to_class_dir(kobj); 3145bc451f20SEric W. Biederman return dir->class->ns_type; 3146bc451f20SEric W. Biederman } 3147bc451f20SEric W. Biederman 3148c83d9ab4SThomas Weißschuh static const struct kobj_type class_dir_ktype = { 3149bc451f20SEric W. Biederman .release = class_dir_release, 3150bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops, 3151bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type 3152bc451f20SEric W. Biederman }; 3153bc451f20SEric W. Biederman 31547d90e81aSGreg Kroah-Hartman static struct kobject *class_dir_create_and_add(struct subsys_private *sp, 31557d90e81aSGreg Kroah-Hartman struct kobject *parent_kobj) 3156bc451f20SEric W. Biederman { 3157bc451f20SEric W. Biederman struct class_dir *dir; 3158bc451f20SEric W. Biederman int retval; 3159bc451f20SEric W. Biederman 3160bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL); 3161bc451f20SEric W. Biederman if (!dir) 316284d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM); 3163bc451f20SEric W. Biederman 31647d90e81aSGreg Kroah-Hartman dir->class = sp->class; 3165bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype); 3166bc451f20SEric W. Biederman 31677d90e81aSGreg Kroah-Hartman dir->kobj.kset = &sp->glue_dirs; 3168bc451f20SEric W. Biederman 31697d90e81aSGreg Kroah-Hartman retval = kobject_add(&dir->kobj, parent_kobj, "%s", sp->class->name); 3170bc451f20SEric W. Biederman if (retval < 0) { 3171bc451f20SEric W. Biederman kobject_put(&dir->kobj); 317284d0c27dSTetsuo Handa return ERR_PTR(retval); 3173bc451f20SEric W. Biederman } 3174bc451f20SEric W. Biederman return &dir->kobj; 3175bc451f20SEric W. Biederman } 3176bc451f20SEric W. Biederman 3177e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex); 3178bc451f20SEric W. Biederman 3179c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev, 3180c744aeaeSCornelia Huck struct device *parent) 318140fa5422SGreg Kroah-Hartman { 31827d90e81aSGreg Kroah-Hartman struct subsys_private *sp = class_to_subsys(dev->class); 318386406245SKay Sievers struct kobject *kobj = NULL; 31848c99377eSGreg Kroah-Hartman 31857d90e81aSGreg Kroah-Hartman if (sp) { 318686406245SKay Sievers struct kobject *parent_kobj; 318786406245SKay Sievers struct kobject *k; 318886406245SKay Sievers 318986406245SKay Sievers /* 319086406245SKay Sievers * If we have no parent, we live in "virtual". 31910f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live 31920f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions. 319386406245SKay Sievers */ 319486406245SKay Sievers if (parent == NULL) 319586406245SKay Sievers parent_kobj = virtual_device_parent(dev); 31967d90e81aSGreg Kroah-Hartman else if (parent->class && !dev->class->ns_type) { 31977d90e81aSGreg Kroah-Hartman subsys_put(sp); 319886406245SKay Sievers return &parent->kobj; 31997d90e81aSGreg Kroah-Hartman } else { 320086406245SKay Sievers parent_kobj = &parent->kobj; 32017d90e81aSGreg Kroah-Hartman } 320286406245SKay Sievers 320377d3d7c1STejun Heo mutex_lock(&gdp_mutex); 320477d3d7c1STejun Heo 320586406245SKay Sievers /* find our class-directory at the parent and reference it */ 32067d90e81aSGreg Kroah-Hartman spin_lock(&sp->glue_dirs.list_lock); 32077d90e81aSGreg Kroah-Hartman list_for_each_entry(k, &sp->glue_dirs.list, entry) 320886406245SKay Sievers if (k->parent == parent_kobj) { 320986406245SKay Sievers kobj = kobject_get(k); 321086406245SKay Sievers break; 321186406245SKay Sievers } 32127d90e81aSGreg Kroah-Hartman spin_unlock(&sp->glue_dirs.list_lock); 321377d3d7c1STejun Heo if (kobj) { 321477d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 32157d90e81aSGreg Kroah-Hartman subsys_put(sp); 321686406245SKay Sievers return kobj; 321777d3d7c1STejun Heo } 321886406245SKay Sievers 321986406245SKay Sievers /* or create a new class-directory at the parent device */ 32207d90e81aSGreg Kroah-Hartman k = class_dir_create_and_add(sp, parent_kobj); 32210f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */ 322277d3d7c1STejun Heo mutex_unlock(&gdp_mutex); 32237d90e81aSGreg Kroah-Hartman subsys_put(sp); 322443968d2fSGreg Kroah-Hartman return k; 322586406245SKay Sievers } 322686406245SKay Sievers 3227ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */ 32288c99377eSGreg Kroah-Hartman if (!parent && dev->bus) { 32298c99377eSGreg Kroah-Hartman struct device *dev_root = bus_get_dev_root(dev->bus); 32308c99377eSGreg Kroah-Hartman 32318c99377eSGreg Kroah-Hartman if (dev_root) { 32328c99377eSGreg Kroah-Hartman kobj = &dev_root->kobj; 32338c99377eSGreg Kroah-Hartman put_device(dev_root); 32348c99377eSGreg Kroah-Hartman return kobj; 32358c99377eSGreg Kroah-Hartman } 32368c99377eSGreg Kroah-Hartman } 3237ca22e56dSKay Sievers 323886406245SKay Sievers if (parent) 3239c744aeaeSCornelia Huck return &parent->kobj; 3240c744aeaeSCornelia Huck return NULL; 3241c744aeaeSCornelia Huck } 3242da231fd5SKay Sievers 3243cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj, 3244cebf8fd1SMing Lei struct device *dev) 3245cebf8fd1SMing Lei { 32467d90e81aSGreg Kroah-Hartman struct subsys_private *sp; 32477d90e81aSGreg Kroah-Hartman bool retval; 32487d90e81aSGreg Kroah-Hartman 32497d90e81aSGreg Kroah-Hartman if (!kobj || !dev->class) 3250cebf8fd1SMing Lei return false; 32517d90e81aSGreg Kroah-Hartman 32527d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class); 32537d90e81aSGreg Kroah-Hartman if (!sp) 32547d90e81aSGreg Kroah-Hartman return false; 32557d90e81aSGreg Kroah-Hartman 32567d90e81aSGreg Kroah-Hartman if (kobj->kset == &sp->glue_dirs) 32577d90e81aSGreg Kroah-Hartman retval = true; 32587d90e81aSGreg Kroah-Hartman else 32597d90e81aSGreg Kroah-Hartman retval = false; 32607d90e81aSGreg Kroah-Hartman 32617d90e81aSGreg Kroah-Hartman subsys_put(sp); 32627d90e81aSGreg Kroah-Hartman return retval; 3263cebf8fd1SMing Lei } 3264cebf8fd1SMing Lei 3265cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev) 3266cebf8fd1SMing Lei { 3267cebf8fd1SMing Lei return dev->kobj.parent; 3268cebf8fd1SMing Lei } 3269cebf8fd1SMing Lei 3270f0832664SIngo Molnar /** 3271f0832664SIngo Molnar * kobject_has_children - Returns whether a kobject has children. 3272f0832664SIngo Molnar * @kobj: the object to test 3273f0832664SIngo Molnar * 3274f0832664SIngo Molnar * This will return whether a kobject has other kobjects as children. 3275f0832664SIngo Molnar * 3276f0832664SIngo Molnar * It does NOT account for the presence of attribute files, only sub 3277f0832664SIngo Molnar * directories. It also assumes there is no concurrent addition or 3278f0832664SIngo Molnar * removal of such children, and thus relies on external locking. 3279f0832664SIngo Molnar */ 3280f0832664SIngo Molnar static inline bool kobject_has_children(struct kobject *kobj) 3281f0832664SIngo Molnar { 3282f0832664SIngo Molnar WARN_ON_ONCE(kref_read(&kobj->kref) == 0); 3283f0832664SIngo Molnar 3284f0832664SIngo Molnar return kobj->sd && kobj->sd->dir.subdirs; 3285f0832664SIngo Molnar } 3286f0832664SIngo Molnar 3287cebf8fd1SMing Lei /* 3288cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make 3289cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the 3290cebf8fd1SMing Lei * global lock 3291cebf8fd1SMing Lei */ 329263b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir) 3293da231fd5SKay Sievers { 3294ac43432cSMuchun Song unsigned int ref; 3295ac43432cSMuchun Song 32960f4dafc0SKay Sievers /* see if we live in a "glue" directory */ 3297cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev)) 3298da231fd5SKay Sievers return; 3299da231fd5SKay Sievers 3300e4a60d13SYijing Wang mutex_lock(&gdp_mutex); 3301ac43432cSMuchun Song /** 3302ac43432cSMuchun Song * There is a race condition between removing glue directory 3303ac43432cSMuchun Song * and adding a new device under the glue directory. 3304ac43432cSMuchun Song * 3305ac43432cSMuchun Song * CPU1: CPU2: 3306ac43432cSMuchun Song * 3307ac43432cSMuchun Song * device_add() 3308ac43432cSMuchun Song * get_device_parent() 3309ac43432cSMuchun Song * class_dir_create_and_add() 3310ac43432cSMuchun Song * kobject_add_internal() 3311ac43432cSMuchun Song * create_dir() // create glue_dir 3312ac43432cSMuchun Song * 3313ac43432cSMuchun Song * device_add() 3314ac43432cSMuchun Song * get_device_parent() 3315ac43432cSMuchun Song * kobject_get() // get glue_dir 3316ac43432cSMuchun Song * 3317ac43432cSMuchun Song * device_del() 3318ac43432cSMuchun Song * cleanup_glue_dir() 3319ac43432cSMuchun Song * kobject_del(glue_dir) 3320ac43432cSMuchun Song * 3321ac43432cSMuchun Song * kobject_add() 3322ac43432cSMuchun Song * kobject_add_internal() 3323ac43432cSMuchun Song * create_dir() // in glue_dir 3324ac43432cSMuchun Song * sysfs_create_dir_ns() 3325ac43432cSMuchun Song * kernfs_create_dir_ns(sd) 3326ac43432cSMuchun Song * 3327ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL 3328ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd 3329ac43432cSMuchun Song * 3330ac43432cSMuchun Song * // sd is freed 3331ac43432cSMuchun Song * kernfs_new_node(sd) 3332ac43432cSMuchun Song * kernfs_get(glue_dir) 3333ac43432cSMuchun Song * kernfs_add_one() 3334ac43432cSMuchun Song * kernfs_put() 3335ac43432cSMuchun Song * 3336ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add 3337ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count 3338ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called 3339ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir() 3340ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed. 3341ac43432cSMuchun Song * 3342ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used 3343ac43432cSMuchun Song * glue dir around in kernfs_new_node(). 3344ac43432cSMuchun Song * 3345ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that 3346ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount 3347ac43432cSMuchun Song * for glue_dir kobj is 1. 3348ac43432cSMuchun Song */ 3349ac43432cSMuchun Song ref = kref_read(&glue_dir->kref); 3350ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref) 3351726e4109SBenjamin Herrenschmidt kobject_del(glue_dir); 33520f4dafc0SKay Sievers kobject_put(glue_dir); 3353e4a60d13SYijing Wang mutex_unlock(&gdp_mutex); 3354da231fd5SKay Sievers } 335563b6971aSCornelia Huck 33562ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev) 33572ee97cafSCornelia Huck { 33585590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev); 33597d90e81aSGreg Kroah-Hartman struct subsys_private *sp; 33602ee97cafSCornelia Huck int error; 33612ee97cafSCornelia Huck 33625590f319SBenjamin Herrenschmidt if (of_node) { 33630c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node"); 33645590f319SBenjamin Herrenschmidt if (error) 33655590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error); 33665590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */ 33675590f319SBenjamin Herrenschmidt } 33685590f319SBenjamin Herrenschmidt 33697d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class); 33707d90e81aSGreg Kroah-Hartman if (!sp) 33712ee97cafSCornelia Huck return 0; 3372da231fd5SKay Sievers 33737d90e81aSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem"); 33742ee97cafSCornelia Huck if (error) 33755590f319SBenjamin Herrenschmidt goto out_devnode; 3376da231fd5SKay Sievers 33774e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) { 33784f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj, 33794f01a757SDmitry Torokhov "device"); 33804f01a757SDmitry Torokhov if (error) 338139aba963SKay Sievers goto out_subsys; 33822ee97cafSCornelia Huck } 338339aba963SKay Sievers 338439aba963SKay Sievers /* link in the class directory pointing to the device */ 33857d90e81aSGreg Kroah-Hartman error = sysfs_create_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); 338639aba963SKay Sievers if (error) 338739aba963SKay Sievers goto out_device; 33887d90e81aSGreg Kroah-Hartman goto exit; 33892ee97cafSCornelia Huck 339039aba963SKay Sievers out_device: 339139aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 33922ee97cafSCornelia Huck out_subsys: 33932ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 33945590f319SBenjamin Herrenschmidt out_devnode: 33955590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 33967d90e81aSGreg Kroah-Hartman exit: 33977d90e81aSGreg Kroah-Hartman subsys_put(sp); 33982ee97cafSCornelia Huck return error; 33992ee97cafSCornelia Huck } 34002ee97cafSCornelia Huck 34012ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev) 34022ee97cafSCornelia Huck { 34037d90e81aSGreg Kroah-Hartman struct subsys_private *sp = class_to_subsys(dev->class); 34047d90e81aSGreg Kroah-Hartman 34055590f319SBenjamin Herrenschmidt if (dev_of_node(dev)) 34065590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node"); 34075590f319SBenjamin Herrenschmidt 34087d90e81aSGreg Kroah-Hartman if (!sp) 34092ee97cafSCornelia Huck return; 3410da231fd5SKay Sievers 34114e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) 3412da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device"); 34132ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem"); 34147d90e81aSGreg Kroah-Hartman sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev)); 34157d90e81aSGreg Kroah-Hartman subsys_put(sp); 34162ee97cafSCornelia Huck } 34172ee97cafSCornelia Huck 34181da177e4SLinus Torvalds /** 3419413c239fSStephen Rothwell * dev_set_name - set a device name 3420413c239fSStephen Rothwell * @dev: device 342146232366SRandy Dunlap * @fmt: format string for the device's name 3422413c239fSStephen Rothwell */ 3423413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...) 3424413c239fSStephen Rothwell { 3425413c239fSStephen Rothwell va_list vargs; 34261fa5ae85SKay Sievers int err; 3427413c239fSStephen Rothwell 3428413c239fSStephen Rothwell va_start(vargs, fmt); 34291fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs); 3430413c239fSStephen Rothwell va_end(vargs); 34311fa5ae85SKay Sievers return err; 3432413c239fSStephen Rothwell } 3433413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name); 3434413c239fSStephen Rothwell 3435d6bdbbdfSGreg Kroah-Hartman /* select a /sys/dev/ directory for the device */ 3436e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev) 3437e105b8bfSDan Williams { 3438d6bdbbdfSGreg Kroah-Hartman if (is_blockdev(dev)) 3439d6bdbbdfSGreg Kroah-Hartman return sysfs_dev_block_kobj; 3440e105b8bfSDan Williams else 3441d6bdbbdfSGreg Kroah-Hartman return sysfs_dev_char_kobj; 3442e105b8bfSDan Williams } 3443e105b8bfSDan Williams 3444e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev) 3445e105b8bfSDan Williams { 3446e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3447e105b8bfSDan Williams int error = 0; 3448e105b8bfSDan Williams char devt_str[15]; 3449e105b8bfSDan Williams 3450e105b8bfSDan Williams if (kobj) { 3451e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3452e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str); 3453e105b8bfSDan Williams } 3454e105b8bfSDan Williams 3455e105b8bfSDan Williams return error; 3456e105b8bfSDan Williams } 3457e105b8bfSDan Williams 3458e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev) 3459e105b8bfSDan Williams { 3460e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev); 3461e105b8bfSDan Williams char devt_str[15]; 3462e105b8bfSDan Williams 3463e105b8bfSDan Williams if (kobj) { 3464e105b8bfSDan Williams format_dev_t(devt_str, dev->devt); 3465e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str); 3466e105b8bfSDan Williams } 3467e105b8bfSDan Williams } 3468e105b8bfSDan Williams 346946d3a037SShaokun Zhang static int device_private_init(struct device *dev) 3470b4028437SGreg Kroah-Hartman { 3471b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL); 3472b4028437SGreg Kroah-Hartman if (!dev->p) 3473b4028437SGreg Kroah-Hartman return -ENOMEM; 3474b4028437SGreg Kroah-Hartman dev->p->device = dev; 3475b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get, 3476b4028437SGreg Kroah-Hartman klist_children_put); 3477ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe); 3478b4028437SGreg Kroah-Hartman return 0; 3479b4028437SGreg Kroah-Hartman } 3480b4028437SGreg Kroah-Hartman 3481e105b8bfSDan Williams /** 34821da177e4SLinus Torvalds * device_add - add device to device hierarchy. 34831da177e4SLinus Torvalds * @dev: device. 34841da177e4SLinus Torvalds * 34851da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called 34861da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately. 34871da177e4SLinus Torvalds * 34885739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it 34891da177e4SLinus Torvalds * to the global and sibling lists for the device, then 34901da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model. 34915739411aSCornelia Huck * 3492b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for 3493b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work 3494b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life. 3495b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references 3496b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate 3497b10d5efdSAlan Stern * and register a fresh new struct device instead. 3498b10d5efdSAlan Stern * 34995739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 35005739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your 35015739411aSCornelia Huck * reference instead. 3502affada72SBorislav Petkov * 3503affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call 3504affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has 3505affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference 3506affada72SBorislav Petkov * count. 35071da177e4SLinus Torvalds */ 35081da177e4SLinus Torvalds int device_add(struct device *dev) 35091da177e4SLinus Torvalds { 35107d90e81aSGreg Kroah-Hartman struct subsys_private *sp; 351135dbf4efSViresh Kumar struct device *parent; 3512ca22e56dSKay Sievers struct kobject *kobj; 3513c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 35145f5377eaSSaravana Kannan int error = -EINVAL; 3515cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3516775b64d2SRafael J. Wysocki 35171da177e4SLinus Torvalds dev = get_device(dev); 3518c906a48aSGreg Kroah-Hartman if (!dev) 3519c906a48aSGreg Kroah-Hartman goto done; 3520c906a48aSGreg Kroah-Hartman 3521fb069a5dSGreg Kroah-Hartman if (!dev->p) { 3522b4028437SGreg Kroah-Hartman error = device_private_init(dev); 3523b4028437SGreg Kroah-Hartman if (error) 3524fb069a5dSGreg Kroah-Hartman goto done; 3525fb069a5dSGreg Kroah-Hartman } 3526fb069a5dSGreg Kroah-Hartman 35271fa5ae85SKay Sievers /* 35281fa5ae85SKay Sievers * for statically allocated devices, which should all be converted 35291fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back 35301fa5ae85SKay Sievers * the name, and force the use of dev_name() 35311fa5ae85SKay Sievers */ 35321fa5ae85SKay Sievers if (dev->init_name) { 3533acc0e90fSGreg Kroah-Hartman dev_set_name(dev, "%s", dev->init_name); 35341fa5ae85SKay Sievers dev->init_name = NULL; 35351fa5ae85SKay Sievers } 3536c906a48aSGreg Kroah-Hartman 3537ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */ 3538ca22e56dSKay Sievers if (!dev_name(dev) && dev->bus && dev->bus->dev_name) 3539ca22e56dSKay Sievers dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); 3540ca22e56dSKay Sievers 3541e6309e75SThomas Gleixner if (!dev_name(dev)) { 3542e6309e75SThomas Gleixner error = -EINVAL; 35435c8563d7SKay Sievers goto name_error; 3544e6309e75SThomas Gleixner } 35451da177e4SLinus Torvalds 35461e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 3547c205ef48SGreg Kroah-Hartman 35481da177e4SLinus Torvalds parent = get_device(dev->parent); 3549ca22e56dSKay Sievers kobj = get_device_parent(dev, parent); 355084d0c27dSTetsuo Handa if (IS_ERR(kobj)) { 355184d0c27dSTetsuo Handa error = PTR_ERR(kobj); 355284d0c27dSTetsuo Handa goto parent_error; 355384d0c27dSTetsuo Handa } 3554ca22e56dSKay Sievers if (kobj) 3555ca22e56dSKay Sievers dev->kobj.parent = kobj; 35561da177e4SLinus Torvalds 35570d358f22SYinghai Lu /* use parent numa_node */ 355856f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE)) 35590d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent)); 35600d358f22SYinghai Lu 35611da177e4SLinus Torvalds /* first, register with generic layer. */ 35628a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */ 35638a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL); 3564cebf8fd1SMing Lei if (error) { 35656977b1a5SZhengchao Shao glue_dir = kobj; 35661da177e4SLinus Torvalds goto Error; 3567cebf8fd1SMing Lei } 3568a7fd6706SKay Sievers 356937022644SBrian Walsh /* notify platform of device entry */ 3570b2ebd9ddSRafael J. Wysocki device_platform_notify(dev); 357137022644SBrian Walsh 3572c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent); 3573a306eea4SCornelia Huck if (error) 3574a306eea4SCornelia Huck goto attrError; 3575a7fd6706SKay Sievers 35762ee97cafSCornelia Huck error = device_add_class_symlinks(dev); 35772ee97cafSCornelia Huck if (error) 35782ee97cafSCornelia Huck goto SymlinkError; 3579dc0afa83SCornelia Huck error = device_add_attrs(dev); 3580dc0afa83SCornelia Huck if (error) 35812620efefSGreg Kroah-Hartman goto AttrsError; 3582dc0afa83SCornelia Huck error = bus_add_device(dev); 3583dc0afa83SCornelia Huck if (error) 35841da177e4SLinus Torvalds goto BusError; 35853b98aeafSAlan Stern error = dpm_sysfs_add(dev); 358657eee3d2SRafael J. Wysocki if (error) 35873b98aeafSAlan Stern goto DPMError; 35883b98aeafSAlan Stern device_pm_add(dev); 3589ec0676eeSAlan Stern 35900cd75047SSergey Klyaus if (MAJOR(dev->devt)) { 35910cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev); 35920cd75047SSergey Klyaus if (error) 35930cd75047SSergey Klyaus goto DevAttrError; 35940cd75047SSergey Klyaus 35950cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev); 35960cd75047SSergey Klyaus if (error) 35970cd75047SSergey Klyaus goto SysEntryError; 35980cd75047SSergey Klyaus 35990cd75047SSergey Klyaus devtmpfs_create_node(dev); 36000cd75047SSergey Klyaus } 36010cd75047SSergey Klyaus 3602ec0676eeSAlan Stern /* Notify clients of device addition. This call must come 3603268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent(). 3604ec0676eeSAlan Stern */ 3605ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_ADD_DEVICE); 360653877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD); 3607372a67c0SSaravana Kannan 3608e2ae9bccSSaravana Kannan /* 3609e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for 3610e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device 3611e2ae9bccSSaravana Kannan * link to it. 3612e2ae9bccSSaravana Kannan * 3613e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add() 3614e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called. 3615e2ae9bccSSaravana Kannan * 36162cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure 3617e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the 3618e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device. 3619e2ae9bccSSaravana Kannan */ 36202cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) { 36212cd38fd1SSaravana Kannan dev->fwnode->dev = dev; 36225f5377eaSSaravana Kannan fw_devlink_link_device(dev); 362303324507SSaravana Kannan } 3624e2ae9bccSSaravana Kannan 36252023c610SAlan Stern bus_probe_device(dev); 3626d46f3e3eSSaravana Kannan 3627d46f3e3eSSaravana Kannan /* 3628d46f3e3eSSaravana Kannan * If all driver registration is done and a newly added device doesn't 3629d46f3e3eSSaravana Kannan * match with any driver, don't block its consumers from probing in 3630d46f3e3eSSaravana Kannan * case the consumer device is able to operate without this supplier. 3631d46f3e3eSSaravana Kannan */ 3632d46f3e3eSSaravana Kannan if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match) 3633d46f3e3eSSaravana Kannan fw_devlink_unblock_consumers(dev); 3634d46f3e3eSSaravana Kannan 36351da177e4SLinus Torvalds if (parent) 3636f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 3637f791b8c8SGreg Kroah-Hartman &parent->p->klist_children); 36381da177e4SLinus Torvalds 36397d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class); 36407d90e81aSGreg Kroah-Hartman if (sp) { 36417d90e81aSGreg Kroah-Hartman mutex_lock(&sp->mutex); 3642c47ed219SGreg Kroah-Hartman /* tie the class to the device */ 36437d90e81aSGreg Kroah-Hartman klist_add_tail(&dev->p->knode_class, &sp->klist_devices); 3644c47ed219SGreg Kroah-Hartman 3645c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */ 36467d90e81aSGreg Kroah-Hartman list_for_each_entry(class_intf, &sp->interfaces, node) 3647c47ed219SGreg Kroah-Hartman if (class_intf->add_dev) 36482243acd5SGreg Kroah-Hartman class_intf->add_dev(dev); 36497d90e81aSGreg Kroah-Hartman mutex_unlock(&sp->mutex); 36507d90e81aSGreg Kroah-Hartman subsys_put(sp); 36515d9fd169SGreg Kroah-Hartman } 3652c906a48aSGreg Kroah-Hartman done: 36531da177e4SLinus Torvalds put_device(dev); 36541da177e4SLinus Torvalds return error; 36550cd75047SSergey Klyaus SysEntryError: 36560cd75047SSergey Klyaus if (MAJOR(dev->devt)) 36570cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev); 36580cd75047SSergey Klyaus DevAttrError: 36590cd75047SSergey Klyaus device_pm_remove(dev); 36600cd75047SSergey Klyaus dpm_sysfs_remove(dev); 36613b98aeafSAlan Stern DPMError: 3662f6837f34SYang Yingliang dev->driver = NULL; 366357eee3d2SRafael J. Wysocki bus_remove_device(dev); 366457eee3d2SRafael J. Wysocki BusError: 36652620efefSGreg Kroah-Hartman device_remove_attrs(dev); 36662620efefSGreg Kroah-Hartman AttrsError: 36672ee97cafSCornelia Huck device_remove_class_symlinks(dev); 36682ee97cafSCornelia Huck SymlinkError: 3669c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 367023681e47SGreg Kroah-Hartman attrError: 3671b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev); 3672312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3673cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 36741da177e4SLinus Torvalds kobject_del(&dev->kobj); 36751da177e4SLinus Torvalds Error: 3676cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 367784d0c27dSTetsuo Handa parent_error: 36781da177e4SLinus Torvalds put_device(parent); 36795c8563d7SKay Sievers name_error: 36805c8563d7SKay Sievers kfree(dev->p); 36815c8563d7SKay Sievers dev->p = NULL; 3682c906a48aSGreg Kroah-Hartman goto done; 36831da177e4SLinus Torvalds } 368486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add); 36851da177e4SLinus Torvalds 36861da177e4SLinus Torvalds /** 36871da177e4SLinus Torvalds * device_register - register a device with the system. 36881da177e4SLinus Torvalds * @dev: pointer to the device structure 36891da177e4SLinus Torvalds * 36901da177e4SLinus Torvalds * This happens in two clean steps - initialize the device 36911da177e4SLinus Torvalds * and add it to the system. The two steps can be called 36921da177e4SLinus Torvalds * separately, but this is the easiest and most common. 36931da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if 36941da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device 36951da177e4SLinus Torvalds * before it is added to the hierarchy. 36965739411aSCornelia Huck * 3697b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize() 3698b10d5efdSAlan Stern * and device_add(). 3699b10d5efdSAlan Stern * 37005739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even 37015739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the 37025739411aSCornelia Huck * reference initialized in this function instead. 37031da177e4SLinus Torvalds */ 37041da177e4SLinus Torvalds int device_register(struct device *dev) 37051da177e4SLinus Torvalds { 37061da177e4SLinus Torvalds device_initialize(dev); 37071da177e4SLinus Torvalds return device_add(dev); 37081da177e4SLinus Torvalds } 370986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register); 37101da177e4SLinus Torvalds 37111da177e4SLinus Torvalds /** 37121da177e4SLinus Torvalds * get_device - increment reference count for device. 37131da177e4SLinus Torvalds * @dev: device. 37141da177e4SLinus Torvalds * 37151da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though 37161da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL 37171da177e4SLinus Torvalds * pointer passed in. 37181da177e4SLinus Torvalds */ 37191da177e4SLinus Torvalds struct device *get_device(struct device *dev) 37201da177e4SLinus Torvalds { 3721b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL; 37221da177e4SLinus Torvalds } 372386df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device); 37241da177e4SLinus Torvalds 37251da177e4SLinus Torvalds /** 37261da177e4SLinus Torvalds * put_device - decrement reference count. 37271da177e4SLinus Torvalds * @dev: device in question. 37281da177e4SLinus Torvalds */ 37291da177e4SLinus Torvalds void put_device(struct device *dev) 37301da177e4SLinus Torvalds { 3731edfaa7c3SKay Sievers /* might_sleep(); */ 37321da177e4SLinus Torvalds if (dev) 37331da177e4SLinus Torvalds kobject_put(&dev->kobj); 37341da177e4SLinus Torvalds } 373586df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device); 37361da177e4SLinus Torvalds 373700289cd8SDan Williams bool kill_device(struct device *dev) 373800289cd8SDan Williams { 373900289cd8SDan Williams /* 374000289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that 374100289cd8SDan Williams * the update behavior is consistent with the other bitfields near 374200289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying 374300289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from 374400289cd8SDan Williams * underneath the device. 374500289cd8SDan Williams */ 37468c60a141SJulian Wiedmann device_lock_assert(dev); 374700289cd8SDan Williams 374800289cd8SDan Williams if (dev->p->dead) 374900289cd8SDan Williams return false; 375000289cd8SDan Williams dev->p->dead = true; 375100289cd8SDan Williams return true; 375200289cd8SDan Williams } 375300289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device); 375400289cd8SDan Williams 37551da177e4SLinus Torvalds /** 37561da177e4SLinus Torvalds * device_del - delete device from system. 37571da177e4SLinus Torvalds * @dev: device. 37581da177e4SLinus Torvalds * 37591da177e4SLinus Torvalds * This is the first part of the device unregistration 37601da177e4SLinus Torvalds * sequence. This removes the device from the lists we control 37611da177e4SLinus Torvalds * from here, has it removed from the other driver model 37621da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it 37631da177e4SLinus Torvalds * from the kobject hierarchy. 37641da177e4SLinus Torvalds * 37651da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was 37661da177e4SLinus Torvalds * also called manually. 37671da177e4SLinus Torvalds */ 37681da177e4SLinus Torvalds void device_del(struct device *dev) 37691da177e4SLinus Torvalds { 37707d90e81aSGreg Kroah-Hartman struct subsys_private *sp; 37711da177e4SLinus Torvalds struct device *parent = dev->parent; 3772cebf8fd1SMing Lei struct kobject *glue_dir = NULL; 3773c47ed219SGreg Kroah-Hartman struct class_interface *class_intf; 3774b8530017SOliver Neukum unsigned int noio_flag; 37751da177e4SLinus Torvalds 37763451a495SAlexander Duyck device_lock(dev); 377700289cd8SDan Williams kill_device(dev); 37783451a495SAlexander Duyck device_unlock(dev); 37793451a495SAlexander Duyck 3780372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) 3781372a67c0SSaravana Kannan dev->fwnode->dev = NULL; 3782372a67c0SSaravana Kannan 3783ec0676eeSAlan Stern /* Notify clients of device removal. This call must come 3784ec0676eeSAlan Stern * before dpm_sysfs_remove(). 3785ec0676eeSAlan Stern */ 3786b8530017SOliver Neukum noio_flag = memalloc_noio_save(); 3787ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_DEL_DEVICE); 37889ed98953SRafael J. Wysocki 37893b98aeafSAlan Stern dpm_sysfs_remove(dev); 37901da177e4SLinus Torvalds if (parent) 3791f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent); 3792e105b8bfSDan Williams if (MAJOR(dev->devt)) { 37932b2af54aSKay Sievers devtmpfs_delete_node(dev); 3794e105b8bfSDan Williams device_remove_sys_dev_entry(dev); 3795c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev); 3796e105b8bfSDan Williams } 37977d90e81aSGreg Kroah-Hartman 37987d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class); 37997d90e81aSGreg Kroah-Hartman if (sp) { 3800da231fd5SKay Sievers device_remove_class_symlinks(dev); 380199ef3ef8SKay Sievers 38027d90e81aSGreg Kroah-Hartman mutex_lock(&sp->mutex); 3803c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */ 38047d90e81aSGreg Kroah-Hartman list_for_each_entry(class_intf, &sp->interfaces, node) 3805c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev) 38062243acd5SGreg Kroah-Hartman class_intf->remove_dev(dev); 3807c47ed219SGreg Kroah-Hartman /* remove the device from the class list */ 3808570d0200SWei Yang klist_del(&dev->p->knode_class); 38097d90e81aSGreg Kroah-Hartman mutex_unlock(&sp->mutex); 38107d90e81aSGreg Kroah-Hartman subsys_put(sp); 3811b9d9c82bSKay Sievers } 3812c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent); 38132620efefSGreg Kroah-Hartman device_remove_attrs(dev); 381428953533SBenjamin Herrenschmidt bus_remove_device(dev); 38154b6d1f12SLongX Zhang device_pm_remove(dev); 3816d1c3414cSGrant Likely driver_deferred_probe_del(dev); 3817b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev); 38182ec16150SJeffy Chen device_links_purge(dev); 38191da177e4SLinus Torvalds 3820*699fb50dSDavid Gow /* 3821*699fb50dSDavid Gow * If a device does not have a driver attached, we need to clean 3822*699fb50dSDavid Gow * up any managed resources. We do this in device_release(), but 3823*699fb50dSDavid Gow * it's never called (and we leak the device) if a managed 3824*699fb50dSDavid Gow * resource holds a reference to the device. So release all 3825*699fb50dSDavid Gow * managed resources here, like we do in driver_detach(). We 3826*699fb50dSDavid Gow * still need to do so again in device_release() in case someone 3827*699fb50dSDavid Gow * adds a new resource after this point, though. 3828*699fb50dSDavid Gow */ 3829*699fb50dSDavid Gow devres_release_all(dev); 3830*699fb50dSDavid Gow 3831ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_REMOVED_DEVICE); 3832312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE); 3833cebf8fd1SMing Lei glue_dir = get_glue_dir(dev); 38341da177e4SLinus Torvalds kobject_del(&dev->kobj); 3835cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir); 3836b8530017SOliver Neukum memalloc_noio_restore(noio_flag); 38371da177e4SLinus Torvalds put_device(parent); 38381da177e4SLinus Torvalds } 383986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del); 38401da177e4SLinus Torvalds 38411da177e4SLinus Torvalds /** 38421da177e4SLinus Torvalds * device_unregister - unregister device from system. 38431da177e4SLinus Torvalds * @dev: device going away. 38441da177e4SLinus Torvalds * 38451da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First, 38461da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then 38471da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that 38481da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up 38491da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will 38501da177e4SLinus Torvalds * stick around until the final reference to the device is dropped. 38511da177e4SLinus Torvalds */ 38521da177e4SLinus Torvalds void device_unregister(struct device *dev) 38531da177e4SLinus Torvalds { 38541e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 38551da177e4SLinus Torvalds device_del(dev); 38561da177e4SLinus Torvalds put_device(dev); 38571da177e4SLinus Torvalds } 385886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister); 38591da177e4SLinus Torvalds 38603d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i) 38613d060aebSAndy Shevchenko { 38623d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i); 38633d060aebSAndy Shevchenko struct device *dev = NULL; 38643d060aebSAndy Shevchenko struct device_private *p; 38653d060aebSAndy Shevchenko 38663d060aebSAndy Shevchenko if (n) { 38673d060aebSAndy Shevchenko p = to_device_private_parent(n); 38683d060aebSAndy Shevchenko dev = p->device; 38693d060aebSAndy Shevchenko } 38703d060aebSAndy Shevchenko return dev; 38713d060aebSAndy Shevchenko } 38723d060aebSAndy Shevchenko 387336239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i) 387436239577Smochel@digitalimplant.org { 387536239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i); 3876f791b8c8SGreg Kroah-Hartman struct device *dev = NULL; 3877f791b8c8SGreg Kroah-Hartman struct device_private *p; 3878f791b8c8SGreg Kroah-Hartman 3879f791b8c8SGreg Kroah-Hartman if (n) { 3880f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n); 3881f791b8c8SGreg Kroah-Hartman dev = p->device; 3882f791b8c8SGreg Kroah-Hartman } 3883f791b8c8SGreg Kroah-Hartman return dev; 388436239577Smochel@digitalimplant.org } 388536239577Smochel@digitalimplant.org 38861da177e4SLinus Torvalds /** 3887e454cea2SKay Sievers * device_get_devnode - path of device node file 38886fcf53acSKay Sievers * @dev: device 3889e454cea2SKay Sievers * @mode: returned file access mode 38903c2670e6SKay Sievers * @uid: returned file owner 38913c2670e6SKay Sievers * @gid: returned file group 38926fcf53acSKay Sievers * @tmp: possibly allocated string 38936fcf53acSKay Sievers * 38946fcf53acSKay Sievers * Return the relative path of a possible device node. 38956fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose 38966fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be 38976fcf53acSKay Sievers * freed by the caller. 38986fcf53acSKay Sievers */ 389942bb5be8SGreg Kroah-Hartman const char *device_get_devnode(const struct device *dev, 39004e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid, 39013c2670e6SKay Sievers const char **tmp) 39026fcf53acSKay Sievers { 39036fcf53acSKay Sievers char *s; 39046fcf53acSKay Sievers 39056fcf53acSKay Sievers *tmp = NULL; 39066fcf53acSKay Sievers 39076fcf53acSKay Sievers /* the device type may provide a specific name */ 3908e454cea2SKay Sievers if (dev->type && dev->type->devnode) 39093c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid); 39106fcf53acSKay Sievers if (*tmp) 39116fcf53acSKay Sievers return *tmp; 39126fcf53acSKay Sievers 39136fcf53acSKay Sievers /* the class may provide a specific name */ 3914e454cea2SKay Sievers if (dev->class && dev->class->devnode) 3915e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode); 39166fcf53acSKay Sievers if (*tmp) 39176fcf53acSKay Sievers return *tmp; 39186fcf53acSKay Sievers 39196fcf53acSKay Sievers /* return name without allocation, tmp == NULL */ 39206fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL) 39216fcf53acSKay Sievers return dev_name(dev); 39226fcf53acSKay Sievers 39236fcf53acSKay Sievers /* replace '!' in the name with '/' */ 3924a29fd614SRasmus Villemoes s = kstrdup(dev_name(dev), GFP_KERNEL); 3925a29fd614SRasmus Villemoes if (!s) 39266fcf53acSKay Sievers return NULL; 3927a29fd614SRasmus Villemoes strreplace(s, '!', '/'); 3928a29fd614SRasmus Villemoes return *tmp = s; 39296fcf53acSKay Sievers } 39306fcf53acSKay Sievers 39316fcf53acSKay Sievers /** 39321da177e4SLinus Torvalds * device_for_each_child - device child iterator. 3933c41455fbSRandy Dunlap * @parent: parent struct device. 39341da177e4SLinus Torvalds * @fn: function to be called for each device. 3935f8878dcbSRobert P. J. Day * @data: data for the callback. 39361da177e4SLinus Torvalds * 3937c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each, 39381da177e4SLinus Torvalds * passing it @data. 39391da177e4SLinus Torvalds * 39401da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything 39411da177e4SLinus Torvalds * other than 0, we break out and return that value. 39421da177e4SLinus Torvalds */ 394336239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data, 39444a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data)) 39451da177e4SLinus Torvalds { 394636239577Smochel@digitalimplant.org struct klist_iter i; 39471da177e4SLinus Torvalds struct device *child; 39481da177e4SLinus Torvalds int error = 0; 39491da177e4SLinus Torvalds 3950014c90dbSGreg Kroah-Hartman if (!parent->p) 3951014c90dbSGreg Kroah-Hartman return 0; 3952014c90dbSGreg Kroah-Hartman 3953f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 395493ead7c9SGimcuan Hui while (!error && (child = next_device(&i))) 395536239577Smochel@digitalimplant.org error = fn(child, data); 395636239577Smochel@digitalimplant.org klist_iter_exit(&i); 39571da177e4SLinus Torvalds return error; 39581da177e4SLinus Torvalds } 395986df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child); 39601da177e4SLinus Torvalds 39615ab69981SCornelia Huck /** 39623d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order. 39633d060aebSAndy Shevchenko * @parent: parent struct device. 39643d060aebSAndy Shevchenko * @fn: function to be called for each device. 39653d060aebSAndy Shevchenko * @data: data for the callback. 39663d060aebSAndy Shevchenko * 39673d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each, 39683d060aebSAndy Shevchenko * passing it @data. 39693d060aebSAndy Shevchenko * 39703d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything 39713d060aebSAndy Shevchenko * other than 0, we break out and return that value. 39723d060aebSAndy Shevchenko */ 39733d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data, 39743d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data)) 39753d060aebSAndy Shevchenko { 39763d060aebSAndy Shevchenko struct klist_iter i; 39773d060aebSAndy Shevchenko struct device *child; 39783d060aebSAndy Shevchenko int error = 0; 39793d060aebSAndy Shevchenko 39803d060aebSAndy Shevchenko if (!parent->p) 39813d060aebSAndy Shevchenko return 0; 39823d060aebSAndy Shevchenko 39833d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i); 39843d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error) 39853d060aebSAndy Shevchenko error = fn(child, data); 39863d060aebSAndy Shevchenko klist_iter_exit(&i); 39873d060aebSAndy Shevchenko return error; 39883d060aebSAndy Shevchenko } 39893d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse); 39903d060aebSAndy Shevchenko 39913d060aebSAndy Shevchenko /** 39925ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device. 39935ab69981SCornelia Huck * @parent: parent struct device 39945ab69981SCornelia Huck * @match: Callback function to check device 3995f8878dcbSRobert P. J. Day * @data: Data to pass to match function 39965ab69981SCornelia Huck * 39975ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it 39985ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as 39995ab69981SCornelia Huck * determined by the @match callback. 40005ab69981SCornelia Huck * 40015ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero 40025ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the 40035ab69981SCornelia Huck * current device can be obtained, this function will return to the caller 40045ab69981SCornelia Huck * and not iterate over any more devices. 4005a4e2400aSFederico Vaga * 4006a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use. 40075ab69981SCornelia Huck */ 40085ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data, 40094a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data)) 40105ab69981SCornelia Huck { 40115ab69981SCornelia Huck struct klist_iter i; 40125ab69981SCornelia Huck struct device *child; 40135ab69981SCornelia Huck 40145ab69981SCornelia Huck if (!parent) 40155ab69981SCornelia Huck return NULL; 40165ab69981SCornelia Huck 4017f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i); 40185ab69981SCornelia Huck while ((child = next_device(&i))) 40195ab69981SCornelia Huck if (match(child, data) && get_device(child)) 40205ab69981SCornelia Huck break; 40215ab69981SCornelia Huck klist_iter_exit(&i); 40225ab69981SCornelia Huck return child; 40235ab69981SCornelia Huck } 402486df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child); 40255ab69981SCornelia Huck 4026dad9bb01SHeikki Krogerus /** 4027dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device. 4028dad9bb01SHeikki Krogerus * @parent: parent struct device 4029dad9bb01SHeikki Krogerus * @name: name of the child device 4030dad9bb01SHeikki Krogerus * 4031dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it 4032dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name. 4033dad9bb01SHeikki Krogerus * 4034dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use. 4035dad9bb01SHeikki Krogerus */ 4036dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent, 4037dad9bb01SHeikki Krogerus const char *name) 4038dad9bb01SHeikki Krogerus { 4039dad9bb01SHeikki Krogerus struct klist_iter i; 4040dad9bb01SHeikki Krogerus struct device *child; 4041dad9bb01SHeikki Krogerus 4042dad9bb01SHeikki Krogerus if (!parent) 4043dad9bb01SHeikki Krogerus return NULL; 4044dad9bb01SHeikki Krogerus 4045dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i); 4046dad9bb01SHeikki Krogerus while ((child = next_device(&i))) 4047c77f520dSDan Williams if (sysfs_streq(dev_name(child), name) && get_device(child)) 4048dad9bb01SHeikki Krogerus break; 4049dad9bb01SHeikki Krogerus klist_iter_exit(&i); 4050dad9bb01SHeikki Krogerus return child; 4051dad9bb01SHeikki Krogerus } 4052dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name); 4053dad9bb01SHeikki Krogerus 405482b070beSAndy Shevchenko static int match_any(struct device *dev, void *unused) 405582b070beSAndy Shevchenko { 405682b070beSAndy Shevchenko return 1; 405782b070beSAndy Shevchenko } 405882b070beSAndy Shevchenko 405982b070beSAndy Shevchenko /** 406082b070beSAndy Shevchenko * device_find_any_child - device iterator for locating a child device, if any. 406182b070beSAndy Shevchenko * @parent: parent struct device 406282b070beSAndy Shevchenko * 406382b070beSAndy Shevchenko * This is similar to the device_find_child() function above, but it 406482b070beSAndy Shevchenko * returns a reference to a child device, if any. 406582b070beSAndy Shevchenko * 406682b070beSAndy Shevchenko * NOTE: you will need to drop the reference with put_device() after use. 406782b070beSAndy Shevchenko */ 406882b070beSAndy Shevchenko struct device *device_find_any_child(struct device *parent) 406982b070beSAndy Shevchenko { 407082b070beSAndy Shevchenko return device_find_child(parent, NULL, match_any); 407182b070beSAndy Shevchenko } 407282b070beSAndy Shevchenko EXPORT_SYMBOL_GPL(device_find_any_child); 407382b070beSAndy Shevchenko 40741da177e4SLinus Torvalds int __init devices_init(void) 40751da177e4SLinus Torvalds { 4076881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL); 4077881c6cfdSGreg Kroah-Hartman if (!devices_kset) 4078881c6cfdSGreg Kroah-Hartman return -ENOMEM; 4079e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL); 4080e105b8bfSDan Williams if (!dev_kobj) 4081e105b8bfSDan Williams goto dev_kobj_err; 4082e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj); 4083e105b8bfSDan Williams if (!sysfs_dev_block_kobj) 4084e105b8bfSDan Williams goto block_kobj_err; 4085e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj); 4086e105b8bfSDan Williams if (!sysfs_dev_char_kobj) 4087e105b8bfSDan Williams goto char_kobj_err; 4088e105b8bfSDan Williams 4089881c6cfdSGreg Kroah-Hartman return 0; 4090e105b8bfSDan Williams 4091e105b8bfSDan Williams char_kobj_err: 4092e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj); 4093e105b8bfSDan Williams block_kobj_err: 4094e105b8bfSDan Williams kobject_put(dev_kobj); 4095e105b8bfSDan Williams dev_kobj_err: 4096e105b8bfSDan Williams kset_unregister(devices_kset); 4097e105b8bfSDan Williams return -ENOMEM; 40981da177e4SLinus Torvalds } 40991da177e4SLinus Torvalds 41004f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used) 41014f3549d7SRafael J. Wysocki { 41024f3549d7SRafael J. Wysocki int ret; 41034f3549d7SRafael J. Wysocki 41044f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 41054f3549d7SRafael J. Wysocki if (ret) 41064f3549d7SRafael J. Wysocki return ret; 41074f3549d7SRafael J. Wysocki 41084f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0; 41094f3549d7SRafael J. Wysocki } 41104f3549d7SRafael J. Wysocki 41114f3549d7SRafael J. Wysocki /** 41124f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal. 41134f3549d7SRafael J. Wysocki * @dev: Device to be put offline. 41144f3549d7SRafael J. Wysocki * 41154f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare 41164f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must 41174f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback 41184f3549d7SRafael J. Wysocki * is executed. 41194f3549d7SRafael J. Wysocki * 41204f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 41214f3549d7SRafael J. Wysocki */ 41224f3549d7SRafael J. Wysocki int device_offline(struct device *dev) 41234f3549d7SRafael J. Wysocki { 41244f3549d7SRafael J. Wysocki int ret; 41254f3549d7SRafael J. Wysocki 41264f3549d7SRafael J. Wysocki if (dev->offline_disabled) 41274f3549d7SRafael J. Wysocki return -EPERM; 41284f3549d7SRafael J. Wysocki 41294f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline); 41304f3549d7SRafael J. Wysocki if (ret) 41314f3549d7SRafael J. Wysocki return ret; 41324f3549d7SRafael J. Wysocki 41334f3549d7SRafael J. Wysocki device_lock(dev); 41344f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 41354f3549d7SRafael J. Wysocki if (dev->offline) { 41364f3549d7SRafael J. Wysocki ret = 1; 41374f3549d7SRafael J. Wysocki } else { 41384f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev); 41394f3549d7SRafael J. Wysocki if (!ret) { 41404f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE); 41414f3549d7SRafael J. Wysocki dev->offline = true; 41424f3549d7SRafael J. Wysocki } 41434f3549d7SRafael J. Wysocki } 41444f3549d7SRafael J. Wysocki } 41454f3549d7SRafael J. Wysocki device_unlock(dev); 41464f3549d7SRafael J. Wysocki 41474f3549d7SRafael J. Wysocki return ret; 41484f3549d7SRafael J. Wysocki } 41494f3549d7SRafael J. Wysocki 41504f3549d7SRafael J. Wysocki /** 41514f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline(). 41524f3549d7SRafael J. Wysocki * @dev: Device to be put back online. 41534f3549d7SRafael J. Wysocki * 41544f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device 41554f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback 41564f3549d7SRafael J. Wysocki * to indicate that the device can be used again. 41574f3549d7SRafael J. Wysocki * 41584f3549d7SRafael J. Wysocki * Call under device_hotplug_lock. 41594f3549d7SRafael J. Wysocki */ 41604f3549d7SRafael J. Wysocki int device_online(struct device *dev) 41614f3549d7SRafael J. Wysocki { 41624f3549d7SRafael J. Wysocki int ret = 0; 41634f3549d7SRafael J. Wysocki 41644f3549d7SRafael J. Wysocki device_lock(dev); 41654f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) { 41664f3549d7SRafael J. Wysocki if (dev->offline) { 41674f3549d7SRafael J. Wysocki ret = dev->bus->online(dev); 41684f3549d7SRafael J. Wysocki if (!ret) { 41694f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE); 41704f3549d7SRafael J. Wysocki dev->offline = false; 41714f3549d7SRafael J. Wysocki } 41724f3549d7SRafael J. Wysocki } else { 41734f3549d7SRafael J. Wysocki ret = 1; 41744f3549d7SRafael J. Wysocki } 41754f3549d7SRafael J. Wysocki } 41764f3549d7SRafael J. Wysocki device_unlock(dev); 41774f3549d7SRafael J. Wysocki 41784f3549d7SRafael J. Wysocki return ret; 41794f3549d7SRafael J. Wysocki } 41804f3549d7SRafael J. Wysocki 41817f100d15SKarthigan Srinivasan struct root_device { 41820aa0dc41SMark McLoughlin struct device dev; 41830aa0dc41SMark McLoughlin struct module *owner; 41840aa0dc41SMark McLoughlin }; 41850aa0dc41SMark McLoughlin 418693058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d) 4187481e2079SFerenc Wagner { 4188481e2079SFerenc Wagner return container_of(d, struct root_device, dev); 4189481e2079SFerenc Wagner } 41900aa0dc41SMark McLoughlin 41910aa0dc41SMark McLoughlin static void root_device_release(struct device *dev) 41920aa0dc41SMark McLoughlin { 41930aa0dc41SMark McLoughlin kfree(to_root_device(dev)); 41940aa0dc41SMark McLoughlin } 41950aa0dc41SMark McLoughlin 41960aa0dc41SMark McLoughlin /** 41970aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device 41980aa0dc41SMark McLoughlin * @name: root device name 41990aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE 42000aa0dc41SMark McLoughlin * 42010aa0dc41SMark McLoughlin * This function allocates a root device and registers it 42020aa0dc41SMark McLoughlin * using device_register(). In order to free the returned 42030aa0dc41SMark McLoughlin * device, use root_device_unregister(). 42040aa0dc41SMark McLoughlin * 42050aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices 42060aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to 42070aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of 42080aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name} 42090aa0dc41SMark McLoughlin * 42100aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a 42110aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory 42120aa0dc41SMark McLoughlin * in sysfs. 42130aa0dc41SMark McLoughlin * 4214f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 4215f0eae0edSJani Nikula * 42160aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register(). 42170aa0dc41SMark McLoughlin */ 42180aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner) 42190aa0dc41SMark McLoughlin { 42200aa0dc41SMark McLoughlin struct root_device *root; 42210aa0dc41SMark McLoughlin int err = -ENOMEM; 42220aa0dc41SMark McLoughlin 42230aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL); 42240aa0dc41SMark McLoughlin if (!root) 42250aa0dc41SMark McLoughlin return ERR_PTR(err); 42260aa0dc41SMark McLoughlin 4227acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name); 42280aa0dc41SMark McLoughlin if (err) { 42290aa0dc41SMark McLoughlin kfree(root); 42300aa0dc41SMark McLoughlin return ERR_PTR(err); 42310aa0dc41SMark McLoughlin } 42320aa0dc41SMark McLoughlin 42330aa0dc41SMark McLoughlin root->dev.release = root_device_release; 42340aa0dc41SMark McLoughlin 42350aa0dc41SMark McLoughlin err = device_register(&root->dev); 42360aa0dc41SMark McLoughlin if (err) { 42370aa0dc41SMark McLoughlin put_device(&root->dev); 42380aa0dc41SMark McLoughlin return ERR_PTR(err); 42390aa0dc41SMark McLoughlin } 42400aa0dc41SMark McLoughlin 42411d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */ 42420aa0dc41SMark McLoughlin if (owner) { 42430aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj; 42440aa0dc41SMark McLoughlin 42450aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module"); 42460aa0dc41SMark McLoughlin if (err) { 42470aa0dc41SMark McLoughlin device_unregister(&root->dev); 42480aa0dc41SMark McLoughlin return ERR_PTR(err); 42490aa0dc41SMark McLoughlin } 42500aa0dc41SMark McLoughlin root->owner = owner; 42510aa0dc41SMark McLoughlin } 42520aa0dc41SMark McLoughlin #endif 42530aa0dc41SMark McLoughlin 42540aa0dc41SMark McLoughlin return &root->dev; 42550aa0dc41SMark McLoughlin } 42560aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register); 42570aa0dc41SMark McLoughlin 42580aa0dc41SMark McLoughlin /** 42590aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device 42607cbcf225SRandy Dunlap * @dev: device going away 42610aa0dc41SMark McLoughlin * 42620aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by 42630aa0dc41SMark McLoughlin * root_device_register(). 42640aa0dc41SMark McLoughlin */ 42650aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev) 42660aa0dc41SMark McLoughlin { 42670aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev); 42680aa0dc41SMark McLoughlin 42690aa0dc41SMark McLoughlin if (root->owner) 42700aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module"); 42710aa0dc41SMark McLoughlin 42720aa0dc41SMark McLoughlin device_unregister(dev); 42730aa0dc41SMark McLoughlin } 42740aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister); 42750aa0dc41SMark McLoughlin 427623681e47SGreg Kroah-Hartman 427723681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev) 427823681e47SGreg Kroah-Hartman { 42791e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__); 428023681e47SGreg Kroah-Hartman kfree(dev); 428123681e47SGreg Kroah-Hartman } 428223681e47SGreg Kroah-Hartman 42836a8b55d7SMathieu Malaterre static __printf(6, 0) struct device * 42842bd5c639SGreg Kroah-Hartman device_create_groups_vargs(const struct class *class, struct device *parent, 428539ef3112SGuenter Roeck dev_t devt, void *drvdata, 428639ef3112SGuenter Roeck const struct attribute_group **groups, 428739ef3112SGuenter Roeck const char *fmt, va_list args) 428839ef3112SGuenter Roeck { 428939ef3112SGuenter Roeck struct device *dev = NULL; 429039ef3112SGuenter Roeck int retval = -ENODEV; 429139ef3112SGuenter Roeck 4292d70590d5SYang Yingliang if (IS_ERR_OR_NULL(class)) 429339ef3112SGuenter Roeck goto error; 429439ef3112SGuenter Roeck 429539ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL); 429639ef3112SGuenter Roeck if (!dev) { 429739ef3112SGuenter Roeck retval = -ENOMEM; 429839ef3112SGuenter Roeck goto error; 429939ef3112SGuenter Roeck } 430039ef3112SGuenter Roeck 4301bbc780f8SDavid Herrmann device_initialize(dev); 430239ef3112SGuenter Roeck dev->devt = devt; 430339ef3112SGuenter Roeck dev->class = class; 430439ef3112SGuenter Roeck dev->parent = parent; 430539ef3112SGuenter Roeck dev->groups = groups; 430639ef3112SGuenter Roeck dev->release = device_create_release; 430739ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata); 430839ef3112SGuenter Roeck 430939ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args); 431039ef3112SGuenter Roeck if (retval) 431139ef3112SGuenter Roeck goto error; 431239ef3112SGuenter Roeck 4313bbc780f8SDavid Herrmann retval = device_add(dev); 431439ef3112SGuenter Roeck if (retval) 431539ef3112SGuenter Roeck goto error; 431639ef3112SGuenter Roeck 431739ef3112SGuenter Roeck return dev; 431839ef3112SGuenter Roeck 431939ef3112SGuenter Roeck error: 432039ef3112SGuenter Roeck put_device(dev); 432139ef3112SGuenter Roeck return ERR_PTR(retval); 432239ef3112SGuenter Roeck } 432339ef3112SGuenter Roeck 432423681e47SGreg Kroah-Hartman /** 43254e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs 43268882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to 43278882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any 43288882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added 43298882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks 43308882b394SGreg Kroah-Hartman * @fmt: string for the device's name 43318882b394SGreg Kroah-Hartman * 43328882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device 43338882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class. 43348882b394SGreg Kroah-Hartman * 43358882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if 43368882b394SGreg Kroah-Hartman * the dev_t is not 0,0. 43378882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created 43388882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs. 43398882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call. 43408882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this 43418882b394SGreg Kroah-Hartman * pointer. 43428882b394SGreg Kroah-Hartman * 4343f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error. 43448882b394SGreg Kroah-Hartman */ 43452bd5c639SGreg Kroah-Hartman struct device *device_create(const struct class *class, struct device *parent, 43464e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...) 43478882b394SGreg Kroah-Hartman { 43488882b394SGreg Kroah-Hartman va_list vargs; 43498882b394SGreg Kroah-Hartman struct device *dev; 43508882b394SGreg Kroah-Hartman 43518882b394SGreg Kroah-Hartman va_start(vargs, fmt); 43524c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL, 43534c747466SChristoph Hellwig fmt, vargs); 43548882b394SGreg Kroah-Hartman va_end(vargs); 43558882b394SGreg Kroah-Hartman return dev; 43568882b394SGreg Kroah-Hartman } 43574e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create); 43588882b394SGreg Kroah-Hartman 435939ef3112SGuenter Roeck /** 436039ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs 436139ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to 436239ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any 436339ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added 436439ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks 436539ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created 436639ef3112SGuenter Roeck * @fmt: string for the device's name 436739ef3112SGuenter Roeck * 436839ef3112SGuenter Roeck * This function can be used by char device classes. A struct device 436939ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class. 437039ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also 437139ef3112SGuenter Roeck * be created automatically. 437239ef3112SGuenter Roeck * 437339ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if 437439ef3112SGuenter Roeck * the dev_t is not 0,0. 437539ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created 437639ef3112SGuenter Roeck * struct device will be a child of that device in sysfs. 437739ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call. 437839ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this 437939ef3112SGuenter Roeck * pointer. 438039ef3112SGuenter Roeck * 438139ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error. 438239ef3112SGuenter Roeck */ 43832bd5c639SGreg Kroah-Hartman struct device *device_create_with_groups(const struct class *class, 438439ef3112SGuenter Roeck struct device *parent, dev_t devt, 438539ef3112SGuenter Roeck void *drvdata, 438639ef3112SGuenter Roeck const struct attribute_group **groups, 438739ef3112SGuenter Roeck const char *fmt, ...) 438839ef3112SGuenter Roeck { 438939ef3112SGuenter Roeck va_list vargs; 439039ef3112SGuenter Roeck struct device *dev; 439139ef3112SGuenter Roeck 439239ef3112SGuenter Roeck va_start(vargs, fmt); 439339ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups, 439439ef3112SGuenter Roeck fmt, vargs); 439539ef3112SGuenter Roeck va_end(vargs); 439639ef3112SGuenter Roeck return dev; 439739ef3112SGuenter Roeck } 439839ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups); 439939ef3112SGuenter Roeck 4400775b64d2SRafael J. Wysocki /** 4401775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create() 4402775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with 4403775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered 4404775b64d2SRafael J. Wysocki * 4405775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a 4406775b64d2SRafael J. Wysocki * call to device_create(). 4407775b64d2SRafael J. Wysocki */ 4408d2fff096SGreg Kroah-Hartman void device_destroy(const struct class *class, dev_t devt) 4409775b64d2SRafael J. Wysocki { 4410775b64d2SRafael J. Wysocki struct device *dev; 4411775b64d2SRafael J. Wysocki 44124495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt); 4413cd35449bSDave Young if (dev) { 4414cd35449bSDave Young put_device(dev); 441523681e47SGreg Kroah-Hartman device_unregister(dev); 441623681e47SGreg Kroah-Hartman } 4417cd35449bSDave Young } 441823681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy); 4419a2de48caSGreg Kroah-Hartman 4420a2de48caSGreg Kroah-Hartman /** 4421a2de48caSGreg Kroah-Hartman * device_rename - renames a device 4422a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed 4423a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device 4424030c1d2bSEric W. Biederman * 4425030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual 4426030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename 4427030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and 4428030c1d2bSEric W. Biederman * won't conflict with other devices. 4429c6c0ac66SMichael Ellerman * 443011a96703SWedson Almeida Filho * Note: given that some subsystems (networking and infiniband) use this 443111a96703SWedson Almeida Filho * function, with no immediate plans for this to change, we cannot assume or 443211a96703SWedson Almeida Filho * require that this function not be called at all. 443311a96703SWedson Almeida Filho * 443411a96703SWedson Almeida Filho * However, if you're writing new code, do not call this function. The following 443511a96703SWedson Almeida Filho * text from Kay Sievers offers some insight: 4436a5462516STimur Tabi * 4437a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not 4438a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to 4439a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at 4440a5462516STimur Tabi * all, there isn't even support for that in the kernel now. 4441a5462516STimur Tabi * 4442a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another 4443a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you 4444a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see 4445a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on 4446a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for 4447a5462516STimur Tabi * other things than (driver-core wise very simple) network devices. 4448a5462516STimur Tabi * 4449a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add 4450a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add 4451a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We 4452a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in 4453a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :) 4454a2de48caSGreg Kroah-Hartman */ 44556937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name) 4456a2de48caSGreg Kroah-Hartman { 44574b30ee58STejun Heo struct kobject *kobj = &dev->kobj; 44582ee97cafSCornelia Huck char *old_device_name = NULL; 4459a2de48caSGreg Kroah-Hartman int error; 4460a2de48caSGreg Kroah-Hartman 4461a2de48caSGreg Kroah-Hartman dev = get_device(dev); 4462a2de48caSGreg Kroah-Hartman if (!dev) 4463a2de48caSGreg Kroah-Hartman return -EINVAL; 4464a2de48caSGreg Kroah-Hartman 446569df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name); 4466a2de48caSGreg Kroah-Hartman 44671fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL); 44682ee97cafSCornelia Huck if (!old_device_name) { 4469952ab431SJesper Juhl error = -ENOMEM; 44702ee97cafSCornelia Huck goto out; 4471952ab431SJesper Juhl } 4472a2de48caSGreg Kroah-Hartman 4473f349cf34SEric W. Biederman if (dev->class) { 44747d90e81aSGreg Kroah-Hartman struct subsys_private *sp = class_to_subsys(dev->class); 44757d90e81aSGreg Kroah-Hartman 44767d90e81aSGreg Kroah-Hartman if (!sp) { 44777d90e81aSGreg Kroah-Hartman error = -EINVAL; 44787d90e81aSGreg Kroah-Hartman goto out; 44797d90e81aSGreg Kroah-Hartman } 44807d90e81aSGreg Kroah-Hartman 44817d90e81aSGreg Kroah-Hartman error = sysfs_rename_link_ns(&sp->subsys.kobj, kobj, old_device_name, 44824b30ee58STejun Heo new_name, kobject_namespace(kobj)); 44837d90e81aSGreg Kroah-Hartman subsys_put(sp); 4484f349cf34SEric W. Biederman if (error) 4485f349cf34SEric W. Biederman goto out; 4486f349cf34SEric W. Biederman } 448739aba963SKay Sievers 44884b30ee58STejun Heo error = kobject_rename(kobj, new_name); 44891fa5ae85SKay Sievers if (error) 44902ee97cafSCornelia Huck goto out; 4491a2de48caSGreg Kroah-Hartman 44922ee97cafSCornelia Huck out: 4493a2de48caSGreg Kroah-Hartman put_device(dev); 4494a2de48caSGreg Kroah-Hartman 44952ee97cafSCornelia Huck kfree(old_device_name); 4496a2de48caSGreg Kroah-Hartman 4497a2de48caSGreg Kroah-Hartman return error; 4498a2de48caSGreg Kroah-Hartman } 4499a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename); 45008a82472fSCornelia Huck 45018a82472fSCornelia Huck static int device_move_class_links(struct device *dev, 45028a82472fSCornelia Huck struct device *old_parent, 45038a82472fSCornelia Huck struct device *new_parent) 45048a82472fSCornelia Huck { 4505f7f3461dSGreg Kroah-Hartman int error = 0; 45068a82472fSCornelia Huck 4507f7f3461dSGreg Kroah-Hartman if (old_parent) 4508f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device"); 4509f7f3461dSGreg Kroah-Hartman if (new_parent) 4510f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj, 4511f7f3461dSGreg Kroah-Hartman "device"); 4512f7f3461dSGreg Kroah-Hartman return error; 45138a82472fSCornelia Huck } 45148a82472fSCornelia Huck 45158a82472fSCornelia Huck /** 45168a82472fSCornelia Huck * device_move - moves a device to a new parent 45178a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved 451813509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL) 4519ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list 45208a82472fSCornelia Huck */ 4521ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent, 4522ffa6a705SCornelia Huck enum dpm_order dpm_order) 45238a82472fSCornelia Huck { 45248a82472fSCornelia Huck int error; 45258a82472fSCornelia Huck struct device *old_parent; 4526c744aeaeSCornelia Huck struct kobject *new_parent_kobj; 45278a82472fSCornelia Huck 45288a82472fSCornelia Huck dev = get_device(dev); 45298a82472fSCornelia Huck if (!dev) 45308a82472fSCornelia Huck return -EINVAL; 45318a82472fSCornelia Huck 4532ffa6a705SCornelia Huck device_pm_lock(); 45338a82472fSCornelia Huck new_parent = get_device(new_parent); 4534c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent); 453584d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) { 453684d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj); 453784d0c27dSTetsuo Handa put_device(new_parent); 453884d0c27dSTetsuo Handa goto out; 453984d0c27dSTetsuo Handa } 454063b6971aSCornelia Huck 45411e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev), 45421e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>"); 4543c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj); 45448a82472fSCornelia Huck if (error) { 454563b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 45468a82472fSCornelia Huck put_device(new_parent); 45478a82472fSCornelia Huck goto out; 45488a82472fSCornelia Huck } 45498a82472fSCornelia Huck old_parent = dev->parent; 45508a82472fSCornelia Huck dev->parent = new_parent; 45518a82472fSCornelia Huck if (old_parent) 4552f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 45530d358f22SYinghai Lu if (new_parent) { 4554f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4555f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children); 45560d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent)); 45570d358f22SYinghai Lu } 45580d358f22SYinghai Lu 4559bdd4034dSRabin Vincent if (dev->class) { 45608a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent); 45618a82472fSCornelia Huck if (error) { 45628a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */ 45638a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent); 45648a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) { 4565c744aeaeSCornelia Huck if (new_parent) 4566f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent); 45670d358f22SYinghai Lu dev->parent = old_parent; 45680d358f22SYinghai Lu if (old_parent) { 4569f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent, 4570f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children); 45710d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent)); 45720d358f22SYinghai Lu } 45738a82472fSCornelia Huck } 457463b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj); 45758a82472fSCornelia Huck put_device(new_parent); 45768a82472fSCornelia Huck goto out; 45778a82472fSCornelia Huck } 4578bdd4034dSRabin Vincent } 4579ffa6a705SCornelia Huck switch (dpm_order) { 4580ffa6a705SCornelia Huck case DPM_ORDER_NONE: 4581ffa6a705SCornelia Huck break; 4582ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT: 4583ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent); 458452cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent); 4585ffa6a705SCornelia Huck break; 4586ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV: 4587ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev); 458852cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev); 4589ffa6a705SCornelia Huck break; 4590ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST: 4591ffa6a705SCornelia Huck device_pm_move_last(dev); 459252cdbdd4SGrygorii Strashko devices_kset_move_last(dev); 4593ffa6a705SCornelia Huck break; 4594ffa6a705SCornelia Huck } 4595bdd4034dSRabin Vincent 45968a82472fSCornelia Huck put_device(old_parent); 45978a82472fSCornelia Huck out: 4598ffa6a705SCornelia Huck device_pm_unlock(); 45998a82472fSCornelia Huck put_device(dev); 46008a82472fSCornelia Huck return error; 46018a82472fSCornelia Huck } 46028a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move); 460337b0c020SGreg Kroah-Hartman 4604b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid, 4605b8f33e5dSChristian Brauner kgid_t kgid) 4606b8f33e5dSChristian Brauner { 4607b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 46089fa120fbSGreg Kroah-Hartman const struct class *class = dev->class; 4609b8f33e5dSChristian Brauner const struct device_type *type = dev->type; 4610b8f33e5dSChristian Brauner int error; 4611b8f33e5dSChristian Brauner 4612b8f33e5dSChristian Brauner if (class) { 4613b8f33e5dSChristian Brauner /* 4614b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to 4615b8f33e5dSChristian Brauner * @kuid/@kgid. 4616b8f33e5dSChristian Brauner */ 4617b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid, 4618b8f33e5dSChristian Brauner kgid); 4619b8f33e5dSChristian Brauner if (error) 4620b8f33e5dSChristian Brauner return error; 4621b8f33e5dSChristian Brauner } 4622b8f33e5dSChristian Brauner 4623b8f33e5dSChristian Brauner if (type) { 4624b8f33e5dSChristian Brauner /* 4625b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to 4626b8f33e5dSChristian Brauner * @kuid/@kgid. 4627b8f33e5dSChristian Brauner */ 4628b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid, 4629b8f33e5dSChristian Brauner kgid); 4630b8f33e5dSChristian Brauner if (error) 4631b8f33e5dSChristian Brauner return error; 4632b8f33e5dSChristian Brauner } 4633b8f33e5dSChristian Brauner 4634b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */ 4635b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid); 4636b8f33e5dSChristian Brauner if (error) 4637b8f33e5dSChristian Brauner return error; 4638b8f33e5dSChristian Brauner 4639b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) { 4640b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */ 4641b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name, 4642b8f33e5dSChristian Brauner kuid, kgid); 4643b8f33e5dSChristian Brauner if (error) 4644b8f33e5dSChristian Brauner return error; 4645b8f33e5dSChristian Brauner } 4646b8f33e5dSChristian Brauner 4647b8f33e5dSChristian Brauner return 0; 4648b8f33e5dSChristian Brauner } 4649b8f33e5dSChristian Brauner 4650b8f33e5dSChristian Brauner /** 4651b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device. 4652b8f33e5dSChristian Brauner * @dev: device. 4653b8f33e5dSChristian Brauner * @kuid: new owner's kuid 4654b8f33e5dSChristian Brauner * @kgid: new owner's kgid 4655b8f33e5dSChristian Brauner * 4656b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to 4657b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver 4658b8f33e5dSChristian Brauner * core. 4659b8f33e5dSChristian Brauner * 4660b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure. 4661b8f33e5dSChristian Brauner */ 4662b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid) 4663b8f33e5dSChristian Brauner { 4664b8f33e5dSChristian Brauner int error; 4665b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj; 46667d90e81aSGreg Kroah-Hartman struct subsys_private *sp; 4667b8f33e5dSChristian Brauner 4668b8f33e5dSChristian Brauner dev = get_device(dev); 4669b8f33e5dSChristian Brauner if (!dev) 4670b8f33e5dSChristian Brauner return -EINVAL; 4671b8f33e5dSChristian Brauner 4672b8f33e5dSChristian Brauner /* 4673b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the 4674b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid. 4675b8f33e5dSChristian Brauner */ 4676b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid); 4677b8f33e5dSChristian Brauner if (error) 4678b8f33e5dSChristian Brauner goto out; 4679b8f33e5dSChristian Brauner 4680b8f33e5dSChristian Brauner /* 4681b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file 4682b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror 4683b8f33e5dSChristian Brauner * that step here. 4684b8f33e5dSChristian Brauner */ 4685b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid, 4686b8f33e5dSChristian Brauner kgid); 4687b8f33e5dSChristian Brauner if (error) 4688b8f33e5dSChristian Brauner goto out; 4689b8f33e5dSChristian Brauner 4690b8f33e5dSChristian Brauner /* 4691b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the 4692b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev 4693b8f33e5dSChristian Brauner * to @kuid/@kgid. 4694b8f33e5dSChristian Brauner */ 4695b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid); 4696b8f33e5dSChristian Brauner if (error) 4697b8f33e5dSChristian Brauner goto out; 4698b8f33e5dSChristian Brauner 46993b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid); 47003b52fc5dSChristian Brauner if (error) 47013b52fc5dSChristian Brauner goto out; 47023b52fc5dSChristian Brauner 4703b8f33e5dSChristian Brauner /* 4704b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of 4705b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual 4706b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the 4707b8f33e5dSChristian Brauner * symlink shows the same permissions as its target. 4708b8f33e5dSChristian Brauner */ 47097d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class); 47107d90e81aSGreg Kroah-Hartman if (!sp) { 47117d90e81aSGreg Kroah-Hartman error = -EINVAL; 4712b8f33e5dSChristian Brauner goto out; 47137d90e81aSGreg Kroah-Hartman } 47147d90e81aSGreg Kroah-Hartman error = sysfs_link_change_owner(&sp->subsys.kobj, &dev->kobj, dev_name(dev), kuid, kgid); 47157d90e81aSGreg Kroah-Hartman subsys_put(sp); 4716b8f33e5dSChristian Brauner 4717b8f33e5dSChristian Brauner out: 4718b8f33e5dSChristian Brauner put_device(dev); 4719b8f33e5dSChristian Brauner return error; 4720b8f33e5dSChristian Brauner } 4721b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner); 4722b8f33e5dSChristian Brauner 472337b0c020SGreg Kroah-Hartman /** 472437b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown. 472537b0c020SGreg Kroah-Hartman */ 472637b0c020SGreg Kroah-Hartman void device_shutdown(void) 472737b0c020SGreg Kroah-Hartman { 4728f123db8eSBenson Leung struct device *dev, *parent; 472937b0c020SGreg Kroah-Hartman 47303297c8fcSPingfan Liu wait_for_device_probe(); 47313297c8fcSPingfan Liu device_block_probing(); 47323297c8fcSPingfan Liu 473365650b35SRafael J. Wysocki cpufreq_suspend(); 473465650b35SRafael J. Wysocki 47356245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 47366245838fSHugh Daschbach /* 47376245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn. 47386245838fSHugh Daschbach * Beware that device unplug events may also start pulling 47396245838fSHugh Daschbach * devices offline, even as the system is shutting down. 47406245838fSHugh Daschbach */ 47416245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) { 47426245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device, 47436245838fSHugh Daschbach kobj.entry); 4744d1c6c030SMing Lei 4745d1c6c030SMing Lei /* 4746d1c6c030SMing Lei * hold reference count of device's parent to 4747d1c6c030SMing Lei * prevent it from being freed because parent's 4748d1c6c030SMing Lei * lock is to be held 4749d1c6c030SMing Lei */ 4750f123db8eSBenson Leung parent = get_device(dev->parent); 47516245838fSHugh Daschbach get_device(dev); 47526245838fSHugh Daschbach /* 47536245838fSHugh Daschbach * Make sure the device is off the kset list, in the 47546245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it. 47556245838fSHugh Daschbach */ 47566245838fSHugh Daschbach list_del_init(&dev->kobj.entry); 47576245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 4758fe6b91f4SAlan Stern 4759d1c6c030SMing Lei /* hold lock to avoid race with probe/release */ 4760f123db8eSBenson Leung if (parent) 4761f123db8eSBenson Leung device_lock(parent); 4762d1c6c030SMing Lei device_lock(dev); 4763d1c6c030SMing Lei 4764fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */ 4765fe6b91f4SAlan Stern pm_runtime_get_noresume(dev); 4766fe6b91f4SAlan Stern pm_runtime_barrier(dev); 47676245838fSHugh Daschbach 47687521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) { 4769f77af151SJosh Zimmerman if (initcall_debug) 47707521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n"); 47717521621eSMichal Suchanek dev->class->shutdown_pre(dev); 47727521621eSMichal Suchanek } 47737521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) { 47740246c4faSShuoX Liu if (initcall_debug) 47750246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 477637b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev); 477737b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) { 47780246c4faSShuoX Liu if (initcall_debug) 47790246c4faSShuoX Liu dev_info(dev, "shutdown\n"); 478037b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev); 478137b0c020SGreg Kroah-Hartman } 4782d1c6c030SMing Lei 4783d1c6c030SMing Lei device_unlock(dev); 4784f123db8eSBenson Leung if (parent) 4785f123db8eSBenson Leung device_unlock(parent); 4786d1c6c030SMing Lei 47876245838fSHugh Daschbach put_device(dev); 4788f123db8eSBenson Leung put_device(parent); 47896245838fSHugh Daschbach 47906245838fSHugh Daschbach spin_lock(&devices_kset->list_lock); 479137b0c020SGreg Kroah-Hartman } 47926245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock); 479337b0c020SGreg Kroah-Hartman } 479499bcf217SJoe Perches 479599bcf217SJoe Perches /* 479699bcf217SJoe Perches * Device logging functions 479799bcf217SJoe Perches */ 479899bcf217SJoe Perches 479999bcf217SJoe Perches #ifdef CONFIG_PRINTK 480074caba7fSJohn Ogness static void 480174caba7fSJohn Ogness set_dev_info(const struct device *dev, struct dev_printk_info *dev_info) 480299bcf217SJoe Perches { 4803c4e00daaSKay Sievers const char *subsys; 480474caba7fSJohn Ogness 480574caba7fSJohn Ogness memset(dev_info, 0, sizeof(*dev_info)); 480699bcf217SJoe Perches 4807c4e00daaSKay Sievers if (dev->class) 4808c4e00daaSKay Sievers subsys = dev->class->name; 4809c4e00daaSKay Sievers else if (dev->bus) 4810c4e00daaSKay Sievers subsys = dev->bus->name; 4811c4e00daaSKay Sievers else 481274caba7fSJohn Ogness return; 4813c4e00daaSKay Sievers 481474caba7fSJohn Ogness strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem)); 4815c4e00daaSKay Sievers 4816c4e00daaSKay Sievers /* 4817c4e00daaSKay Sievers * Add device identifier DEVICE=: 4818c4e00daaSKay Sievers * b12:8 block dev_t 4819c4e00daaSKay Sievers * c127:3 char dev_t 4820c4e00daaSKay Sievers * n8 netdev ifindex 4821c4e00daaSKay Sievers * +sound:card0 subsystem:devname 4822c4e00daaSKay Sievers */ 4823c4e00daaSKay Sievers if (MAJOR(dev->devt)) { 4824c4e00daaSKay Sievers char c; 4825c4e00daaSKay Sievers 4826c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0) 4827c4e00daaSKay Sievers c = 'b'; 4828c4e00daaSKay Sievers else 4829c4e00daaSKay Sievers c = 'c'; 483074caba7fSJohn Ogness 483174caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 483274caba7fSJohn Ogness "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt)); 4833c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) { 4834c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev); 4835c4e00daaSKay Sievers 483674caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 483774caba7fSJohn Ogness "n%u", net->ifindex); 4838c4e00daaSKay Sievers } else { 483974caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device), 484074caba7fSJohn Ogness "+%s:%s", subsys, dev_name(dev)); 4841c4e00daaSKay Sievers } 484299bcf217SJoe Perches } 4843798efc60SJoe Perches 484405e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev, 484505e4e5b8SJoe Perches const char *fmt, va_list args) 484605e4e5b8SJoe Perches { 484774caba7fSJohn Ogness struct dev_printk_info dev_info; 484805e4e5b8SJoe Perches 484974caba7fSJohn Ogness set_dev_info(dev, &dev_info); 485005e4e5b8SJoe Perches 485174caba7fSJohn Ogness return vprintk_emit(0, level, &dev_info, fmt, args); 485205e4e5b8SJoe Perches } 485305e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit); 485405e4e5b8SJoe Perches 485505e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 485605e4e5b8SJoe Perches { 485705e4e5b8SJoe Perches va_list args; 485805e4e5b8SJoe Perches int r; 485905e4e5b8SJoe Perches 486005e4e5b8SJoe Perches va_start(args, fmt); 486105e4e5b8SJoe Perches 486205e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args); 486305e4e5b8SJoe Perches 486405e4e5b8SJoe Perches va_end(args); 486505e4e5b8SJoe Perches 486605e4e5b8SJoe Perches return r; 486705e4e5b8SJoe Perches } 486805e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit); 486905e4e5b8SJoe Perches 4870d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev, 4871798efc60SJoe Perches struct va_format *vaf) 4872798efc60SJoe Perches { 4873d1f1052cSJoe Perches if (dev) 4874d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV", 4875798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf); 4876d1f1052cSJoe Perches else 4877d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf); 4878798efc60SJoe Perches } 487999bcf217SJoe Perches 4880ad7d61f1SChris Down void _dev_printk(const char *level, const struct device *dev, 488199bcf217SJoe Perches const char *fmt, ...) 488299bcf217SJoe Perches { 488399bcf217SJoe Perches struct va_format vaf; 488499bcf217SJoe Perches va_list args; 488599bcf217SJoe Perches 488699bcf217SJoe Perches va_start(args, fmt); 488799bcf217SJoe Perches 488899bcf217SJoe Perches vaf.fmt = fmt; 488999bcf217SJoe Perches vaf.va = &args; 489099bcf217SJoe Perches 4891d1f1052cSJoe Perches __dev_printk(level, dev, &vaf); 4892798efc60SJoe Perches 489399bcf217SJoe Perches va_end(args); 489499bcf217SJoe Perches } 4895ad7d61f1SChris Down EXPORT_SYMBOL(_dev_printk); 489699bcf217SJoe Perches 489799bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \ 4898d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \ 489999bcf217SJoe Perches { \ 490099bcf217SJoe Perches struct va_format vaf; \ 490199bcf217SJoe Perches va_list args; \ 490299bcf217SJoe Perches \ 490399bcf217SJoe Perches va_start(args, fmt); \ 490499bcf217SJoe Perches \ 490599bcf217SJoe Perches vaf.fmt = fmt; \ 490699bcf217SJoe Perches vaf.va = &args; \ 490799bcf217SJoe Perches \ 4908d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \ 4909798efc60SJoe Perches \ 491099bcf217SJoe Perches va_end(args); \ 491199bcf217SJoe Perches } \ 491299bcf217SJoe Perches EXPORT_SYMBOL(func); 491399bcf217SJoe Perches 4914663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG); 4915663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT); 4916663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT); 4917663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR); 4918663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING); 4919663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE); 492099bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO); 492199bcf217SJoe Perches 492299bcf217SJoe Perches #endif 492397badf87SRafael J. Wysocki 4924a787e540SAndrzej Hajda /** 4925a787e540SAndrzej Hajda * dev_err_probe - probe error check and log helper 4926a787e540SAndrzej Hajda * @dev: the pointer to the struct device 4927a787e540SAndrzej Hajda * @err: error value to test 4928a787e540SAndrzej Hajda * @fmt: printf-style format string 4929a787e540SAndrzej Hajda * @...: arguments as specified in the format string 4930a787e540SAndrzej Hajda * 4931a787e540SAndrzej Hajda * This helper implements common pattern present in probe functions for error 4932a787e540SAndrzej Hajda * checking: print debug or error message depending if the error value is 4933a787e540SAndrzej Hajda * -EPROBE_DEFER and propagate error upwards. 4934d090b70eSAndrzej Hajda * In case of -EPROBE_DEFER it sets also defer probe reason, which can be 4935d090b70eSAndrzej Hajda * checked later by reading devices_deferred debugfs attribute. 4936074b3aadSMauro Carvalho Chehab * It replaces code sequence:: 4937074b3aadSMauro Carvalho Chehab * 4938a787e540SAndrzej Hajda * if (err != -EPROBE_DEFER) 4939a787e540SAndrzej Hajda * dev_err(dev, ...); 4940a787e540SAndrzej Hajda * else 4941a787e540SAndrzej Hajda * dev_dbg(dev, ...); 4942a787e540SAndrzej Hajda * return err; 4943074b3aadSMauro Carvalho Chehab * 4944074b3aadSMauro Carvalho Chehab * with:: 4945074b3aadSMauro Carvalho Chehab * 4946a787e540SAndrzej Hajda * return dev_err_probe(dev, err, ...); 4947a787e540SAndrzej Hajda * 49487065f922SDouglas Anderson * Note that it is deemed acceptable to use this function for error 49497065f922SDouglas Anderson * prints during probe even if the @err is known to never be -EPROBE_DEFER. 49507065f922SDouglas Anderson * The benefit compared to a normal dev_err() is the standardized format 49517065f922SDouglas Anderson * of the error code and the fact that the error code is returned. 49527065f922SDouglas Anderson * 4953a787e540SAndrzej Hajda * Returns @err. 4954a787e540SAndrzej Hajda * 4955a787e540SAndrzej Hajda */ 4956a787e540SAndrzej Hajda int dev_err_probe(const struct device *dev, int err, const char *fmt, ...) 4957a787e540SAndrzej Hajda { 4958a787e540SAndrzej Hajda struct va_format vaf; 4959a787e540SAndrzej Hajda va_list args; 4960a787e540SAndrzej Hajda 4961a787e540SAndrzej Hajda va_start(args, fmt); 4962a787e540SAndrzej Hajda vaf.fmt = fmt; 4963a787e540SAndrzej Hajda vaf.va = &args; 4964a787e540SAndrzej Hajda 4965d090b70eSAndrzej Hajda if (err != -EPROBE_DEFER) { 4966693a8e93SMichał Mirosław dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4967d090b70eSAndrzej Hajda } else { 4968d090b70eSAndrzej Hajda device_set_deferred_probe_reason(dev, &vaf); 4969693a8e93SMichał Mirosław dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf); 4970d090b70eSAndrzej Hajda } 4971a787e540SAndrzej Hajda 4972a787e540SAndrzej Hajda va_end(args); 4973a787e540SAndrzej Hajda 4974a787e540SAndrzej Hajda return err; 4975a787e540SAndrzej Hajda } 4976a787e540SAndrzej Hajda EXPORT_SYMBOL_GPL(dev_err_probe); 4977a787e540SAndrzej Hajda 497897badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode) 497997badf87SRafael J. Wysocki { 498097badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary); 498197badf87SRafael J. Wysocki } 498297badf87SRafael J. Wysocki 498397badf87SRafael J. Wysocki /** 498497badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device. 498597badf87SRafael J. Wysocki * @dev: Device to handle. 498697badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device. 498797badf87SRafael J. Wysocki * 498897badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary 498997badf87SRafael J. Wysocki * firmware node of the device is present, preserve it. 49903f7bddafSBard Liao * 49913f7bddafSBard Liao * Valid fwnode cases are: 49923f7bddafSBard Liao * - primary --> secondary --> -ENODEV 49933f7bddafSBard Liao * - primary --> NULL 49943f7bddafSBard Liao * - secondary --> -ENODEV 49953f7bddafSBard Liao * - NULL 499697badf87SRafael J. Wysocki */ 499797badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 499897badf87SRafael J. Wysocki { 499999aed922SAndy Shevchenko struct device *parent = dev->parent; 500097badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode; 500197badf87SRafael J. Wysocki 5002c15e1bddSHeikki Krogerus if (fwnode) { 500397badf87SRafael J. Wysocki if (fwnode_is_primary(fn)) 500497badf87SRafael J. Wysocki fn = fn->secondary; 500597badf87SRafael J. Wysocki 500655f89a8aSMika Westerberg if (fn) { 500755f89a8aSMika Westerberg WARN_ON(fwnode->secondary); 500897badf87SRafael J. Wysocki fwnode->secondary = fn; 500955f89a8aSMika Westerberg } 501097badf87SRafael J. Wysocki dev->fwnode = fwnode; 501197badf87SRafael J. Wysocki } else { 5012c15e1bddSHeikki Krogerus if (fwnode_is_primary(fn)) { 5013c15e1bddSHeikki Krogerus dev->fwnode = fn->secondary; 50142f9e87f5SAndy Shevchenko 50152f9e87f5SAndy Shevchenko /* Skip nullifying fn->secondary if the primary is shared */ 50162f9e87f5SAndy Shevchenko if (parent && fn == parent->fwnode) 50172f9e87f5SAndy Shevchenko return; 50182f9e87f5SAndy Shevchenko 50193f7bddafSBard Liao /* Set fn->secondary = NULL, so fn remains the primary fwnode */ 502047f44699SBard Liao fn->secondary = NULL; 5021c15e1bddSHeikki Krogerus } else { 5022c15e1bddSHeikki Krogerus dev->fwnode = NULL; 5023c15e1bddSHeikki Krogerus } 502497badf87SRafael J. Wysocki } 502597badf87SRafael J. Wysocki } 502697badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode); 502797badf87SRafael J. Wysocki 502897badf87SRafael J. Wysocki /** 502997badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device. 503097badf87SRafael J. Wysocki * @dev: Device to handle. 503197badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device. 503297badf87SRafael J. Wysocki * 503397badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary 503497badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to 503597badf87SRafael J. Wysocki * @fwnode. 503697badf87SRafael J. Wysocki */ 503797badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode) 503897badf87SRafael J. Wysocki { 503997badf87SRafael J. Wysocki if (fwnode) 504097badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV); 504197badf87SRafael J. Wysocki 504297badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode)) 504397badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode; 504497badf87SRafael J. Wysocki else 504597badf87SRafael J. Wysocki dev->fwnode = fwnode; 504697badf87SRafael J. Wysocki } 504796489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode); 50484e75e1d7SJohan Hovold 50494e75e1d7SJohan Hovold /** 50504e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device 50514e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set 50524e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused 50534e75e1d7SJohan Hovold * 50544e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping 50554e75e1d7SJohan Hovold * any reference held to the old node. 50564e75e1d7SJohan Hovold */ 50574e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2) 50584e75e1d7SJohan Hovold { 50594e75e1d7SJohan Hovold of_node_put(dev->of_node); 50604e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node); 50614e75e1d7SJohan Hovold dev->of_node_reused = true; 50624e75e1d7SJohan Hovold } 50634e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev); 506465b66682SSuzuki K Poulose 506543e76d46SIoana Ciornei void device_set_node(struct device *dev, struct fwnode_handle *fwnode) 506643e76d46SIoana Ciornei { 506743e76d46SIoana Ciornei dev->fwnode = fwnode; 506843e76d46SIoana Ciornei dev->of_node = to_of_node(fwnode); 506943e76d46SIoana Ciornei } 507043e76d46SIoana Ciornei EXPORT_SYMBOL_GPL(device_set_node); 507143e76d46SIoana Ciornei 50726cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name) 50736cda08a2SSuzuki K Poulose { 50746cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name); 50756cda08a2SSuzuki K Poulose } 50766cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name); 50776cda08a2SSuzuki K Poulose 507865b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np) 507965b66682SSuzuki K Poulose { 508065b66682SSuzuki K Poulose return dev->of_node == np; 508165b66682SSuzuki K Poulose } 508265b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node); 508367843bbaSSuzuki K Poulose 508467843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode) 508567843bbaSSuzuki K Poulose { 508667843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode; 508767843bbaSSuzuki K Poulose } 508867843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode); 50894495dfddSSuzuki K Poulose 50904495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt) 50914495dfddSSuzuki K Poulose { 50924495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt; 50934495dfddSSuzuki K Poulose } 50944495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt); 509500500147SSuzuki K Poulose 509600500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev) 509700500147SSuzuki K Poulose { 509800500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev; 509900500147SSuzuki K Poulose } 510000500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev); 51016bf85ba9SSuzuki K Poulose 5102a164ff53SAndy Shevchenko int device_match_acpi_handle(struct device *dev, const void *handle) 5103a164ff53SAndy Shevchenko { 5104a164ff53SAndy Shevchenko return ACPI_HANDLE(dev) == handle; 5105a164ff53SAndy Shevchenko } 5106a164ff53SAndy Shevchenko EXPORT_SYMBOL(device_match_acpi_handle); 5107a164ff53SAndy Shevchenko 51086bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused) 51096bf85ba9SSuzuki K Poulose { 51106bf85ba9SSuzuki K Poulose return 1; 51116bf85ba9SSuzuki K Poulose } 51126bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any); 5113