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>
2023681e47SGreg Kroah-Hartman #include <linux/kdev_t.h>
21116af378SBenjamin Herrenschmidt #include <linux/notifier.h>
2207d57a32SGrant Likely #include <linux/of.h>
2307d57a32SGrant Likely #include <linux/of_device.h>
24322cbb50SChristoph Hellwig #include <linux/blkdev.h>
25f75b1c60SDave Young #include <linux/mutex.h>
26af8db150SPeter Chen #include <linux/pm_runtime.h>
27c4e00daaSKay Sievers #include <linux/netdevice.h>
28174cd4b1SIngo Molnar #include <linux/sched/signal.h>
29b8530017SOliver Neukum #include <linux/sched/mm.h>
307f146b24SAndy Shevchenko #include <linux/string_helpers.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;
47dfa65572SHerve Codina static struct workqueue_struct *device_link_wq;
487b337cb3SSaravana Kannan
497b337cb3SSaravana Kannan /**
503a2dbc51SSaravana Kannan * __fwnode_link_add - Create a link between two fwnode_handles.
517b337cb3SSaravana Kannan * @con: Consumer end of the link.
527b337cb3SSaravana Kannan * @sup: Supplier end of the link.
537b337cb3SSaravana Kannan *
547b337cb3SSaravana Kannan * Create a fwnode link between fwnode handles @con and @sup. The fwnode link
557b337cb3SSaravana Kannan * represents the detail that the firmware lists @sup fwnode as supplying a
567b337cb3SSaravana Kannan * resource to @con.
577b337cb3SSaravana Kannan *
587b337cb3SSaravana Kannan * The driver core will use the fwnode link to create a device link between the
597b337cb3SSaravana Kannan * two device objects corresponding to @con and @sup when they are created. The
607b337cb3SSaravana Kannan * driver core will automatically delete the fwnode link between @con and @sup
617b337cb3SSaravana Kannan * after doing that.
627b337cb3SSaravana Kannan *
637b337cb3SSaravana Kannan * Attempts to create duplicate links between the same pair of fwnode handles
647b337cb3SSaravana Kannan * are ignored and there is no reference counting.
657b337cb3SSaravana Kannan */
__fwnode_link_add(struct fwnode_handle * con,struct fwnode_handle * sup,u8 flags)663a2dbc51SSaravana Kannan static int __fwnode_link_add(struct fwnode_handle *con,
676a6dfdf8SSaravana Kannan struct fwnode_handle *sup, u8 flags)
687b337cb3SSaravana Kannan {
697b337cb3SSaravana Kannan struct fwnode_link *link;
707b337cb3SSaravana Kannan
717b337cb3SSaravana Kannan list_for_each_entry(link, &sup->consumers, s_hook)
726a6dfdf8SSaravana Kannan if (link->consumer == con) {
736a6dfdf8SSaravana Kannan link->flags |= flags;
743a2dbc51SSaravana Kannan return 0;
756a6dfdf8SSaravana Kannan }
767b337cb3SSaravana Kannan
777b337cb3SSaravana Kannan link = kzalloc(sizeof(*link), GFP_KERNEL);
783a2dbc51SSaravana Kannan if (!link)
793a2dbc51SSaravana Kannan return -ENOMEM;
807b337cb3SSaravana Kannan
817b337cb3SSaravana Kannan link->supplier = sup;
827b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->s_hook);
837b337cb3SSaravana Kannan link->consumer = con;
847b337cb3SSaravana Kannan INIT_LIST_HEAD(&link->c_hook);
856a6dfdf8SSaravana Kannan link->flags = flags;
867b337cb3SSaravana Kannan
877b337cb3SSaravana Kannan list_add(&link->s_hook, &sup->consumers);
887b337cb3SSaravana Kannan list_add(&link->c_hook, &con->suppliers);
890c058fb9SSaravana Kannan pr_debug("%pfwf Linked as a fwnode consumer to %pfwf\n",
90ebd6823aSSaravana Kannan con, sup);
917b337cb3SSaravana Kannan
923a2dbc51SSaravana Kannan return 0;
933a2dbc51SSaravana Kannan }
943a2dbc51SSaravana Kannan
fwnode_link_add(struct fwnode_handle * con,struct fwnode_handle * sup)953a2dbc51SSaravana Kannan int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup)
963a2dbc51SSaravana Kannan {
973a2dbc51SSaravana Kannan int ret;
983a2dbc51SSaravana Kannan
993a2dbc51SSaravana Kannan mutex_lock(&fwnode_link_lock);
1006a6dfdf8SSaravana Kannan ret = __fwnode_link_add(con, sup, 0);
1013a2dbc51SSaravana Kannan mutex_unlock(&fwnode_link_lock);
1027b337cb3SSaravana Kannan return ret;
1037b337cb3SSaravana Kannan }
1047b337cb3SSaravana Kannan
1057b337cb3SSaravana Kannan /**
10676f13081SSaravana Kannan * __fwnode_link_del - Delete a link between two fwnode_handles.
10776f13081SSaravana Kannan * @link: the fwnode_link to be deleted
10876f13081SSaravana Kannan *
10976f13081SSaravana Kannan * The fwnode_link_lock needs to be held when this function is called.
11076f13081SSaravana Kannan */
__fwnode_link_del(struct fwnode_link * link)11176f13081SSaravana Kannan static void __fwnode_link_del(struct fwnode_link *link)
11276f13081SSaravana Kannan {
1130c058fb9SSaravana Kannan pr_debug("%pfwf Dropping the fwnode link to %pfwf\n",
114ebd6823aSSaravana Kannan link->consumer, link->supplier);
11576f13081SSaravana Kannan list_del(&link->s_hook);
11676f13081SSaravana Kannan list_del(&link->c_hook);
11776f13081SSaravana Kannan kfree(link);
11876f13081SSaravana Kannan }
11976f13081SSaravana Kannan
12076f13081SSaravana Kannan /**
1216a6dfdf8SSaravana Kannan * __fwnode_link_cycle - Mark a fwnode link as being part of a cycle.
1226a6dfdf8SSaravana Kannan * @link: the fwnode_link to be marked
1236a6dfdf8SSaravana Kannan *
1246a6dfdf8SSaravana Kannan * The fwnode_link_lock needs to be held when this function is called.
1256a6dfdf8SSaravana Kannan */
__fwnode_link_cycle(struct fwnode_link * link)1266a6dfdf8SSaravana Kannan static void __fwnode_link_cycle(struct fwnode_link *link)
1276a6dfdf8SSaravana Kannan {
1286a6dfdf8SSaravana Kannan pr_debug("%pfwf: Relaxing link with %pfwf\n",
1296a6dfdf8SSaravana Kannan link->consumer, link->supplier);
1306a6dfdf8SSaravana Kannan link->flags |= FWLINK_FLAG_CYCLE;
1316a6dfdf8SSaravana Kannan }
1326a6dfdf8SSaravana Kannan
1336a6dfdf8SSaravana Kannan /**
1347b337cb3SSaravana Kannan * fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle.
1357b337cb3SSaravana Kannan * @fwnode: fwnode whose supplier links need to be deleted
1367b337cb3SSaravana Kannan *
1377b337cb3SSaravana Kannan * Deletes all supplier links connecting directly to @fwnode.
1387b337cb3SSaravana Kannan */
fwnode_links_purge_suppliers(struct fwnode_handle * fwnode)1397b337cb3SSaravana Kannan static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode)
1407b337cb3SSaravana Kannan {
1417b337cb3SSaravana Kannan struct fwnode_link *link, *tmp;
1427b337cb3SSaravana Kannan
1437b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock);
14476f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook)
14576f13081SSaravana Kannan __fwnode_link_del(link);
1467b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock);
1477b337cb3SSaravana Kannan }
1487b337cb3SSaravana Kannan
1497b337cb3SSaravana Kannan /**
1507b337cb3SSaravana Kannan * fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle.
1517b337cb3SSaravana Kannan * @fwnode: fwnode whose consumer links need to be deleted
1527b337cb3SSaravana Kannan *
1537b337cb3SSaravana Kannan * Deletes all consumer links connecting directly to @fwnode.
1547b337cb3SSaravana Kannan */
fwnode_links_purge_consumers(struct fwnode_handle * fwnode)1557b337cb3SSaravana Kannan static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode)
1567b337cb3SSaravana Kannan {
1577b337cb3SSaravana Kannan struct fwnode_link *link, *tmp;
1587b337cb3SSaravana Kannan
1597b337cb3SSaravana Kannan mutex_lock(&fwnode_link_lock);
16076f13081SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook)
16176f13081SSaravana Kannan __fwnode_link_del(link);
1627b337cb3SSaravana Kannan mutex_unlock(&fwnode_link_lock);
1637b337cb3SSaravana Kannan }
1647b337cb3SSaravana Kannan
1657b337cb3SSaravana Kannan /**
1667b337cb3SSaravana Kannan * fwnode_links_purge - Delete all links connected to a fwnode_handle.
1677b337cb3SSaravana Kannan * @fwnode: fwnode whose links needs to be deleted
1687b337cb3SSaravana Kannan *
1697b337cb3SSaravana Kannan * Deletes all links connecting directly to a fwnode.
1707b337cb3SSaravana Kannan */
fwnode_links_purge(struct fwnode_handle * fwnode)1717b337cb3SSaravana Kannan void fwnode_links_purge(struct fwnode_handle *fwnode)
1727b337cb3SSaravana Kannan {
1737b337cb3SSaravana Kannan fwnode_links_purge_suppliers(fwnode);
1747b337cb3SSaravana Kannan fwnode_links_purge_consumers(fwnode);
1757b337cb3SSaravana Kannan }
1769ed98953SRafael J. Wysocki
fw_devlink_purge_absent_suppliers(struct fwnode_handle * fwnode)17728ec344bSSaravana Kannan void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode)
1789528e0d9SSaravana Kannan {
1799528e0d9SSaravana Kannan struct fwnode_handle *child;
1809528e0d9SSaravana Kannan
1819528e0d9SSaravana Kannan /* Don't purge consumer links of an added child */
1829528e0d9SSaravana Kannan if (fwnode->dev)
1839528e0d9SSaravana Kannan return;
1849528e0d9SSaravana Kannan
1859528e0d9SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE;
1869528e0d9SSaravana Kannan fwnode_links_purge_consumers(fwnode);
1879528e0d9SSaravana Kannan
1889528e0d9SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child)
1899528e0d9SSaravana Kannan fw_devlink_purge_absent_suppliers(child);
1909528e0d9SSaravana Kannan }
19128ec344bSSaravana Kannan EXPORT_SYMBOL_GPL(fw_devlink_purge_absent_suppliers);
1929528e0d9SSaravana Kannan
1933a2dbc51SSaravana Kannan /**
1943a2dbc51SSaravana Kannan * __fwnode_links_move_consumers - Move consumer from @from to @to fwnode_handle
1953a2dbc51SSaravana Kannan * @from: move consumers away from this fwnode
1963a2dbc51SSaravana Kannan * @to: move consumers to this fwnode
1973a2dbc51SSaravana Kannan *
1983a2dbc51SSaravana Kannan * Move all consumer links from @from fwnode to @to fwnode.
1993a2dbc51SSaravana Kannan */
__fwnode_links_move_consumers(struct fwnode_handle * from,struct fwnode_handle * to)2003a2dbc51SSaravana Kannan static void __fwnode_links_move_consumers(struct fwnode_handle *from,
2013a2dbc51SSaravana Kannan struct fwnode_handle *to)
2023a2dbc51SSaravana Kannan {
2033a2dbc51SSaravana Kannan struct fwnode_link *link, *tmp;
2043a2dbc51SSaravana Kannan
2053a2dbc51SSaravana Kannan list_for_each_entry_safe(link, tmp, &from->consumers, s_hook) {
2066a6dfdf8SSaravana Kannan __fwnode_link_add(link->consumer, to, link->flags);
2073a2dbc51SSaravana Kannan __fwnode_link_del(link);
2083a2dbc51SSaravana Kannan }
2093a2dbc51SSaravana Kannan }
2103a2dbc51SSaravana Kannan
2113a2dbc51SSaravana Kannan /**
2123a2dbc51SSaravana Kannan * __fw_devlink_pickup_dangling_consumers - Pick up dangling consumers
2133a2dbc51SSaravana Kannan * @fwnode: fwnode from which to pick up dangling consumers
2143a2dbc51SSaravana Kannan * @new_sup: fwnode of new supplier
2153a2dbc51SSaravana Kannan *
2163a2dbc51SSaravana Kannan * If the @fwnode has a corresponding struct device and the device supports
2173a2dbc51SSaravana Kannan * probing (that is, added to a bus), then we want to let fw_devlink create
2183a2dbc51SSaravana Kannan * MANAGED device links to this device, so leave @fwnode and its descendant's
2193a2dbc51SSaravana Kannan * fwnode links alone.
2203a2dbc51SSaravana Kannan *
2213a2dbc51SSaravana Kannan * Otherwise, move its consumers to the new supplier @new_sup.
2223a2dbc51SSaravana Kannan */
__fw_devlink_pickup_dangling_consumers(struct fwnode_handle * fwnode,struct fwnode_handle * new_sup)2233a2dbc51SSaravana Kannan static void __fw_devlink_pickup_dangling_consumers(struct fwnode_handle *fwnode,
2243a2dbc51SSaravana Kannan struct fwnode_handle *new_sup)
2253a2dbc51SSaravana Kannan {
2263a2dbc51SSaravana Kannan struct fwnode_handle *child;
2273a2dbc51SSaravana Kannan
2283a2dbc51SSaravana Kannan if (fwnode->dev && fwnode->dev->bus)
2293a2dbc51SSaravana Kannan return;
2303a2dbc51SSaravana Kannan
2313a2dbc51SSaravana Kannan fwnode->flags |= FWNODE_FLAG_NOT_DEVICE;
2323a2dbc51SSaravana Kannan __fwnode_links_move_consumers(fwnode, new_sup);
2333a2dbc51SSaravana Kannan
2343a2dbc51SSaravana Kannan fwnode_for_each_available_child_node(fwnode, child)
2353a2dbc51SSaravana Kannan __fw_devlink_pickup_dangling_consumers(child, new_sup);
2363a2dbc51SSaravana Kannan }
2373a2dbc51SSaravana Kannan
2389ed98953SRafael J. Wysocki static DEFINE_MUTEX(device_links_lock);
2399ed98953SRafael J. Wysocki DEFINE_STATIC_SRCU(device_links_srcu);
2409ed98953SRafael J. Wysocki
device_links_write_lock(void)2419ed98953SRafael J. Wysocki static inline void device_links_write_lock(void)
2429ed98953SRafael J. Wysocki {
2439ed98953SRafael J. Wysocki mutex_lock(&device_links_lock);
2449ed98953SRafael J. Wysocki }
2459ed98953SRafael J. Wysocki
device_links_write_unlock(void)2469ed98953SRafael J. Wysocki static inline void device_links_write_unlock(void)
2479ed98953SRafael J. Wysocki {
2489ed98953SRafael J. Wysocki mutex_unlock(&device_links_lock);
2499ed98953SRafael J. Wysocki }
2509ed98953SRafael J. Wysocki
device_links_read_lock(void)25168464d79SJules Irenge int device_links_read_lock(void) __acquires(&device_links_srcu)
2529ed98953SRafael J. Wysocki {
2539ed98953SRafael J. Wysocki return srcu_read_lock(&device_links_srcu);
2549ed98953SRafael J. Wysocki }
2559ed98953SRafael J. Wysocki
device_links_read_unlock(int idx)256ab7789c5SJules Irenge void device_links_read_unlock(int idx) __releases(&device_links_srcu)
2579ed98953SRafael J. Wysocki {
2589ed98953SRafael J. Wysocki srcu_read_unlock(&device_links_srcu, idx);
2599ed98953SRafael J. Wysocki }
260c2fa1e1bSJoel Fernandes (Google)
device_links_read_lock_held(void)261c2fa1e1bSJoel Fernandes (Google) int device_links_read_lock_held(void)
262c2fa1e1bSJoel Fernandes (Google) {
263c2fa1e1bSJoel Fernandes (Google) return srcu_read_lock_held(&device_links_srcu);
264c2fa1e1bSJoel Fernandes (Google) }
26580dd33cfSRafael J. Wysocki
device_link_synchronize_removal(void)26680dd33cfSRafael J. Wysocki static void device_link_synchronize_removal(void)
26780dd33cfSRafael J. Wysocki {
26880dd33cfSRafael J. Wysocki synchronize_srcu(&device_links_srcu);
26980dd33cfSRafael J. Wysocki }
2700c871315SRafael J. Wysocki
device_link_remove_from_lists(struct device_link * link)2710c871315SRafael J. Wysocki static void device_link_remove_from_lists(struct device_link *link)
2720c871315SRafael J. Wysocki {
2730c871315SRafael J. Wysocki list_del_rcu(&link->s_node);
2740c871315SRafael J. Wysocki list_del_rcu(&link->c_node);
2750c871315SRafael J. Wysocki }
2769ed98953SRafael J. Wysocki
device_is_ancestor(struct device * dev,struct device * target)2773d1cf435SRafael J. Wysocki static bool device_is_ancestor(struct device *dev, struct device *target)
2783d1cf435SRafael J. Wysocki {
2793d1cf435SRafael J. Wysocki while (target->parent) {
2803d1cf435SRafael J. Wysocki target = target->parent;
2813d1cf435SRafael J. Wysocki if (dev == target)
2823d1cf435SRafael J. Wysocki return true;
2833d1cf435SRafael J. Wysocki }
2843d1cf435SRafael J. Wysocki return false;
2853d1cf435SRafael J. Wysocki }
2863d1cf435SRafael J. Wysocki
2878f190386SSaravana Kannan #define DL_MARKER_FLAGS (DL_FLAG_INFERRED | \
2888f190386SSaravana Kannan DL_FLAG_CYCLE | \
2898f190386SSaravana Kannan DL_FLAG_MANAGED)
device_link_flag_is_sync_state_only(u32 flags)29067cad5c6SSaravana Kannan static inline bool device_link_flag_is_sync_state_only(u32 flags)
29167cad5c6SSaravana Kannan {
2928f190386SSaravana Kannan return (flags & ~DL_MARKER_FLAGS) == DL_FLAG_SYNC_STATE_ONLY;
29367cad5c6SSaravana Kannan }
29467cad5c6SSaravana Kannan
2959ed98953SRafael J. Wysocki /**
2969ed98953SRafael J. Wysocki * device_is_dependent - Check if one device depends on another one
2979ed98953SRafael J. Wysocki * @dev: Device to check dependencies for.
2989ed98953SRafael J. Wysocki * @target: Device to check against.
2999ed98953SRafael J. Wysocki *
3009ed98953SRafael J. Wysocki * Check if @target depends on @dev or any device dependent on it (its child or
3019ed98953SRafael J. Wysocki * its consumer etc). Return 1 if that is the case or 0 otherwise.
3029ed98953SRafael J. Wysocki */
device_is_dependent(struct device * dev,void * target)3037d34ca38SSaravana Kannan int device_is_dependent(struct device *dev, void *target)
3049ed98953SRafael J. Wysocki {
3059ed98953SRafael J. Wysocki struct device_link *link;
3069ed98953SRafael J. Wysocki int ret;
3079ed98953SRafael J. Wysocki
3083d1cf435SRafael J. Wysocki /*
3093d1cf435SRafael J. Wysocki * The "ancestors" check is needed to catch the case when the target
3103d1cf435SRafael J. Wysocki * device has not been completely initialized yet and it is still
3113d1cf435SRafael J. Wysocki * missing from the list of children of its parent device.
3123d1cf435SRafael J. Wysocki */
3133d1cf435SRafael J. Wysocki if (dev == target || device_is_ancestor(dev, target))
3149ed98953SRafael J. Wysocki return 1;
3159ed98953SRafael J. Wysocki
3169ed98953SRafael J. Wysocki ret = device_for_each_child(dev, target, device_is_dependent);
3179ed98953SRafael J. Wysocki if (ret)
3189ed98953SRafael J. Wysocki return ret;
3199ed98953SRafael J. Wysocki
3209ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) {
32167cad5c6SSaravana Kannan if (device_link_flag_is_sync_state_only(link->flags))
32205ef983eSSaravana Kannan continue;
32305ef983eSSaravana Kannan
324e16f4f3eSBenjamin Gaignard if (link->consumer == target)
3259ed98953SRafael J. Wysocki return 1;
3269ed98953SRafael J. Wysocki
3279ed98953SRafael J. Wysocki ret = device_is_dependent(link->consumer, target);
3289ed98953SRafael J. Wysocki if (ret)
3299ed98953SRafael J. Wysocki break;
3309ed98953SRafael J. Wysocki }
3319ed98953SRafael J. Wysocki return ret;
3329ed98953SRafael J. Wysocki }
3339ed98953SRafael J. Wysocki
device_link_init_status(struct device_link * link,struct device * consumer,struct device * supplier)334515db266SRafael J. Wysocki static void device_link_init_status(struct device_link *link,
335515db266SRafael J. Wysocki struct device *consumer,
336515db266SRafael J. Wysocki struct device *supplier)
337515db266SRafael J. Wysocki {
338515db266SRafael J. Wysocki switch (supplier->links.status) {
339515db266SRafael J. Wysocki case DL_DEV_PROBING:
340515db266SRafael J. Wysocki switch (consumer->links.status) {
341515db266SRafael J. Wysocki case DL_DEV_PROBING:
342515db266SRafael J. Wysocki /*
343515db266SRafael J. Wysocki * A consumer driver can create a link to a supplier
344515db266SRafael J. Wysocki * that has not completed its probing yet as long as it
345515db266SRafael J. Wysocki * knows that the supplier is already functional (for
346515db266SRafael J. Wysocki * example, it has just acquired some resources from the
347515db266SRafael J. Wysocki * supplier).
348515db266SRafael J. Wysocki */
349515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE;
350515db266SRafael J. Wysocki break;
351515db266SRafael J. Wysocki default:
352515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT;
353515db266SRafael J. Wysocki break;
354515db266SRafael J. Wysocki }
355515db266SRafael J. Wysocki break;
356515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND:
357515db266SRafael J. Wysocki switch (consumer->links.status) {
358515db266SRafael J. Wysocki case DL_DEV_PROBING:
359515db266SRafael J. Wysocki link->status = DL_STATE_CONSUMER_PROBE;
360515db266SRafael J. Wysocki break;
361515db266SRafael J. Wysocki case DL_DEV_DRIVER_BOUND:
362515db266SRafael J. Wysocki link->status = DL_STATE_ACTIVE;
363515db266SRafael J. Wysocki break;
364515db266SRafael J. Wysocki default:
365515db266SRafael J. Wysocki link->status = DL_STATE_AVAILABLE;
366515db266SRafael J. Wysocki break;
367515db266SRafael J. Wysocki }
368515db266SRafael J. Wysocki break;
369515db266SRafael J. Wysocki case DL_DEV_UNBINDING:
370515db266SRafael J. Wysocki link->status = DL_STATE_SUPPLIER_UNBIND;
371515db266SRafael J. Wysocki break;
372515db266SRafael J. Wysocki default:
373515db266SRafael J. Wysocki link->status = DL_STATE_DORMANT;
374515db266SRafael J. Wysocki break;
375515db266SRafael J. Wysocki }
376515db266SRafael J. Wysocki }
377515db266SRafael J. Wysocki
device_reorder_to_tail(struct device * dev,void * not_used)3789ed98953SRafael J. Wysocki static int device_reorder_to_tail(struct device *dev, void *not_used)
3799ed98953SRafael J. Wysocki {
3809ed98953SRafael J. Wysocki struct device_link *link;
3819ed98953SRafael J. Wysocki
3829ed98953SRafael J. Wysocki /*
3839ed98953SRafael J. Wysocki * Devices that have not been registered yet will be put to the ends
3849ed98953SRafael J. Wysocki * of the lists during the registration, so skip them here.
3859ed98953SRafael J. Wysocki */
3869ed98953SRafael J. Wysocki if (device_is_registered(dev))
3879ed98953SRafael J. Wysocki devices_kset_move_last(dev);
3889ed98953SRafael J. Wysocki
3899ed98953SRafael J. Wysocki if (device_pm_initialized(dev))
3909ed98953SRafael J. Wysocki device_pm_move_last(dev);
3919ed98953SRafael J. Wysocki
3929ed98953SRafael J. Wysocki device_for_each_child(dev, NULL, device_reorder_to_tail);
39305ef983eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) {
39467cad5c6SSaravana Kannan if (device_link_flag_is_sync_state_only(link->flags))
39505ef983eSSaravana Kannan continue;
3969ed98953SRafael J. Wysocki device_reorder_to_tail(link->consumer, NULL);
39705ef983eSSaravana Kannan }
3989ed98953SRafael J. Wysocki
3999ed98953SRafael J. Wysocki return 0;
4009ed98953SRafael J. Wysocki }
4019ed98953SRafael J. Wysocki
4029ed98953SRafael J. Wysocki /**
403494fd7b7SFeng Kan * device_pm_move_to_tail - Move set of devices to the end of device lists
404494fd7b7SFeng Kan * @dev: Device to move
405494fd7b7SFeng Kan *
406494fd7b7SFeng Kan * This is a device_reorder_to_tail() wrapper taking the requisite locks.
407494fd7b7SFeng Kan *
408494fd7b7SFeng Kan * It moves the @dev along with all of its children and all of its consumers
409494fd7b7SFeng Kan * to the ends of the device_kset and dpm_list, recursively.
410494fd7b7SFeng Kan */
device_pm_move_to_tail(struct device * dev)411494fd7b7SFeng Kan void device_pm_move_to_tail(struct device *dev)
412494fd7b7SFeng Kan {
413494fd7b7SFeng Kan int idx;
414494fd7b7SFeng Kan
415494fd7b7SFeng Kan idx = device_links_read_lock();
416494fd7b7SFeng Kan device_pm_lock();
417494fd7b7SFeng Kan device_reorder_to_tail(dev, NULL);
418494fd7b7SFeng Kan device_pm_unlock();
419494fd7b7SFeng Kan device_links_read_unlock(idx);
420494fd7b7SFeng Kan }
421494fd7b7SFeng Kan
422287905e6SSaravana Kannan #define to_devlink(dev) container_of((dev), struct device_link, link_dev)
423287905e6SSaravana Kannan
status_show(struct device * dev,struct device_attribute * attr,char * buf)424287905e6SSaravana Kannan static ssize_t status_show(struct device *dev,
425287905e6SSaravana Kannan struct device_attribute *attr, char *buf)
426287905e6SSaravana Kannan {
427948b3edbSJoe Perches const char *output;
428287905e6SSaravana Kannan
429287905e6SSaravana Kannan switch (to_devlink(dev)->status) {
430287905e6SSaravana Kannan case DL_STATE_NONE:
431948b3edbSJoe Perches output = "not tracked";
432948b3edbSJoe Perches break;
433287905e6SSaravana Kannan case DL_STATE_DORMANT:
434948b3edbSJoe Perches output = "dormant";
435948b3edbSJoe Perches break;
436287905e6SSaravana Kannan case DL_STATE_AVAILABLE:
437948b3edbSJoe Perches output = "available";
438948b3edbSJoe Perches break;
439287905e6SSaravana Kannan case DL_STATE_CONSUMER_PROBE:
440948b3edbSJoe Perches output = "consumer probing";
441948b3edbSJoe Perches break;
442287905e6SSaravana Kannan case DL_STATE_ACTIVE:
443948b3edbSJoe Perches output = "active";
444948b3edbSJoe Perches break;
445287905e6SSaravana Kannan case DL_STATE_SUPPLIER_UNBIND:
446948b3edbSJoe Perches output = "supplier unbinding";
447948b3edbSJoe Perches break;
448287905e6SSaravana Kannan default:
449948b3edbSJoe Perches output = "unknown";
450948b3edbSJoe Perches break;
451287905e6SSaravana Kannan }
452948b3edbSJoe Perches
453948b3edbSJoe Perches return sysfs_emit(buf, "%s\n", output);
454287905e6SSaravana Kannan }
455287905e6SSaravana Kannan static DEVICE_ATTR_RO(status);
456287905e6SSaravana Kannan
auto_remove_on_show(struct device * dev,struct device_attribute * attr,char * buf)457287905e6SSaravana Kannan static ssize_t auto_remove_on_show(struct device *dev,
458287905e6SSaravana Kannan struct device_attribute *attr, char *buf)
459287905e6SSaravana Kannan {
460287905e6SSaravana Kannan struct device_link *link = to_devlink(dev);
461973c3911SJoe Perches const char *output;
462287905e6SSaravana Kannan
463287905e6SSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
464973c3911SJoe Perches output = "supplier unbind";
465287905e6SSaravana Kannan else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER)
466973c3911SJoe Perches output = "consumer unbind";
467287905e6SSaravana Kannan else
468973c3911SJoe Perches output = "never";
469287905e6SSaravana Kannan
470973c3911SJoe Perches return sysfs_emit(buf, "%s\n", output);
471287905e6SSaravana Kannan }
472287905e6SSaravana Kannan static DEVICE_ATTR_RO(auto_remove_on);
473287905e6SSaravana Kannan
runtime_pm_show(struct device * dev,struct device_attribute * attr,char * buf)474287905e6SSaravana Kannan static ssize_t runtime_pm_show(struct device *dev,
475287905e6SSaravana Kannan struct device_attribute *attr, char *buf)
476287905e6SSaravana Kannan {
477287905e6SSaravana Kannan struct device_link *link = to_devlink(dev);
478287905e6SSaravana Kannan
479aa838896SJoe Perches return sysfs_emit(buf, "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME));
480287905e6SSaravana Kannan }
481287905e6SSaravana Kannan static DEVICE_ATTR_RO(runtime_pm);
482287905e6SSaravana Kannan
sync_state_only_show(struct device * dev,struct device_attribute * attr,char * buf)483287905e6SSaravana Kannan static ssize_t sync_state_only_show(struct device *dev,
484287905e6SSaravana Kannan struct device_attribute *attr, char *buf)
485287905e6SSaravana Kannan {
486287905e6SSaravana Kannan struct device_link *link = to_devlink(dev);
487287905e6SSaravana Kannan
488aa838896SJoe Perches return sysfs_emit(buf, "%d\n",
489aa838896SJoe Perches !!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
490287905e6SSaravana Kannan }
491287905e6SSaravana Kannan static DEVICE_ATTR_RO(sync_state_only);
492287905e6SSaravana Kannan
493287905e6SSaravana Kannan static struct attribute *devlink_attrs[] = {
494287905e6SSaravana Kannan &dev_attr_status.attr,
495287905e6SSaravana Kannan &dev_attr_auto_remove_on.attr,
496287905e6SSaravana Kannan &dev_attr_runtime_pm.attr,
497287905e6SSaravana Kannan &dev_attr_sync_state_only.attr,
498287905e6SSaravana Kannan NULL,
499287905e6SSaravana Kannan };
500287905e6SSaravana Kannan ATTRIBUTE_GROUPS(devlink);
501287905e6SSaravana Kannan
device_link_release_fn(struct work_struct * work)50280dd33cfSRafael J. Wysocki static void device_link_release_fn(struct work_struct *work)
503843e600bSSaravana Kannan {
50480dd33cfSRafael J. Wysocki struct device_link *link = container_of(work, struct device_link, rm_work);
50580dd33cfSRafael J. Wysocki
50680dd33cfSRafael J. Wysocki /* Ensure that all references to the link object have been dropped. */
50780dd33cfSRafael J. Wysocki device_link_synchronize_removal();
50880dd33cfSRafael J. Wysocki
50907358194SRafael J. Wysocki pm_runtime_release_supplier(link);
51088737106SRafael J. Wysocki /*
51188737106SRafael J. Wysocki * If supplier_preactivated is set, the link has been dropped between
51288737106SRafael J. Wysocki * the pm_runtime_get_suppliers() and pm_runtime_put_suppliers() calls
51388737106SRafael J. Wysocki * in __driver_probe_device(). In that case, drop the supplier's
51488737106SRafael J. Wysocki * PM-runtime usage counter to remove the reference taken by
51588737106SRafael J. Wysocki * pm_runtime_get_suppliers().
51688737106SRafael J. Wysocki */
51788737106SRafael J. Wysocki if (link->supplier_preactivated)
51888737106SRafael J. Wysocki pm_runtime_put_noidle(link->supplier);
51988737106SRafael J. Wysocki
52007358194SRafael J. Wysocki pm_request_idle(link->supplier);
521843e600bSSaravana Kannan
522843e600bSSaravana Kannan put_device(link->consumer);
523843e600bSSaravana Kannan put_device(link->supplier);
524843e600bSSaravana Kannan kfree(link);
525843e600bSSaravana Kannan }
526843e600bSSaravana Kannan
devlink_dev_release(struct device * dev)527287905e6SSaravana Kannan static void devlink_dev_release(struct device *dev)
528287905e6SSaravana Kannan {
529843e600bSSaravana Kannan struct device_link *link = to_devlink(dev);
530843e600bSSaravana Kannan
53180dd33cfSRafael J. Wysocki INIT_WORK(&link->rm_work, device_link_release_fn);
53280dd33cfSRafael J. Wysocki /*
53380dd33cfSRafael J. Wysocki * It may take a while to complete this work because of the SRCU
53480dd33cfSRafael J. Wysocki * synchronization in device_link_release_fn() and if the consumer or
535dfa65572SHerve Codina * supplier devices get deleted when it runs, so put it into the
536dfa65572SHerve Codina * dedicated workqueue.
53780dd33cfSRafael J. Wysocki */
538dfa65572SHerve Codina queue_work(device_link_wq, &link->rm_work);
539287905e6SSaravana Kannan }
540287905e6SSaravana Kannan
541dfa65572SHerve Codina /**
542dfa65572SHerve Codina * device_link_wait_removal - Wait for ongoing devlink removal jobs to terminate
543dfa65572SHerve Codina */
device_link_wait_removal(void)544dfa65572SHerve Codina void device_link_wait_removal(void)
545dfa65572SHerve Codina {
546dfa65572SHerve Codina /*
547dfa65572SHerve Codina * devlink removal jobs are queued in the dedicated work queue.
548dfa65572SHerve Codina * To be sure that all removal jobs are terminated, ensure that any
549dfa65572SHerve Codina * scheduled work has run to completion.
550dfa65572SHerve Codina */
551dfa65572SHerve Codina flush_workqueue(device_link_wq);
552dfa65572SHerve Codina }
553dfa65572SHerve Codina EXPORT_SYMBOL_GPL(device_link_wait_removal);
554dfa65572SHerve Codina
555287905e6SSaravana Kannan static struct class devlink_class = {
556287905e6SSaravana Kannan .name = "devlink",
557287905e6SSaravana Kannan .dev_groups = devlink_groups,
558287905e6SSaravana Kannan .dev_release = devlink_dev_release,
559287905e6SSaravana Kannan };
560287905e6SSaravana Kannan
devlink_add_symlinks(struct device * dev)5612243acd5SGreg Kroah-Hartman static int devlink_add_symlinks(struct device *dev)
562287905e6SSaravana Kannan {
563287905e6SSaravana Kannan int ret;
564287905e6SSaravana Kannan size_t len;
565287905e6SSaravana Kannan struct device_link *link = to_devlink(dev);
566287905e6SSaravana Kannan struct device *sup = link->supplier;
567287905e6SSaravana Kannan struct device *con = link->consumer;
568287905e6SSaravana Kannan char *buf;
569287905e6SSaravana Kannan
570e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)),
571e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con)));
572e020ff61SSaravana Kannan len += strlen(":");
573287905e6SSaravana Kannan len += strlen("supplier:") + 1;
574287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL);
575287905e6SSaravana Kannan if (!buf)
576287905e6SSaravana Kannan return -ENOMEM;
577287905e6SSaravana Kannan
578287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier");
579287905e6SSaravana Kannan if (ret)
580287905e6SSaravana Kannan goto out;
581287905e6SSaravana Kannan
582287905e6SSaravana Kannan ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer");
583287905e6SSaravana Kannan if (ret)
584287905e6SSaravana Kannan goto err_con;
585287905e6SSaravana Kannan
586e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con));
587287905e6SSaravana Kannan ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf);
588287905e6SSaravana Kannan if (ret)
589287905e6SSaravana Kannan goto err_con_dev;
590287905e6SSaravana Kannan
591e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup));
592287905e6SSaravana Kannan ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf);
593287905e6SSaravana Kannan if (ret)
594287905e6SSaravana Kannan goto err_sup_dev;
595287905e6SSaravana Kannan
596287905e6SSaravana Kannan goto out;
597287905e6SSaravana Kannan
598287905e6SSaravana Kannan err_sup_dev:
599e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con));
600287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf);
601287905e6SSaravana Kannan err_con_dev:
602287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer");
603287905e6SSaravana Kannan err_con:
604287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier");
605287905e6SSaravana Kannan out:
606287905e6SSaravana Kannan kfree(buf);
607287905e6SSaravana Kannan return ret;
608287905e6SSaravana Kannan }
609287905e6SSaravana Kannan
devlink_remove_symlinks(struct device * dev)6102243acd5SGreg Kroah-Hartman static void devlink_remove_symlinks(struct device *dev)
611287905e6SSaravana Kannan {
612287905e6SSaravana Kannan struct device_link *link = to_devlink(dev);
613287905e6SSaravana Kannan size_t len;
614287905e6SSaravana Kannan struct device *sup = link->supplier;
615287905e6SSaravana Kannan struct device *con = link->consumer;
616287905e6SSaravana Kannan char *buf;
617287905e6SSaravana Kannan
618287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "consumer");
619287905e6SSaravana Kannan sysfs_remove_link(&link->link_dev.kobj, "supplier");
620287905e6SSaravana Kannan
621e020ff61SSaravana Kannan len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)),
622e020ff61SSaravana Kannan strlen(dev_bus_name(con)) + strlen(dev_name(con)));
623e020ff61SSaravana Kannan len += strlen(":");
624287905e6SSaravana Kannan len += strlen("supplier:") + 1;
625287905e6SSaravana Kannan buf = kzalloc(len, GFP_KERNEL);
626287905e6SSaravana Kannan if (!buf) {
627287905e6SSaravana Kannan WARN(1, "Unable to properly free device link symlinks!\n");
628287905e6SSaravana Kannan return;
629287905e6SSaravana Kannan }
630287905e6SSaravana Kannan
631e64daad6SAdrian Hunter if (device_is_registered(con)) {
632e020ff61SSaravana Kannan snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup));
633287905e6SSaravana Kannan sysfs_remove_link(&con->kobj, buf);
634e64daad6SAdrian Hunter }
635e020ff61SSaravana Kannan snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con));
636287905e6SSaravana Kannan sysfs_remove_link(&sup->kobj, buf);
637287905e6SSaravana Kannan kfree(buf);
638287905e6SSaravana Kannan }
639287905e6SSaravana Kannan
640287905e6SSaravana Kannan static struct class_interface devlink_class_intf = {
641287905e6SSaravana Kannan .class = &devlink_class,
642287905e6SSaravana Kannan .add_dev = devlink_add_symlinks,
643287905e6SSaravana Kannan .remove_dev = devlink_remove_symlinks,
644287905e6SSaravana Kannan };
645287905e6SSaravana Kannan
devlink_class_init(void)646287905e6SSaravana Kannan static int __init devlink_class_init(void)
647287905e6SSaravana Kannan {
648287905e6SSaravana Kannan int ret;
649287905e6SSaravana Kannan
650287905e6SSaravana Kannan ret = class_register(&devlink_class);
651287905e6SSaravana Kannan if (ret)
652287905e6SSaravana Kannan return ret;
653287905e6SSaravana Kannan
654287905e6SSaravana Kannan ret = class_interface_register(&devlink_class_intf);
655287905e6SSaravana Kannan if (ret)
656287905e6SSaravana Kannan class_unregister(&devlink_class);
657287905e6SSaravana Kannan
658287905e6SSaravana Kannan return ret;
659287905e6SSaravana Kannan }
660287905e6SSaravana Kannan postcore_initcall(devlink_class_init);
661287905e6SSaravana Kannan
662515db266SRafael J. Wysocki #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \
663515db266SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER | \
66405ef983eSSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER | \
6654b9bbb29SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY | \
66667cad5c6SSaravana Kannan DL_FLAG_INFERRED | \
66767cad5c6SSaravana Kannan DL_FLAG_CYCLE)
668515db266SRafael J. Wysocki
669fb583c8eSRafael J. Wysocki #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \
670fb583c8eSRafael J. Wysocki DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE)
671fb583c8eSRafael J. Wysocki
672494fd7b7SFeng Kan /**
6739ed98953SRafael J. Wysocki * device_link_add - Create a link between two devices.
6749ed98953SRafael J. Wysocki * @consumer: Consumer end of the link.
6759ed98953SRafael J. Wysocki * @supplier: Supplier end of the link.
6769ed98953SRafael J. Wysocki * @flags: Link flags.
6779ed98953SRafael J. Wysocki *
67821d5c57bSRafael J. Wysocki * The caller is responsible for the proper synchronization of the link creation
67921d5c57bSRafael J. Wysocki * with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the
68021d5c57bSRafael J. Wysocki * runtime PM framework to take the link into account. Second, if the
68121d5c57bSRafael J. Wysocki * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will
68221d5c57bSRafael J. Wysocki * be forced into the active meta state and reference-counted upon the creation
68321d5c57bSRafael J. Wysocki * of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be
68421d5c57bSRafael J. Wysocki * ignored.
68521d5c57bSRafael J. Wysocki *
686515db266SRafael J. Wysocki * If DL_FLAG_STATELESS is set in @flags, the caller of this function is
687515db266SRafael J. Wysocki * expected to release the link returned by it directly with the help of either
688515db266SRafael J. Wysocki * device_link_del() or device_link_remove().
68972175d4eSRafael J. Wysocki *
69072175d4eSRafael J. Wysocki * If that flag is not set, however, the caller of this function is handing the
69172175d4eSRafael J. Wysocki * management of the link over to the driver core entirely and its return value
69272175d4eSRafael J. Wysocki * can only be used to check whether or not the link is present. In that case,
69372175d4eSRafael J. Wysocki * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link
69472175d4eSRafael J. Wysocki * flags can be used to indicate to the driver core when the link can be safely
69572175d4eSRafael J. Wysocki * deleted. Namely, setting one of them in @flags indicates to the driver core
69672175d4eSRafael J. Wysocki * that the link is not going to be used (by the given caller of this function)
69772175d4eSRafael J. Wysocki * after unbinding the consumer or supplier driver, respectively, from its
69872175d4eSRafael J. Wysocki * device, so the link can be deleted at that point. If none of them is set,
69972175d4eSRafael J. Wysocki * the link will be maintained until one of the devices pointed to by it (either
70072175d4eSRafael J. Wysocki * the consumer or the supplier) is unregistered.
701c8d50986SRafael J. Wysocki *
702e7dd4010SRafael J. Wysocki * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and
703e7dd4010SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent
704e7dd4010SRafael J. Wysocki * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can
705d475f8eaSThierry Reding * be used to request the driver core to automatically probe for a consumer
706e7dd4010SRafael J. Wysocki * driver after successfully binding a driver to the supplier device.
707e7dd4010SRafael J. Wysocki *
708515db266SRafael J. Wysocki * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER,
709515db266SRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at
710515db266SRafael J. Wysocki * the same time is invalid and will cause NULL to be returned upfront.
711515db266SRafael J. Wysocki * However, if a device link between the given @consumer and @supplier pair
712515db266SRafael J. Wysocki * exists already when this function is called for them, the existing link will
713515db266SRafael J. Wysocki * be returned regardless of its current type and status (the link's flags may
714515db266SRafael J. Wysocki * be modified then). The caller of this function is then expected to treat
715515db266SRafael J. Wysocki * the link as though it has just been created, so (in particular) if
716515db266SRafael J. Wysocki * DL_FLAG_STATELESS was passed in @flags, the link needs to be released
717515db266SRafael J. Wysocki * explicitly when not needed any more (as stated above).
7189ed98953SRafael J. Wysocki *
7199ed98953SRafael J. Wysocki * A side effect of the link creation is re-ordering of dpm_list and the
7209ed98953SRafael J. Wysocki * devices_kset list by moving the consumer device and all devices depending
7219ed98953SRafael J. Wysocki * on it to the ends of these lists (that does not happen to devices that have
7229ed98953SRafael J. Wysocki * not been registered when this function is called).
7239ed98953SRafael J. Wysocki *
7249ed98953SRafael J. Wysocki * The supplier device is required to be registered when this function is called
7259ed98953SRafael J. Wysocki * and NULL will be returned if that is not the case. The consumer device need
72664df1148SLukas Wunner * not be registered, however.
7279ed98953SRafael J. Wysocki */
device_link_add(struct device * consumer,struct device * supplier,u32 flags)7289ed98953SRafael J. Wysocki struct device_link *device_link_add(struct device *consumer,
7299ed98953SRafael J. Wysocki struct device *supplier, u32 flags)
7309ed98953SRafael J. Wysocki {
7319ed98953SRafael J. Wysocki struct device_link *link;
7329ed98953SRafael J. Wysocki
733f729a592SSaravana Kannan if (!consumer || !supplier || consumer == supplier ||
734f729a592SSaravana Kannan flags & ~DL_ADD_VALID_FLAGS ||
735515db266SRafael J. Wysocki (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) ||
736e7dd4010SRafael J. Wysocki (flags & DL_FLAG_AUTOPROBE_CONSUMER &&
737e7dd4010SRafael J. Wysocki flags & (DL_FLAG_AUTOREMOVE_CONSUMER |
738e7dd4010SRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER)))
7399ed98953SRafael J. Wysocki return NULL;
7409ed98953SRafael J. Wysocki
7415db25c9eSRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) {
7425db25c9eSRafael J. Wysocki if (pm_runtime_get_sync(supplier) < 0) {
7435db25c9eSRafael J. Wysocki pm_runtime_put_noidle(supplier);
7445db25c9eSRafael J. Wysocki return NULL;
7455db25c9eSRafael J. Wysocki }
7465db25c9eSRafael J. Wysocki }
7475db25c9eSRafael J. Wysocki
748515db266SRafael J. Wysocki if (!(flags & DL_FLAG_STATELESS))
749515db266SRafael J. Wysocki flags |= DL_FLAG_MANAGED;
750515db266SRafael J. Wysocki
75167cad5c6SSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY &&
75267cad5c6SSaravana Kannan !device_link_flag_is_sync_state_only(flags))
75367cad5c6SSaravana Kannan return NULL;
75467cad5c6SSaravana Kannan
7559ed98953SRafael J. Wysocki device_links_write_lock();
7569ed98953SRafael J. Wysocki device_pm_lock();
7579ed98953SRafael J. Wysocki
7589ed98953SRafael J. Wysocki /*
7599ed98953SRafael J. Wysocki * If the supplier has not been fully registered yet or there is a
76005ef983eSSaravana Kannan * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and
76105ef983eSSaravana Kannan * the supplier already in the graph, return NULL. If the link is a
76205ef983eSSaravana Kannan * SYNC_STATE_ONLY link, we don't check for reverse dependencies
76305ef983eSSaravana Kannan * because it only affects sync_state() callbacks.
7649ed98953SRafael J. Wysocki */
7659ed98953SRafael J. Wysocki if (!device_pm_initialized(supplier)
76605ef983eSSaravana Kannan || (!(flags & DL_FLAG_SYNC_STATE_ONLY) &&
76705ef983eSSaravana Kannan device_is_dependent(consumer, supplier))) {
7689ed98953SRafael J. Wysocki link = NULL;
7699ed98953SRafael J. Wysocki goto out;
7709ed98953SRafael J. Wysocki }
7719ed98953SRafael J. Wysocki
77272175d4eSRafael J. Wysocki /*
773ac66c5bbSSaravana Kannan * SYNC_STATE_ONLY links are useless once a consumer device has probed.
774ac66c5bbSSaravana Kannan * So, only create it if the consumer hasn't probed yet.
775ac66c5bbSSaravana Kannan */
776ac66c5bbSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY &&
777ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_NO_DRIVER &&
778ac66c5bbSSaravana Kannan consumer->links.status != DL_DEV_PROBING) {
779ac66c5bbSSaravana Kannan link = NULL;
780ac66c5bbSSaravana Kannan goto out;
781ac66c5bbSSaravana Kannan }
782ac66c5bbSSaravana Kannan
783ac66c5bbSSaravana Kannan /*
78472175d4eSRafael J. Wysocki * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed
78572175d4eSRafael J. Wysocki * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both
78672175d4eSRafael J. Wysocki * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER.
78772175d4eSRafael J. Wysocki */
78872175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
78972175d4eSRafael J. Wysocki flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
79072175d4eSRafael J. Wysocki
791f265df55SRafael J. Wysocki list_for_each_entry(link, &supplier->links.consumers, s_node) {
792f265df55SRafael J. Wysocki if (link->consumer != consumer)
793f265df55SRafael J. Wysocki continue;
794f265df55SRafael J. Wysocki
7954b9bbb29SSaravana Kannan if (link->flags & DL_FLAG_INFERRED &&
7964b9bbb29SSaravana Kannan !(flags & DL_FLAG_INFERRED))
7974b9bbb29SSaravana Kannan link->flags &= ~DL_FLAG_INFERRED;
7984b9bbb29SSaravana Kannan
799e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_PM_RUNTIME) {
800e2f3cd83SRafael J. Wysocki if (!(link->flags & DL_FLAG_PM_RUNTIME)) {
8014c06c4e6SRafael J. Wysocki pm_runtime_new_link(consumer);
802e2f3cd83SRafael J. Wysocki link->flags |= DL_FLAG_PM_RUNTIME;
803e2f3cd83SRafael J. Wysocki }
804e2f3cd83SRafael J. Wysocki if (flags & DL_FLAG_RPM_ACTIVE)
80536003d4cSRafael J. Wysocki refcount_inc(&link->rpm_active);
806e2f3cd83SRafael J. Wysocki }
807e2f3cd83SRafael J. Wysocki
80872175d4eSRafael J. Wysocki if (flags & DL_FLAG_STATELESS) {
809ead18c23SLukas Wunner kref_get(&link->kref);
81021c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&
81144e96049SSaravana Kannan !(link->flags & DL_FLAG_STATELESS)) {
81244e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS;
81305ef983eSSaravana Kannan goto reorder;
81444e96049SSaravana Kannan } else {
81544e96049SSaravana Kannan link->flags |= DL_FLAG_STATELESS;
8169ed98953SRafael J. Wysocki goto out;
817ead18c23SLukas Wunner }
81844e96049SSaravana Kannan }
8199ed98953SRafael J. Wysocki
82072175d4eSRafael J. Wysocki /*
82172175d4eSRafael J. Wysocki * If the life time of the link following from the new flags is
82272175d4eSRafael J. Wysocki * longer than indicated by the flags of the existing link,
82372175d4eSRafael J. Wysocki * update the existing link to stay around longer.
82472175d4eSRafael J. Wysocki */
82572175d4eSRafael J. Wysocki if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) {
82672175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {
82772175d4eSRafael J. Wysocki link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
82872175d4eSRafael J. Wysocki link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER;
82972175d4eSRafael J. Wysocki }
83072175d4eSRafael J. Wysocki } else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) {
83172175d4eSRafael J. Wysocki link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER |
83272175d4eSRafael J. Wysocki DL_FLAG_AUTOREMOVE_SUPPLIER);
83372175d4eSRafael J. Wysocki }
834515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED)) {
835515db266SRafael J. Wysocki kref_get(&link->kref);
836515db266SRafael J. Wysocki link->flags |= DL_FLAG_MANAGED;
837515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier);
838515db266SRafael J. Wysocki }
83905ef983eSSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&
84005ef983eSSaravana Kannan !(flags & DL_FLAG_SYNC_STATE_ONLY)) {
84105ef983eSSaravana Kannan link->flags &= ~DL_FLAG_SYNC_STATE_ONLY;
84205ef983eSSaravana Kannan goto reorder;
84305ef983eSSaravana Kannan }
84405ef983eSSaravana Kannan
84572175d4eSRafael J. Wysocki goto out;
84672175d4eSRafael J. Wysocki }
84772175d4eSRafael J. Wysocki
84821d5c57bSRafael J. Wysocki link = kzalloc(sizeof(*link), GFP_KERNEL);
8499ed98953SRafael J. Wysocki if (!link)
8509ed98953SRafael J. Wysocki goto out;
8519ed98953SRafael J. Wysocki
852e2f3cd83SRafael J. Wysocki refcount_set(&link->rpm_active, 1);
853e2f3cd83SRafael J. Wysocki
8549ed98953SRafael J. Wysocki get_device(supplier);
8559ed98953SRafael J. Wysocki link->supplier = supplier;
8569ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->s_node);
8579ed98953SRafael J. Wysocki get_device(consumer);
8589ed98953SRafael J. Wysocki link->consumer = consumer;
8599ed98953SRafael J. Wysocki INIT_LIST_HEAD(&link->c_node);
8609ed98953SRafael J. Wysocki link->flags = flags;
861ead18c23SLukas Wunner kref_init(&link->kref);
8629ed98953SRafael J. Wysocki
863287905e6SSaravana Kannan link->link_dev.class = &devlink_class;
864287905e6SSaravana Kannan device_set_pm_not_required(&link->link_dev);
865e020ff61SSaravana Kannan dev_set_name(&link->link_dev, "%s:%s--%s:%s",
866e020ff61SSaravana Kannan dev_bus_name(supplier), dev_name(supplier),
867e020ff61SSaravana Kannan dev_bus_name(consumer), dev_name(consumer));
868287905e6SSaravana Kannan if (device_register(&link->link_dev)) {
869df0a1814SYang Yingliang put_device(&link->link_dev);
870287905e6SSaravana Kannan link = NULL;
871287905e6SSaravana Kannan goto out;
872287905e6SSaravana Kannan }
873287905e6SSaravana Kannan
874287905e6SSaravana Kannan if (flags & DL_FLAG_PM_RUNTIME) {
875287905e6SSaravana Kannan if (flags & DL_FLAG_RPM_ACTIVE)
876287905e6SSaravana Kannan refcount_inc(&link->rpm_active);
877287905e6SSaravana Kannan
878287905e6SSaravana Kannan pm_runtime_new_link(consumer);
879287905e6SSaravana Kannan }
880287905e6SSaravana Kannan
88164df1148SLukas Wunner /* Determine the initial link state. */
882515db266SRafael J. Wysocki if (flags & DL_FLAG_STATELESS)
8839ed98953SRafael J. Wysocki link->status = DL_STATE_NONE;
884515db266SRafael J. Wysocki else
885515db266SRafael J. Wysocki device_link_init_status(link, consumer, supplier);
8869ed98953SRafael J. Wysocki
8879ed98953SRafael J. Wysocki /*
88815cfb094SRafael J. Wysocki * Some callers expect the link creation during consumer driver probe to
88915cfb094SRafael J. Wysocki * resume the supplier even without DL_FLAG_RPM_ACTIVE.
89015cfb094SRafael J. Wysocki */
89115cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE &&
89215cfb094SRafael J. Wysocki flags & DL_FLAG_PM_RUNTIME)
89315cfb094SRafael J. Wysocki pm_runtime_resume(supplier);
89415cfb094SRafael J. Wysocki
89521c27f06SSaravana Kannan list_add_tail_rcu(&link->s_node, &supplier->links.consumers);
89621c27f06SSaravana Kannan list_add_tail_rcu(&link->c_node, &consumer->links.suppliers);
89721c27f06SSaravana Kannan
89805ef983eSSaravana Kannan if (flags & DL_FLAG_SYNC_STATE_ONLY) {
89905ef983eSSaravana Kannan dev_dbg(consumer,
90005ef983eSSaravana Kannan "Linked as a sync state only consumer to %s\n",
90105ef983eSSaravana Kannan dev_name(supplier));
90205ef983eSSaravana Kannan goto out;
90305ef983eSSaravana Kannan }
90421c27f06SSaravana Kannan
90505ef983eSSaravana Kannan reorder:
90615cfb094SRafael J. Wysocki /*
9079ed98953SRafael J. Wysocki * Move the consumer and all of the devices depending on it to the end
9089ed98953SRafael J. Wysocki * of dpm_list and the devices_kset list.
9099ed98953SRafael J. Wysocki *
9109ed98953SRafael J. Wysocki * It is necessary to hold dpm_list locked throughout all that or else
9119ed98953SRafael J. Wysocki * we may end up suspending with a wrong ordering of it.
9129ed98953SRafael J. Wysocki */
9139ed98953SRafael J. Wysocki device_reorder_to_tail(consumer, NULL);
9149ed98953SRafael J. Wysocki
9158a4b3269SJerome Brunet dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier));
9169ed98953SRafael J. Wysocki
9179ed98953SRafael J. Wysocki out:
9189ed98953SRafael J. Wysocki device_pm_unlock();
9199ed98953SRafael J. Wysocki device_links_write_unlock();
9205db25c9eSRafael J. Wysocki
921e2f3cd83SRafael J. Wysocki if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link)
9225db25c9eSRafael J. Wysocki pm_runtime_put(supplier);
9235db25c9eSRafael J. Wysocki
9249ed98953SRafael J. Wysocki return link;
9259ed98953SRafael J. Wysocki }
9269ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_add);
9279ed98953SRafael J. Wysocki
__device_link_del(struct kref * kref)928ead18c23SLukas Wunner static void __device_link_del(struct kref *kref)
9299ed98953SRafael J. Wysocki {
930ead18c23SLukas Wunner struct device_link *link = container_of(kref, struct device_link, kref);
931ead18c23SLukas Wunner
9328a4b3269SJerome Brunet dev_dbg(link->consumer, "Dropping the link to %s\n",
9339ed98953SRafael J. Wysocki dev_name(link->supplier));
9349ed98953SRafael J. Wysocki
935e0e398e2SRafael J. Wysocki pm_runtime_drop_link(link);
936baa8809fSRafael J. Wysocki
9370c871315SRafael J. Wysocki device_link_remove_from_lists(link);
938843e600bSSaravana Kannan device_unregister(&link->link_dev);
9399ed98953SRafael J. Wysocki }
9409ed98953SRafael J. Wysocki
device_link_put_kref(struct device_link * link)94172175d4eSRafael J. Wysocki static void device_link_put_kref(struct device_link *link)
94272175d4eSRafael J. Wysocki {
94372175d4eSRafael J. Wysocki if (link->flags & DL_FLAG_STATELESS)
94472175d4eSRafael J. Wysocki kref_put(&link->kref, __device_link_del);
945bf25967aSAdrian Hunter else if (!device_is_registered(link->consumer))
946bf25967aSAdrian Hunter __device_link_del(&link->kref);
94772175d4eSRafael J. Wysocki else
94872175d4eSRafael J. Wysocki WARN(1, "Unable to drop a managed device link reference\n");
94972175d4eSRafael J. Wysocki }
95072175d4eSRafael J. Wysocki
9519ed98953SRafael J. Wysocki /**
95272175d4eSRafael J. Wysocki * device_link_del - Delete a stateless link between two devices.
9539ed98953SRafael J. Wysocki * @link: Device link to delete.
9549ed98953SRafael J. Wysocki *
9559ed98953SRafael J. Wysocki * The caller must ensure proper synchronization of this function with runtime
956ead18c23SLukas Wunner * PM. If the link was added multiple times, it needs to be deleted as often.
957ead18c23SLukas Wunner * Care is required for hotplugged devices: Their links are purged on removal
958ead18c23SLukas Wunner * and calling device_link_del() is then no longer allowed.
9599ed98953SRafael J. Wysocki */
device_link_del(struct device_link * link)9609ed98953SRafael J. Wysocki void device_link_del(struct device_link *link)
9619ed98953SRafael J. Wysocki {
9629ed98953SRafael J. Wysocki device_links_write_lock();
96372175d4eSRafael J. Wysocki device_link_put_kref(link);
9649ed98953SRafael J. Wysocki device_links_write_unlock();
9659ed98953SRafael J. Wysocki }
9669ed98953SRafael J. Wysocki EXPORT_SYMBOL_GPL(device_link_del);
9679ed98953SRafael J. Wysocki
968d8842211Spascal paillet /**
96972175d4eSRafael J. Wysocki * device_link_remove - Delete a stateless link between two devices.
970d8842211Spascal paillet * @consumer: Consumer end of the link.
971d8842211Spascal paillet * @supplier: Supplier end of the link.
972d8842211Spascal paillet *
973d8842211Spascal paillet * The caller must ensure proper synchronization of this function with runtime
974d8842211Spascal paillet * PM.
975d8842211Spascal paillet */
device_link_remove(void * consumer,struct device * supplier)976d8842211Spascal paillet void device_link_remove(void *consumer, struct device *supplier)
977d8842211Spascal paillet {
978d8842211Spascal paillet struct device_link *link;
979d8842211Spascal paillet
980d8842211Spascal paillet if (WARN_ON(consumer == supplier))
981d8842211Spascal paillet return;
982d8842211Spascal paillet
983d8842211Spascal paillet device_links_write_lock();
984d8842211Spascal paillet
985d8842211Spascal paillet list_for_each_entry(link, &supplier->links.consumers, s_node) {
986d8842211Spascal paillet if (link->consumer == consumer) {
98772175d4eSRafael J. Wysocki device_link_put_kref(link);
988d8842211Spascal paillet break;
989d8842211Spascal paillet }
990d8842211Spascal paillet }
991d8842211Spascal paillet
992d8842211Spascal paillet device_links_write_unlock();
993d8842211Spascal paillet }
994d8842211Spascal paillet EXPORT_SYMBOL_GPL(device_link_remove);
995d8842211Spascal paillet
device_links_missing_supplier(struct device * dev)9969ed98953SRafael J. Wysocki static void device_links_missing_supplier(struct device *dev)
9979ed98953SRafael J. Wysocki {
9989ed98953SRafael J. Wysocki struct device_link *link;
9999ed98953SRafael J. Wysocki
10008c3e315dSSaravana Kannan list_for_each_entry(link, &dev->links.suppliers, c_node) {
10018c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE)
10028c3e315dSSaravana Kannan continue;
10038c3e315dSSaravana Kannan
10048c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) {
10059ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
10068c3e315dSSaravana Kannan } else {
10078c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
10088c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT);
10098c3e315dSSaravana Kannan }
10108c3e315dSSaravana Kannan }
10119ed98953SRafael J. Wysocki }
10129ed98953SRafael J. Wysocki
dev_is_best_effort(struct device * dev)10132f8c3ae8SSaravana Kannan static bool dev_is_best_effort(struct device *dev)
10142f8c3ae8SSaravana Kannan {
10158f486cabSSaravana Kannan return (fw_devlink_best_effort && dev->can_match) ||
10168f486cabSSaravana Kannan (dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT));
10172f8c3ae8SSaravana Kannan }
10182f8c3ae8SSaravana Kannan
fwnode_links_check_suppliers(struct fwnode_handle * fwnode)10196a6dfdf8SSaravana Kannan static struct fwnode_handle *fwnode_links_check_suppliers(
10206a6dfdf8SSaravana Kannan struct fwnode_handle *fwnode)
10216a6dfdf8SSaravana Kannan {
10226a6dfdf8SSaravana Kannan struct fwnode_link *link;
10236a6dfdf8SSaravana Kannan
10246a6dfdf8SSaravana Kannan if (!fwnode || fw_devlink_is_permissive())
10256a6dfdf8SSaravana Kannan return NULL;
10266a6dfdf8SSaravana Kannan
10276a6dfdf8SSaravana Kannan list_for_each_entry(link, &fwnode->suppliers, c_hook)
10286a6dfdf8SSaravana Kannan if (!(link->flags & FWLINK_FLAG_CYCLE))
10296a6dfdf8SSaravana Kannan return link->supplier;
10306a6dfdf8SSaravana Kannan
10316a6dfdf8SSaravana Kannan return NULL;
10326a6dfdf8SSaravana Kannan }
10336a6dfdf8SSaravana Kannan
10349ed98953SRafael J. Wysocki /**
10359ed98953SRafael J. Wysocki * device_links_check_suppliers - Check presence of supplier drivers.
10369ed98953SRafael J. Wysocki * @dev: Consumer device.
10379ed98953SRafael J. Wysocki *
10389ed98953SRafael J. Wysocki * Check links from this device to any suppliers. Walk the list of the device's
10399ed98953SRafael J. Wysocki * links to suppliers and see if all of them are available. If not, simply
10409ed98953SRafael J. Wysocki * return -EPROBE_DEFER.
10419ed98953SRafael J. Wysocki *
10429ed98953SRafael J. Wysocki * We need to guarantee that the supplier will not go away after the check has
10439ed98953SRafael J. Wysocki * been positive here. It only can go away in __device_release_driver() and
10449ed98953SRafael J. Wysocki * that function checks the device's links to consumers. This means we need to
10459ed98953SRafael J. Wysocki * mark the link as "consumer probe in progress" to make the supplier removal
10469ed98953SRafael J. Wysocki * wait for us to complete (or bad things may happen).
10479ed98953SRafael J. Wysocki *
1048515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored.
10499ed98953SRafael J. Wysocki */
device_links_check_suppliers(struct device * dev)10509ed98953SRafael J. Wysocki int device_links_check_suppliers(struct device *dev)
10519ed98953SRafael J. Wysocki {
10529ed98953SRafael J. Wysocki struct device_link *link;
10532f8c3ae8SSaravana Kannan int ret = 0, fwnode_ret = 0;
105468223eeeSSaravana Kannan struct fwnode_handle *sup_fw;
10559ed98953SRafael J. Wysocki
1056e2ae9bccSSaravana Kannan /*
1057e2ae9bccSSaravana Kannan * Device waiting for supplier to become available is not allowed to
1058e2ae9bccSSaravana Kannan * probe.
1059e2ae9bccSSaravana Kannan */
106025ac86c6SSaravana Kannan mutex_lock(&fwnode_link_lock);
10616a6dfdf8SSaravana Kannan sup_fw = fwnode_links_check_suppliers(dev->fwnode);
10626a6dfdf8SSaravana Kannan if (sup_fw) {
10632f8c3ae8SSaravana Kannan if (!dev_is_best_effort(dev)) {
10642f8c3ae8SSaravana Kannan fwnode_ret = -EPROBE_DEFER;
10652f8c3ae8SSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER,
10660c058fb9SSaravana Kannan "wait for supplier %pfwf\n", sup_fw);
10672f8c3ae8SSaravana Kannan } else {
10682f8c3ae8SSaravana Kannan fwnode_ret = -EAGAIN;
10692f8c3ae8SSaravana Kannan }
1070e2ae9bccSSaravana Kannan }
107125ac86c6SSaravana Kannan mutex_unlock(&fwnode_link_lock);
10722f8c3ae8SSaravana Kannan if (fwnode_ret == -EPROBE_DEFER)
10732f8c3ae8SSaravana Kannan return fwnode_ret;
1074e2ae9bccSSaravana Kannan
10759ed98953SRafael J. Wysocki device_links_write_lock();
10769ed98953SRafael J. Wysocki
10779ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.suppliers, c_node) {
10788c3e315dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED))
10799ed98953SRafael J. Wysocki continue;
10809ed98953SRafael J. Wysocki
10818c3e315dSSaravana Kannan if (link->status != DL_STATE_AVAILABLE &&
10828c3e315dSSaravana Kannan !(link->flags & DL_FLAG_SYNC_STATE_ONLY)) {
10832f8c3ae8SSaravana Kannan
10842f8c3ae8SSaravana Kannan if (dev_is_best_effort(dev) &&
10852f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED &&
10862f8c3ae8SSaravana Kannan !link->supplier->can_match) {
10872f8c3ae8SSaravana Kannan ret = -EAGAIN;
10882f8c3ae8SSaravana Kannan continue;
10892f8c3ae8SSaravana Kannan }
10902f8c3ae8SSaravana Kannan
10919ed98953SRafael J. Wysocki device_links_missing_supplier(dev);
109268223eeeSSaravana Kannan dev_err_probe(dev, -EPROBE_DEFER,
109368223eeeSSaravana Kannan "supplier %s not ready\n",
10941f0dfa05SSaravana Kannan dev_name(link->supplier));
10959ed98953SRafael J. Wysocki ret = -EPROBE_DEFER;
10969ed98953SRafael J. Wysocki break;
10979ed98953SRafael J. Wysocki }
10989ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
10999ed98953SRafael J. Wysocki }
11009ed98953SRafael J. Wysocki dev->links.status = DL_DEV_PROBING;
11019ed98953SRafael J. Wysocki
11029ed98953SRafael J. Wysocki device_links_write_unlock();
11032f8c3ae8SSaravana Kannan
11042f8c3ae8SSaravana Kannan return ret ? ret : fwnode_ret;
11059ed98953SRafael J. Wysocki }
11069ed98953SRafael J. Wysocki
110726e77708SSaravana Kannan /**
110826e77708SSaravana Kannan * __device_links_queue_sync_state - Queue a device for sync_state() callback
110926e77708SSaravana Kannan * @dev: Device to call sync_state() on
111026e77708SSaravana Kannan * @list: List head to queue the @dev on
111126e77708SSaravana Kannan *
111226e77708SSaravana Kannan * Queues a device for a sync_state() callback when the device links write lock
111326e77708SSaravana Kannan * isn't held. This allows the sync_state() execution flow to use device links
111426e77708SSaravana Kannan * APIs. The caller must ensure this function is called with
111526e77708SSaravana Kannan * device_links_write_lock() held.
111626e77708SSaravana Kannan *
111726e77708SSaravana Kannan * This function does a get_device() to make sure the device is not freed while
111826e77708SSaravana Kannan * on this list.
111926e77708SSaravana Kannan *
112026e77708SSaravana Kannan * So the caller must also ensure that device_links_flush_sync_list() is called
112126e77708SSaravana Kannan * as soon as the caller releases device_links_write_lock(). This is necessary
112226e77708SSaravana Kannan * to make sure the sync_state() is called in a timely fashion and the
112326e77708SSaravana Kannan * put_device() is called on this device.
112426e77708SSaravana Kannan */
__device_links_queue_sync_state(struct device * dev,struct list_head * list)112526e77708SSaravana Kannan static void __device_links_queue_sync_state(struct device *dev,
112626e77708SSaravana Kannan struct list_head *list)
1127fc5a251dSSaravana Kannan {
1128fc5a251dSSaravana Kannan struct device_link *link;
1129fc5a251dSSaravana Kannan
113077036165SSaravana Kannan if (!dev_has_sync_state(dev))
113177036165SSaravana Kannan return;
1132fc5a251dSSaravana Kannan if (dev->state_synced)
1133fc5a251dSSaravana Kannan return;
1134fc5a251dSSaravana Kannan
1135fc5a251dSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node) {
1136fc5a251dSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED))
1137fc5a251dSSaravana Kannan continue;
1138fc5a251dSSaravana Kannan if (link->status != DL_STATE_ACTIVE)
1139fc5a251dSSaravana Kannan return;
1140fc5a251dSSaravana Kannan }
1141fc5a251dSSaravana Kannan
114226e77708SSaravana Kannan /*
114326e77708SSaravana Kannan * Set the flag here to avoid adding the same device to a list more
114426e77708SSaravana Kannan * than once. This can happen if new consumers get added to the device
114526e77708SSaravana Kannan * and probed before the list is flushed.
114626e77708SSaravana Kannan */
114726e77708SSaravana Kannan dev->state_synced = true;
114826e77708SSaravana Kannan
11493b052a3eSSaravana Kannan if (WARN_ON(!list_empty(&dev->links.defer_sync)))
115026e77708SSaravana Kannan return;
115126e77708SSaravana Kannan
115226e77708SSaravana Kannan get_device(dev);
11533b052a3eSSaravana Kannan list_add_tail(&dev->links.defer_sync, list);
115426e77708SSaravana Kannan }
115526e77708SSaravana Kannan
115626e77708SSaravana Kannan /**
115726e77708SSaravana Kannan * device_links_flush_sync_list - Call sync_state() on a list of devices
115826e77708SSaravana Kannan * @list: List of devices to call sync_state() on
115921eb93f4SSaravana Kannan * @dont_lock_dev: Device for which lock is already held by the caller
116026e77708SSaravana Kannan *
116126e77708SSaravana Kannan * Calls sync_state() on all the devices that have been queued for it. This
116221eb93f4SSaravana Kannan * function is used in conjunction with __device_links_queue_sync_state(). The
116321eb93f4SSaravana Kannan * @dont_lock_dev parameter is useful when this function is called from a
116421eb93f4SSaravana Kannan * context where a device lock is already held.
116526e77708SSaravana Kannan */
device_links_flush_sync_list(struct list_head * list,struct device * dont_lock_dev)116621eb93f4SSaravana Kannan static void device_links_flush_sync_list(struct list_head *list,
116721eb93f4SSaravana Kannan struct device *dont_lock_dev)
116826e77708SSaravana Kannan {
116926e77708SSaravana Kannan struct device *dev, *tmp;
117026e77708SSaravana Kannan
11713b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, list, links.defer_sync) {
11723b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync);
117326e77708SSaravana Kannan
117421eb93f4SSaravana Kannan if (dev != dont_lock_dev)
117526e77708SSaravana Kannan device_lock(dev);
117626e77708SSaravana Kannan
1177f8fb5766SSaravana Kannan dev_sync_state(dev);
1178fc5a251dSSaravana Kannan
117921eb93f4SSaravana Kannan if (dev != dont_lock_dev)
118026e77708SSaravana Kannan device_unlock(dev);
118126e77708SSaravana Kannan
118226e77708SSaravana Kannan put_device(dev);
118326e77708SSaravana Kannan }
1184fc5a251dSSaravana Kannan }
1185fc5a251dSSaravana Kannan
device_links_supplier_sync_state_pause(void)1186fc5a251dSSaravana Kannan void device_links_supplier_sync_state_pause(void)
1187fc5a251dSSaravana Kannan {
1188fc5a251dSSaravana Kannan device_links_write_lock();
1189fc5a251dSSaravana Kannan defer_sync_state_count++;
1190fc5a251dSSaravana Kannan device_links_write_unlock();
1191fc5a251dSSaravana Kannan }
1192fc5a251dSSaravana Kannan
device_links_supplier_sync_state_resume(void)1193fc5a251dSSaravana Kannan void device_links_supplier_sync_state_resume(void)
1194fc5a251dSSaravana Kannan {
1195fc5a251dSSaravana Kannan struct device *dev, *tmp;
119626e77708SSaravana Kannan LIST_HEAD(sync_list);
1197fc5a251dSSaravana Kannan
1198fc5a251dSSaravana Kannan device_links_write_lock();
1199fc5a251dSSaravana Kannan if (!defer_sync_state_count) {
1200fc5a251dSSaravana Kannan WARN(true, "Unmatched sync_state pause/resume!");
1201fc5a251dSSaravana Kannan goto out;
1202fc5a251dSSaravana Kannan }
1203fc5a251dSSaravana Kannan defer_sync_state_count--;
1204fc5a251dSSaravana Kannan if (defer_sync_state_count)
1205fc5a251dSSaravana Kannan goto out;
1206fc5a251dSSaravana Kannan
12073b052a3eSSaravana Kannan list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) {
120826e77708SSaravana Kannan /*
120926e77708SSaravana Kannan * Delete from deferred_sync list before queuing it to
12103b052a3eSSaravana Kannan * sync_list because defer_sync is used for both lists.
121126e77708SSaravana Kannan */
12123b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync);
121326e77708SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list);
1214fc5a251dSSaravana Kannan }
1215fc5a251dSSaravana Kannan out:
1216fc5a251dSSaravana Kannan device_links_write_unlock();
121726e77708SSaravana Kannan
121821eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL);
1219fc5a251dSSaravana Kannan }
1220fc5a251dSSaravana Kannan
sync_state_resume_initcall(void)1221fc5a251dSSaravana Kannan static int sync_state_resume_initcall(void)
1222fc5a251dSSaravana Kannan {
1223fc5a251dSSaravana Kannan device_links_supplier_sync_state_resume();
1224fc5a251dSSaravana Kannan return 0;
1225fc5a251dSSaravana Kannan }
1226fc5a251dSSaravana Kannan late_initcall(sync_state_resume_initcall);
1227fc5a251dSSaravana Kannan
__device_links_supplier_defer_sync(struct device * sup)1228fc5a251dSSaravana Kannan static void __device_links_supplier_defer_sync(struct device *sup)
1229fc5a251dSSaravana Kannan {
12303b052a3eSSaravana Kannan if (list_empty(&sup->links.defer_sync) && dev_has_sync_state(sup))
12313b052a3eSSaravana Kannan list_add_tail(&sup->links.defer_sync, &deferred_sync);
1232fc5a251dSSaravana Kannan }
1233fc5a251dSSaravana Kannan
device_link_drop_managed(struct device_link * link)123421c27f06SSaravana Kannan static void device_link_drop_managed(struct device_link *link)
123521c27f06SSaravana Kannan {
123621c27f06SSaravana Kannan link->flags &= ~DL_FLAG_MANAGED;
123721c27f06SSaravana Kannan WRITE_ONCE(link->status, DL_STATE_NONE);
123821c27f06SSaravana Kannan kref_put(&link->kref, __device_link_del);
123921c27f06SSaravana Kannan }
124021c27f06SSaravana Kannan
waiting_for_supplier_show(struct device * dev,struct device_attribute * attr,char * buf)1241da6d6475SSaravana Kannan static ssize_t waiting_for_supplier_show(struct device *dev,
1242da6d6475SSaravana Kannan struct device_attribute *attr,
1243da6d6475SSaravana Kannan char *buf)
1244da6d6475SSaravana Kannan {
1245da6d6475SSaravana Kannan bool val;
1246da6d6475SSaravana Kannan
1247da6d6475SSaravana Kannan device_lock(dev);
12486a6dfdf8SSaravana Kannan mutex_lock(&fwnode_link_lock);
12496a6dfdf8SSaravana Kannan val = !!fwnode_links_check_suppliers(dev->fwnode);
12506a6dfdf8SSaravana Kannan mutex_unlock(&fwnode_link_lock);
1251da6d6475SSaravana Kannan device_unlock(dev);
1252aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val);
1253da6d6475SSaravana Kannan }
1254da6d6475SSaravana Kannan static DEVICE_ATTR_RO(waiting_for_supplier);
1255da6d6475SSaravana Kannan
12569ed98953SRafael J. Wysocki /**
1257b6f617dfSSaravana Kannan * device_links_force_bind - Prepares device to be force bound
1258b6f617dfSSaravana Kannan * @dev: Consumer device.
1259b6f617dfSSaravana Kannan *
1260b6f617dfSSaravana Kannan * device_bind_driver() force binds a device to a driver without calling any
1261b6f617dfSSaravana Kannan * driver probe functions. So the consumer really isn't going to wait for any
1262b6f617dfSSaravana Kannan * supplier before it's bound to the driver. We still want the device link
1263b6f617dfSSaravana Kannan * states to be sensible when this happens.
1264b6f617dfSSaravana Kannan *
1265b6f617dfSSaravana Kannan * In preparation for device_bind_driver(), this function goes through each
1266b6f617dfSSaravana Kannan * supplier device links and checks if the supplier is bound. If it is, then
1267b6f617dfSSaravana Kannan * the device link status is set to CONSUMER_PROBE. Otherwise, the device link
1268b6f617dfSSaravana Kannan * is dropped. Links without the DL_FLAG_MANAGED flag set are ignored.
1269b6f617dfSSaravana Kannan */
device_links_force_bind(struct device * dev)1270b6f617dfSSaravana Kannan void device_links_force_bind(struct device *dev)
1271b6f617dfSSaravana Kannan {
1272b6f617dfSSaravana Kannan struct device_link *link, *ln;
1273b6f617dfSSaravana Kannan
1274b6f617dfSSaravana Kannan device_links_write_lock();
1275b6f617dfSSaravana Kannan
1276b6f617dfSSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) {
1277b6f617dfSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED))
1278b6f617dfSSaravana Kannan continue;
1279b6f617dfSSaravana Kannan
1280b6f617dfSSaravana Kannan if (link->status != DL_STATE_AVAILABLE) {
1281b6f617dfSSaravana Kannan device_link_drop_managed(link);
1282b6f617dfSSaravana Kannan continue;
1283b6f617dfSSaravana Kannan }
1284b6f617dfSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
1285b6f617dfSSaravana Kannan }
1286b6f617dfSSaravana Kannan dev->links.status = DL_DEV_PROBING;
1287b6f617dfSSaravana Kannan
1288b6f617dfSSaravana Kannan device_links_write_unlock();
1289b6f617dfSSaravana Kannan }
1290b6f617dfSSaravana Kannan
1291b6f617dfSSaravana Kannan /**
12929ed98953SRafael J. Wysocki * device_links_driver_bound - Update device links after probing its driver.
12939ed98953SRafael J. Wysocki * @dev: Device to update the links for.
12949ed98953SRafael J. Wysocki *
12959ed98953SRafael J. Wysocki * The probe has been successful, so update links from this device to any
12969ed98953SRafael J. Wysocki * consumers by changing their status to "available".
12979ed98953SRafael J. Wysocki *
12989ed98953SRafael J. Wysocki * Also change the status of @dev's links to suppliers to "active".
12999ed98953SRafael J. Wysocki *
1300515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored.
13019ed98953SRafael J. Wysocki */
device_links_driver_bound(struct device * dev)13029ed98953SRafael J. Wysocki void device_links_driver_bound(struct device *dev)
13039ed98953SRafael J. Wysocki {
130421c27f06SSaravana Kannan struct device_link *link, *ln;
130526e77708SSaravana Kannan LIST_HEAD(sync_list);
13069ed98953SRafael J. Wysocki
1307bcbbcfd5SSaravana Kannan /*
13089528e0d9SSaravana Kannan * If a device binds successfully, it's expected to have created all
1309bcbbcfd5SSaravana Kannan * the device links it needs to or make new device links as it needs
13109528e0d9SSaravana Kannan * them. So, fw_devlink no longer needs to create device links to any
13119528e0d9SSaravana Kannan * of the device's suppliers.
13129528e0d9SSaravana Kannan *
13133a2dbc51SSaravana Kannan * Also, if a child firmware node of this bound device is not added as a
13143a2dbc51SSaravana Kannan * device by now, assume it is never going to be added. Make this bound
13153a2dbc51SSaravana Kannan * device the fallback supplier to the dangling consumers of the child
13163a2dbc51SSaravana Kannan * firmware node because this bound device is probably implementing the
13173a2dbc51SSaravana Kannan * child firmware node functionality and we don't want the dangling
13183a2dbc51SSaravana Kannan * consumers to defer probe indefinitely waiting for a device for the
13193a2dbc51SSaravana Kannan * child firmware node.
1320bcbbcfd5SSaravana Kannan */
13219528e0d9SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev) {
13229528e0d9SSaravana Kannan struct fwnode_handle *child;
1323f9aa4606SSaravana Kannan fwnode_links_purge_suppliers(dev->fwnode);
13243a2dbc51SSaravana Kannan mutex_lock(&fwnode_link_lock);
13259528e0d9SSaravana Kannan fwnode_for_each_available_child_node(dev->fwnode, child)
13263a2dbc51SSaravana Kannan __fw_devlink_pickup_dangling_consumers(child,
13273a2dbc51SSaravana Kannan dev->fwnode);
13283a2dbc51SSaravana Kannan __fw_devlink_link_to_consumers(dev);
13293a2dbc51SSaravana Kannan mutex_unlock(&fwnode_link_lock);
13309528e0d9SSaravana Kannan }
1331da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier);
1332bcbbcfd5SSaravana Kannan
13339ed98953SRafael J. Wysocki device_links_write_lock();
13349ed98953SRafael J. Wysocki
13359ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) {
1336515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED))
13379ed98953SRafael J. Wysocki continue;
13389ed98953SRafael J. Wysocki
133915cfb094SRafael J. Wysocki /*
134015cfb094SRafael J. Wysocki * Links created during consumer probe may be in the "consumer
134115cfb094SRafael J. Wysocki * probe" state to start with if the supplier is still probing
134215cfb094SRafael J. Wysocki * when they are created and they may become "active" if the
134315cfb094SRafael J. Wysocki * consumer probe returns first. Skip them here.
134415cfb094SRafael J. Wysocki */
134515cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE ||
134615cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE)
134715cfb094SRafael J. Wysocki continue;
134815cfb094SRafael J. Wysocki
13499ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT);
13509ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
1351e7dd4010SRafael J. Wysocki
1352e7dd4010SRafael J. Wysocki if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER)
1353e7dd4010SRafael J. Wysocki driver_deferred_probe_add(link->consumer);
13549ed98953SRafael J. Wysocki }
13559ed98953SRafael J. Wysocki
135621eb93f4SSaravana Kannan if (defer_sync_state_count)
135721eb93f4SSaravana Kannan __device_links_supplier_defer_sync(dev);
135821eb93f4SSaravana Kannan else
135921eb93f4SSaravana Kannan __device_links_queue_sync_state(dev, &sync_list);
136021eb93f4SSaravana Kannan
136121c27f06SSaravana Kannan list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) {
136221c27f06SSaravana Kannan struct device *supplier;
136321c27f06SSaravana Kannan
1364515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED))
13659ed98953SRafael J. Wysocki continue;
13669ed98953SRafael J. Wysocki
136721c27f06SSaravana Kannan supplier = link->supplier;
136821c27f06SSaravana Kannan if (link->flags & DL_FLAG_SYNC_STATE_ONLY) {
136921c27f06SSaravana Kannan /*
137021c27f06SSaravana Kannan * When DL_FLAG_SYNC_STATE_ONLY is set, it means no
137121c27f06SSaravana Kannan * other DL_MANAGED_LINK_FLAGS have been set. So, it's
137221c27f06SSaravana Kannan * save to drop the managed link completely.
137321c27f06SSaravana Kannan */
137421c27f06SSaravana Kannan device_link_drop_managed(link);
13752f8c3ae8SSaravana Kannan } else if (dev_is_best_effort(dev) &&
13762f8c3ae8SSaravana Kannan link->flags & DL_FLAG_INFERRED &&
13772f8c3ae8SSaravana Kannan link->status != DL_STATE_CONSUMER_PROBE &&
13782f8c3ae8SSaravana Kannan !link->supplier->can_match) {
13792f8c3ae8SSaravana Kannan /*
13802f8c3ae8SSaravana Kannan * When dev_is_best_effort() is true, we ignore device
13812f8c3ae8SSaravana Kannan * links to suppliers that don't have a driver. If the
13822f8c3ae8SSaravana Kannan * consumer device still managed to probe, there's no
13832f8c3ae8SSaravana Kannan * point in maintaining a device link in a weird state
13842f8c3ae8SSaravana Kannan * (consumer probed before supplier). So delete it.
13852f8c3ae8SSaravana Kannan */
13862f8c3ae8SSaravana Kannan device_link_drop_managed(link);
138721c27f06SSaravana Kannan } else {
13889ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_CONSUMER_PROBE);
13899ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_ACTIVE);
139021c27f06SSaravana Kannan }
1391fc5a251dSSaravana Kannan
139221c27f06SSaravana Kannan /*
139321c27f06SSaravana Kannan * This needs to be done even for the deleted
139421c27f06SSaravana Kannan * DL_FLAG_SYNC_STATE_ONLY device link in case it was the last
139521c27f06SSaravana Kannan * device link that was preventing the supplier from getting a
139621c27f06SSaravana Kannan * sync_state() call.
139721c27f06SSaravana Kannan */
1398fc5a251dSSaravana Kannan if (defer_sync_state_count)
139921c27f06SSaravana Kannan __device_links_supplier_defer_sync(supplier);
1400fc5a251dSSaravana Kannan else
140121c27f06SSaravana Kannan __device_links_queue_sync_state(supplier, &sync_list);
14029ed98953SRafael J. Wysocki }
14039ed98953SRafael J. Wysocki
14049ed98953SRafael J. Wysocki dev->links.status = DL_DEV_DRIVER_BOUND;
14059ed98953SRafael J. Wysocki
14069ed98953SRafael J. Wysocki device_links_write_unlock();
140726e77708SSaravana Kannan
140821eb93f4SSaravana Kannan device_links_flush_sync_list(&sync_list, dev);
14099ed98953SRafael J. Wysocki }
14109ed98953SRafael J. Wysocki
14119ed98953SRafael J. Wysocki /**
14129ed98953SRafael J. Wysocki * __device_links_no_driver - Update links of a device without a driver.
14139ed98953SRafael J. Wysocki * @dev: Device without a drvier.
14149ed98953SRafael J. Wysocki *
14159ed98953SRafael J. Wysocki * Delete all non-persistent links from this device to any suppliers.
14169ed98953SRafael J. Wysocki *
14179ed98953SRafael J. Wysocki * Persistent links stay around, but their status is changed to "available",
14189ed98953SRafael J. Wysocki * unless they already are in the "supplier unbind in progress" state in which
14199ed98953SRafael J. Wysocki * case they need not be updated.
14209ed98953SRafael J. Wysocki *
1421515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored.
14229ed98953SRafael J. Wysocki */
__device_links_no_driver(struct device * dev)14239ed98953SRafael J. Wysocki static void __device_links_no_driver(struct device *dev)
14249ed98953SRafael J. Wysocki {
14259ed98953SRafael J. Wysocki struct device_link *link, *ln;
14269ed98953SRafael J. Wysocki
14279ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
1428515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED))
14299ed98953SRafael J. Wysocki continue;
14309ed98953SRafael J. Wysocki
14318c3e315dSSaravana Kannan if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {
1432515db266SRafael J. Wysocki device_link_drop_managed(link);
14338c3e315dSSaravana Kannan continue;
14348c3e315dSSaravana Kannan }
14358c3e315dSSaravana Kannan
14368c3e315dSSaravana Kannan if (link->status != DL_STATE_CONSUMER_PROBE &&
14378c3e315dSSaravana Kannan link->status != DL_STATE_ACTIVE)
14388c3e315dSSaravana Kannan continue;
14398c3e315dSSaravana Kannan
14408c3e315dSSaravana Kannan if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) {
14419ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
14428c3e315dSSaravana Kannan } else {
14438c3e315dSSaravana Kannan WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
14448c3e315dSSaravana Kannan WRITE_ONCE(link->status, DL_STATE_DORMANT);
14458c3e315dSSaravana Kannan }
14469ed98953SRafael J. Wysocki }
14479ed98953SRafael J. Wysocki
14489ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER;
14499ed98953SRafael J. Wysocki }
14509ed98953SRafael J. Wysocki
145115cfb094SRafael J. Wysocki /**
145215cfb094SRafael J. Wysocki * device_links_no_driver - Update links after failing driver probe.
145315cfb094SRafael J. Wysocki * @dev: Device whose driver has just failed to probe.
145415cfb094SRafael J. Wysocki *
145515cfb094SRafael J. Wysocki * Clean up leftover links to consumers for @dev and invoke
145615cfb094SRafael J. Wysocki * %__device_links_no_driver() to update links to suppliers for it as
145715cfb094SRafael J. Wysocki * appropriate.
145815cfb094SRafael J. Wysocki *
1459515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored.
146015cfb094SRafael J. Wysocki */
device_links_no_driver(struct device * dev)14619ed98953SRafael J. Wysocki void device_links_no_driver(struct device *dev)
14629ed98953SRafael J. Wysocki {
146315cfb094SRafael J. Wysocki struct device_link *link;
146415cfb094SRafael J. Wysocki
14659ed98953SRafael J. Wysocki device_links_write_lock();
146615cfb094SRafael J. Wysocki
146715cfb094SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) {
1468515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED))
146915cfb094SRafael J. Wysocki continue;
147015cfb094SRafael J. Wysocki
147115cfb094SRafael J. Wysocki /*
147215cfb094SRafael J. Wysocki * The probe has failed, so if the status of the link is
147315cfb094SRafael J. Wysocki * "consumer probe" or "active", it must have been added by
147415cfb094SRafael J. Wysocki * a probing consumer while this device was still probing.
147515cfb094SRafael J. Wysocki * Change its state to "dormant", as it represents a valid
147615cfb094SRafael J. Wysocki * relationship, but it is not functionally meaningful.
147715cfb094SRafael J. Wysocki */
147815cfb094SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE ||
147915cfb094SRafael J. Wysocki link->status == DL_STATE_ACTIVE)
148015cfb094SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT);
148115cfb094SRafael J. Wysocki }
148215cfb094SRafael J. Wysocki
14839ed98953SRafael J. Wysocki __device_links_no_driver(dev);
148415cfb094SRafael J. Wysocki
14859ed98953SRafael J. Wysocki device_links_write_unlock();
14869ed98953SRafael J. Wysocki }
14879ed98953SRafael J. Wysocki
14889ed98953SRafael J. Wysocki /**
14899ed98953SRafael J. Wysocki * device_links_driver_cleanup - Update links after driver removal.
14909ed98953SRafael J. Wysocki * @dev: Device whose driver has just gone away.
14919ed98953SRafael J. Wysocki *
14929ed98953SRafael J. Wysocki * Update links to consumers for @dev by changing their status to "dormant" and
14939ed98953SRafael J. Wysocki * invoke %__device_links_no_driver() to update links to suppliers for it as
14949ed98953SRafael J. Wysocki * appropriate.
14959ed98953SRafael J. Wysocki *
1496515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored.
14979ed98953SRafael J. Wysocki */
device_links_driver_cleanup(struct device * dev)14989ed98953SRafael J. Wysocki void device_links_driver_cleanup(struct device *dev)
14999ed98953SRafael J. Wysocki {
1500c8d50986SRafael J. Wysocki struct device_link *link, *ln;
15019ed98953SRafael J. Wysocki
15029ed98953SRafael J. Wysocki device_links_write_lock();
15039ed98953SRafael J. Wysocki
1504c8d50986SRafael J. Wysocki list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) {
1505515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED))
15069ed98953SRafael J. Wysocki continue;
15079ed98953SRafael J. Wysocki
1508e88728f4SVivek Gautam WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER);
15099ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND);
15101689cac5SVivek Gautam
15111689cac5SVivek Gautam /*
15121689cac5SVivek Gautam * autoremove the links between this @dev and its consumer
15131689cac5SVivek Gautam * devices that are not active, i.e. where the link state
15141689cac5SVivek Gautam * has moved to DL_STATE_SUPPLIER_UNBIND.
15151689cac5SVivek Gautam */
15161689cac5SVivek Gautam if (link->status == DL_STATE_SUPPLIER_UNBIND &&
15171689cac5SVivek Gautam link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
1518515db266SRafael J. Wysocki device_link_drop_managed(link);
15191689cac5SVivek Gautam
15209ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_DORMANT);
15219ed98953SRafael J. Wysocki }
15229ed98953SRafael J. Wysocki
15233b052a3eSSaravana Kannan list_del_init(&dev->links.defer_sync);
15249ed98953SRafael J. Wysocki __device_links_no_driver(dev);
15259ed98953SRafael J. Wysocki
15269ed98953SRafael J. Wysocki device_links_write_unlock();
15279ed98953SRafael J. Wysocki }
15289ed98953SRafael J. Wysocki
15299ed98953SRafael J. Wysocki /**
15309ed98953SRafael J. Wysocki * device_links_busy - Check if there are any busy links to consumers.
15319ed98953SRafael J. Wysocki * @dev: Device to check.
15329ed98953SRafael J. Wysocki *
15339ed98953SRafael J. Wysocki * Check each consumer of the device and return 'true' if its link's status
15349ed98953SRafael J. Wysocki * is one of "consumer probe" or "active" (meaning that the given consumer is
15359ed98953SRafael J. Wysocki * probing right now or its driver is present). Otherwise, change the link
15369ed98953SRafael J. Wysocki * state to "supplier unbind" to prevent the consumer from being probed
15379ed98953SRafael J. Wysocki * successfully going forward.
15389ed98953SRafael J. Wysocki *
15399ed98953SRafael J. Wysocki * Return 'false' if there are no probing or active consumers.
15409ed98953SRafael J. Wysocki *
1541515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored.
15429ed98953SRafael J. Wysocki */
device_links_busy(struct device * dev)15439ed98953SRafael J. Wysocki bool device_links_busy(struct device *dev)
15449ed98953SRafael J. Wysocki {
15459ed98953SRafael J. Wysocki struct device_link *link;
15469ed98953SRafael J. Wysocki bool ret = false;
15479ed98953SRafael J. Wysocki
15489ed98953SRafael J. Wysocki device_links_write_lock();
15499ed98953SRafael J. Wysocki
15509ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) {
1551515db266SRafael J. Wysocki if (!(link->flags & DL_FLAG_MANAGED))
15529ed98953SRafael J. Wysocki continue;
15539ed98953SRafael J. Wysocki
15549ed98953SRafael J. Wysocki if (link->status == DL_STATE_CONSUMER_PROBE
15559ed98953SRafael J. Wysocki || link->status == DL_STATE_ACTIVE) {
15569ed98953SRafael J. Wysocki ret = true;
15579ed98953SRafael J. Wysocki break;
15589ed98953SRafael J. Wysocki }
15599ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
15609ed98953SRafael J. Wysocki }
15619ed98953SRafael J. Wysocki
15629ed98953SRafael J. Wysocki dev->links.status = DL_DEV_UNBINDING;
15639ed98953SRafael J. Wysocki
15649ed98953SRafael J. Wysocki device_links_write_unlock();
15659ed98953SRafael J. Wysocki return ret;
15669ed98953SRafael J. Wysocki }
15679ed98953SRafael J. Wysocki
15689ed98953SRafael J. Wysocki /**
15699ed98953SRafael J. Wysocki * device_links_unbind_consumers - Force unbind consumers of the given device.
15709ed98953SRafael J. Wysocki * @dev: Device to unbind the consumers of.
15719ed98953SRafael J. Wysocki *
15729ed98953SRafael J. Wysocki * Walk the list of links to consumers for @dev and if any of them is in the
15739ed98953SRafael J. Wysocki * "consumer probe" state, wait for all device probes in progress to complete
15749ed98953SRafael J. Wysocki * and start over.
15759ed98953SRafael J. Wysocki *
15769ed98953SRafael J. Wysocki * If that's not the case, change the status of the link to "supplier unbind"
15779ed98953SRafael J. Wysocki * and check if the link was in the "active" state. If so, force the consumer
15789ed98953SRafael J. Wysocki * driver to unbind and start over (the consumer will not re-probe as we have
15799ed98953SRafael J. Wysocki * changed the state of the link already).
15809ed98953SRafael J. Wysocki *
1581515db266SRafael J. Wysocki * Links without the DL_FLAG_MANAGED flag set are ignored.
15829ed98953SRafael J. Wysocki */
device_links_unbind_consumers(struct device * dev)15839ed98953SRafael J. Wysocki void device_links_unbind_consumers(struct device *dev)
15849ed98953SRafael J. Wysocki {
15859ed98953SRafael J. Wysocki struct device_link *link;
15869ed98953SRafael J. Wysocki
15879ed98953SRafael J. Wysocki start:
15889ed98953SRafael J. Wysocki device_links_write_lock();
15899ed98953SRafael J. Wysocki
15909ed98953SRafael J. Wysocki list_for_each_entry(link, &dev->links.consumers, s_node) {
15919ed98953SRafael J. Wysocki enum device_link_state status;
15929ed98953SRafael J. Wysocki
159305ef983eSSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) ||
159405ef983eSSaravana Kannan link->flags & DL_FLAG_SYNC_STATE_ONLY)
15959ed98953SRafael J. Wysocki continue;
15969ed98953SRafael J. Wysocki
15979ed98953SRafael J. Wysocki status = link->status;
15989ed98953SRafael J. Wysocki if (status == DL_STATE_CONSUMER_PROBE) {
15999ed98953SRafael J. Wysocki device_links_write_unlock();
16009ed98953SRafael J. Wysocki
16019ed98953SRafael J. Wysocki wait_for_device_probe();
16029ed98953SRafael J. Wysocki goto start;
16039ed98953SRafael J. Wysocki }
16049ed98953SRafael J. Wysocki WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
16059ed98953SRafael J. Wysocki if (status == DL_STATE_ACTIVE) {
16069ed98953SRafael J. Wysocki struct device *consumer = link->consumer;
16079ed98953SRafael J. Wysocki
16089ed98953SRafael J. Wysocki get_device(consumer);
16099ed98953SRafael J. Wysocki
16109ed98953SRafael J. Wysocki device_links_write_unlock();
16119ed98953SRafael J. Wysocki
16129ed98953SRafael J. Wysocki device_release_driver_internal(consumer, NULL,
16139ed98953SRafael J. Wysocki consumer->parent);
16149ed98953SRafael J. Wysocki put_device(consumer);
16159ed98953SRafael J. Wysocki goto start;
16169ed98953SRafael J. Wysocki }
16179ed98953SRafael J. Wysocki }
16189ed98953SRafael J. Wysocki
16199ed98953SRafael J. Wysocki device_links_write_unlock();
16209ed98953SRafael J. Wysocki }
16219ed98953SRafael J. Wysocki
16229ed98953SRafael J. Wysocki /**
16239ed98953SRafael J. Wysocki * device_links_purge - Delete existing links to other devices.
16249ed98953SRafael J. Wysocki * @dev: Target device.
16259ed98953SRafael J. Wysocki */
device_links_purge(struct device * dev)16269ed98953SRafael J. Wysocki static void device_links_purge(struct device *dev)
16279ed98953SRafael J. Wysocki {
16289ed98953SRafael J. Wysocki struct device_link *link, *ln;
16299ed98953SRafael J. Wysocki
1630287905e6SSaravana Kannan if (dev->class == &devlink_class)
1631287905e6SSaravana Kannan return;
1632287905e6SSaravana Kannan
16339ed98953SRafael J. Wysocki /*
16349ed98953SRafael J. Wysocki * Delete all of the remaining links from this device to any other
16359ed98953SRafael J. Wysocki * devices (either consumers or suppliers).
16369ed98953SRafael J. Wysocki */
16379ed98953SRafael J. Wysocki device_links_write_lock();
16389ed98953SRafael J. Wysocki
16399ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
16409ed98953SRafael J. Wysocki WARN_ON(link->status == DL_STATE_ACTIVE);
1641ead18c23SLukas Wunner __device_link_del(&link->kref);
16429ed98953SRafael J. Wysocki }
16439ed98953SRafael J. Wysocki
16449ed98953SRafael J. Wysocki list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) {
16459ed98953SRafael J. Wysocki WARN_ON(link->status != DL_STATE_DORMANT &&
16469ed98953SRafael J. Wysocki link->status != DL_STATE_NONE);
1647ead18c23SLukas Wunner __device_link_del(&link->kref);
16489ed98953SRafael J. Wysocki }
16499ed98953SRafael J. Wysocki
16509ed98953SRafael J. Wysocki device_links_write_unlock();
16519ed98953SRafael J. Wysocki }
16529ed98953SRafael J. Wysocki
1653b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_PERMISSIVE (DL_FLAG_INFERRED | \
1654b90fb8f6SSaravana Kannan DL_FLAG_SYNC_STATE_ONLY)
1655b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_ON (DL_FLAG_INFERRED | \
1656b90fb8f6SSaravana Kannan DL_FLAG_AUTOPROBE_CONSUMER)
1657b90fb8f6SSaravana Kannan #define FW_DEVLINK_FLAGS_RPM (FW_DEVLINK_FLAGS_ON | \
1658b90fb8f6SSaravana Kannan DL_FLAG_PM_RUNTIME)
1659b90fb8f6SSaravana Kannan
1660ea718c69SSaravana Kannan static u32 fw_devlink_flags = FW_DEVLINK_FLAGS_ON;
fw_devlink_setup(char * arg)166142926ac3SSaravana Kannan static int __init fw_devlink_setup(char *arg)
166242926ac3SSaravana Kannan {
166342926ac3SSaravana Kannan if (!arg)
166442926ac3SSaravana Kannan return -EINVAL;
166542926ac3SSaravana Kannan
166642926ac3SSaravana Kannan if (strcmp(arg, "off") == 0) {
166742926ac3SSaravana Kannan fw_devlink_flags = 0;
166842926ac3SSaravana Kannan } else if (strcmp(arg, "permissive") == 0) {
1669b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_PERMISSIVE;
167042926ac3SSaravana Kannan } else if (strcmp(arg, "on") == 0) {
1671b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_ON;
167242926ac3SSaravana Kannan } else if (strcmp(arg, "rpm") == 0) {
1673b90fb8f6SSaravana Kannan fw_devlink_flags = FW_DEVLINK_FLAGS_RPM;
167442926ac3SSaravana Kannan }
167542926ac3SSaravana Kannan return 0;
167642926ac3SSaravana Kannan }
167742926ac3SSaravana Kannan early_param("fw_devlink", fw_devlink_setup);
167842926ac3SSaravana Kannan
1679d8ab4685SGreg Kroah-Hartman static bool fw_devlink_strict;
fw_devlink_strict_setup(char * arg)168019d0f5f6SSaravana Kannan static int __init fw_devlink_strict_setup(char *arg)
168119d0f5f6SSaravana Kannan {
168273060022SChristophe JAILLET return kstrtobool(arg, &fw_devlink_strict);
168319d0f5f6SSaravana Kannan }
168419d0f5f6SSaravana Kannan early_param("fw_devlink.strict", fw_devlink_strict_setup);
168519d0f5f6SSaravana Kannan
1686ffbe08a8SSaravana Kannan #define FW_DEVLINK_SYNC_STATE_STRICT 0
1687ffbe08a8SSaravana Kannan #define FW_DEVLINK_SYNC_STATE_TIMEOUT 1
1688ffbe08a8SSaravana Kannan
16898ad266d1SSaravana Kannan #ifndef CONFIG_FW_DEVLINK_SYNC_STATE_TIMEOUT
1690ffbe08a8SSaravana Kannan static int fw_devlink_sync_state;
16918ad266d1SSaravana Kannan #else
16928ad266d1SSaravana Kannan static int fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_TIMEOUT;
16938ad266d1SSaravana Kannan #endif
16948ad266d1SSaravana Kannan
fw_devlink_sync_state_setup(char * arg)1695ffbe08a8SSaravana Kannan static int __init fw_devlink_sync_state_setup(char *arg)
1696ffbe08a8SSaravana Kannan {
1697ffbe08a8SSaravana Kannan if (!arg)
1698ffbe08a8SSaravana Kannan return -EINVAL;
1699ffbe08a8SSaravana Kannan
1700ffbe08a8SSaravana Kannan if (strcmp(arg, "strict") == 0) {
1701ffbe08a8SSaravana Kannan fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_STRICT;
1702ffbe08a8SSaravana Kannan return 0;
1703ffbe08a8SSaravana Kannan } else if (strcmp(arg, "timeout") == 0) {
1704ffbe08a8SSaravana Kannan fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_TIMEOUT;
1705ffbe08a8SSaravana Kannan return 0;
1706ffbe08a8SSaravana Kannan }
1707ffbe08a8SSaravana Kannan return -EINVAL;
1708ffbe08a8SSaravana Kannan }
1709ffbe08a8SSaravana Kannan early_param("fw_devlink.sync_state", fw_devlink_sync_state_setup);
1710ffbe08a8SSaravana Kannan
fw_devlink_get_flags(u8 fwlink_flags)1711cd115c04SSaravana Kannan static inline u32 fw_devlink_get_flags(u8 fwlink_flags)
171242926ac3SSaravana Kannan {
1713cd115c04SSaravana Kannan if (fwlink_flags & FWLINK_FLAG_CYCLE)
1714cd115c04SSaravana Kannan return FW_DEVLINK_FLAGS_PERMISSIVE | DL_FLAG_CYCLE;
1715cd115c04SSaravana Kannan
171642926ac3SSaravana Kannan return fw_devlink_flags;
171742926ac3SSaravana Kannan }
171842926ac3SSaravana Kannan
fw_devlink_is_permissive(void)171942926ac3SSaravana Kannan static bool fw_devlink_is_permissive(void)
172042926ac3SSaravana Kannan {
1721b90fb8f6SSaravana Kannan return fw_devlink_flags == FW_DEVLINK_FLAGS_PERMISSIVE;
172242926ac3SSaravana Kannan }
172342926ac3SSaravana Kannan
fw_devlink_is_strict(void)172419d0f5f6SSaravana Kannan bool fw_devlink_is_strict(void)
172519d0f5f6SSaravana Kannan {
172619d0f5f6SSaravana Kannan return fw_devlink_strict && !fw_devlink_is_permissive();
17279ed98953SRafael J. Wysocki }
17289ed98953SRafael J. Wysocki
fw_devlink_parse_fwnode(struct fwnode_handle * fwnode)1729c2c724c8SSaravana Kannan static void fw_devlink_parse_fwnode(struct fwnode_handle *fwnode)
1730c2c724c8SSaravana Kannan {
1731c2c724c8SSaravana Kannan if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED)
1732c2c724c8SSaravana Kannan return;
1733c2c724c8SSaravana Kannan
17342d09e6ebSSaravana Kannan fwnode_call_int_op(fwnode, add_links);
1735c2c724c8SSaravana Kannan fwnode->flags |= FWNODE_FLAG_LINKS_ADDED;
1736c2c724c8SSaravana Kannan }
1737c2c724c8SSaravana Kannan
fw_devlink_parse_fwtree(struct fwnode_handle * fwnode)1738c2c724c8SSaravana Kannan static void fw_devlink_parse_fwtree(struct fwnode_handle *fwnode)
1739c2c724c8SSaravana Kannan {
1740c2c724c8SSaravana Kannan struct fwnode_handle *child = NULL;
1741c2c724c8SSaravana Kannan
1742c2c724c8SSaravana Kannan fw_devlink_parse_fwnode(fwnode);
1743c2c724c8SSaravana Kannan
1744c2c724c8SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child)))
1745c2c724c8SSaravana Kannan fw_devlink_parse_fwtree(child);
1746c2c724c8SSaravana Kannan }
1747c2c724c8SSaravana Kannan
fw_devlink_relax_link(struct device_link * link)1748d46f3e3eSSaravana Kannan static void fw_devlink_relax_link(struct device_link *link)
1749d46f3e3eSSaravana Kannan {
1750d46f3e3eSSaravana Kannan if (!(link->flags & DL_FLAG_INFERRED))
1751d46f3e3eSSaravana Kannan return;
1752d46f3e3eSSaravana Kannan
175367cad5c6SSaravana Kannan if (device_link_flag_is_sync_state_only(link->flags))
1754d46f3e3eSSaravana Kannan return;
1755d46f3e3eSSaravana Kannan
1756d46f3e3eSSaravana Kannan pm_runtime_drop_link(link);
1757d46f3e3eSSaravana Kannan link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE;
1758d46f3e3eSSaravana Kannan dev_dbg(link->consumer, "Relaxing link with %s\n",
1759d46f3e3eSSaravana Kannan dev_name(link->supplier));
1760d46f3e3eSSaravana Kannan }
1761d46f3e3eSSaravana Kannan
fw_devlink_no_driver(struct device * dev,void * data)1762d46f3e3eSSaravana Kannan static int fw_devlink_no_driver(struct device *dev, void *data)
1763d46f3e3eSSaravana Kannan {
1764d46f3e3eSSaravana Kannan struct device_link *link = to_devlink(dev);
1765d46f3e3eSSaravana Kannan
1766d46f3e3eSSaravana Kannan if (!link->supplier->can_match)
1767d46f3e3eSSaravana Kannan fw_devlink_relax_link(link);
1768d46f3e3eSSaravana Kannan
1769d46f3e3eSSaravana Kannan return 0;
1770d46f3e3eSSaravana Kannan }
1771d46f3e3eSSaravana Kannan
fw_devlink_drivers_done(void)1772d46f3e3eSSaravana Kannan void fw_devlink_drivers_done(void)
1773d46f3e3eSSaravana Kannan {
1774d46f3e3eSSaravana Kannan fw_devlink_drv_reg_done = true;
1775d46f3e3eSSaravana Kannan device_links_write_lock();
1776d46f3e3eSSaravana Kannan class_for_each_device(&devlink_class, NULL, NULL,
1777d46f3e3eSSaravana Kannan fw_devlink_no_driver);
1778d46f3e3eSSaravana Kannan device_links_write_unlock();
1779d46f3e3eSSaravana Kannan }
1780d46f3e3eSSaravana Kannan
fw_devlink_dev_sync_state(struct device * dev,void * data)1781ffbe08a8SSaravana Kannan static int fw_devlink_dev_sync_state(struct device *dev, void *data)
1782ffbe08a8SSaravana Kannan {
1783ffbe08a8SSaravana Kannan struct device_link *link = to_devlink(dev);
1784ffbe08a8SSaravana Kannan struct device *sup = link->supplier;
1785ffbe08a8SSaravana Kannan
1786ffbe08a8SSaravana Kannan if (!(link->flags & DL_FLAG_MANAGED) ||
1787ffbe08a8SSaravana Kannan link->status == DL_STATE_ACTIVE || sup->state_synced ||
1788ffbe08a8SSaravana Kannan !dev_has_sync_state(sup))
1789ffbe08a8SSaravana Kannan return 0;
1790ffbe08a8SSaravana Kannan
1791ffbe08a8SSaravana Kannan if (fw_devlink_sync_state == FW_DEVLINK_SYNC_STATE_STRICT) {
1792ffbe08a8SSaravana Kannan dev_warn(sup, "sync_state() pending due to %s\n",
1793ffbe08a8SSaravana Kannan dev_name(link->consumer));
1794ffbe08a8SSaravana Kannan return 0;
1795ffbe08a8SSaravana Kannan }
1796ffbe08a8SSaravana Kannan
1797ffbe08a8SSaravana Kannan if (!list_empty(&sup->links.defer_sync))
1798ffbe08a8SSaravana Kannan return 0;
1799ffbe08a8SSaravana Kannan
1800ffbe08a8SSaravana Kannan dev_warn(sup, "Timed out. Forcing sync_state()\n");
1801ffbe08a8SSaravana Kannan sup->state_synced = true;
1802ffbe08a8SSaravana Kannan get_device(sup);
1803ffbe08a8SSaravana Kannan list_add_tail(&sup->links.defer_sync, data);
1804ffbe08a8SSaravana Kannan
1805ffbe08a8SSaravana Kannan return 0;
1806ffbe08a8SSaravana Kannan }
1807ffbe08a8SSaravana Kannan
fw_devlink_probing_done(void)1808ffbe08a8SSaravana Kannan void fw_devlink_probing_done(void)
1809ffbe08a8SSaravana Kannan {
1810ffbe08a8SSaravana Kannan LIST_HEAD(sync_list);
1811ffbe08a8SSaravana Kannan
1812ffbe08a8SSaravana Kannan device_links_write_lock();
1813ffbe08a8SSaravana Kannan class_for_each_device(&devlink_class, NULL, &sync_list,
1814ffbe08a8SSaravana Kannan fw_devlink_dev_sync_state);
1815ffbe08a8SSaravana Kannan device_links_write_unlock();
1816ffbe08a8SSaravana Kannan device_links_flush_sync_list(&sync_list, NULL);
1817ffbe08a8SSaravana Kannan }
1818ffbe08a8SSaravana Kannan
18192f8c3ae8SSaravana Kannan /**
18202f8c3ae8SSaravana Kannan * wait_for_init_devices_probe - Try to probe any device needed for init
18212f8c3ae8SSaravana Kannan *
18222f8c3ae8SSaravana Kannan * Some devices might need to be probed and bound successfully before the kernel
18232f8c3ae8SSaravana Kannan * boot sequence can finish and move on to init/userspace. For example, a
18242f8c3ae8SSaravana Kannan * network interface might need to be bound to be able to mount a NFS rootfs.
18252f8c3ae8SSaravana Kannan *
18262f8c3ae8SSaravana Kannan * With fw_devlink=on by default, some of these devices might be blocked from
18272f8c3ae8SSaravana Kannan * probing because they are waiting on a optional supplier that doesn't have a
18282f8c3ae8SSaravana Kannan * driver. While fw_devlink will eventually identify such devices and unblock
18292f8c3ae8SSaravana Kannan * the probing automatically, it might be too late by the time it unblocks the
18302f8c3ae8SSaravana Kannan * probing of devices. For example, the IP4 autoconfig might timeout before
18312f8c3ae8SSaravana Kannan * fw_devlink unblocks probing of the network interface.
18322f8c3ae8SSaravana Kannan *
18332f8c3ae8SSaravana Kannan * This function is available to temporarily try and probe all devices that have
18342f8c3ae8SSaravana Kannan * a driver even if some of their suppliers haven't been added or don't have
18352f8c3ae8SSaravana Kannan * drivers.
18362f8c3ae8SSaravana Kannan *
18372f8c3ae8SSaravana Kannan * The drivers can then decide which of the suppliers are optional vs mandatory
18382f8c3ae8SSaravana Kannan * and probe the device if possible. By the time this function returns, all such
18392f8c3ae8SSaravana Kannan * "best effort" probes are guaranteed to be completed. If a device successfully
18402f8c3ae8SSaravana Kannan * probes in this mode, we delete all fw_devlink discovered dependencies of that
18412f8c3ae8SSaravana Kannan * device where the supplier hasn't yet probed successfully because they have to
18422f8c3ae8SSaravana Kannan * be optional dependencies.
18432f8c3ae8SSaravana Kannan *
18442f8c3ae8SSaravana Kannan * Any devices that didn't successfully probe go back to being treated as if
18452f8c3ae8SSaravana Kannan * this function was never called.
18462f8c3ae8SSaravana Kannan *
18472f8c3ae8SSaravana Kannan * This also means that some devices that aren't needed for init and could have
18482f8c3ae8SSaravana Kannan * waited for their optional supplier to probe (when the supplier's module is
18492f8c3ae8SSaravana Kannan * loaded later on) would end up probing prematurely with limited functionality.
18502f8c3ae8SSaravana Kannan * So call this function only when boot would fail without it.
18512f8c3ae8SSaravana Kannan */
wait_for_init_devices_probe(void)18522f8c3ae8SSaravana Kannan void __init wait_for_init_devices_probe(void)
18532f8c3ae8SSaravana Kannan {
18542f8c3ae8SSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive())
18552f8c3ae8SSaravana Kannan return;
18562f8c3ae8SSaravana Kannan
18572f8c3ae8SSaravana Kannan /*
18582f8c3ae8SSaravana Kannan * Wait for all ongoing probes to finish so that the "best effort" is
18592f8c3ae8SSaravana Kannan * only applied to devices that can't probe otherwise.
18602f8c3ae8SSaravana Kannan */
18612f8c3ae8SSaravana Kannan wait_for_device_probe();
18622f8c3ae8SSaravana Kannan
18632f8c3ae8SSaravana Kannan pr_info("Trying to probe devices needed for running init ...\n");
18642f8c3ae8SSaravana Kannan fw_devlink_best_effort = true;
18652f8c3ae8SSaravana Kannan driver_deferred_probe_trigger();
18662f8c3ae8SSaravana Kannan
18672f8c3ae8SSaravana Kannan /*
18682f8c3ae8SSaravana Kannan * Wait for all "best effort" probes to finish before going back to
18692f8c3ae8SSaravana Kannan * normal enforcement.
18702f8c3ae8SSaravana Kannan */
18712f8c3ae8SSaravana Kannan wait_for_device_probe();
18722f8c3ae8SSaravana Kannan fw_devlink_best_effort = false;
18732f8c3ae8SSaravana Kannan }
18742f8c3ae8SSaravana Kannan
fw_devlink_unblock_consumers(struct device * dev)1875d46f3e3eSSaravana Kannan static void fw_devlink_unblock_consumers(struct device *dev)
1876d46f3e3eSSaravana Kannan {
1877d46f3e3eSSaravana Kannan struct device_link *link;
1878d46f3e3eSSaravana Kannan
1879d46f3e3eSSaravana Kannan if (!fw_devlink_flags || fw_devlink_is_permissive())
1880d46f3e3eSSaravana Kannan return;
1881d46f3e3eSSaravana Kannan
1882d46f3e3eSSaravana Kannan device_links_write_lock();
1883d46f3e3eSSaravana Kannan list_for_each_entry(link, &dev->links.consumers, s_node)
1884d46f3e3eSSaravana Kannan fw_devlink_relax_link(link);
1885d46f3e3eSSaravana Kannan device_links_write_unlock();
1886d46f3e3eSSaravana Kannan }
1887d46f3e3eSSaravana Kannan
1888b0e2fa4fSSaravana Kannan
fwnode_init_without_drv(struct fwnode_handle * fwnode)1889411c0d58SSaravana Kannan static bool fwnode_init_without_drv(struct fwnode_handle *fwnode)
1890b0e2fa4fSSaravana Kannan {
1891411c0d58SSaravana Kannan struct device *dev;
1892411c0d58SSaravana Kannan bool ret;
1893b0e2fa4fSSaravana Kannan
1894411c0d58SSaravana Kannan if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED))
1895411c0d58SSaravana Kannan return false;
1896b0e2fa4fSSaravana Kannan
1897411c0d58SSaravana Kannan dev = get_dev_from_fwnode(fwnode);
1898411c0d58SSaravana Kannan ret = !dev || dev->links.status == DL_DEV_NO_DRIVER;
1899411c0d58SSaravana Kannan put_device(dev);
1900411c0d58SSaravana Kannan
1901b0e2fa4fSSaravana Kannan return ret;
1902b0e2fa4fSSaravana Kannan }
1903411c0d58SSaravana Kannan
fwnode_ancestor_init_without_drv(struct fwnode_handle * fwnode)1904411c0d58SSaravana Kannan static bool fwnode_ancestor_init_without_drv(struct fwnode_handle *fwnode)
1905411c0d58SSaravana Kannan {
1906411c0d58SSaravana Kannan struct fwnode_handle *parent;
1907411c0d58SSaravana Kannan
1908411c0d58SSaravana Kannan fwnode_for_each_parent_node(fwnode, parent) {
1909411c0d58SSaravana Kannan if (fwnode_init_without_drv(parent)) {
1910411c0d58SSaravana Kannan fwnode_handle_put(parent);
1911411c0d58SSaravana Kannan return true;
1912411c0d58SSaravana Kannan }
1913411c0d58SSaravana Kannan }
1914411c0d58SSaravana Kannan
1915411c0d58SSaravana Kannan return false;
1916411c0d58SSaravana Kannan }
1917411c0d58SSaravana Kannan
1918b0e2fa4fSSaravana Kannan /**
19193fb16866SSaravana Kannan * __fw_devlink_relax_cycles - Relax and mark dependency cycles.
19203fb16866SSaravana Kannan * @con: Potential consumer device.
19213fb16866SSaravana Kannan * @sup_handle: Potential supplier's fwnode.
19223fb16866SSaravana Kannan *
19233fb16866SSaravana Kannan * Needs to be called with fwnode_lock and device link lock held.
19243fb16866SSaravana Kannan *
19253fb16866SSaravana Kannan * Check if @sup_handle or any of its ancestors or suppliers direct/indirectly
19263fb16866SSaravana Kannan * depend on @con. This function can detect multiple cyles between @sup_handle
19273fb16866SSaravana Kannan * and @con. When such dependency cycles are found, convert all device links
19283fb16866SSaravana Kannan * created solely by fw_devlink into SYNC_STATE_ONLY device links. Also, mark
19293fb16866SSaravana Kannan * all fwnode links in the cycle with FWLINK_FLAG_CYCLE so that when they are
19303fb16866SSaravana Kannan * converted into a device link in the future, they are created as
19313fb16866SSaravana Kannan * SYNC_STATE_ONLY device links. This is the equivalent of doing
19323fb16866SSaravana Kannan * fw_devlink=permissive just between the devices in the cycle. We need to do
19333fb16866SSaravana Kannan * this because, at this point, fw_devlink can't tell which of these
19343fb16866SSaravana Kannan * dependencies is not a real dependency.
19353fb16866SSaravana Kannan *
19363fb16866SSaravana Kannan * Return true if one or more cycles were found. Otherwise, return false.
19373fb16866SSaravana Kannan */
__fw_devlink_relax_cycles(struct device * con,struct fwnode_handle * sup_handle)19383fb16866SSaravana Kannan static bool __fw_devlink_relax_cycles(struct device *con,
19393fb16866SSaravana Kannan struct fwnode_handle *sup_handle)
19403fb16866SSaravana Kannan {
19413fb16866SSaravana Kannan struct device *sup_dev = NULL, *par_dev = NULL;
19423fb16866SSaravana Kannan struct fwnode_link *link;
19433fb16866SSaravana Kannan struct device_link *dev_link;
19443fb16866SSaravana Kannan bool ret = false;
19453fb16866SSaravana Kannan
19463fb16866SSaravana Kannan if (!sup_handle)
19473fb16866SSaravana Kannan return false;
19483fb16866SSaravana Kannan
19493fb16866SSaravana Kannan /*
19503fb16866SSaravana Kannan * We aren't trying to find all cycles. Just a cycle between con and
19513fb16866SSaravana Kannan * sup_handle.
19523fb16866SSaravana Kannan */
19533fb16866SSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_VISITED)
19543fb16866SSaravana Kannan return false;
19553fb16866SSaravana Kannan
19563fb16866SSaravana Kannan sup_handle->flags |= FWNODE_FLAG_VISITED;
19573fb16866SSaravana Kannan
19583fb16866SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle);
19593fb16866SSaravana Kannan
19603fb16866SSaravana Kannan /* Termination condition. */
19613fb16866SSaravana Kannan if (sup_dev == con) {
19623fb16866SSaravana Kannan ret = true;
19633fb16866SSaravana Kannan goto out;
19643fb16866SSaravana Kannan }
19653fb16866SSaravana Kannan
19663fb16866SSaravana Kannan /*
19673fb16866SSaravana Kannan * If sup_dev is bound to a driver and @con hasn't started binding to a
19683fb16866SSaravana Kannan * driver, sup_dev can't be a consumer of @con. So, no need to check
19693fb16866SSaravana Kannan * further.
19703fb16866SSaravana Kannan */
19713fb16866SSaravana Kannan if (sup_dev && sup_dev->links.status == DL_DEV_DRIVER_BOUND &&
19723fb16866SSaravana Kannan con->links.status == DL_DEV_NO_DRIVER) {
19733fb16866SSaravana Kannan ret = false;
19743fb16866SSaravana Kannan goto out;
19753fb16866SSaravana Kannan }
19763fb16866SSaravana Kannan
19773fb16866SSaravana Kannan list_for_each_entry(link, &sup_handle->suppliers, c_hook) {
19783fb16866SSaravana Kannan if (__fw_devlink_relax_cycles(con, link->supplier)) {
19793fb16866SSaravana Kannan __fwnode_link_cycle(link);
19803fb16866SSaravana Kannan ret = true;
19813fb16866SSaravana Kannan }
19823fb16866SSaravana Kannan }
19833fb16866SSaravana Kannan
19843fb16866SSaravana Kannan /*
19853fb16866SSaravana Kannan * Give priority to device parent over fwnode parent to account for any
19863fb16866SSaravana Kannan * quirks in how fwnodes are converted to devices.
19873fb16866SSaravana Kannan */
19883fb16866SSaravana Kannan if (sup_dev)
19893fb16866SSaravana Kannan par_dev = get_device(sup_dev->parent);
19903fb16866SSaravana Kannan else
19913fb16866SSaravana Kannan par_dev = fwnode_get_next_parent_dev(sup_handle);
19923fb16866SSaravana Kannan
19933fb16866SSaravana Kannan if (par_dev && __fw_devlink_relax_cycles(con, par_dev->fwnode))
19943fb16866SSaravana Kannan ret = true;
19953fb16866SSaravana Kannan
19963fb16866SSaravana Kannan if (!sup_dev)
19973fb16866SSaravana Kannan goto out;
19983fb16866SSaravana Kannan
19993fb16866SSaravana Kannan list_for_each_entry(dev_link, &sup_dev->links.suppliers, c_node) {
20003fb16866SSaravana Kannan /*
20013fb16866SSaravana Kannan * Ignore a SYNC_STATE_ONLY flag only if it wasn't marked as
20023fb16866SSaravana Kannan * such due to a cycle.
20033fb16866SSaravana Kannan */
20043fb16866SSaravana Kannan if (device_link_flag_is_sync_state_only(dev_link->flags) &&
20053fb16866SSaravana Kannan !(dev_link->flags & DL_FLAG_CYCLE))
20063fb16866SSaravana Kannan continue;
20073fb16866SSaravana Kannan
20083fb16866SSaravana Kannan if (__fw_devlink_relax_cycles(con,
20093fb16866SSaravana Kannan dev_link->supplier->fwnode)) {
20103fb16866SSaravana Kannan fw_devlink_relax_link(dev_link);
20113fb16866SSaravana Kannan dev_link->flags |= DL_FLAG_CYCLE;
20123fb16866SSaravana Kannan ret = true;
20133fb16866SSaravana Kannan }
20143fb16866SSaravana Kannan }
20153fb16866SSaravana Kannan
20163fb16866SSaravana Kannan out:
20173fb16866SSaravana Kannan sup_handle->flags &= ~FWNODE_FLAG_VISITED;
20183fb16866SSaravana Kannan put_device(sup_dev);
20193fb16866SSaravana Kannan put_device(par_dev);
20209ed98953SRafael J. Wysocki return ret;
20211da177e4SLinus Torvalds }
20221da177e4SLinus Torvalds
2023f9aa4606SSaravana Kannan /**
2024f9aa4606SSaravana Kannan * fw_devlink_create_devlink - Create a device link from a consumer to fwnode
202537c52f74SPierre-Louis Bossart * @con: consumer device for the device link
202637c52f74SPierre-Louis Bossart * @sup_handle: fwnode handle of supplier
2027cd115c04SSaravana Kannan * @link: fwnode link that's being converted to a device link
2028f9aa4606SSaravana Kannan *
2029f9aa4606SSaravana Kannan * This function will try to create a device link between the consumer device
2030f9aa4606SSaravana Kannan * @con and the supplier device represented by @sup_handle.
2031f9aa4606SSaravana Kannan *
2032f9aa4606SSaravana Kannan * The supplier has to be provided as a fwnode because incorrect cycles in
2033f9aa4606SSaravana Kannan * fwnode links can sometimes cause the supplier device to never be created.
2034f9aa4606SSaravana Kannan * This function detects such cases and returns an error if it cannot create a
2035f9aa4606SSaravana Kannan * device link from the consumer to a missing supplier.
2036f9aa4606SSaravana Kannan *
2037f9aa4606SSaravana Kannan * Returns,
2038f9aa4606SSaravana Kannan * 0 on successfully creating a device link
2039f9aa4606SSaravana Kannan * -EINVAL if the device link cannot be created as expected
2040f9aa4606SSaravana Kannan * -EAGAIN if the device link cannot be created right now, but it may be
2041f9aa4606SSaravana Kannan * possible to do that in the future
2042f9aa4606SSaravana Kannan */
fw_devlink_create_devlink(struct device * con,struct fwnode_handle * sup_handle,struct fwnode_link * link)2043f9aa4606SSaravana Kannan static int fw_devlink_create_devlink(struct device *con,
2044cd115c04SSaravana Kannan struct fwnode_handle *sup_handle,
2045cd115c04SSaravana Kannan struct fwnode_link *link)
2046f9aa4606SSaravana Kannan {
2047f9aa4606SSaravana Kannan struct device *sup_dev;
2048f9aa4606SSaravana Kannan int ret = 0;
2049cd115c04SSaravana Kannan u32 flags;
2050cd115c04SSaravana Kannan
2051cd115c04SSaravana Kannan if (con->fwnode == link->consumer)
2052cd115c04SSaravana Kannan flags = fw_devlink_get_flags(link->flags);
2053cd115c04SSaravana Kannan else
2054cd115c04SSaravana Kannan flags = FW_DEVLINK_FLAGS_PERMISSIVE;
2055f9aa4606SSaravana Kannan
20565501765aSSaravana Kannan /*
20575501765aSSaravana Kannan * In some cases, a device P might also be a supplier to its child node
20585501765aSSaravana Kannan * C. However, this would defer the probe of C until the probe of P
20595501765aSSaravana Kannan * completes successfully. This is perfectly fine in the device driver
20605501765aSSaravana Kannan * model. device_add() doesn't guarantee probe completion of the device
20615501765aSSaravana Kannan * by the time it returns.
20625501765aSSaravana Kannan *
20635501765aSSaravana Kannan * However, there are a few drivers that assume C will finish probing
20645501765aSSaravana Kannan * as soon as it's added and before P finishes probing. So, we provide
20655501765aSSaravana Kannan * a flag to let fw_devlink know not to delay the probe of C until the
20665501765aSSaravana Kannan * probe of P completes successfully.
20675501765aSSaravana Kannan *
20685501765aSSaravana Kannan * When such a flag is set, we can't create device links where P is the
20695501765aSSaravana Kannan * supplier of C as that would delay the probe of C.
20705501765aSSaravana Kannan */
20715501765aSSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD &&
20725501765aSSaravana Kannan fwnode_is_ancestor_of(sup_handle, con->fwnode))
20735501765aSSaravana Kannan return -EINVAL;
20745501765aSSaravana Kannan
20753fb16866SSaravana Kannan /*
20763fb16866SSaravana Kannan * SYNC_STATE_ONLY device links don't block probing and supports cycles.
207722920e41SSaravana Kannan * So, one might expect that cycle detection isn't necessary for them.
207822920e41SSaravana Kannan * However, if the device link was marked as SYNC_STATE_ONLY because
207922920e41SSaravana Kannan * it's part of a cycle, then we still need to do cycle detection. This
208022920e41SSaravana Kannan * is because the consumer and supplier might be part of multiple cycles
208122920e41SSaravana Kannan * and we need to detect all those cycles.
20823fb16866SSaravana Kannan */
208322920e41SSaravana Kannan if (!device_link_flag_is_sync_state_only(flags) ||
208422920e41SSaravana Kannan flags & DL_FLAG_CYCLE) {
20853fb16866SSaravana Kannan device_links_write_lock();
20863fb16866SSaravana Kannan if (__fw_devlink_relax_cycles(con, sup_handle)) {
20873fb16866SSaravana Kannan __fwnode_link_cycle(link);
20883fb16866SSaravana Kannan flags = fw_devlink_get_flags(link->flags);
20893fb16866SSaravana Kannan dev_info(con, "Fixed dependency cycle(s) with %pfwf\n",
20903fb16866SSaravana Kannan sup_handle);
20913fb16866SSaravana Kannan }
20923fb16866SSaravana Kannan device_links_write_unlock();
20933fb16866SSaravana Kannan }
20943fb16866SSaravana Kannan
20953a2dbc51SSaravana Kannan if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE)
20963a2dbc51SSaravana Kannan sup_dev = fwnode_get_next_parent_dev(sup_handle);
20973a2dbc51SSaravana Kannan else
2098f9aa4606SSaravana Kannan sup_dev = get_dev_from_fwnode(sup_handle);
20993a2dbc51SSaravana Kannan
2100f9aa4606SSaravana Kannan if (sup_dev) {
2101f9aa4606SSaravana Kannan /*
210274c782cfSSaravana Kannan * If it's one of those drivers that don't actually bind to
210374c782cfSSaravana Kannan * their device using driver core, then don't wait on this
210474c782cfSSaravana Kannan * supplier device indefinitely.
210574c782cfSSaravana Kannan */
210674c782cfSSaravana Kannan if (sup_dev->links.status == DL_DEV_NO_DRIVER &&
210774c782cfSSaravana Kannan sup_handle->flags & FWNODE_FLAG_INITIALIZED) {
21083fb16866SSaravana Kannan dev_dbg(con,
21093fb16866SSaravana Kannan "Not linking %pfwf - dev might never probe\n",
21103fb16866SSaravana Kannan sup_handle);
211174c782cfSSaravana Kannan ret = -EINVAL;
211274c782cfSSaravana Kannan goto out;
211374c782cfSSaravana Kannan }
211474c782cfSSaravana Kannan
211563098724SSaravana Kannan if (con != sup_dev && !device_link_add(con, sup_dev, flags)) {
211663098724SSaravana Kannan dev_err(con, "Failed to create device link (0x%x) with %s\n",
211763098724SSaravana Kannan flags, dev_name(sup_dev));
2118f9aa4606SSaravana Kannan ret = -EINVAL;
2119b0e2fa4fSSaravana Kannan }
2120f9aa4606SSaravana Kannan
2121f9aa4606SSaravana Kannan goto out;
2122f9aa4606SSaravana Kannan }
2123f9aa4606SSaravana Kannan
2124411c0d58SSaravana Kannan /*
2125411c0d58SSaravana Kannan * Supplier or supplier's ancestor already initialized without a struct
2126411c0d58SSaravana Kannan * device or being probed by a driver.
2127411c0d58SSaravana Kannan */
2128411c0d58SSaravana Kannan if (fwnode_init_without_drv(sup_handle) ||
2129411c0d58SSaravana Kannan fwnode_ancestor_init_without_drv(sup_handle)) {
21303fb16866SSaravana Kannan dev_dbg(con, "Not linking %pfwf - might never become dev\n",
2131411c0d58SSaravana Kannan sup_handle);
213274c782cfSSaravana Kannan return -EINVAL;
2133f9aa4606SSaravana Kannan }
2134f9aa4606SSaravana Kannan
2135f9aa4606SSaravana Kannan ret = -EAGAIN;
2136f9aa4606SSaravana Kannan out:
2137f9aa4606SSaravana Kannan put_device(sup_dev);
2138f9aa4606SSaravana Kannan return ret;
2139f9aa4606SSaravana Kannan }
2140f9aa4606SSaravana Kannan
2141f9aa4606SSaravana Kannan /**
2142f9aa4606SSaravana Kannan * __fw_devlink_link_to_consumers - Create device links to consumers of a device
214337c52f74SPierre-Louis Bossart * @dev: Device that needs to be linked to its consumers
2144f9aa4606SSaravana Kannan *
2145f9aa4606SSaravana Kannan * This function looks at all the consumer fwnodes of @dev and creates device
2146f9aa4606SSaravana Kannan * links between the consumer device and @dev (supplier).
2147f9aa4606SSaravana Kannan *
2148f9aa4606SSaravana Kannan * If the consumer device has not been added yet, then this function creates a
2149f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link between @dev (supplier) and the closest ancestor device
2150f9aa4606SSaravana Kannan * of the consumer fwnode. This is necessary to make sure @dev doesn't get a
2151f9aa4606SSaravana Kannan * sync_state() callback before the real consumer device gets to be added and
2152f9aa4606SSaravana Kannan * then probed.
2153f9aa4606SSaravana Kannan *
2154f9aa4606SSaravana Kannan * Once device links are created from the real consumer to @dev (supplier), the
2155f9aa4606SSaravana Kannan * fwnode links are deleted.
2156f9aa4606SSaravana Kannan */
__fw_devlink_link_to_consumers(struct device * dev)2157f9aa4606SSaravana Kannan static void __fw_devlink_link_to_consumers(struct device *dev)
2158f9aa4606SSaravana Kannan {
2159f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode;
2160f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp;
2161f9aa4606SSaravana Kannan
2162f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) {
2163f9aa4606SSaravana Kannan struct device *con_dev;
2164f9aa4606SSaravana Kannan bool own_link = true;
2165f9aa4606SSaravana Kannan int ret;
2166f9aa4606SSaravana Kannan
2167f9aa4606SSaravana Kannan con_dev = get_dev_from_fwnode(link->consumer);
2168f9aa4606SSaravana Kannan /*
2169f9aa4606SSaravana Kannan * If consumer device is not available yet, make a "proxy"
2170f9aa4606SSaravana Kannan * SYNC_STATE_ONLY link from the consumer's parent device to
2171f9aa4606SSaravana Kannan * the supplier device. This is necessary to make sure the
2172f9aa4606SSaravana Kannan * supplier doesn't get a sync_state() callback before the real
2173f9aa4606SSaravana Kannan * consumer can create a device link to the supplier.
2174f9aa4606SSaravana Kannan *
2175f9aa4606SSaravana Kannan * This proxy link step is needed to handle the case where the
2176f9aa4606SSaravana Kannan * consumer's parent device is added before the supplier.
2177f9aa4606SSaravana Kannan */
2178f9aa4606SSaravana Kannan if (!con_dev) {
2179f9aa4606SSaravana Kannan con_dev = fwnode_get_next_parent_dev(link->consumer);
2180f9aa4606SSaravana Kannan /*
2181f9aa4606SSaravana Kannan * However, if the consumer's parent device is also the
2182f9aa4606SSaravana Kannan * parent of the supplier, don't create a
2183f9aa4606SSaravana Kannan * consumer-supplier link from the parent to its child
2184f9aa4606SSaravana Kannan * device. Such a dependency is impossible.
2185f9aa4606SSaravana Kannan */
2186f9aa4606SSaravana Kannan if (con_dev &&
2187f9aa4606SSaravana Kannan fwnode_is_ancestor_of(con_dev->fwnode, fwnode)) {
2188f9aa4606SSaravana Kannan put_device(con_dev);
2189f9aa4606SSaravana Kannan con_dev = NULL;
2190f9aa4606SSaravana Kannan } else {
2191f9aa4606SSaravana Kannan own_link = false;
2192f9aa4606SSaravana Kannan }
2193f9aa4606SSaravana Kannan }
2194f9aa4606SSaravana Kannan
2195f9aa4606SSaravana Kannan if (!con_dev)
2196f9aa4606SSaravana Kannan continue;
2197f9aa4606SSaravana Kannan
2198cd115c04SSaravana Kannan ret = fw_devlink_create_devlink(con_dev, fwnode, link);
2199f9aa4606SSaravana Kannan put_device(con_dev);
2200f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN)
2201f9aa4606SSaravana Kannan continue;
2202f9aa4606SSaravana Kannan
220376f13081SSaravana Kannan __fwnode_link_del(link);
2204f9aa4606SSaravana Kannan }
2205f9aa4606SSaravana Kannan }
2206f9aa4606SSaravana Kannan
2207f9aa4606SSaravana Kannan /**
2208f9aa4606SSaravana Kannan * __fw_devlink_link_to_suppliers - Create device links to suppliers of a device
220937c52f74SPierre-Louis Bossart * @dev: The consumer device that needs to be linked to its suppliers
221037c52f74SPierre-Louis Bossart * @fwnode: Root of the fwnode tree that is used to create device links
2211f9aa4606SSaravana Kannan *
2212f9aa4606SSaravana Kannan * This function looks at all the supplier fwnodes of fwnode tree rooted at
2213f9aa4606SSaravana Kannan * @fwnode and creates device links between @dev (consumer) and all the
2214f9aa4606SSaravana Kannan * supplier devices of the entire fwnode tree at @fwnode.
2215f9aa4606SSaravana Kannan *
2216f9aa4606SSaravana Kannan * The function creates normal (non-SYNC_STATE_ONLY) device links between @dev
2217f9aa4606SSaravana Kannan * and the real suppliers of @dev. Once these device links are created, the
22183fb16866SSaravana Kannan * fwnode links are deleted.
2219f9aa4606SSaravana Kannan *
2220f9aa4606SSaravana Kannan * In addition, it also looks at all the suppliers of the entire fwnode tree
2221f9aa4606SSaravana Kannan * because some of the child devices of @dev that have not been added yet
2222f9aa4606SSaravana Kannan * (because @dev hasn't probed) might already have their suppliers added to
2223f9aa4606SSaravana Kannan * driver core. So, this function creates SYNC_STATE_ONLY device links between
2224f9aa4606SSaravana Kannan * @dev (consumer) and these suppliers to make sure they don't execute their
2225f9aa4606SSaravana Kannan * sync_state() callbacks before these child devices have a chance to create
2226f9aa4606SSaravana Kannan * their device links. The fwnode links that correspond to the child devices
2227f9aa4606SSaravana Kannan * aren't delete because they are needed later to create the device links
2228f9aa4606SSaravana Kannan * between the real consumer and supplier devices.
2229f9aa4606SSaravana Kannan */
__fw_devlink_link_to_suppliers(struct device * dev,struct fwnode_handle * fwnode)2230f9aa4606SSaravana Kannan static void __fw_devlink_link_to_suppliers(struct device *dev,
2231f9aa4606SSaravana Kannan struct fwnode_handle *fwnode)
2232f9aa4606SSaravana Kannan {
2233f9aa4606SSaravana Kannan bool own_link = (dev->fwnode == fwnode);
2234f9aa4606SSaravana Kannan struct fwnode_link *link, *tmp;
2235f9aa4606SSaravana Kannan struct fwnode_handle *child = NULL;
2236f9aa4606SSaravana Kannan
2237f9aa4606SSaravana Kannan list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) {
2238f9aa4606SSaravana Kannan int ret;
2239f9aa4606SSaravana Kannan struct fwnode_handle *sup = link->supplier;
2240f9aa4606SSaravana Kannan
2241cd115c04SSaravana Kannan ret = fw_devlink_create_devlink(dev, sup, link);
2242f9aa4606SSaravana Kannan if (!own_link || ret == -EAGAIN)
2243f9aa4606SSaravana Kannan continue;
2244f9aa4606SSaravana Kannan
224576f13081SSaravana Kannan __fwnode_link_del(link);
2246f9aa4606SSaravana Kannan }
2247f9aa4606SSaravana Kannan
2248f9aa4606SSaravana Kannan /*
2249f9aa4606SSaravana Kannan * Make "proxy" SYNC_STATE_ONLY device links to represent the needs of
2250f9aa4606SSaravana Kannan * all the descendants. This proxy link step is needed to handle the
2251f9aa4606SSaravana Kannan * case where the supplier is added before the consumer's parent device
2252f9aa4606SSaravana Kannan * (@dev).
2253f9aa4606SSaravana Kannan */
2254f9aa4606SSaravana Kannan while ((child = fwnode_get_next_available_child_node(fwnode, child)))
2255f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, child);
2256f9aa4606SSaravana Kannan }
2257f9aa4606SSaravana Kannan
fw_devlink_link_device(struct device * dev)22581da177e4SLinus Torvalds static void fw_devlink_link_device(struct device *dev)
22591da177e4SLinus Torvalds {
2260f9aa4606SSaravana Kannan struct fwnode_handle *fwnode = dev->fwnode;
22611da177e4SLinus Torvalds
2262f9aa4606SSaravana Kannan if (!fw_devlink_flags)
2263f9aa4606SSaravana Kannan return;
22641da177e4SLinus Torvalds
2265f9aa4606SSaravana Kannan fw_devlink_parse_fwtree(fwnode);
2266f9aa4606SSaravana Kannan
2267f9aa4606SSaravana Kannan mutex_lock(&fwnode_link_lock);
2268f9aa4606SSaravana Kannan __fw_devlink_link_to_consumers(dev);
2269f9aa4606SSaravana Kannan __fw_devlink_link_to_suppliers(dev, fwnode);
2270f9aa4606SSaravana Kannan mutex_unlock(&fwnode_link_lock);
22711da177e4SLinus Torvalds }
22721da177e4SLinus Torvalds
22731da177e4SLinus Torvalds /* Device links support end. */
22741da177e4SLinus Torvalds
22751da177e4SLinus Torvalds int (*platform_notify)(struct device *dev) = NULL;
22761da177e4SLinus Torvalds int (*platform_notify_remove)(struct device *dev) = NULL;
22771da177e4SLinus Torvalds static struct kobject *dev_kobj;
2278980c0561SGreg Kroah-Hartman
2279980c0561SGreg Kroah-Hartman /* /sys/dev/char */
2280980c0561SGreg Kroah-Hartman static struct kobject *sysfs_dev_char_kobj;
2281575ab414SGreg Kroah-Hartman
2282575ab414SGreg Kroah-Hartman /* /sys/dev/block */
2283575ab414SGreg Kroah-Hartman static struct kobject *sysfs_dev_block_kobj;
22841da177e4SLinus Torvalds
22855e33bc41SRafael J. Wysocki static DEFINE_MUTEX(device_hotplug_lock);
22865e33bc41SRafael J. Wysocki
lock_device_hotplug(void)22875e33bc41SRafael J. Wysocki void lock_device_hotplug(void)
22885e33bc41SRafael J. Wysocki {
22895e33bc41SRafael J. Wysocki mutex_lock(&device_hotplug_lock);
22905e33bc41SRafael J. Wysocki }
22915e33bc41SRafael J. Wysocki
unlock_device_hotplug(void)22925e33bc41SRafael J. Wysocki void unlock_device_hotplug(void)
22935e33bc41SRafael J. Wysocki {
22945e33bc41SRafael J. Wysocki mutex_unlock(&device_hotplug_lock);
22955e33bc41SRafael J. Wysocki }
22965e33bc41SRafael J. Wysocki
lock_device_hotplug_sysfs(void)22975e33bc41SRafael J. Wysocki int lock_device_hotplug_sysfs(void)
22985e33bc41SRafael J. Wysocki {
22995e33bc41SRafael J. Wysocki if (mutex_trylock(&device_hotplug_lock))
23005e33bc41SRafael J. Wysocki return 0;
23015e33bc41SRafael J. Wysocki
23025e33bc41SRafael J. Wysocki /* Avoid busy looping (5 ms of sleep should do). */
23035e33bc41SRafael J. Wysocki msleep(5);
23045e33bc41SRafael J. Wysocki return restart_syscall();
23055e33bc41SRafael J. Wysocki }
23065e33bc41SRafael J. Wysocki
23074e886c29SGreg Kroah-Hartman #ifdef CONFIG_BLOCK
device_is_not_partition(struct device * dev)23084e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev)
23094e886c29SGreg Kroah-Hartman {
23104e886c29SGreg Kroah-Hartman return !(dev->type == &part_type);
23114e886c29SGreg Kroah-Hartman }
23124e886c29SGreg Kroah-Hartman #else
device_is_not_partition(struct device * dev)23134e886c29SGreg Kroah-Hartman static inline int device_is_not_partition(struct device *dev)
23144e886c29SGreg Kroah-Hartman {
23154e886c29SGreg Kroah-Hartman return 1;
23164e886c29SGreg Kroah-Hartman }
23174e886c29SGreg Kroah-Hartman #endif
23181da177e4SLinus Torvalds
device_platform_notify(struct device * dev)2319b2ebd9ddSRafael J. Wysocki static void device_platform_notify(struct device *dev)
232007de0e86SHeikki Krogerus {
2321d0b8e398SRafael J. Wysocki acpi_device_notify(dev);
23227847a145SHeikki Krogerus
2323b2ebd9ddSRafael J. Wysocki software_node_notify(dev);
23247847a145SHeikki Krogerus
2325b2ebd9ddSRafael J. Wysocki if (platform_notify)
232607de0e86SHeikki Krogerus platform_notify(dev);
2327b2ebd9ddSRafael J. Wysocki }
2328b2ebd9ddSRafael J. Wysocki
device_platform_notify_remove(struct device * dev)2329b2ebd9ddSRafael J. Wysocki static void device_platform_notify_remove(struct device *dev)
2330b2ebd9ddSRafael J. Wysocki {
233129c8ab79SAndy Shevchenko if (platform_notify_remove)
233229c8ab79SAndy Shevchenko platform_notify_remove(dev);
233307de0e86SHeikki Krogerus
2334384f5a85SRafael J. Wysocki software_node_notify_remove(dev);
23351da177e4SLinus Torvalds
233629c8ab79SAndy Shevchenko acpi_device_notify_remove(dev);
23371da177e4SLinus Torvalds }
23381da177e4SLinus Torvalds
23393e95637aSAlan Stern /**
23403e95637aSAlan Stern * dev_driver_string - Return a device's driver name, if at all possible
23413e95637aSAlan Stern * @dev: struct device to get the name of
23423e95637aSAlan Stern *
23433e95637aSAlan Stern * Will return the device's driver's name if it is bound to a device. If
23449169c012Syan * the device is not bound to a driver, it will return the name of the bus
23453e95637aSAlan Stern * it is attached to. If it is not attached to a bus either, an empty
23463e95637aSAlan Stern * string will be returned.
23473e95637aSAlan Stern */
dev_driver_string(const struct device * dev)2348bf9ca69fSJean Delvare const char *dev_driver_string(const struct device *dev)
23493e95637aSAlan Stern {
23503589972eSAlan Stern struct device_driver *drv;
23513589972eSAlan Stern
23523589972eSAlan Stern /* dev->driver can change to NULL underneath us because of unbinding,
23533589972eSAlan Stern * so be careful about accessing it. dev->bus and dev->class should
23543589972eSAlan Stern * never change once they are set, so they don't need special care.
23553589972eSAlan Stern */
23566aa7de05SMark Rutland drv = READ_ONCE(dev->driver);
2357e020ff61SSaravana Kannan return drv ? drv->name : dev_bus_name(dev);
23583e95637aSAlan Stern }
2359310a922dSMatthew Wilcox EXPORT_SYMBOL(dev_driver_string);
23603e95637aSAlan Stern
23611da177e4SLinus Torvalds #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
23621da177e4SLinus Torvalds
dev_attr_show(struct kobject * kobj,struct attribute * attr,char * buf)23634a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
23644a3ad20cSGreg Kroah-Hartman char *buf)
23651da177e4SLinus Torvalds {
23661da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr);
2367b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj);
23684a0c20bfSDmitry Torokhov ssize_t ret = -EIO;
23691da177e4SLinus Torvalds
23701da177e4SLinus Torvalds if (dev_attr->show)
237154b6f35cSYani Ioannou ret = dev_attr->show(dev, dev_attr, buf);
2372815d2d50SAndrew Morton if (ret >= (ssize_t)PAGE_SIZE) {
2373a52668c6SSergey Senozhatsky printk("dev_attr_show: %pS returned bad count\n",
2374a52668c6SSergey Senozhatsky dev_attr->show);
2375815d2d50SAndrew Morton }
23761da177e4SLinus Torvalds return ret;
23771da177e4SLinus Torvalds }
23781da177e4SLinus Torvalds
dev_attr_store(struct kobject * kobj,struct attribute * attr,const char * buf,size_t count)23794a3ad20cSGreg Kroah-Hartman static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
23801da177e4SLinus Torvalds const char *buf, size_t count)
23811da177e4SLinus Torvalds {
23821da177e4SLinus Torvalds struct device_attribute *dev_attr = to_dev_attr(attr);
2383b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj);
23844a0c20bfSDmitry Torokhov ssize_t ret = -EIO;
23851da177e4SLinus Torvalds
23861da177e4SLinus Torvalds if (dev_attr->store)
238754b6f35cSYani Ioannou ret = dev_attr->store(dev, dev_attr, buf, count);
23881da177e4SLinus Torvalds return ret;
23891da177e4SLinus Torvalds }
23901da177e4SLinus Torvalds
239152cf25d0SEmese Revfy static const struct sysfs_ops dev_sysfs_ops = {
23921da177e4SLinus Torvalds .show = dev_attr_show,
23931da177e4SLinus Torvalds .store = dev_attr_store,
23941da177e4SLinus Torvalds };
23951da177e4SLinus Torvalds
2396ca22e56dSKay Sievers #define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
2397ca22e56dSKay Sievers
device_store_ulong(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)2398ca22e56dSKay Sievers ssize_t device_store_ulong(struct device *dev,
2399ca22e56dSKay Sievers struct device_attribute *attr,
2400ca22e56dSKay Sievers const char *buf, size_t size)
2401ca22e56dSKay Sievers {
2402ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr);
2403f88184bfSKaitao cheng int ret;
2404f88184bfSKaitao cheng unsigned long new;
2405f88184bfSKaitao cheng
2406f88184bfSKaitao cheng ret = kstrtoul(buf, 0, &new);
2407f88184bfSKaitao cheng if (ret)
2408f88184bfSKaitao cheng return ret;
2409ca22e56dSKay Sievers *(unsigned long *)(ea->var) = new;
2410ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */
2411ca22e56dSKay Sievers return size;
2412ca22e56dSKay Sievers }
2413ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_ulong);
2414ca22e56dSKay Sievers
device_show_ulong(struct device * dev,struct device_attribute * attr,char * buf)2415ca22e56dSKay Sievers ssize_t device_show_ulong(struct device *dev,
2416ca22e56dSKay Sievers struct device_attribute *attr,
2417ca22e56dSKay Sievers char *buf)
2418ca22e56dSKay Sievers {
2419ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr);
2420aa838896SJoe Perches return sysfs_emit(buf, "%lx\n", *(unsigned long *)(ea->var));
2421ca22e56dSKay Sievers }
2422ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_ulong);
2423ca22e56dSKay Sievers
device_store_int(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)2424ca22e56dSKay Sievers ssize_t device_store_int(struct device *dev,
2425ca22e56dSKay Sievers struct device_attribute *attr,
2426ca22e56dSKay Sievers const char *buf, size_t size)
2427ca22e56dSKay Sievers {
2428ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr);
2429f88184bfSKaitao cheng int ret;
2430f88184bfSKaitao cheng long new;
2431f88184bfSKaitao cheng
2432f88184bfSKaitao cheng ret = kstrtol(buf, 0, &new);
2433f88184bfSKaitao cheng if (ret)
2434f88184bfSKaitao cheng return ret;
2435f88184bfSKaitao cheng
2436f88184bfSKaitao cheng if (new > INT_MAX || new < INT_MIN)
2437ca22e56dSKay Sievers return -EINVAL;
2438ca22e56dSKay Sievers *(int *)(ea->var) = new;
2439ca22e56dSKay Sievers /* Always return full write size even if we didn't consume all */
2440ca22e56dSKay Sievers return size;
2441ca22e56dSKay Sievers }
2442ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_store_int);
2443ca22e56dSKay Sievers
device_show_int(struct device * dev,struct device_attribute * attr,char * buf)2444ca22e56dSKay Sievers ssize_t device_show_int(struct device *dev,
2445ca22e56dSKay Sievers struct device_attribute *attr,
2446ca22e56dSKay Sievers char *buf)
2447ca22e56dSKay Sievers {
2448ca22e56dSKay Sievers struct dev_ext_attribute *ea = to_ext_attr(attr);
2449ca22e56dSKay Sievers
2450aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(int *)(ea->var));
2451ca22e56dSKay Sievers }
2452ca22e56dSKay Sievers EXPORT_SYMBOL_GPL(device_show_int);
24531da177e4SLinus Torvalds
device_store_bool(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)245491872392SBorislav Petkov ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
245591872392SBorislav Petkov const char *buf, size_t size)
245691872392SBorislav Petkov {
245791872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr);
245891872392SBorislav Petkov
245973060022SChristophe JAILLET if (kstrtobool(buf, ea->var) < 0)
246091872392SBorislav Petkov return -EINVAL;
246191872392SBorislav Petkov
246291872392SBorislav Petkov return size;
246391872392SBorislav Petkov }
246491872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_store_bool);
246591872392SBorislav Petkov
device_show_bool(struct device * dev,struct device_attribute * attr,char * buf)246691872392SBorislav Petkov ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
246791872392SBorislav Petkov char *buf)
246891872392SBorislav Petkov {
246991872392SBorislav Petkov struct dev_ext_attribute *ea = to_ext_attr(attr);
247091872392SBorislav Petkov
2471aa838896SJoe Perches return sysfs_emit(buf, "%d\n", *(bool *)(ea->var));
247291872392SBorislav Petkov }
247391872392SBorislav Petkov EXPORT_SYMBOL_GPL(device_show_bool);
247491872392SBorislav Petkov
24751da177e4SLinus Torvalds /**
24761da177e4SLinus Torvalds * device_release - free device structure.
24771da177e4SLinus Torvalds * @kobj: device's kobject.
24781da177e4SLinus Torvalds *
24791da177e4SLinus Torvalds * This is called once the reference count for the object
24801da177e4SLinus Torvalds * reaches 0. We forward the call to the device's release
24811da177e4SLinus Torvalds * method, which should handle actually freeing the structure.
24821da177e4SLinus Torvalds */
device_release(struct kobject * kobj)24831da177e4SLinus Torvalds static void device_release(struct kobject *kobj)
24841da177e4SLinus Torvalds {
2485b0d1f807SLars-Peter Clausen struct device *dev = kobj_to_dev(kobj);
2486fb069a5dSGreg Kroah-Hartman struct device_private *p = dev->p;
24871da177e4SLinus Torvalds
2488a525a3ddSMing Lei /*
2489a525a3ddSMing Lei * Some platform devices are driven without driver attached
2490a525a3ddSMing Lei * and managed resources may have been acquired. Make sure
2491a525a3ddSMing Lei * all resources are released.
2492a525a3ddSMing Lei *
2493a525a3ddSMing Lei * Drivers still can add resources into device after device
2494a525a3ddSMing Lei * is deleted but alive, so release devres here to avoid
2495a525a3ddSMing Lei * possible memory leak.
2496a525a3ddSMing Lei */
2497a525a3ddSMing Lei devres_release_all(dev);
2498a525a3ddSMing Lei
2499e0d07278SJim Quinlan kfree(dev->dma_range_map);
2500e0d07278SJim Quinlan
25011da177e4SLinus Torvalds if (dev->release)
25021da177e4SLinus Torvalds dev->release(dev);
2503f9f852dfSKay Sievers else if (dev->type && dev->type->release)
2504f9f852dfSKay Sievers dev->type->release(dev);
25052620efefSGreg Kroah-Hartman else if (dev->class && dev->class->dev_release)
25062620efefSGreg Kroah-Hartman dev->class->dev_release(dev);
2507f810a5cfSArjan van de Ven else
25080c1bc6b8SMauro 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",
25091e0b2cf9SKay Sievers dev_name(dev));
2510fb069a5dSGreg Kroah-Hartman kfree(p);
25111da177e4SLinus Torvalds }
25121da177e4SLinus Torvalds
device_namespace(const struct kobject * kobj)251302a476d9SGreg Kroah-Hartman static const void *device_namespace(const struct kobject *kobj)
2514bc451f20SEric W. Biederman {
2515fa627348SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj);
2516bc451f20SEric W. Biederman const void *ns = NULL;
2517bc451f20SEric W. Biederman
2518bc451f20SEric W. Biederman if (dev->class && dev->class->ns_type)
2519bc451f20SEric W. Biederman ns = dev->class->namespace(dev);
2520bc451f20SEric W. Biederman
2521bc451f20SEric W. Biederman return ns;
2522bc451f20SEric W. Biederman }
2523bc451f20SEric W. Biederman
device_get_ownership(const struct kobject * kobj,kuid_t * uid,kgid_t * gid)252402a476d9SGreg Kroah-Hartman static void device_get_ownership(const struct kobject *kobj, kuid_t *uid, kgid_t *gid)
25259944e894SDmitry Torokhov {
2526fa627348SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj);
25279944e894SDmitry Torokhov
25289944e894SDmitry Torokhov if (dev->class && dev->class->get_ownership)
25299944e894SDmitry Torokhov dev->class->get_ownership(dev, uid, gid);
25309944e894SDmitry Torokhov }
25319944e894SDmitry Torokhov
2532c83d9ab4SThomas Weißschuh static const struct kobj_type device_ktype = {
25331da177e4SLinus Torvalds .release = device_release,
25341da177e4SLinus Torvalds .sysfs_ops = &dev_sysfs_ops,
2535bc451f20SEric W. Biederman .namespace = device_namespace,
25369944e894SDmitry Torokhov .get_ownership = device_get_ownership,
25371da177e4SLinus Torvalds };
25381da177e4SLinus Torvalds
25391da177e4SLinus Torvalds
dev_uevent_filter(const struct kobject * kobj)2540c45a88bbSGreg Kroah-Hartman static int dev_uevent_filter(const struct kobject *kobj)
25411da177e4SLinus Torvalds {
2542ee6d3dd4SWedson Almeida Filho const struct kobj_type *ktype = get_ktype(kobj);
25431da177e4SLinus Torvalds
25448f4afc41SGreg Kroah-Hartman if (ktype == &device_ktype) {
2545c45a88bbSGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj);
25461da177e4SLinus Torvalds if (dev->bus)
25471da177e4SLinus Torvalds return 1;
254823681e47SGreg Kroah-Hartman if (dev->class)
254923681e47SGreg Kroah-Hartman return 1;
25501da177e4SLinus Torvalds }
25511da177e4SLinus Torvalds return 0;
25521da177e4SLinus Torvalds }
25531da177e4SLinus Torvalds
dev_uevent_name(const struct kobject * kobj)2554a53d1accSGreg Kroah-Hartman static const char *dev_uevent_name(const struct kobject *kobj)
25551da177e4SLinus Torvalds {
2556a53d1accSGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj);
25571da177e4SLinus Torvalds
255823681e47SGreg Kroah-Hartman if (dev->bus)
25591da177e4SLinus Torvalds return dev->bus->name;
256023681e47SGreg Kroah-Hartman if (dev->class)
256123681e47SGreg Kroah-Hartman return dev->class->name;
256223681e47SGreg Kroah-Hartman return NULL;
25631da177e4SLinus Torvalds }
25641da177e4SLinus Torvalds
dev_uevent(const struct kobject * kobj,struct kobj_uevent_env * env)256556d5f362SGreg Kroah-Hartman static int dev_uevent(const struct kobject *kobj, struct kobj_uevent_env *env)
25661da177e4SLinus Torvalds {
256756d5f362SGreg Kroah-Hartman const struct device *dev = kobj_to_dev(kobj);
25681da177e4SLinus Torvalds int retval = 0;
25691da177e4SLinus Torvalds
25706fcf53acSKay Sievers /* add device node properties if present */
257123681e47SGreg Kroah-Hartman if (MAJOR(dev->devt)) {
25726fcf53acSKay Sievers const char *tmp;
25736fcf53acSKay Sievers const char *name;
25742c9ede55SAl Viro umode_t mode = 0;
25754e4098a3SGreg Kroah-Hartman kuid_t uid = GLOBAL_ROOT_UID;
25764e4098a3SGreg Kroah-Hartman kgid_t gid = GLOBAL_ROOT_GID;
25776fcf53acSKay Sievers
25787eff2e7aSKay Sievers add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
25797eff2e7aSKay Sievers add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
25803c2670e6SKay Sievers name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
25816fcf53acSKay Sievers if (name) {
25826fcf53acSKay Sievers add_uevent_var(env, "DEVNAME=%s", name);
2583e454cea2SKay Sievers if (mode)
2584e454cea2SKay Sievers add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
25854e4098a3SGreg Kroah-Hartman if (!uid_eq(uid, GLOBAL_ROOT_UID))
25864e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
25874e4098a3SGreg Kroah-Hartman if (!gid_eq(gid, GLOBAL_ROOT_GID))
25884e4098a3SGreg Kroah-Hartman add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
25893c2670e6SKay Sievers kfree(tmp);
25906fcf53acSKay Sievers }
259123681e47SGreg Kroah-Hartman }
259223681e47SGreg Kroah-Hartman
2593414264f9SKay Sievers if (dev->type && dev->type->name)
25947eff2e7aSKay Sievers add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
2595414264f9SKay Sievers
2596239378f1SKay Sievers if (dev->driver)
25977eff2e7aSKay Sievers add_uevent_var(env, "DRIVER=%s", dev->driver->name);
2598239378f1SKay Sievers
259907d57a32SGrant Likely /* Add common DT information about the device */
260007d57a32SGrant Likely of_device_uevent(dev, env);
260107d57a32SGrant Likely
26021da177e4SLinus Torvalds /* have the bus specific function add its stuff */
26037eff2e7aSKay Sievers if (dev->bus && dev->bus->uevent) {
26047eff2e7aSKay Sievers retval = dev->bus->uevent(dev, env);
2605f9f852dfSKay Sievers if (retval)
26067dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: bus uevent() returned %d\n",
26071e0b2cf9SKay Sievers dev_name(dev), __func__, retval);
26081da177e4SLinus Torvalds }
26091da177e4SLinus Torvalds
26102620efefSGreg Kroah-Hartman /* have the class specific function add its stuff */
26117eff2e7aSKay Sievers if (dev->class && dev->class->dev_uevent) {
26127eff2e7aSKay Sievers retval = dev->class->dev_uevent(dev, env);
2613f9f852dfSKay Sievers if (retval)
26147dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: class uevent() "
26151e0b2cf9SKay Sievers "returned %d\n", dev_name(dev),
26162b3a302aSHarvey Harrison __func__, retval);
26172620efefSGreg Kroah-Hartman }
2618f9f852dfSKay Sievers
2619eef35c2dSStefan Weil /* have the device type specific function add its stuff */
26207eff2e7aSKay Sievers if (dev->type && dev->type->uevent) {
26217eff2e7aSKay Sievers retval = dev->type->uevent(dev, env);
2622f9f852dfSKay Sievers if (retval)
26237dc72b28SGreg Kroah-Hartman pr_debug("device: '%s': %s: dev_type uevent() "
26241e0b2cf9SKay Sievers "returned %d\n", dev_name(dev),
26252b3a302aSHarvey Harrison __func__, retval);
26262620efefSGreg Kroah-Hartman }
26272620efefSGreg Kroah-Hartman
26281da177e4SLinus Torvalds return retval;
26291da177e4SLinus Torvalds }
26301da177e4SLinus Torvalds
26319cd43611SEmese Revfy static const struct kset_uevent_ops device_uevent_ops = {
2632312c004dSKay Sievers .filter = dev_uevent_filter,
2633312c004dSKay Sievers .name = dev_uevent_name,
2634312c004dSKay Sievers .uevent = dev_uevent,
26351da177e4SLinus Torvalds };
26361da177e4SLinus Torvalds
uevent_show(struct device * dev,struct device_attribute * attr,char * buf)2637c5e064a6SGreg Kroah-Hartman static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
263816574dccSKay Sievers char *buf)
263916574dccSKay Sievers {
264016574dccSKay Sievers struct kobject *top_kobj;
264116574dccSKay Sievers struct kset *kset;
26427eff2e7aSKay Sievers struct kobj_uevent_env *env = NULL;
264316574dccSKay Sievers int i;
2644948b3edbSJoe Perches int len = 0;
264516574dccSKay Sievers int retval;
264616574dccSKay Sievers
264716574dccSKay Sievers /* search the kset, the device belongs to */
264816574dccSKay Sievers top_kobj = &dev->kobj;
26495c5daf65SKay Sievers while (!top_kobj->kset && top_kobj->parent)
265016574dccSKay Sievers top_kobj = top_kobj->parent;
265116574dccSKay Sievers if (!top_kobj->kset)
265216574dccSKay Sievers goto out;
26535c5daf65SKay Sievers
265416574dccSKay Sievers kset = top_kobj->kset;
265516574dccSKay Sievers if (!kset->uevent_ops || !kset->uevent_ops->uevent)
265616574dccSKay Sievers goto out;
265716574dccSKay Sievers
265816574dccSKay Sievers /* respect filter */
265916574dccSKay Sievers if (kset->uevent_ops && kset->uevent_ops->filter)
2660cf6299b6SGreg Kroah-Hartman if (!kset->uevent_ops->filter(&dev->kobj))
266116574dccSKay Sievers goto out;
266216574dccSKay Sievers
26637eff2e7aSKay Sievers env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
26647eff2e7aSKay Sievers if (!env)
2665c7308c81SGreg Kroah-Hartman return -ENOMEM;
2666c7308c81SGreg Kroah-Hartman
2667a42b0060SDirk Behme /* Synchronize with really_probe() */
2668a42b0060SDirk Behme device_lock(dev);
266916574dccSKay Sievers /* let the kset specific function add its keys */
2670cf6299b6SGreg Kroah-Hartman retval = kset->uevent_ops->uevent(&dev->kobj, env);
2671a42b0060SDirk Behme device_unlock(dev);
267216574dccSKay Sievers if (retval)
267316574dccSKay Sievers goto out;
267416574dccSKay Sievers
267516574dccSKay Sievers /* copy keys to file */
26767eff2e7aSKay Sievers for (i = 0; i < env->envp_idx; i++)
2677948b3edbSJoe Perches len += sysfs_emit_at(buf, len, "%s\n", env->envp[i]);
267816574dccSKay Sievers out:
26797eff2e7aSKay Sievers kfree(env);
2680948b3edbSJoe Perches return len;
268116574dccSKay Sievers }
268216574dccSKay Sievers
uevent_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2683c5e064a6SGreg Kroah-Hartman static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
2684a7fd6706SKay Sievers const char *buf, size_t count)
2685a7fd6706SKay Sievers {
2686df44b479SPeter Rajnoha int rc;
2687df44b479SPeter Rajnoha
2688df44b479SPeter Rajnoha rc = kobject_synth_uevent(&dev->kobj, buf, count);
2689df44b479SPeter Rajnoha
2690df44b479SPeter Rajnoha if (rc) {
26916bb7ea3aSBrian Norris dev_err(dev, "uevent: failed to send synthetic uevent: %d\n", rc);
2692df44b479SPeter Rajnoha return rc;
2693df44b479SPeter Rajnoha }
269460a96a59SKay Sievers
2695a7fd6706SKay Sievers return count;
2696a7fd6706SKay Sievers }
2697c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(uevent);
2698a7fd6706SKay Sievers
online_show(struct device * dev,struct device_attribute * attr,char * buf)2699c5e064a6SGreg Kroah-Hartman static ssize_t online_show(struct device *dev, struct device_attribute *attr,
27004f3549d7SRafael J. Wysocki char *buf)
27014f3549d7SRafael J. Wysocki {
27024f3549d7SRafael J. Wysocki bool val;
27034f3549d7SRafael J. Wysocki
27045e33bc41SRafael J. Wysocki device_lock(dev);
27054f3549d7SRafael J. Wysocki val = !dev->offline;
27065e33bc41SRafael J. Wysocki device_unlock(dev);
2707aa838896SJoe Perches return sysfs_emit(buf, "%u\n", val);
27084f3549d7SRafael J. Wysocki }
27094f3549d7SRafael J. Wysocki
online_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2710c5e064a6SGreg Kroah-Hartman static ssize_t online_store(struct device *dev, struct device_attribute *attr,
27114f3549d7SRafael J. Wysocki const char *buf, size_t count)
27124f3549d7SRafael J. Wysocki {
27134f3549d7SRafael J. Wysocki bool val;
27144f3549d7SRafael J. Wysocki int ret;
27154f3549d7SRafael J. Wysocki
271673060022SChristophe JAILLET ret = kstrtobool(buf, &val);
27174f3549d7SRafael J. Wysocki if (ret < 0)
27184f3549d7SRafael J. Wysocki return ret;
27194f3549d7SRafael J. Wysocki
27205e33bc41SRafael J. Wysocki ret = lock_device_hotplug_sysfs();
27215e33bc41SRafael J. Wysocki if (ret)
27225e33bc41SRafael J. Wysocki return ret;
27235e33bc41SRafael J. Wysocki
27244f3549d7SRafael J. Wysocki ret = val ? device_online(dev) : device_offline(dev);
27254f3549d7SRafael J. Wysocki unlock_device_hotplug();
27264f3549d7SRafael J. Wysocki return ret < 0 ? ret : count;
27274f3549d7SRafael J. Wysocki }
2728c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RW(online);
27294f3549d7SRafael J. Wysocki
removable_show(struct device * dev,struct device_attribute * attr,char * buf)273070f400d4SRajat Jain static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
273170f400d4SRajat Jain char *buf)
273270f400d4SRajat Jain {
273370f400d4SRajat Jain const char *loc;
273470f400d4SRajat Jain
273570f400d4SRajat Jain switch (dev->removable) {
273670f400d4SRajat Jain case DEVICE_REMOVABLE:
273770f400d4SRajat Jain loc = "removable";
273870f400d4SRajat Jain break;
273970f400d4SRajat Jain case DEVICE_FIXED:
274070f400d4SRajat Jain loc = "fixed";
274170f400d4SRajat Jain break;
274270f400d4SRajat Jain default:
274370f400d4SRajat Jain loc = "unknown";
274470f400d4SRajat Jain }
274570f400d4SRajat Jain return sysfs_emit(buf, "%s\n", loc);
274670f400d4SRajat Jain }
274770f400d4SRajat Jain static DEVICE_ATTR_RO(removable);
274870f400d4SRajat Jain
device_add_groups(struct device * dev,const struct attribute_group ** groups)2749fa6fdb33SGreg Kroah-Hartman int device_add_groups(struct device *dev, const struct attribute_group **groups)
2750621a1672SDmitry Torokhov {
27513e9b2baeSGreg Kroah-Hartman return sysfs_create_groups(&dev->kobj, groups);
2752621a1672SDmitry Torokhov }
2753a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_add_groups);
2754621a1672SDmitry Torokhov
device_remove_groups(struct device * dev,const struct attribute_group ** groups)2755fa6fdb33SGreg Kroah-Hartman void device_remove_groups(struct device *dev,
2756a4dbd674SDavid Brownell const struct attribute_group **groups)
2757621a1672SDmitry Torokhov {
27583e9b2baeSGreg Kroah-Hartman sysfs_remove_groups(&dev->kobj, groups);
2759621a1672SDmitry Torokhov }
2760a7670d42SDmitry Torokhov EXPORT_SYMBOL_GPL(device_remove_groups);
2761de0ff00dSGreg Kroah-Hartman
276257b8ff07SDmitry Torokhov union device_attr_group_devres {
276357b8ff07SDmitry Torokhov const struct attribute_group *group;
276457b8ff07SDmitry Torokhov const struct attribute_group **groups;
276557b8ff07SDmitry Torokhov };
276657b8ff07SDmitry Torokhov
devm_attr_group_remove(struct device * dev,void * res)276757b8ff07SDmitry Torokhov static void devm_attr_group_remove(struct device *dev, void *res)
276857b8ff07SDmitry Torokhov {
276957b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res;
277057b8ff07SDmitry Torokhov const struct attribute_group *group = devres->group;
277157b8ff07SDmitry Torokhov
277257b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing group %p\n", __func__, group);
277357b8ff07SDmitry Torokhov sysfs_remove_group(&dev->kobj, group);
277457b8ff07SDmitry Torokhov }
277557b8ff07SDmitry Torokhov
devm_attr_groups_remove(struct device * dev,void * res)277657b8ff07SDmitry Torokhov static void devm_attr_groups_remove(struct device *dev, void *res)
277757b8ff07SDmitry Torokhov {
277857b8ff07SDmitry Torokhov union device_attr_group_devres *devres = res;
277957b8ff07SDmitry Torokhov const struct attribute_group **groups = devres->groups;
278057b8ff07SDmitry Torokhov
278157b8ff07SDmitry Torokhov dev_dbg(dev, "%s: removing groups %p\n", __func__, groups);
278257b8ff07SDmitry Torokhov sysfs_remove_groups(&dev->kobj, groups);
278357b8ff07SDmitry Torokhov }
278457b8ff07SDmitry Torokhov
278557b8ff07SDmitry Torokhov /**
278657b8ff07SDmitry Torokhov * devm_device_add_group - given a device, create a managed attribute group
278757b8ff07SDmitry Torokhov * @dev: The device to create the group for
278857b8ff07SDmitry Torokhov * @grp: The attribute group to create
278957b8ff07SDmitry Torokhov *
279057b8ff07SDmitry Torokhov * This function creates a group for the first time. It will explicitly
279157b8ff07SDmitry Torokhov * warn and error if any of the attribute files being created already exist.
279257b8ff07SDmitry Torokhov *
279357b8ff07SDmitry Torokhov * Returns 0 on success or error code on failure.
279457b8ff07SDmitry Torokhov */
devm_device_add_group(struct device * dev,const struct attribute_group * grp)279557b8ff07SDmitry Torokhov int devm_device_add_group(struct device *dev, const struct attribute_group *grp)
279657b8ff07SDmitry Torokhov {
279757b8ff07SDmitry Torokhov union device_attr_group_devres *devres;
279857b8ff07SDmitry Torokhov int error;
279957b8ff07SDmitry Torokhov
280057b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_group_remove,
280157b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL);
280257b8ff07SDmitry Torokhov if (!devres)
280357b8ff07SDmitry Torokhov return -ENOMEM;
280457b8ff07SDmitry Torokhov
280557b8ff07SDmitry Torokhov error = sysfs_create_group(&dev->kobj, grp);
280657b8ff07SDmitry Torokhov if (error) {
280757b8ff07SDmitry Torokhov devres_free(devres);
280857b8ff07SDmitry Torokhov return error;
280957b8ff07SDmitry Torokhov }
281057b8ff07SDmitry Torokhov
281157b8ff07SDmitry Torokhov devres->group = grp;
281257b8ff07SDmitry Torokhov devres_add(dev, devres);
281357b8ff07SDmitry Torokhov return 0;
281457b8ff07SDmitry Torokhov }
281557b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_group);
281657b8ff07SDmitry Torokhov
281757b8ff07SDmitry Torokhov /**
281857b8ff07SDmitry Torokhov * devm_device_add_groups - create a bunch of managed attribute groups
281957b8ff07SDmitry Torokhov * @dev: The device to create the group for
282057b8ff07SDmitry Torokhov * @groups: The attribute groups to create, NULL terminated
282157b8ff07SDmitry Torokhov *
282257b8ff07SDmitry Torokhov * This function creates a bunch of managed attribute groups. If an error
282357b8ff07SDmitry Torokhov * occurs when creating a group, all previously created groups will be
282457b8ff07SDmitry Torokhov * removed, unwinding everything back to the original state when this
282557b8ff07SDmitry Torokhov * function was called. It will explicitly warn and error if any of the
282657b8ff07SDmitry Torokhov * attribute files being created already exist.
282757b8ff07SDmitry Torokhov *
282857b8ff07SDmitry Torokhov * Returns 0 on success or error code from sysfs_create_group on failure.
282957b8ff07SDmitry Torokhov */
devm_device_add_groups(struct device * dev,const struct attribute_group ** groups)283057b8ff07SDmitry Torokhov int devm_device_add_groups(struct device *dev,
283157b8ff07SDmitry Torokhov const struct attribute_group **groups)
283257b8ff07SDmitry Torokhov {
283357b8ff07SDmitry Torokhov union device_attr_group_devres *devres;
283457b8ff07SDmitry Torokhov int error;
283557b8ff07SDmitry Torokhov
283657b8ff07SDmitry Torokhov devres = devres_alloc(devm_attr_groups_remove,
283757b8ff07SDmitry Torokhov sizeof(*devres), GFP_KERNEL);
283857b8ff07SDmitry Torokhov if (!devres)
283957b8ff07SDmitry Torokhov return -ENOMEM;
284057b8ff07SDmitry Torokhov
284157b8ff07SDmitry Torokhov error = sysfs_create_groups(&dev->kobj, groups);
284257b8ff07SDmitry Torokhov if (error) {
284357b8ff07SDmitry Torokhov devres_free(devres);
284457b8ff07SDmitry Torokhov return error;
284557b8ff07SDmitry Torokhov }
284657b8ff07SDmitry Torokhov
284757b8ff07SDmitry Torokhov devres->groups = groups;
284857b8ff07SDmitry Torokhov devres_add(dev, devres);
284957b8ff07SDmitry Torokhov return 0;
285057b8ff07SDmitry Torokhov }
285157b8ff07SDmitry Torokhov EXPORT_SYMBOL_GPL(devm_device_add_groups);
285257b8ff07SDmitry Torokhov
device_add_attrs(struct device * dev)28532620efefSGreg Kroah-Hartman static int device_add_attrs(struct device *dev)
28542620efefSGreg Kroah-Hartman {
28559fa120fbSGreg Kroah-Hartman const struct class *class = dev->class;
2856aed65af1SStephen Hemminger const struct device_type *type = dev->type;
2857621a1672SDmitry Torokhov int error;
28582620efefSGreg Kroah-Hartman
2859621a1672SDmitry Torokhov if (class) {
2860d05a6f96SGreg Kroah-Hartman error = device_add_groups(dev, class->dev_groups);
28612620efefSGreg Kroah-Hartman if (error)
2862621a1672SDmitry Torokhov return error;
2863f9f852dfSKay Sievers }
2864f9f852dfSKay Sievers
2865621a1672SDmitry Torokhov if (type) {
2866621a1672SDmitry Torokhov error = device_add_groups(dev, type->groups);
2867f9f852dfSKay Sievers if (error)
2868a6b01dedSGreg Kroah-Hartman goto err_remove_class_groups;
2869f9f852dfSKay Sievers }
2870621a1672SDmitry Torokhov
2871621a1672SDmitry Torokhov error = device_add_groups(dev, dev->groups);
2872f9f852dfSKay Sievers if (error)
2873621a1672SDmitry Torokhov goto err_remove_type_groups;
2874621a1672SDmitry Torokhov
28754f3549d7SRafael J. Wysocki if (device_supports_offline(dev) && !dev->offline_disabled) {
2876c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_online);
28774f3549d7SRafael J. Wysocki if (error)
2878ecfbf6fdSRafael J. Wysocki goto err_remove_dev_groups;
28794f3549d7SRafael J. Wysocki }
28804f3549d7SRafael J. Wysocki
288125ac86c6SSaravana Kannan if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) {
2882da6d6475SSaravana Kannan error = device_create_file(dev, &dev_attr_waiting_for_supplier);
2883da6d6475SSaravana Kannan if (error)
2884da6d6475SSaravana Kannan goto err_remove_dev_online;
2885da6d6475SSaravana Kannan }
2886da6d6475SSaravana Kannan
288770f400d4SRajat Jain if (dev_removable_is_valid(dev)) {
288870f400d4SRajat Jain error = device_create_file(dev, &dev_attr_removable);
288970f400d4SRajat Jain if (error)
289070f400d4SRajat Jain goto err_remove_dev_waiting_for_supplier;
289170f400d4SRajat Jain }
289270f400d4SRajat Jain
28936423d295SWon Chung if (dev_add_physical_location(dev)) {
28946423d295SWon Chung error = device_add_group(dev,
28956423d295SWon Chung &dev_attr_physical_location_group);
28966423d295SWon Chung if (error)
28976423d295SWon Chung goto err_remove_dev_removable;
28986423d295SWon Chung }
28996423d295SWon Chung
2900621a1672SDmitry Torokhov return 0;
2901621a1672SDmitry Torokhov
29026423d295SWon Chung err_remove_dev_removable:
29036423d295SWon Chung device_remove_file(dev, &dev_attr_removable);
290470f400d4SRajat Jain err_remove_dev_waiting_for_supplier:
290570f400d4SRajat Jain device_remove_file(dev, &dev_attr_waiting_for_supplier);
2906da6d6475SSaravana Kannan err_remove_dev_online:
2907da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_online);
2908ecfbf6fdSRafael J. Wysocki err_remove_dev_groups:
2909ecfbf6fdSRafael J. Wysocki device_remove_groups(dev, dev->groups);
2910621a1672SDmitry Torokhov err_remove_type_groups:
2911621a1672SDmitry Torokhov if (type)
2912621a1672SDmitry Torokhov device_remove_groups(dev, type->groups);
2913d05a6f96SGreg Kroah-Hartman err_remove_class_groups:
2914d05a6f96SGreg Kroah-Hartman if (class)
2915d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups);
2916f9f852dfSKay Sievers
29172620efefSGreg Kroah-Hartman return error;
29182620efefSGreg Kroah-Hartman }
29192620efefSGreg Kroah-Hartman
device_remove_attrs(struct device * dev)29202620efefSGreg Kroah-Hartman static void device_remove_attrs(struct device *dev)
29212620efefSGreg Kroah-Hartman {
29229fa120fbSGreg Kroah-Hartman const struct class *class = dev->class;
2923aed65af1SStephen Hemminger const struct device_type *type = dev->type;
29242620efefSGreg Kroah-Hartman
29256423d295SWon Chung if (dev->physical_location) {
29266423d295SWon Chung device_remove_group(dev, &dev_attr_physical_location_group);
29276423d295SWon Chung kfree(dev->physical_location);
29286423d295SWon Chung }
29296423d295SWon Chung
293070f400d4SRajat Jain device_remove_file(dev, &dev_attr_removable);
2931da6d6475SSaravana Kannan device_remove_file(dev, &dev_attr_waiting_for_supplier);
2932c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_online);
2933621a1672SDmitry Torokhov device_remove_groups(dev, dev->groups);
2934f9f852dfSKay Sievers
2935621a1672SDmitry Torokhov if (type)
2936621a1672SDmitry Torokhov device_remove_groups(dev, type->groups);
2937621a1672SDmitry Torokhov
2938a6b01dedSGreg Kroah-Hartman if (class)
2939d05a6f96SGreg Kroah-Hartman device_remove_groups(dev, class->dev_groups);
2940c97415a7SStefan Achatz }
29412620efefSGreg Kroah-Hartman
dev_show(struct device * dev,struct device_attribute * attr,char * buf)2942c5e064a6SGreg Kroah-Hartman static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
294323681e47SGreg Kroah-Hartman char *buf)
294423681e47SGreg Kroah-Hartman {
294523681e47SGreg Kroah-Hartman return print_dev_t(buf, dev->devt);
294623681e47SGreg Kroah-Hartman }
2947c5e064a6SGreg Kroah-Hartman static DEVICE_ATTR_RO(dev);
2948ad6a1e1cSTejun Heo
2949ca22e56dSKay Sievers /* /sys/devices/ */
2950881c6cfdSGreg Kroah-Hartman struct kset *devices_kset;
29511da177e4SLinus Torvalds
29521da177e4SLinus Torvalds /**
295352cdbdd4SGrygorii Strashko * devices_kset_move_before - Move device in the devices_kset's list.
295452cdbdd4SGrygorii Strashko * @deva: Device to move.
295552cdbdd4SGrygorii Strashko * @devb: Device @deva should come before.
295652cdbdd4SGrygorii Strashko */
devices_kset_move_before(struct device * deva,struct device * devb)295752cdbdd4SGrygorii Strashko static void devices_kset_move_before(struct device *deva, struct device *devb)
295852cdbdd4SGrygorii Strashko {
295952cdbdd4SGrygorii Strashko if (!devices_kset)
296052cdbdd4SGrygorii Strashko return;
296152cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s before %s\n",
296252cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb));
296352cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock);
296452cdbdd4SGrygorii Strashko list_move_tail(&deva->kobj.entry, &devb->kobj.entry);
296552cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock);
296652cdbdd4SGrygorii Strashko }
296752cdbdd4SGrygorii Strashko
296852cdbdd4SGrygorii Strashko /**
296952cdbdd4SGrygorii Strashko * devices_kset_move_after - Move device in the devices_kset's list.
297052cdbdd4SGrygorii Strashko * @deva: Device to move
297152cdbdd4SGrygorii Strashko * @devb: Device @deva should come after.
297252cdbdd4SGrygorii Strashko */
devices_kset_move_after(struct device * deva,struct device * devb)297352cdbdd4SGrygorii Strashko static void devices_kset_move_after(struct device *deva, struct device *devb)
297452cdbdd4SGrygorii Strashko {
297552cdbdd4SGrygorii Strashko if (!devices_kset)
297652cdbdd4SGrygorii Strashko return;
297752cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s after %s\n",
297852cdbdd4SGrygorii Strashko dev_name(deva), dev_name(devb));
297952cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock);
298052cdbdd4SGrygorii Strashko list_move(&deva->kobj.entry, &devb->kobj.entry);
298152cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock);
298252cdbdd4SGrygorii Strashko }
298352cdbdd4SGrygorii Strashko
298452cdbdd4SGrygorii Strashko /**
298552cdbdd4SGrygorii Strashko * devices_kset_move_last - move the device to the end of devices_kset's list.
298652cdbdd4SGrygorii Strashko * @dev: device to move
298752cdbdd4SGrygorii Strashko */
devices_kset_move_last(struct device * dev)298852cdbdd4SGrygorii Strashko void devices_kset_move_last(struct device *dev)
298952cdbdd4SGrygorii Strashko {
299052cdbdd4SGrygorii Strashko if (!devices_kset)
299152cdbdd4SGrygorii Strashko return;
299252cdbdd4SGrygorii Strashko pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev));
299352cdbdd4SGrygorii Strashko spin_lock(&devices_kset->list_lock);
299452cdbdd4SGrygorii Strashko list_move_tail(&dev->kobj.entry, &devices_kset->list);
299552cdbdd4SGrygorii Strashko spin_unlock(&devices_kset->list_lock);
299652cdbdd4SGrygorii Strashko }
299752cdbdd4SGrygorii Strashko
299852cdbdd4SGrygorii Strashko /**
29991da177e4SLinus Torvalds * device_create_file - create sysfs attribute file for device.
30001da177e4SLinus Torvalds * @dev: device.
30011da177e4SLinus Torvalds * @attr: device attribute descriptor.
30021da177e4SLinus Torvalds */
device_create_file(struct device * dev,const struct device_attribute * attr)300326579ab7SPhil Carmody int device_create_file(struct device *dev,
300426579ab7SPhil Carmody const struct device_attribute *attr)
30051da177e4SLinus Torvalds {
30061da177e4SLinus Torvalds int error = 0;
30078f46baaaSFelipe Balbi
30088f46baaaSFelipe Balbi if (dev) {
30098f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
301097521978Sdyoung@redhat.com "Attribute %s: write permission without 'store'\n",
301197521978Sdyoung@redhat.com attr->attr.name);
30128f46baaaSFelipe Balbi WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
301397521978Sdyoung@redhat.com "Attribute %s: read permission without 'show'\n",
301497521978Sdyoung@redhat.com attr->attr.name);
30151da177e4SLinus Torvalds error = sysfs_create_file(&dev->kobj, &attr->attr);
30168f46baaaSFelipe Balbi }
30178f46baaaSFelipe Balbi
30181da177e4SLinus Torvalds return error;
30191da177e4SLinus Torvalds }
302086df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_create_file);
30211da177e4SLinus Torvalds
30221da177e4SLinus Torvalds /**
30231da177e4SLinus Torvalds * device_remove_file - remove sysfs attribute file.
30241da177e4SLinus Torvalds * @dev: device.
30251da177e4SLinus Torvalds * @attr: device attribute descriptor.
30261da177e4SLinus Torvalds */
device_remove_file(struct device * dev,const struct device_attribute * attr)302726579ab7SPhil Carmody void device_remove_file(struct device *dev,
302826579ab7SPhil Carmody const struct device_attribute *attr)
30291da177e4SLinus Torvalds {
30300c98b19fSCornelia Huck if (dev)
30311da177e4SLinus Torvalds sysfs_remove_file(&dev->kobj, &attr->attr);
30321da177e4SLinus Torvalds }
303386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_remove_file);
30341da177e4SLinus Torvalds
30352589f188SGreg Kroah-Hartman /**
30366b0afc2aSTejun Heo * device_remove_file_self - remove sysfs attribute file from its own method.
30376b0afc2aSTejun Heo * @dev: device.
30386b0afc2aSTejun Heo * @attr: device attribute descriptor.
30396b0afc2aSTejun Heo *
30406b0afc2aSTejun Heo * See kernfs_remove_self() for details.
30416b0afc2aSTejun Heo */
device_remove_file_self(struct device * dev,const struct device_attribute * attr)30426b0afc2aSTejun Heo bool device_remove_file_self(struct device *dev,
30436b0afc2aSTejun Heo const struct device_attribute *attr)
30446b0afc2aSTejun Heo {
30456b0afc2aSTejun Heo if (dev)
30466b0afc2aSTejun Heo return sysfs_remove_file_self(&dev->kobj, &attr->attr);
30476b0afc2aSTejun Heo else
30486b0afc2aSTejun Heo return false;
30496b0afc2aSTejun Heo }
30506b0afc2aSTejun Heo EXPORT_SYMBOL_GPL(device_remove_file_self);
30516b0afc2aSTejun Heo
30526b0afc2aSTejun Heo /**
30532589f188SGreg Kroah-Hartman * device_create_bin_file - create sysfs binary attribute file for device.
30542589f188SGreg Kroah-Hartman * @dev: device.
30552589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor.
30562589f188SGreg Kroah-Hartman */
device_create_bin_file(struct device * dev,const struct bin_attribute * attr)305766ecb92bSPhil Carmody int device_create_bin_file(struct device *dev,
305866ecb92bSPhil Carmody const struct bin_attribute *attr)
30592589f188SGreg Kroah-Hartman {
30602589f188SGreg Kroah-Hartman int error = -EINVAL;
30612589f188SGreg Kroah-Hartman if (dev)
30622589f188SGreg Kroah-Hartman error = sysfs_create_bin_file(&dev->kobj, attr);
30632589f188SGreg Kroah-Hartman return error;
30642589f188SGreg Kroah-Hartman }
30652589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create_bin_file);
30662589f188SGreg Kroah-Hartman
30672589f188SGreg Kroah-Hartman /**
30682589f188SGreg Kroah-Hartman * device_remove_bin_file - remove sysfs binary attribute file
30692589f188SGreg Kroah-Hartman * @dev: device.
30702589f188SGreg Kroah-Hartman * @attr: device binary attribute descriptor.
30712589f188SGreg Kroah-Hartman */
device_remove_bin_file(struct device * dev,const struct bin_attribute * attr)307266ecb92bSPhil Carmody void device_remove_bin_file(struct device *dev,
307366ecb92bSPhil Carmody const struct bin_attribute *attr)
30742589f188SGreg Kroah-Hartman {
30752589f188SGreg Kroah-Hartman if (dev)
30762589f188SGreg Kroah-Hartman sysfs_remove_bin_file(&dev->kobj, attr);
30772589f188SGreg Kroah-Hartman }
30782589f188SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_remove_bin_file);
30792589f188SGreg Kroah-Hartman
klist_children_get(struct klist_node * n)308034bb61f9SJames Bottomley static void klist_children_get(struct klist_node *n)
308134bb61f9SJames Bottomley {
3082f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n);
3083f791b8c8SGreg Kroah-Hartman struct device *dev = p->device;
308434bb61f9SJames Bottomley
308534bb61f9SJames Bottomley get_device(dev);
308634bb61f9SJames Bottomley }
308734bb61f9SJames Bottomley
klist_children_put(struct klist_node * n)308834bb61f9SJames Bottomley static void klist_children_put(struct klist_node *n)
308934bb61f9SJames Bottomley {
3090f791b8c8SGreg Kroah-Hartman struct device_private *p = to_device_private_parent(n);
3091f791b8c8SGreg Kroah-Hartman struct device *dev = p->device;
309234bb61f9SJames Bottomley
309334bb61f9SJames Bottomley put_device(dev);
309434bb61f9SJames Bottomley }
309534bb61f9SJames Bottomley
30961da177e4SLinus Torvalds /**
30971da177e4SLinus Torvalds * device_initialize - init device structure.
30981da177e4SLinus Torvalds * @dev: device.
30991da177e4SLinus Torvalds *
31005739411aSCornelia Huck * This prepares the device for use by other layers by initializing
31015739411aSCornelia Huck * its fields.
31021da177e4SLinus Torvalds * It is the first half of device_register(), if called by
31035739411aSCornelia Huck * that function, though it can also be called separately, so one
31045739411aSCornelia Huck * may use @dev's fields. In particular, get_device()/put_device()
31055739411aSCornelia Huck * may be used for reference counting of @dev after calling this
31065739411aSCornelia Huck * function.
31075739411aSCornelia Huck *
3108b10d5efdSAlan Stern * All fields in @dev must be initialized by the caller to 0, except
3109b10d5efdSAlan Stern * for those explicitly set to some other value. The simplest
3110b10d5efdSAlan Stern * approach is to use kzalloc() to allocate the structure containing
3111b10d5efdSAlan Stern * @dev.
3112b10d5efdSAlan Stern *
31135739411aSCornelia Huck * NOTE: Use put_device() to give up your reference instead of freeing
31145739411aSCornelia Huck * @dev directly once you have called this function.
31151da177e4SLinus Torvalds */
device_initialize(struct device * dev)31161da177e4SLinus Torvalds void device_initialize(struct device *dev)
31171da177e4SLinus Torvalds {
3118881c6cfdSGreg Kroah-Hartman dev->kobj.kset = devices_kset;
3119f9cb074bSGreg Kroah-Hartman kobject_init(&dev->kobj, &device_ktype);
31201da177e4SLinus Torvalds INIT_LIST_HEAD(&dev->dma_pools);
31213142788bSThomas Gleixner mutex_init(&dev->mutex);
31221704f47bSPeter Zijlstra lockdep_set_novalidate_class(&dev->mutex);
31239ac7849eSTejun Heo spin_lock_init(&dev->devres_lock);
31249ac7849eSTejun Heo INIT_LIST_HEAD(&dev->devres_head);
31253b98aeafSAlan Stern device_pm_init(dev);
3126d460d7f7SMax Gurtovoy set_dev_node(dev, NUMA_NO_NODE);
31279ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.consumers);
31289ed98953SRafael J. Wysocki INIT_LIST_HEAD(&dev->links.suppliers);
31293b052a3eSSaravana Kannan INIT_LIST_HEAD(&dev->links.defer_sync);
31309ed98953SRafael J. Wysocki dev->links.status = DL_DEV_NO_DRIVER;
31316d4e9a8eSChristoph Hellwig #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
31326d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
31336d4e9a8eSChristoph Hellwig defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
31346d4e9a8eSChristoph Hellwig dev->dma_coherent = dma_default_coherent;
31356d4e9a8eSChristoph Hellwig #endif
313605ee7741SPetr Tesarik swiotlb_dev_init(dev);
31371da177e4SLinus Torvalds }
313886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_initialize);
31391da177e4SLinus Torvalds
virtual_device_parent(struct device * dev)3140d73ce004STejun Heo struct kobject *virtual_device_parent(struct device *dev)
3141f0ee61a6SGreg Kroah-Hartman {
3142f0ee61a6SGreg Kroah-Hartman static struct kobject *virtual_dir = NULL;
3143f0ee61a6SGreg Kroah-Hartman
3144f0ee61a6SGreg Kroah-Hartman if (!virtual_dir)
31454ff6abffSGreg Kroah-Hartman virtual_dir = kobject_create_and_add("virtual",
3146881c6cfdSGreg Kroah-Hartman &devices_kset->kobj);
3147f0ee61a6SGreg Kroah-Hartman
314886406245SKay Sievers return virtual_dir;
3149f0ee61a6SGreg Kroah-Hartman }
3150f0ee61a6SGreg Kroah-Hartman
3151bc451f20SEric W. Biederman struct class_dir {
3152bc451f20SEric W. Biederman struct kobject kobj;
31539fa120fbSGreg Kroah-Hartman const struct class *class;
3154bc451f20SEric W. Biederman };
3155bc451f20SEric W. Biederman
3156bc451f20SEric W. Biederman #define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
3157bc451f20SEric W. Biederman
class_dir_release(struct kobject * kobj)3158bc451f20SEric W. Biederman static void class_dir_release(struct kobject *kobj)
3159bc451f20SEric W. Biederman {
3160bc451f20SEric W. Biederman struct class_dir *dir = to_class_dir(kobj);
3161bc451f20SEric W. Biederman kfree(dir);
3162bc451f20SEric W. Biederman }
3163bc451f20SEric W. Biederman
3164bc451f20SEric W. Biederman static const
class_dir_child_ns_type(const struct kobject * kobj)316502a476d9SGreg Kroah-Hartman struct kobj_ns_type_operations *class_dir_child_ns_type(const struct kobject *kobj)
3166bc451f20SEric W. Biederman {
316702a476d9SGreg Kroah-Hartman const struct class_dir *dir = to_class_dir(kobj);
3168bc451f20SEric W. Biederman return dir->class->ns_type;
3169bc451f20SEric W. Biederman }
3170bc451f20SEric W. Biederman
3171c83d9ab4SThomas Weißschuh static const struct kobj_type class_dir_ktype = {
3172bc451f20SEric W. Biederman .release = class_dir_release,
3173bc451f20SEric W. Biederman .sysfs_ops = &kobj_sysfs_ops,
3174bc451f20SEric W. Biederman .child_ns_type = class_dir_child_ns_type
3175bc451f20SEric W. Biederman };
3176bc451f20SEric W. Biederman
class_dir_create_and_add(struct subsys_private * sp,struct kobject * parent_kobj)31777d90e81aSGreg Kroah-Hartman static struct kobject *class_dir_create_and_add(struct subsys_private *sp,
31787d90e81aSGreg Kroah-Hartman struct kobject *parent_kobj)
3179bc451f20SEric W. Biederman {
3180bc451f20SEric W. Biederman struct class_dir *dir;
3181bc451f20SEric W. Biederman int retval;
3182bc451f20SEric W. Biederman
3183bc451f20SEric W. Biederman dir = kzalloc(sizeof(*dir), GFP_KERNEL);
3184bc451f20SEric W. Biederman if (!dir)
318584d0c27dSTetsuo Handa return ERR_PTR(-ENOMEM);
3186bc451f20SEric W. Biederman
31877d90e81aSGreg Kroah-Hartman dir->class = sp->class;
3188bc451f20SEric W. Biederman kobject_init(&dir->kobj, &class_dir_ktype);
3189bc451f20SEric W. Biederman
31907d90e81aSGreg Kroah-Hartman dir->kobj.kset = &sp->glue_dirs;
3191bc451f20SEric W. Biederman
31927d90e81aSGreg Kroah-Hartman retval = kobject_add(&dir->kobj, parent_kobj, "%s", sp->class->name);
3193bc451f20SEric W. Biederman if (retval < 0) {
3194bc451f20SEric W. Biederman kobject_put(&dir->kobj);
319584d0c27dSTetsuo Handa return ERR_PTR(retval);
3196bc451f20SEric W. Biederman }
3197bc451f20SEric W. Biederman return &dir->kobj;
3198bc451f20SEric W. Biederman }
3199bc451f20SEric W. Biederman
3200e4a60d13SYijing Wang static DEFINE_MUTEX(gdp_mutex);
3201bc451f20SEric W. Biederman
get_device_parent(struct device * dev,struct device * parent)3202c744aeaeSCornelia Huck static struct kobject *get_device_parent(struct device *dev,
3203c744aeaeSCornelia Huck struct device *parent)
320440fa5422SGreg Kroah-Hartman {
32057d90e81aSGreg Kroah-Hartman struct subsys_private *sp = class_to_subsys(dev->class);
320686406245SKay Sievers struct kobject *kobj = NULL;
32078c99377eSGreg Kroah-Hartman
32087d90e81aSGreg Kroah-Hartman if (sp) {
320986406245SKay Sievers struct kobject *parent_kobj;
321086406245SKay Sievers struct kobject *k;
321186406245SKay Sievers
321286406245SKay Sievers /*
321386406245SKay Sievers * If we have no parent, we live in "virtual".
32140f4dafc0SKay Sievers * Class-devices with a non class-device as parent, live
32150f4dafc0SKay Sievers * in a "glue" directory to prevent namespace collisions.
321686406245SKay Sievers */
321786406245SKay Sievers if (parent == NULL)
321886406245SKay Sievers parent_kobj = virtual_device_parent(dev);
32197d90e81aSGreg Kroah-Hartman else if (parent->class && !dev->class->ns_type) {
32207d90e81aSGreg Kroah-Hartman subsys_put(sp);
322186406245SKay Sievers return &parent->kobj;
32227d90e81aSGreg Kroah-Hartman } else {
322386406245SKay Sievers parent_kobj = &parent->kobj;
32247d90e81aSGreg Kroah-Hartman }
322586406245SKay Sievers
322677d3d7c1STejun Heo mutex_lock(&gdp_mutex);
322777d3d7c1STejun Heo
322886406245SKay Sievers /* find our class-directory at the parent and reference it */
32297d90e81aSGreg Kroah-Hartman spin_lock(&sp->glue_dirs.list_lock);
32307d90e81aSGreg Kroah-Hartman list_for_each_entry(k, &sp->glue_dirs.list, entry)
323186406245SKay Sievers if (k->parent == parent_kobj) {
323286406245SKay Sievers kobj = kobject_get(k);
323386406245SKay Sievers break;
323486406245SKay Sievers }
32357d90e81aSGreg Kroah-Hartman spin_unlock(&sp->glue_dirs.list_lock);
323677d3d7c1STejun Heo if (kobj) {
323777d3d7c1STejun Heo mutex_unlock(&gdp_mutex);
32387d90e81aSGreg Kroah-Hartman subsys_put(sp);
323986406245SKay Sievers return kobj;
324077d3d7c1STejun Heo }
324186406245SKay Sievers
324286406245SKay Sievers /* or create a new class-directory at the parent device */
32437d90e81aSGreg Kroah-Hartman k = class_dir_create_and_add(sp, parent_kobj);
32440f4dafc0SKay Sievers /* do not emit an uevent for this simple "glue" directory */
324577d3d7c1STejun Heo mutex_unlock(&gdp_mutex);
32467d90e81aSGreg Kroah-Hartman subsys_put(sp);
324743968d2fSGreg Kroah-Hartman return k;
324886406245SKay Sievers }
324986406245SKay Sievers
3250ca22e56dSKay Sievers /* subsystems can specify a default root directory for their devices */
32518c99377eSGreg Kroah-Hartman if (!parent && dev->bus) {
32528c99377eSGreg Kroah-Hartman struct device *dev_root = bus_get_dev_root(dev->bus);
32538c99377eSGreg Kroah-Hartman
32548c99377eSGreg Kroah-Hartman if (dev_root) {
32558c99377eSGreg Kroah-Hartman kobj = &dev_root->kobj;
32568c99377eSGreg Kroah-Hartman put_device(dev_root);
32578c99377eSGreg Kroah-Hartman return kobj;
32588c99377eSGreg Kroah-Hartman }
32598c99377eSGreg Kroah-Hartman }
3260ca22e56dSKay Sievers
326186406245SKay Sievers if (parent)
3262c744aeaeSCornelia Huck return &parent->kobj;
3263c744aeaeSCornelia Huck return NULL;
3264c744aeaeSCornelia Huck }
3265da231fd5SKay Sievers
live_in_glue_dir(struct kobject * kobj,struct device * dev)3266cebf8fd1SMing Lei static inline bool live_in_glue_dir(struct kobject *kobj,
3267cebf8fd1SMing Lei struct device *dev)
3268cebf8fd1SMing Lei {
32697d90e81aSGreg Kroah-Hartman struct subsys_private *sp;
32707d90e81aSGreg Kroah-Hartman bool retval;
32717d90e81aSGreg Kroah-Hartman
32727d90e81aSGreg Kroah-Hartman if (!kobj || !dev->class)
3273cebf8fd1SMing Lei return false;
32747d90e81aSGreg Kroah-Hartman
32757d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class);
32767d90e81aSGreg Kroah-Hartman if (!sp)
32777d90e81aSGreg Kroah-Hartman return false;
32787d90e81aSGreg Kroah-Hartman
32797d90e81aSGreg Kroah-Hartman if (kobj->kset == &sp->glue_dirs)
32807d90e81aSGreg Kroah-Hartman retval = true;
32817d90e81aSGreg Kroah-Hartman else
32827d90e81aSGreg Kroah-Hartman retval = false;
32837d90e81aSGreg Kroah-Hartman
32847d90e81aSGreg Kroah-Hartman subsys_put(sp);
32857d90e81aSGreg Kroah-Hartman return retval;
3286cebf8fd1SMing Lei }
3287cebf8fd1SMing Lei
get_glue_dir(struct device * dev)3288cebf8fd1SMing Lei static inline struct kobject *get_glue_dir(struct device *dev)
3289cebf8fd1SMing Lei {
3290cebf8fd1SMing Lei return dev->kobj.parent;
3291cebf8fd1SMing Lei }
3292cebf8fd1SMing Lei
3293f0832664SIngo Molnar /**
3294f0832664SIngo Molnar * kobject_has_children - Returns whether a kobject has children.
3295f0832664SIngo Molnar * @kobj: the object to test
3296f0832664SIngo Molnar *
3297f0832664SIngo Molnar * This will return whether a kobject has other kobjects as children.
3298f0832664SIngo Molnar *
3299f0832664SIngo Molnar * It does NOT account for the presence of attribute files, only sub
3300f0832664SIngo Molnar * directories. It also assumes there is no concurrent addition or
3301f0832664SIngo Molnar * removal of such children, and thus relies on external locking.
3302f0832664SIngo Molnar */
kobject_has_children(struct kobject * kobj)3303f0832664SIngo Molnar static inline bool kobject_has_children(struct kobject *kobj)
3304f0832664SIngo Molnar {
3305f0832664SIngo Molnar WARN_ON_ONCE(kref_read(&kobj->kref) == 0);
3306f0832664SIngo Molnar
3307f0832664SIngo Molnar return kobj->sd && kobj->sd->dir.subdirs;
3308f0832664SIngo Molnar }
3309f0832664SIngo Molnar
3310cebf8fd1SMing Lei /*
3311cebf8fd1SMing Lei * make sure cleaning up dir as the last step, we need to make
3312cebf8fd1SMing Lei * sure .release handler of kobject is run with holding the
3313cebf8fd1SMing Lei * global lock
3314cebf8fd1SMing Lei */
cleanup_glue_dir(struct device * dev,struct kobject * glue_dir)331563b6971aSCornelia Huck static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
3316da231fd5SKay Sievers {
3317ac43432cSMuchun Song unsigned int ref;
3318ac43432cSMuchun Song
33190f4dafc0SKay Sievers /* see if we live in a "glue" directory */
3320cebf8fd1SMing Lei if (!live_in_glue_dir(glue_dir, dev))
3321da231fd5SKay Sievers return;
3322da231fd5SKay Sievers
3323e4a60d13SYijing Wang mutex_lock(&gdp_mutex);
3324ac43432cSMuchun Song /**
3325ac43432cSMuchun Song * There is a race condition between removing glue directory
3326ac43432cSMuchun Song * and adding a new device under the glue directory.
3327ac43432cSMuchun Song *
3328ac43432cSMuchun Song * CPU1: CPU2:
3329ac43432cSMuchun Song *
3330ac43432cSMuchun Song * device_add()
3331ac43432cSMuchun Song * get_device_parent()
3332ac43432cSMuchun Song * class_dir_create_and_add()
3333ac43432cSMuchun Song * kobject_add_internal()
3334ac43432cSMuchun Song * create_dir() // create glue_dir
3335ac43432cSMuchun Song *
3336ac43432cSMuchun Song * device_add()
3337ac43432cSMuchun Song * get_device_parent()
3338ac43432cSMuchun Song * kobject_get() // get glue_dir
3339ac43432cSMuchun Song *
3340ac43432cSMuchun Song * device_del()
3341ac43432cSMuchun Song * cleanup_glue_dir()
3342ac43432cSMuchun Song * kobject_del(glue_dir)
3343ac43432cSMuchun Song *
3344ac43432cSMuchun Song * kobject_add()
3345ac43432cSMuchun Song * kobject_add_internal()
3346ac43432cSMuchun Song * create_dir() // in glue_dir
3347ac43432cSMuchun Song * sysfs_create_dir_ns()
3348ac43432cSMuchun Song * kernfs_create_dir_ns(sd)
3349ac43432cSMuchun Song *
3350ac43432cSMuchun Song * sysfs_remove_dir() // glue_dir->sd=NULL
3351ac43432cSMuchun Song * sysfs_put() // free glue_dir->sd
3352ac43432cSMuchun Song *
3353ac43432cSMuchun Song * // sd is freed
3354ac43432cSMuchun Song * kernfs_new_node(sd)
3355ac43432cSMuchun Song * kernfs_get(glue_dir)
3356ac43432cSMuchun Song * kernfs_add_one()
3357ac43432cSMuchun Song * kernfs_put()
3358ac43432cSMuchun Song *
3359ac43432cSMuchun Song * Before CPU1 remove last child device under glue dir, if CPU2 add
3360ac43432cSMuchun Song * a new device under glue dir, the glue_dir kobject reference count
3361ac43432cSMuchun Song * will be increase to 2 in kobject_get(k). And CPU2 has been called
3362ac43432cSMuchun Song * kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir()
3363ac43432cSMuchun Song * and sysfs_put(). This result in glue_dir->sd is freed.
3364ac43432cSMuchun Song *
3365ac43432cSMuchun Song * Then the CPU2 will see a stale "empty" but still potentially used
3366ac43432cSMuchun Song * glue dir around in kernfs_new_node().
3367ac43432cSMuchun Song *
3368ac43432cSMuchun Song * In order to avoid this happening, we also should make sure that
3369ac43432cSMuchun Song * kernfs_node for glue_dir is released in CPU1 only when refcount
3370ac43432cSMuchun Song * for glue_dir kobj is 1.
3371ac43432cSMuchun Song */
3372ac43432cSMuchun Song ref = kref_read(&glue_dir->kref);
3373ac43432cSMuchun Song if (!kobject_has_children(glue_dir) && !--ref)
3374726e4109SBenjamin Herrenschmidt kobject_del(glue_dir);
33750f4dafc0SKay Sievers kobject_put(glue_dir);
3376e4a60d13SYijing Wang mutex_unlock(&gdp_mutex);
3377da231fd5SKay Sievers }
337863b6971aSCornelia Huck
device_add_class_symlinks(struct device * dev)33792ee97cafSCornelia Huck static int device_add_class_symlinks(struct device *dev)
33802ee97cafSCornelia Huck {
33815590f319SBenjamin Herrenschmidt struct device_node *of_node = dev_of_node(dev);
33827d90e81aSGreg Kroah-Hartman struct subsys_private *sp;
33832ee97cafSCornelia Huck int error;
33842ee97cafSCornelia Huck
33855590f319SBenjamin Herrenschmidt if (of_node) {
33860c3c234bSRob Herring error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node");
33875590f319SBenjamin Herrenschmidt if (error)
33885590f319SBenjamin Herrenschmidt dev_warn(dev, "Error %d creating of_node link\n",error);
33895590f319SBenjamin Herrenschmidt /* An error here doesn't warrant bringing down the device */
33905590f319SBenjamin Herrenschmidt }
33915590f319SBenjamin Herrenschmidt
33927d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class);
33937d90e81aSGreg Kroah-Hartman if (!sp)
33942ee97cafSCornelia Huck return 0;
3395da231fd5SKay Sievers
33967d90e81aSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem");
33972ee97cafSCornelia Huck if (error)
33985590f319SBenjamin Herrenschmidt goto out_devnode;
3399da231fd5SKay Sievers
34004e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev)) {
34014f01a757SDmitry Torokhov error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
34024f01a757SDmitry Torokhov "device");
34034f01a757SDmitry Torokhov if (error)
340439aba963SKay Sievers goto out_subsys;
34052ee97cafSCornelia Huck }
340639aba963SKay Sievers
340739aba963SKay Sievers /* link in the class directory pointing to the device */
34087d90e81aSGreg Kroah-Hartman error = sysfs_create_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev));
340939aba963SKay Sievers if (error)
341039aba963SKay Sievers goto out_device;
34117d90e81aSGreg Kroah-Hartman goto exit;
34122ee97cafSCornelia Huck
341339aba963SKay Sievers out_device:
341439aba963SKay Sievers sysfs_remove_link(&dev->kobj, "device");
34152ee97cafSCornelia Huck out_subsys:
34162ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem");
34175590f319SBenjamin Herrenschmidt out_devnode:
34185590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node");
34197d90e81aSGreg Kroah-Hartman exit:
34207d90e81aSGreg Kroah-Hartman subsys_put(sp);
34212ee97cafSCornelia Huck return error;
34222ee97cafSCornelia Huck }
34232ee97cafSCornelia Huck
device_remove_class_symlinks(struct device * dev)34242ee97cafSCornelia Huck static void device_remove_class_symlinks(struct device *dev)
34252ee97cafSCornelia Huck {
34267d90e81aSGreg Kroah-Hartman struct subsys_private *sp = class_to_subsys(dev->class);
34277d90e81aSGreg Kroah-Hartman
34285590f319SBenjamin Herrenschmidt if (dev_of_node(dev))
34295590f319SBenjamin Herrenschmidt sysfs_remove_link(&dev->kobj, "of_node");
34305590f319SBenjamin Herrenschmidt
34317d90e81aSGreg Kroah-Hartman if (!sp)
34322ee97cafSCornelia Huck return;
3433da231fd5SKay Sievers
34344e886c29SGreg Kroah-Hartman if (dev->parent && device_is_not_partition(dev))
3435da231fd5SKay Sievers sysfs_remove_link(&dev->kobj, "device");
34362ee97cafSCornelia Huck sysfs_remove_link(&dev->kobj, "subsystem");
34377d90e81aSGreg Kroah-Hartman sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, dev_name(dev));
34387d90e81aSGreg Kroah-Hartman subsys_put(sp);
34392ee97cafSCornelia Huck }
34402ee97cafSCornelia Huck
34411da177e4SLinus Torvalds /**
3442413c239fSStephen Rothwell * dev_set_name - set a device name
3443413c239fSStephen Rothwell * @dev: device
344446232366SRandy Dunlap * @fmt: format string for the device's name
3445413c239fSStephen Rothwell */
dev_set_name(struct device * dev,const char * fmt,...)3446413c239fSStephen Rothwell int dev_set_name(struct device *dev, const char *fmt, ...)
3447413c239fSStephen Rothwell {
3448413c239fSStephen Rothwell va_list vargs;
34491fa5ae85SKay Sievers int err;
3450413c239fSStephen Rothwell
3451413c239fSStephen Rothwell va_start(vargs, fmt);
34521fa5ae85SKay Sievers err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
3453413c239fSStephen Rothwell va_end(vargs);
34541fa5ae85SKay Sievers return err;
3455413c239fSStephen Rothwell }
3456413c239fSStephen Rothwell EXPORT_SYMBOL_GPL(dev_set_name);
3457413c239fSStephen Rothwell
3458d6bdbbdfSGreg Kroah-Hartman /* select a /sys/dev/ directory for the device */
device_to_dev_kobj(struct device * dev)3459e105b8bfSDan Williams static struct kobject *device_to_dev_kobj(struct device *dev)
3460e105b8bfSDan Williams {
3461d6bdbbdfSGreg Kroah-Hartman if (is_blockdev(dev))
3462d6bdbbdfSGreg Kroah-Hartman return sysfs_dev_block_kobj;
3463e105b8bfSDan Williams else
3464d6bdbbdfSGreg Kroah-Hartman return sysfs_dev_char_kobj;
3465e105b8bfSDan Williams }
3466e105b8bfSDan Williams
device_create_sys_dev_entry(struct device * dev)3467e105b8bfSDan Williams static int device_create_sys_dev_entry(struct device *dev)
3468e105b8bfSDan Williams {
3469e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev);
3470e105b8bfSDan Williams int error = 0;
3471e105b8bfSDan Williams char devt_str[15];
3472e105b8bfSDan Williams
3473e105b8bfSDan Williams if (kobj) {
3474e105b8bfSDan Williams format_dev_t(devt_str, dev->devt);
3475e105b8bfSDan Williams error = sysfs_create_link(kobj, &dev->kobj, devt_str);
3476e105b8bfSDan Williams }
3477e105b8bfSDan Williams
3478e105b8bfSDan Williams return error;
3479e105b8bfSDan Williams }
3480e105b8bfSDan Williams
device_remove_sys_dev_entry(struct device * dev)3481e105b8bfSDan Williams static void device_remove_sys_dev_entry(struct device *dev)
3482e105b8bfSDan Williams {
3483e105b8bfSDan Williams struct kobject *kobj = device_to_dev_kobj(dev);
3484e105b8bfSDan Williams char devt_str[15];
3485e105b8bfSDan Williams
3486e105b8bfSDan Williams if (kobj) {
3487e105b8bfSDan Williams format_dev_t(devt_str, dev->devt);
3488e105b8bfSDan Williams sysfs_remove_link(kobj, devt_str);
3489e105b8bfSDan Williams }
3490e105b8bfSDan Williams }
3491e105b8bfSDan Williams
device_private_init(struct device * dev)349246d3a037SShaokun Zhang static int device_private_init(struct device *dev)
3493b4028437SGreg Kroah-Hartman {
3494b4028437SGreg Kroah-Hartman dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
3495b4028437SGreg Kroah-Hartman if (!dev->p)
3496b4028437SGreg Kroah-Hartman return -ENOMEM;
3497b4028437SGreg Kroah-Hartman dev->p->device = dev;
3498b4028437SGreg Kroah-Hartman klist_init(&dev->p->klist_children, klist_children_get,
3499b4028437SGreg Kroah-Hartman klist_children_put);
3500ef8a3fd6SGreg Kroah-Hartman INIT_LIST_HEAD(&dev->p->deferred_probe);
3501b4028437SGreg Kroah-Hartman return 0;
3502b4028437SGreg Kroah-Hartman }
3503b4028437SGreg Kroah-Hartman
3504e105b8bfSDan Williams /**
35051da177e4SLinus Torvalds * device_add - add device to device hierarchy.
35061da177e4SLinus Torvalds * @dev: device.
35071da177e4SLinus Torvalds *
35081da177e4SLinus Torvalds * This is part 2 of device_register(), though may be called
35091da177e4SLinus Torvalds * separately _iff_ device_initialize() has been called separately.
35101da177e4SLinus Torvalds *
35115739411aSCornelia Huck * This adds @dev to the kobject hierarchy via kobject_add(), adds it
35121da177e4SLinus Torvalds * to the global and sibling lists for the device, then
35131da177e4SLinus Torvalds * adds it to the other relevant subsystems of the driver model.
35145739411aSCornelia Huck *
3515b10d5efdSAlan Stern * Do not call this routine or device_register() more than once for
3516b10d5efdSAlan Stern * any device structure. The driver model core is not designed to work
3517b10d5efdSAlan Stern * with devices that get unregistered and then spring back to life.
3518b10d5efdSAlan Stern * (Among other things, it's very hard to guarantee that all references
3519b10d5efdSAlan Stern * to the previous incarnation of @dev have been dropped.) Allocate
3520b10d5efdSAlan Stern * and register a fresh new struct device instead.
3521b10d5efdSAlan Stern *
35225739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even
35235739411aSCornelia Huck * if it returned an error! Always use put_device() to give up your
35245739411aSCornelia Huck * reference instead.
3525affada72SBorislav Petkov *
3526affada72SBorislav Petkov * Rule of thumb is: if device_add() succeeds, you should call
3527affada72SBorislav Petkov * device_del() when you want to get rid of it. If device_add() has
3528affada72SBorislav Petkov * *not* succeeded, use *only* put_device() to drop the reference
3529affada72SBorislav Petkov * count.
35301da177e4SLinus Torvalds */
device_add(struct device * dev)35311da177e4SLinus Torvalds int device_add(struct device *dev)
35321da177e4SLinus Torvalds {
35337d90e81aSGreg Kroah-Hartman struct subsys_private *sp;
353435dbf4efSViresh Kumar struct device *parent;
3535ca22e56dSKay Sievers struct kobject *kobj;
3536c47ed219SGreg Kroah-Hartman struct class_interface *class_intf;
35375f5377eaSSaravana Kannan int error = -EINVAL;
3538cebf8fd1SMing Lei struct kobject *glue_dir = NULL;
3539775b64d2SRafael J. Wysocki
35401da177e4SLinus Torvalds dev = get_device(dev);
3541c906a48aSGreg Kroah-Hartman if (!dev)
3542c906a48aSGreg Kroah-Hartman goto done;
3543c906a48aSGreg Kroah-Hartman
3544fb069a5dSGreg Kroah-Hartman if (!dev->p) {
3545b4028437SGreg Kroah-Hartman error = device_private_init(dev);
3546b4028437SGreg Kroah-Hartman if (error)
3547fb069a5dSGreg Kroah-Hartman goto done;
3548fb069a5dSGreg Kroah-Hartman }
3549fb069a5dSGreg Kroah-Hartman
35501fa5ae85SKay Sievers /*
35511fa5ae85SKay Sievers * for statically allocated devices, which should all be converted
35521fa5ae85SKay Sievers * some day, we need to initialize the name. We prevent reading back
35531fa5ae85SKay Sievers * the name, and force the use of dev_name()
35541fa5ae85SKay Sievers */
35551fa5ae85SKay Sievers if (dev->init_name) {
3556d21fdd07SAndy Shevchenko error = dev_set_name(dev, "%s", dev->init_name);
35571fa5ae85SKay Sievers dev->init_name = NULL;
35581fa5ae85SKay Sievers }
3559c906a48aSGreg Kroah-Hartman
3560d21fdd07SAndy Shevchenko if (dev_name(dev))
3561d21fdd07SAndy Shevchenko error = 0;
3562ca22e56dSKay Sievers /* subsystems can specify simple device enumeration */
3563d21fdd07SAndy Shevchenko else if (dev->bus && dev->bus->dev_name)
3564d21fdd07SAndy Shevchenko error = dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
3565fd6f7ad2SAndy Shevchenko else
3566fd6f7ad2SAndy Shevchenko error = -EINVAL;
3567d21fdd07SAndy Shevchenko if (error)
35685c8563d7SKay Sievers goto name_error;
35691da177e4SLinus Torvalds
35701e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3571c205ef48SGreg Kroah-Hartman
35721da177e4SLinus Torvalds parent = get_device(dev->parent);
3573ca22e56dSKay Sievers kobj = get_device_parent(dev, parent);
357484d0c27dSTetsuo Handa if (IS_ERR(kobj)) {
357584d0c27dSTetsuo Handa error = PTR_ERR(kobj);
357684d0c27dSTetsuo Handa goto parent_error;
357784d0c27dSTetsuo Handa }
3578ca22e56dSKay Sievers if (kobj)
3579ca22e56dSKay Sievers dev->kobj.parent = kobj;
35801da177e4SLinus Torvalds
35810d358f22SYinghai Lu /* use parent numa_node */
358256f2de81SZhen Lei if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
35830d358f22SYinghai Lu set_dev_node(dev, dev_to_node(parent));
35840d358f22SYinghai Lu
35851da177e4SLinus Torvalds /* first, register with generic layer. */
35868a577ffcSKay Sievers /* we require the name to be set before, and pass NULL */
35878a577ffcSKay Sievers error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
3588cebf8fd1SMing Lei if (error) {
35896977b1a5SZhengchao Shao glue_dir = kobj;
35901da177e4SLinus Torvalds goto Error;
3591cebf8fd1SMing Lei }
3592a7fd6706SKay Sievers
359337022644SBrian Walsh /* notify platform of device entry */
3594b2ebd9ddSRafael J. Wysocki device_platform_notify(dev);
359537022644SBrian Walsh
3596c5e064a6SGreg Kroah-Hartman error = device_create_file(dev, &dev_attr_uevent);
3597a306eea4SCornelia Huck if (error)
3598a306eea4SCornelia Huck goto attrError;
3599a7fd6706SKay Sievers
36002ee97cafSCornelia Huck error = device_add_class_symlinks(dev);
36012ee97cafSCornelia Huck if (error)
36022ee97cafSCornelia Huck goto SymlinkError;
3603dc0afa83SCornelia Huck error = device_add_attrs(dev);
3604dc0afa83SCornelia Huck if (error)
36052620efefSGreg Kroah-Hartman goto AttrsError;
3606dc0afa83SCornelia Huck error = bus_add_device(dev);
3607dc0afa83SCornelia Huck if (error)
36081da177e4SLinus Torvalds goto BusError;
36093b98aeafSAlan Stern error = dpm_sysfs_add(dev);
361057eee3d2SRafael J. Wysocki if (error)
36113b98aeafSAlan Stern goto DPMError;
36123b98aeafSAlan Stern device_pm_add(dev);
3613ec0676eeSAlan Stern
36140cd75047SSergey Klyaus if (MAJOR(dev->devt)) {
36150cd75047SSergey Klyaus error = device_create_file(dev, &dev_attr_dev);
36160cd75047SSergey Klyaus if (error)
36170cd75047SSergey Klyaus goto DevAttrError;
36180cd75047SSergey Klyaus
36190cd75047SSergey Klyaus error = device_create_sys_dev_entry(dev);
36200cd75047SSergey Klyaus if (error)
36210cd75047SSergey Klyaus goto SysEntryError;
36220cd75047SSergey Klyaus
36230cd75047SSergey Klyaus devtmpfs_create_node(dev);
36240cd75047SSergey Klyaus }
36250cd75047SSergey Klyaus
3626ec0676eeSAlan Stern /* Notify clients of device addition. This call must come
3627268863f4Smajianpeng * after dpm_sysfs_add() and before kobject_uevent().
3628ec0676eeSAlan Stern */
3629ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_ADD_DEVICE);
363053877d06SKay Sievers kobject_uevent(&dev->kobj, KOBJ_ADD);
3631372a67c0SSaravana Kannan
3632e2ae9bccSSaravana Kannan /*
3633e2ae9bccSSaravana Kannan * Check if any of the other devices (consumers) have been waiting for
3634e2ae9bccSSaravana Kannan * this device (supplier) to be added so that they can create a device
3635e2ae9bccSSaravana Kannan * link to it.
3636e2ae9bccSSaravana Kannan *
3637e2ae9bccSSaravana Kannan * This needs to happen after device_pm_add() because device_link_add()
3638e2ae9bccSSaravana Kannan * requires the supplier be registered before it's called.
3639e2ae9bccSSaravana Kannan *
36402cd38fd1SSaravana Kannan * But this also needs to happen before bus_probe_device() to make sure
3641e2ae9bccSSaravana Kannan * waiting consumers can link to it before the driver is bound to the
3642e2ae9bccSSaravana Kannan * device and the driver sync_state callback is called for this device.
3643e2ae9bccSSaravana Kannan */
36442cd38fd1SSaravana Kannan if (dev->fwnode && !dev->fwnode->dev) {
36452cd38fd1SSaravana Kannan dev->fwnode->dev = dev;
36465f5377eaSSaravana Kannan fw_devlink_link_device(dev);
364703324507SSaravana Kannan }
3648e2ae9bccSSaravana Kannan
36492023c610SAlan Stern bus_probe_device(dev);
3650d46f3e3eSSaravana Kannan
3651d46f3e3eSSaravana Kannan /*
3652d46f3e3eSSaravana Kannan * If all driver registration is done and a newly added device doesn't
3653d46f3e3eSSaravana Kannan * match with any driver, don't block its consumers from probing in
3654d46f3e3eSSaravana Kannan * case the consumer device is able to operate without this supplier.
3655d46f3e3eSSaravana Kannan */
3656d46f3e3eSSaravana Kannan if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match)
3657d46f3e3eSSaravana Kannan fw_devlink_unblock_consumers(dev);
3658d46f3e3eSSaravana Kannan
36591da177e4SLinus Torvalds if (parent)
3660f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent,
3661f791b8c8SGreg Kroah-Hartman &parent->p->klist_children);
36621da177e4SLinus Torvalds
36637d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class);
36647d90e81aSGreg Kroah-Hartman if (sp) {
36657d90e81aSGreg Kroah-Hartman mutex_lock(&sp->mutex);
3666c47ed219SGreg Kroah-Hartman /* tie the class to the device */
36677d90e81aSGreg Kroah-Hartman klist_add_tail(&dev->p->knode_class, &sp->klist_devices);
3668c47ed219SGreg Kroah-Hartman
3669c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is here */
36707d90e81aSGreg Kroah-Hartman list_for_each_entry(class_intf, &sp->interfaces, node)
3671c47ed219SGreg Kroah-Hartman if (class_intf->add_dev)
36722243acd5SGreg Kroah-Hartman class_intf->add_dev(dev);
36737d90e81aSGreg Kroah-Hartman mutex_unlock(&sp->mutex);
36747d90e81aSGreg Kroah-Hartman subsys_put(sp);
36755d9fd169SGreg Kroah-Hartman }
3676c906a48aSGreg Kroah-Hartman done:
36771da177e4SLinus Torvalds put_device(dev);
36781da177e4SLinus Torvalds return error;
36790cd75047SSergey Klyaus SysEntryError:
36800cd75047SSergey Klyaus if (MAJOR(dev->devt))
36810cd75047SSergey Klyaus device_remove_file(dev, &dev_attr_dev);
36820cd75047SSergey Klyaus DevAttrError:
36830cd75047SSergey Klyaus device_pm_remove(dev);
36840cd75047SSergey Klyaus dpm_sysfs_remove(dev);
36853b98aeafSAlan Stern DPMError:
3686f6837f34SYang Yingliang dev->driver = NULL;
368757eee3d2SRafael J. Wysocki bus_remove_device(dev);
368857eee3d2SRafael J. Wysocki BusError:
36892620efefSGreg Kroah-Hartman device_remove_attrs(dev);
36902620efefSGreg Kroah-Hartman AttrsError:
36912ee97cafSCornelia Huck device_remove_class_symlinks(dev);
36922ee97cafSCornelia Huck SymlinkError:
3693c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent);
369423681e47SGreg Kroah-Hartman attrError:
3695b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev);
3696312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE);
3697cebf8fd1SMing Lei glue_dir = get_glue_dir(dev);
36981da177e4SLinus Torvalds kobject_del(&dev->kobj);
36991da177e4SLinus Torvalds Error:
3700cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir);
370184d0c27dSTetsuo Handa parent_error:
37021da177e4SLinus Torvalds put_device(parent);
37035c8563d7SKay Sievers name_error:
37045c8563d7SKay Sievers kfree(dev->p);
37055c8563d7SKay Sievers dev->p = NULL;
3706c906a48aSGreg Kroah-Hartman goto done;
37071da177e4SLinus Torvalds }
370886df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_add);
37091da177e4SLinus Torvalds
37101da177e4SLinus Torvalds /**
37111da177e4SLinus Torvalds * device_register - register a device with the system.
37121da177e4SLinus Torvalds * @dev: pointer to the device structure
37131da177e4SLinus Torvalds *
37141da177e4SLinus Torvalds * This happens in two clean steps - initialize the device
37151da177e4SLinus Torvalds * and add it to the system. The two steps can be called
37161da177e4SLinus Torvalds * separately, but this is the easiest and most common.
37171da177e4SLinus Torvalds * I.e. you should only call the two helpers separately if
37181da177e4SLinus Torvalds * have a clearly defined need to use and refcount the device
37191da177e4SLinus Torvalds * before it is added to the hierarchy.
37205739411aSCornelia Huck *
3721b10d5efdSAlan Stern * For more information, see the kerneldoc for device_initialize()
3722b10d5efdSAlan Stern * and device_add().
3723b10d5efdSAlan Stern *
37245739411aSCornelia Huck * NOTE: _Never_ directly free @dev after calling this function, even
37255739411aSCornelia Huck * if it returned an error! Always use put_device() to give up the
37265739411aSCornelia Huck * reference initialized in this function instead.
37271da177e4SLinus Torvalds */
device_register(struct device * dev)37281da177e4SLinus Torvalds int device_register(struct device *dev)
37291da177e4SLinus Torvalds {
37301da177e4SLinus Torvalds device_initialize(dev);
37311da177e4SLinus Torvalds return device_add(dev);
37321da177e4SLinus Torvalds }
373386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_register);
37341da177e4SLinus Torvalds
37351da177e4SLinus Torvalds /**
37361da177e4SLinus Torvalds * get_device - increment reference count for device.
37371da177e4SLinus Torvalds * @dev: device.
37381da177e4SLinus Torvalds *
37391da177e4SLinus Torvalds * This simply forwards the call to kobject_get(), though
37401da177e4SLinus Torvalds * we do take care to provide for the case that we get a NULL
37411da177e4SLinus Torvalds * pointer passed in.
37421da177e4SLinus Torvalds */
get_device(struct device * dev)37431da177e4SLinus Torvalds struct device *get_device(struct device *dev)
37441da177e4SLinus Torvalds {
3745b0d1f807SLars-Peter Clausen return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
37461da177e4SLinus Torvalds }
374786df2687SDavid Graham White EXPORT_SYMBOL_GPL(get_device);
37481da177e4SLinus Torvalds
37491da177e4SLinus Torvalds /**
37501da177e4SLinus Torvalds * put_device - decrement reference count.
37511da177e4SLinus Torvalds * @dev: device in question.
37521da177e4SLinus Torvalds */
put_device(struct device * dev)37531da177e4SLinus Torvalds void put_device(struct device *dev)
37541da177e4SLinus Torvalds {
3755edfaa7c3SKay Sievers /* might_sleep(); */
37561da177e4SLinus Torvalds if (dev)
37571da177e4SLinus Torvalds kobject_put(&dev->kobj);
37581da177e4SLinus Torvalds }
375986df2687SDavid Graham White EXPORT_SYMBOL_GPL(put_device);
37601da177e4SLinus Torvalds
kill_device(struct device * dev)376100289cd8SDan Williams bool kill_device(struct device *dev)
376200289cd8SDan Williams {
376300289cd8SDan Williams /*
376400289cd8SDan Williams * Require the device lock and set the "dead" flag to guarantee that
376500289cd8SDan Williams * the update behavior is consistent with the other bitfields near
376600289cd8SDan Williams * it and that we cannot have an asynchronous probe routine trying
376700289cd8SDan Williams * to run while we are tearing out the bus/class/sysfs from
376800289cd8SDan Williams * underneath the device.
376900289cd8SDan Williams */
37708c60a141SJulian Wiedmann device_lock_assert(dev);
377100289cd8SDan Williams
377200289cd8SDan Williams if (dev->p->dead)
377300289cd8SDan Williams return false;
377400289cd8SDan Williams dev->p->dead = true;
377500289cd8SDan Williams return true;
377600289cd8SDan Williams }
377700289cd8SDan Williams EXPORT_SYMBOL_GPL(kill_device);
377800289cd8SDan Williams
37791da177e4SLinus Torvalds /**
37801da177e4SLinus Torvalds * device_del - delete device from system.
37811da177e4SLinus Torvalds * @dev: device.
37821da177e4SLinus Torvalds *
37831da177e4SLinus Torvalds * This is the first part of the device unregistration
37841da177e4SLinus Torvalds * sequence. This removes the device from the lists we control
37851da177e4SLinus Torvalds * from here, has it removed from the other driver model
37861da177e4SLinus Torvalds * subsystems it was added to in device_add(), and removes it
37871da177e4SLinus Torvalds * from the kobject hierarchy.
37881da177e4SLinus Torvalds *
37891da177e4SLinus Torvalds * NOTE: this should be called manually _iff_ device_add() was
37901da177e4SLinus Torvalds * also called manually.
37911da177e4SLinus Torvalds */
device_del(struct device * dev)37921da177e4SLinus Torvalds void device_del(struct device *dev)
37931da177e4SLinus Torvalds {
37947d90e81aSGreg Kroah-Hartman struct subsys_private *sp;
37951da177e4SLinus Torvalds struct device *parent = dev->parent;
3796cebf8fd1SMing Lei struct kobject *glue_dir = NULL;
3797c47ed219SGreg Kroah-Hartman struct class_interface *class_intf;
3798b8530017SOliver Neukum unsigned int noio_flag;
37991da177e4SLinus Torvalds
38003451a495SAlexander Duyck device_lock(dev);
380100289cd8SDan Williams kill_device(dev);
38023451a495SAlexander Duyck device_unlock(dev);
38033451a495SAlexander Duyck
3804372a67c0SSaravana Kannan if (dev->fwnode && dev->fwnode->dev == dev)
3805372a67c0SSaravana Kannan dev->fwnode->dev = NULL;
3806372a67c0SSaravana Kannan
3807ec0676eeSAlan Stern /* Notify clients of device removal. This call must come
3808ec0676eeSAlan Stern * before dpm_sysfs_remove().
3809ec0676eeSAlan Stern */
3810b8530017SOliver Neukum noio_flag = memalloc_noio_save();
3811ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_DEL_DEVICE);
38129ed98953SRafael J. Wysocki
38133b98aeafSAlan Stern dpm_sysfs_remove(dev);
38141da177e4SLinus Torvalds if (parent)
3815f791b8c8SGreg Kroah-Hartman klist_del(&dev->p->knode_parent);
3816e105b8bfSDan Williams if (MAJOR(dev->devt)) {
38172b2af54aSKay Sievers devtmpfs_delete_node(dev);
3818e105b8bfSDan Williams device_remove_sys_dev_entry(dev);
3819c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_dev);
3820e105b8bfSDan Williams }
38217d90e81aSGreg Kroah-Hartman
38227d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class);
38237d90e81aSGreg Kroah-Hartman if (sp) {
3824da231fd5SKay Sievers device_remove_class_symlinks(dev);
382599ef3ef8SKay Sievers
38267d90e81aSGreg Kroah-Hartman mutex_lock(&sp->mutex);
3827c47ed219SGreg Kroah-Hartman /* notify any interfaces that the device is now gone */
38287d90e81aSGreg Kroah-Hartman list_for_each_entry(class_intf, &sp->interfaces, node)
3829c47ed219SGreg Kroah-Hartman if (class_intf->remove_dev)
38302243acd5SGreg Kroah-Hartman class_intf->remove_dev(dev);
3831c47ed219SGreg Kroah-Hartman /* remove the device from the class list */
3832570d0200SWei Yang klist_del(&dev->p->knode_class);
38337d90e81aSGreg Kroah-Hartman mutex_unlock(&sp->mutex);
38347d90e81aSGreg Kroah-Hartman subsys_put(sp);
3835b9d9c82bSKay Sievers }
3836c5e064a6SGreg Kroah-Hartman device_remove_file(dev, &dev_attr_uevent);
38372620efefSGreg Kroah-Hartman device_remove_attrs(dev);
383828953533SBenjamin Herrenschmidt bus_remove_device(dev);
38394b6d1f12SLongX Zhang device_pm_remove(dev);
3840d1c3414cSGrant Likely driver_deferred_probe_del(dev);
3841b2ebd9ddSRafael J. Wysocki device_platform_notify_remove(dev);
38422ec16150SJeffy Chen device_links_purge(dev);
38431da177e4SLinus Torvalds
3844699fb50dSDavid Gow /*
3845699fb50dSDavid Gow * If a device does not have a driver attached, we need to clean
3846699fb50dSDavid Gow * up any managed resources. We do this in device_release(), but
3847699fb50dSDavid Gow * it's never called (and we leak the device) if a managed
3848699fb50dSDavid Gow * resource holds a reference to the device. So release all
3849699fb50dSDavid Gow * managed resources here, like we do in driver_detach(). We
3850699fb50dSDavid Gow * still need to do so again in device_release() in case someone
3851699fb50dSDavid Gow * adds a new resource after this point, though.
3852699fb50dSDavid Gow */
3853699fb50dSDavid Gow devres_release_all(dev);
3854699fb50dSDavid Gow
3855ed9f9181SGreg Kroah-Hartman bus_notify(dev, BUS_NOTIFY_REMOVED_DEVICE);
3856312c004dSKay Sievers kobject_uevent(&dev->kobj, KOBJ_REMOVE);
3857cebf8fd1SMing Lei glue_dir = get_glue_dir(dev);
38581da177e4SLinus Torvalds kobject_del(&dev->kobj);
3859cebf8fd1SMing Lei cleanup_glue_dir(dev, glue_dir);
3860b8530017SOliver Neukum memalloc_noio_restore(noio_flag);
38611da177e4SLinus Torvalds put_device(parent);
38621da177e4SLinus Torvalds }
386386df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_del);
38641da177e4SLinus Torvalds
38651da177e4SLinus Torvalds /**
38661da177e4SLinus Torvalds * device_unregister - unregister device from system.
38671da177e4SLinus Torvalds * @dev: device going away.
38681da177e4SLinus Torvalds *
38691da177e4SLinus Torvalds * We do this in two parts, like we do device_register(). First,
38701da177e4SLinus Torvalds * we remove it from all the subsystems with device_del(), then
38711da177e4SLinus Torvalds * we decrement the reference count via put_device(). If that
38721da177e4SLinus Torvalds * is the final reference count, the device will be cleaned up
38731da177e4SLinus Torvalds * via device_release() above. Otherwise, the structure will
38741da177e4SLinus Torvalds * stick around until the final reference to the device is dropped.
38751da177e4SLinus Torvalds */
device_unregister(struct device * dev)38761da177e4SLinus Torvalds void device_unregister(struct device *dev)
38771da177e4SLinus Torvalds {
38781e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
38791da177e4SLinus Torvalds device_del(dev);
38801da177e4SLinus Torvalds put_device(dev);
38811da177e4SLinus Torvalds }
388286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_unregister);
38831da177e4SLinus Torvalds
prev_device(struct klist_iter * i)38843d060aebSAndy Shevchenko static struct device *prev_device(struct klist_iter *i)
38853d060aebSAndy Shevchenko {
38863d060aebSAndy Shevchenko struct klist_node *n = klist_prev(i);
38873d060aebSAndy Shevchenko struct device *dev = NULL;
38883d060aebSAndy Shevchenko struct device_private *p;
38893d060aebSAndy Shevchenko
38903d060aebSAndy Shevchenko if (n) {
38913d060aebSAndy Shevchenko p = to_device_private_parent(n);
38923d060aebSAndy Shevchenko dev = p->device;
38933d060aebSAndy Shevchenko }
38943d060aebSAndy Shevchenko return dev;
38953d060aebSAndy Shevchenko }
38963d060aebSAndy Shevchenko
next_device(struct klist_iter * i)389736239577Smochel@digitalimplant.org static struct device *next_device(struct klist_iter *i)
389836239577Smochel@digitalimplant.org {
389936239577Smochel@digitalimplant.org struct klist_node *n = klist_next(i);
3900f791b8c8SGreg Kroah-Hartman struct device *dev = NULL;
3901f791b8c8SGreg Kroah-Hartman struct device_private *p;
3902f791b8c8SGreg Kroah-Hartman
3903f791b8c8SGreg Kroah-Hartman if (n) {
3904f791b8c8SGreg Kroah-Hartman p = to_device_private_parent(n);
3905f791b8c8SGreg Kroah-Hartman dev = p->device;
3906f791b8c8SGreg Kroah-Hartman }
3907f791b8c8SGreg Kroah-Hartman return dev;
390836239577Smochel@digitalimplant.org }
390936239577Smochel@digitalimplant.org
39101da177e4SLinus Torvalds /**
3911e454cea2SKay Sievers * device_get_devnode - path of device node file
39126fcf53acSKay Sievers * @dev: device
3913e454cea2SKay Sievers * @mode: returned file access mode
39143c2670e6SKay Sievers * @uid: returned file owner
39153c2670e6SKay Sievers * @gid: returned file group
39166fcf53acSKay Sievers * @tmp: possibly allocated string
39176fcf53acSKay Sievers *
39186fcf53acSKay Sievers * Return the relative path of a possible device node.
39196fcf53acSKay Sievers * Non-default names may need to allocate a memory to compose
39206fcf53acSKay Sievers * a name. This memory is returned in tmp and needs to be
39216fcf53acSKay Sievers * freed by the caller.
39226fcf53acSKay Sievers */
device_get_devnode(const struct device * dev,umode_t * mode,kuid_t * uid,kgid_t * gid,const char ** tmp)392342bb5be8SGreg Kroah-Hartman const char *device_get_devnode(const struct device *dev,
39244e4098a3SGreg Kroah-Hartman umode_t *mode, kuid_t *uid, kgid_t *gid,
39253c2670e6SKay Sievers const char **tmp)
39266fcf53acSKay Sievers {
39276fcf53acSKay Sievers char *s;
39286fcf53acSKay Sievers
39296fcf53acSKay Sievers *tmp = NULL;
39306fcf53acSKay Sievers
39316fcf53acSKay Sievers /* the device type may provide a specific name */
3932e454cea2SKay Sievers if (dev->type && dev->type->devnode)
39333c2670e6SKay Sievers *tmp = dev->type->devnode(dev, mode, uid, gid);
39346fcf53acSKay Sievers if (*tmp)
39356fcf53acSKay Sievers return *tmp;
39366fcf53acSKay Sievers
39376fcf53acSKay Sievers /* the class may provide a specific name */
3938e454cea2SKay Sievers if (dev->class && dev->class->devnode)
3939e454cea2SKay Sievers *tmp = dev->class->devnode(dev, mode);
39406fcf53acSKay Sievers if (*tmp)
39416fcf53acSKay Sievers return *tmp;
39426fcf53acSKay Sievers
39436fcf53acSKay Sievers /* return name without allocation, tmp == NULL */
39446fcf53acSKay Sievers if (strchr(dev_name(dev), '!') == NULL)
39456fcf53acSKay Sievers return dev_name(dev);
39466fcf53acSKay Sievers
39476fcf53acSKay Sievers /* replace '!' in the name with '/' */
39487f146b24SAndy Shevchenko s = kstrdup_and_replace(dev_name(dev), '!', '/', GFP_KERNEL);
3949a29fd614SRasmus Villemoes if (!s)
39506fcf53acSKay Sievers return NULL;
3951a29fd614SRasmus Villemoes return *tmp = s;
39526fcf53acSKay Sievers }
39536fcf53acSKay Sievers
39546fcf53acSKay Sievers /**
39551da177e4SLinus Torvalds * device_for_each_child - device child iterator.
3956c41455fbSRandy Dunlap * @parent: parent struct device.
39571da177e4SLinus Torvalds * @fn: function to be called for each device.
3958f8878dcbSRobert P. J. Day * @data: data for the callback.
39591da177e4SLinus Torvalds *
3960c41455fbSRandy Dunlap * Iterate over @parent's child devices, and call @fn for each,
39611da177e4SLinus Torvalds * passing it @data.
39621da177e4SLinus Torvalds *
39631da177e4SLinus Torvalds * We check the return of @fn each time. If it returns anything
39641da177e4SLinus Torvalds * other than 0, we break out and return that value.
39651da177e4SLinus Torvalds */
device_for_each_child(struct device * parent,void * data,int (* fn)(struct device * dev,void * data))396636239577Smochel@digitalimplant.org int device_for_each_child(struct device *parent, void *data,
39674a3ad20cSGreg Kroah-Hartman int (*fn)(struct device *dev, void *data))
39681da177e4SLinus Torvalds {
396936239577Smochel@digitalimplant.org struct klist_iter i;
39701da177e4SLinus Torvalds struct device *child;
39711da177e4SLinus Torvalds int error = 0;
39721da177e4SLinus Torvalds
3973014c90dbSGreg Kroah-Hartman if (!parent->p)
3974014c90dbSGreg Kroah-Hartman return 0;
3975014c90dbSGreg Kroah-Hartman
3976f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i);
397793ead7c9SGimcuan Hui while (!error && (child = next_device(&i)))
397836239577Smochel@digitalimplant.org error = fn(child, data);
397936239577Smochel@digitalimplant.org klist_iter_exit(&i);
39801da177e4SLinus Torvalds return error;
39811da177e4SLinus Torvalds }
398286df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_for_each_child);
39831da177e4SLinus Torvalds
39845ab69981SCornelia Huck /**
39853d060aebSAndy Shevchenko * device_for_each_child_reverse - device child iterator in reversed order.
39863d060aebSAndy Shevchenko * @parent: parent struct device.
39873d060aebSAndy Shevchenko * @fn: function to be called for each device.
39883d060aebSAndy Shevchenko * @data: data for the callback.
39893d060aebSAndy Shevchenko *
39903d060aebSAndy Shevchenko * Iterate over @parent's child devices, and call @fn for each,
39913d060aebSAndy Shevchenko * passing it @data.
39923d060aebSAndy Shevchenko *
39933d060aebSAndy Shevchenko * We check the return of @fn each time. If it returns anything
39943d060aebSAndy Shevchenko * other than 0, we break out and return that value.
39953d060aebSAndy Shevchenko */
device_for_each_child_reverse(struct device * parent,void * data,int (* fn)(struct device * dev,void * data))39963d060aebSAndy Shevchenko int device_for_each_child_reverse(struct device *parent, void *data,
39973d060aebSAndy Shevchenko int (*fn)(struct device *dev, void *data))
39983d060aebSAndy Shevchenko {
39993d060aebSAndy Shevchenko struct klist_iter i;
40003d060aebSAndy Shevchenko struct device *child;
40013d060aebSAndy Shevchenko int error = 0;
40023d060aebSAndy Shevchenko
40033d060aebSAndy Shevchenko if (!parent->p)
40043d060aebSAndy Shevchenko return 0;
40053d060aebSAndy Shevchenko
40063d060aebSAndy Shevchenko klist_iter_init(&parent->p->klist_children, &i);
40073d060aebSAndy Shevchenko while ((child = prev_device(&i)) && !error)
40083d060aebSAndy Shevchenko error = fn(child, data);
40093d060aebSAndy Shevchenko klist_iter_exit(&i);
40103d060aebSAndy Shevchenko return error;
40113d060aebSAndy Shevchenko }
40123d060aebSAndy Shevchenko EXPORT_SYMBOL_GPL(device_for_each_child_reverse);
40133d060aebSAndy Shevchenko
40143d060aebSAndy Shevchenko /**
40155ab69981SCornelia Huck * device_find_child - device iterator for locating a particular device.
40165ab69981SCornelia Huck * @parent: parent struct device
40175ab69981SCornelia Huck * @match: Callback function to check device
4018f8878dcbSRobert P. J. Day * @data: Data to pass to match function
40195ab69981SCornelia Huck *
40205ab69981SCornelia Huck * This is similar to the device_for_each_child() function above, but it
40215ab69981SCornelia Huck * returns a reference to a device that is 'found' for later use, as
40225ab69981SCornelia Huck * determined by the @match callback.
40235ab69981SCornelia Huck *
40245ab69981SCornelia Huck * The callback should return 0 if the device doesn't match and non-zero
40255ab69981SCornelia Huck * if it does. If the callback returns non-zero and a reference to the
40265ab69981SCornelia Huck * current device can be obtained, this function will return to the caller
40275ab69981SCornelia Huck * and not iterate over any more devices.
4028a4e2400aSFederico Vaga *
4029a4e2400aSFederico Vaga * NOTE: you will need to drop the reference with put_device() after use.
40305ab69981SCornelia Huck */
device_find_child(struct device * parent,void * data,int (* match)(struct device * dev,void * data))40315ab69981SCornelia Huck struct device *device_find_child(struct device *parent, void *data,
40324a3ad20cSGreg Kroah-Hartman int (*match)(struct device *dev, void *data))
40335ab69981SCornelia Huck {
40345ab69981SCornelia Huck struct klist_iter i;
40355ab69981SCornelia Huck struct device *child;
40365ab69981SCornelia Huck
40375ab69981SCornelia Huck if (!parent)
40385ab69981SCornelia Huck return NULL;
40395ab69981SCornelia Huck
4040f791b8c8SGreg Kroah-Hartman klist_iter_init(&parent->p->klist_children, &i);
40415ab69981SCornelia Huck while ((child = next_device(&i)))
40425ab69981SCornelia Huck if (match(child, data) && get_device(child))
40435ab69981SCornelia Huck break;
40445ab69981SCornelia Huck klist_iter_exit(&i);
40455ab69981SCornelia Huck return child;
40465ab69981SCornelia Huck }
404786df2687SDavid Graham White EXPORT_SYMBOL_GPL(device_find_child);
40485ab69981SCornelia Huck
4049dad9bb01SHeikki Krogerus /**
4050dad9bb01SHeikki Krogerus * device_find_child_by_name - device iterator for locating a child device.
4051dad9bb01SHeikki Krogerus * @parent: parent struct device
4052dad9bb01SHeikki Krogerus * @name: name of the child device
4053dad9bb01SHeikki Krogerus *
4054dad9bb01SHeikki Krogerus * This is similar to the device_find_child() function above, but it
4055dad9bb01SHeikki Krogerus * returns a reference to a device that has the name @name.
4056dad9bb01SHeikki Krogerus *
4057dad9bb01SHeikki Krogerus * NOTE: you will need to drop the reference with put_device() after use.
4058dad9bb01SHeikki Krogerus */
device_find_child_by_name(struct device * parent,const char * name)4059dad9bb01SHeikki Krogerus struct device *device_find_child_by_name(struct device *parent,
4060dad9bb01SHeikki Krogerus const char *name)
4061dad9bb01SHeikki Krogerus {
4062dad9bb01SHeikki Krogerus struct klist_iter i;
4063dad9bb01SHeikki Krogerus struct device *child;
4064dad9bb01SHeikki Krogerus
4065dad9bb01SHeikki Krogerus if (!parent)
4066dad9bb01SHeikki Krogerus return NULL;
4067dad9bb01SHeikki Krogerus
4068dad9bb01SHeikki Krogerus klist_iter_init(&parent->p->klist_children, &i);
4069dad9bb01SHeikki Krogerus while ((child = next_device(&i)))
4070c77f520dSDan Williams if (sysfs_streq(dev_name(child), name) && get_device(child))
4071dad9bb01SHeikki Krogerus break;
4072dad9bb01SHeikki Krogerus klist_iter_exit(&i);
4073dad9bb01SHeikki Krogerus return child;
4074dad9bb01SHeikki Krogerus }
4075dad9bb01SHeikki Krogerus EXPORT_SYMBOL_GPL(device_find_child_by_name);
4076dad9bb01SHeikki Krogerus
match_any(struct device * dev,void * unused)407782b070beSAndy Shevchenko static int match_any(struct device *dev, void *unused)
407882b070beSAndy Shevchenko {
407982b070beSAndy Shevchenko return 1;
408082b070beSAndy Shevchenko }
408182b070beSAndy Shevchenko
408282b070beSAndy Shevchenko /**
408382b070beSAndy Shevchenko * device_find_any_child - device iterator for locating a child device, if any.
408482b070beSAndy Shevchenko * @parent: parent struct device
408582b070beSAndy Shevchenko *
408682b070beSAndy Shevchenko * This is similar to the device_find_child() function above, but it
408782b070beSAndy Shevchenko * returns a reference to a child device, if any.
408882b070beSAndy Shevchenko *
408982b070beSAndy Shevchenko * NOTE: you will need to drop the reference with put_device() after use.
409082b070beSAndy Shevchenko */
device_find_any_child(struct device * parent)409182b070beSAndy Shevchenko struct device *device_find_any_child(struct device *parent)
409282b070beSAndy Shevchenko {
409382b070beSAndy Shevchenko return device_find_child(parent, NULL, match_any);
409482b070beSAndy Shevchenko }
409582b070beSAndy Shevchenko EXPORT_SYMBOL_GPL(device_find_any_child);
409682b070beSAndy Shevchenko
devices_init(void)40971da177e4SLinus Torvalds int __init devices_init(void)
40981da177e4SLinus Torvalds {
4099881c6cfdSGreg Kroah-Hartman devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
4100881c6cfdSGreg Kroah-Hartman if (!devices_kset)
4101881c6cfdSGreg Kroah-Hartman return -ENOMEM;
4102e105b8bfSDan Williams dev_kobj = kobject_create_and_add("dev", NULL);
4103e105b8bfSDan Williams if (!dev_kobj)
4104e105b8bfSDan Williams goto dev_kobj_err;
4105e105b8bfSDan Williams sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
4106e105b8bfSDan Williams if (!sysfs_dev_block_kobj)
4107e105b8bfSDan Williams goto block_kobj_err;
4108e105b8bfSDan Williams sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
4109e105b8bfSDan Williams if (!sysfs_dev_char_kobj)
4110e105b8bfSDan Williams goto char_kobj_err;
4111dfa65572SHerve Codina device_link_wq = alloc_workqueue("device_link_wq", 0, 0);
4112dfa65572SHerve Codina if (!device_link_wq)
4113dfa65572SHerve Codina goto wq_err;
4114e105b8bfSDan Williams
4115881c6cfdSGreg Kroah-Hartman return 0;
4116e105b8bfSDan Williams
4117dfa65572SHerve Codina wq_err:
4118dfa65572SHerve Codina kobject_put(sysfs_dev_char_kobj);
4119e105b8bfSDan Williams char_kobj_err:
4120e105b8bfSDan Williams kobject_put(sysfs_dev_block_kobj);
4121e105b8bfSDan Williams block_kobj_err:
4122e105b8bfSDan Williams kobject_put(dev_kobj);
4123e105b8bfSDan Williams dev_kobj_err:
4124e105b8bfSDan Williams kset_unregister(devices_kset);
4125e105b8bfSDan Williams return -ENOMEM;
41261da177e4SLinus Torvalds }
41271da177e4SLinus Torvalds
device_check_offline(struct device * dev,void * not_used)41284f3549d7SRafael J. Wysocki static int device_check_offline(struct device *dev, void *not_used)
41294f3549d7SRafael J. Wysocki {
41304f3549d7SRafael J. Wysocki int ret;
41314f3549d7SRafael J. Wysocki
41324f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline);
41334f3549d7SRafael J. Wysocki if (ret)
41344f3549d7SRafael J. Wysocki return ret;
41354f3549d7SRafael J. Wysocki
41364f3549d7SRafael J. Wysocki return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
41374f3549d7SRafael J. Wysocki }
41384f3549d7SRafael J. Wysocki
41394f3549d7SRafael J. Wysocki /**
41404f3549d7SRafael J. Wysocki * device_offline - Prepare the device for hot-removal.
41414f3549d7SRafael J. Wysocki * @dev: Device to be put offline.
41424f3549d7SRafael J. Wysocki *
41434f3549d7SRafael J. Wysocki * Execute the device bus type's .offline() callback, if present, to prepare
41444f3549d7SRafael J. Wysocki * the device for a subsequent hot-removal. If that succeeds, the device must
41454f3549d7SRafael J. Wysocki * not be used until either it is removed or its bus type's .online() callback
41464f3549d7SRafael J. Wysocki * is executed.
41474f3549d7SRafael J. Wysocki *
41484f3549d7SRafael J. Wysocki * Call under device_hotplug_lock.
41494f3549d7SRafael J. Wysocki */
device_offline(struct device * dev)41504f3549d7SRafael J. Wysocki int device_offline(struct device *dev)
41514f3549d7SRafael J. Wysocki {
41524f3549d7SRafael J. Wysocki int ret;
41534f3549d7SRafael J. Wysocki
41544f3549d7SRafael J. Wysocki if (dev->offline_disabled)
41554f3549d7SRafael J. Wysocki return -EPERM;
41564f3549d7SRafael J. Wysocki
41574f3549d7SRafael J. Wysocki ret = device_for_each_child(dev, NULL, device_check_offline);
41584f3549d7SRafael J. Wysocki if (ret)
41594f3549d7SRafael J. Wysocki return ret;
41604f3549d7SRafael J. Wysocki
41614f3549d7SRafael J. Wysocki device_lock(dev);
41624f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) {
41634f3549d7SRafael J. Wysocki if (dev->offline) {
41644f3549d7SRafael J. Wysocki ret = 1;
41654f3549d7SRafael J. Wysocki } else {
41664f3549d7SRafael J. Wysocki ret = dev->bus->offline(dev);
41674f3549d7SRafael J. Wysocki if (!ret) {
41684f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
41694f3549d7SRafael J. Wysocki dev->offline = true;
41704f3549d7SRafael J. Wysocki }
41714f3549d7SRafael J. Wysocki }
41724f3549d7SRafael J. Wysocki }
41734f3549d7SRafael J. Wysocki device_unlock(dev);
41744f3549d7SRafael J. Wysocki
41754f3549d7SRafael J. Wysocki return ret;
41764f3549d7SRafael J. Wysocki }
41774f3549d7SRafael J. Wysocki
41784f3549d7SRafael J. Wysocki /**
41794f3549d7SRafael J. Wysocki * device_online - Put the device back online after successful device_offline().
41804f3549d7SRafael J. Wysocki * @dev: Device to be put back online.
41814f3549d7SRafael J. Wysocki *
41824f3549d7SRafael J. Wysocki * If device_offline() has been successfully executed for @dev, but the device
41834f3549d7SRafael J. Wysocki * has not been removed subsequently, execute its bus type's .online() callback
41844f3549d7SRafael J. Wysocki * to indicate that the device can be used again.
41854f3549d7SRafael J. Wysocki *
41864f3549d7SRafael J. Wysocki * Call under device_hotplug_lock.
41874f3549d7SRafael J. Wysocki */
device_online(struct device * dev)41884f3549d7SRafael J. Wysocki int device_online(struct device *dev)
41894f3549d7SRafael J. Wysocki {
41904f3549d7SRafael J. Wysocki int ret = 0;
41914f3549d7SRafael J. Wysocki
41924f3549d7SRafael J. Wysocki device_lock(dev);
41934f3549d7SRafael J. Wysocki if (device_supports_offline(dev)) {
41944f3549d7SRafael J. Wysocki if (dev->offline) {
41954f3549d7SRafael J. Wysocki ret = dev->bus->online(dev);
41964f3549d7SRafael J. Wysocki if (!ret) {
41974f3549d7SRafael J. Wysocki kobject_uevent(&dev->kobj, KOBJ_ONLINE);
41984f3549d7SRafael J. Wysocki dev->offline = false;
41994f3549d7SRafael J. Wysocki }
42004f3549d7SRafael J. Wysocki } else {
42014f3549d7SRafael J. Wysocki ret = 1;
42024f3549d7SRafael J. Wysocki }
42034f3549d7SRafael J. Wysocki }
42044f3549d7SRafael J. Wysocki device_unlock(dev);
42054f3549d7SRafael J. Wysocki
42064f3549d7SRafael J. Wysocki return ret;
42074f3549d7SRafael J. Wysocki }
42084f3549d7SRafael J. Wysocki
42097f100d15SKarthigan Srinivasan struct root_device {
42100aa0dc41SMark McLoughlin struct device dev;
42110aa0dc41SMark McLoughlin struct module *owner;
42120aa0dc41SMark McLoughlin };
42130aa0dc41SMark McLoughlin
to_root_device(struct device * d)421493058424SJosh Triplett static inline struct root_device *to_root_device(struct device *d)
4215481e2079SFerenc Wagner {
4216481e2079SFerenc Wagner return container_of(d, struct root_device, dev);
4217481e2079SFerenc Wagner }
42180aa0dc41SMark McLoughlin
root_device_release(struct device * dev)42190aa0dc41SMark McLoughlin static void root_device_release(struct device *dev)
42200aa0dc41SMark McLoughlin {
42210aa0dc41SMark McLoughlin kfree(to_root_device(dev));
42220aa0dc41SMark McLoughlin }
42230aa0dc41SMark McLoughlin
42240aa0dc41SMark McLoughlin /**
42250aa0dc41SMark McLoughlin * __root_device_register - allocate and register a root device
42260aa0dc41SMark McLoughlin * @name: root device name
42270aa0dc41SMark McLoughlin * @owner: owner module of the root device, usually THIS_MODULE
42280aa0dc41SMark McLoughlin *
42290aa0dc41SMark McLoughlin * This function allocates a root device and registers it
42300aa0dc41SMark McLoughlin * using device_register(). In order to free the returned
42310aa0dc41SMark McLoughlin * device, use root_device_unregister().
42320aa0dc41SMark McLoughlin *
42330aa0dc41SMark McLoughlin * Root devices are dummy devices which allow other devices
42340aa0dc41SMark McLoughlin * to be grouped under /sys/devices. Use this function to
42350aa0dc41SMark McLoughlin * allocate a root device and then use it as the parent of
42360aa0dc41SMark McLoughlin * any device which should appear under /sys/devices/{name}
42370aa0dc41SMark McLoughlin *
42380aa0dc41SMark McLoughlin * The /sys/devices/{name} directory will also contain a
42390aa0dc41SMark McLoughlin * 'module' symlink which points to the @owner directory
42400aa0dc41SMark McLoughlin * in sysfs.
42410aa0dc41SMark McLoughlin *
4242f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error.
4243f0eae0edSJani Nikula *
42440aa0dc41SMark McLoughlin * Note: You probably want to use root_device_register().
42450aa0dc41SMark McLoughlin */
__root_device_register(const char * name,struct module * owner)42460aa0dc41SMark McLoughlin struct device *__root_device_register(const char *name, struct module *owner)
42470aa0dc41SMark McLoughlin {
42480aa0dc41SMark McLoughlin struct root_device *root;
42490aa0dc41SMark McLoughlin int err = -ENOMEM;
42500aa0dc41SMark McLoughlin
42510aa0dc41SMark McLoughlin root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
42520aa0dc41SMark McLoughlin if (!root)
42530aa0dc41SMark McLoughlin return ERR_PTR(err);
42540aa0dc41SMark McLoughlin
4255acc0e90fSGreg Kroah-Hartman err = dev_set_name(&root->dev, "%s", name);
42560aa0dc41SMark McLoughlin if (err) {
42570aa0dc41SMark McLoughlin kfree(root);
42580aa0dc41SMark McLoughlin return ERR_PTR(err);
42590aa0dc41SMark McLoughlin }
42600aa0dc41SMark McLoughlin
42610aa0dc41SMark McLoughlin root->dev.release = root_device_release;
42620aa0dc41SMark McLoughlin
42630aa0dc41SMark McLoughlin err = device_register(&root->dev);
42640aa0dc41SMark McLoughlin if (err) {
42650aa0dc41SMark McLoughlin put_device(&root->dev);
42660aa0dc41SMark McLoughlin return ERR_PTR(err);
42670aa0dc41SMark McLoughlin }
42680aa0dc41SMark McLoughlin
42691d9e882bSChristoph Egger #ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */
42700aa0dc41SMark McLoughlin if (owner) {
42710aa0dc41SMark McLoughlin struct module_kobject *mk = &owner->mkobj;
42720aa0dc41SMark McLoughlin
42730aa0dc41SMark McLoughlin err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
42740aa0dc41SMark McLoughlin if (err) {
42750aa0dc41SMark McLoughlin device_unregister(&root->dev);
42760aa0dc41SMark McLoughlin return ERR_PTR(err);
42770aa0dc41SMark McLoughlin }
42780aa0dc41SMark McLoughlin root->owner = owner;
42790aa0dc41SMark McLoughlin }
42800aa0dc41SMark McLoughlin #endif
42810aa0dc41SMark McLoughlin
42820aa0dc41SMark McLoughlin return &root->dev;
42830aa0dc41SMark McLoughlin }
42840aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(__root_device_register);
42850aa0dc41SMark McLoughlin
42860aa0dc41SMark McLoughlin /**
42870aa0dc41SMark McLoughlin * root_device_unregister - unregister and free a root device
42887cbcf225SRandy Dunlap * @dev: device going away
42890aa0dc41SMark McLoughlin *
42900aa0dc41SMark McLoughlin * This function unregisters and cleans up a device that was created by
42910aa0dc41SMark McLoughlin * root_device_register().
42920aa0dc41SMark McLoughlin */
root_device_unregister(struct device * dev)42930aa0dc41SMark McLoughlin void root_device_unregister(struct device *dev)
42940aa0dc41SMark McLoughlin {
42950aa0dc41SMark McLoughlin struct root_device *root = to_root_device(dev);
42960aa0dc41SMark McLoughlin
42970aa0dc41SMark McLoughlin if (root->owner)
42980aa0dc41SMark McLoughlin sysfs_remove_link(&root->dev.kobj, "module");
42990aa0dc41SMark McLoughlin
43000aa0dc41SMark McLoughlin device_unregister(dev);
43010aa0dc41SMark McLoughlin }
43020aa0dc41SMark McLoughlin EXPORT_SYMBOL_GPL(root_device_unregister);
43030aa0dc41SMark McLoughlin
430423681e47SGreg Kroah-Hartman
device_create_release(struct device * dev)430523681e47SGreg Kroah-Hartman static void device_create_release(struct device *dev)
430623681e47SGreg Kroah-Hartman {
43071e0b2cf9SKay Sievers pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
430823681e47SGreg Kroah-Hartman kfree(dev);
430923681e47SGreg Kroah-Hartman }
431023681e47SGreg Kroah-Hartman
43116a8b55d7SMathieu Malaterre static __printf(6, 0) struct device *
device_create_groups_vargs(const struct class * class,struct device * parent,dev_t devt,void * drvdata,const struct attribute_group ** groups,const char * fmt,va_list args)43122bd5c639SGreg Kroah-Hartman device_create_groups_vargs(const struct class *class, struct device *parent,
431339ef3112SGuenter Roeck dev_t devt, void *drvdata,
431439ef3112SGuenter Roeck const struct attribute_group **groups,
431539ef3112SGuenter Roeck const char *fmt, va_list args)
431639ef3112SGuenter Roeck {
431739ef3112SGuenter Roeck struct device *dev = NULL;
431839ef3112SGuenter Roeck int retval = -ENODEV;
431939ef3112SGuenter Roeck
4320d70590d5SYang Yingliang if (IS_ERR_OR_NULL(class))
432139ef3112SGuenter Roeck goto error;
432239ef3112SGuenter Roeck
432339ef3112SGuenter Roeck dev = kzalloc(sizeof(*dev), GFP_KERNEL);
432439ef3112SGuenter Roeck if (!dev) {
432539ef3112SGuenter Roeck retval = -ENOMEM;
432639ef3112SGuenter Roeck goto error;
432739ef3112SGuenter Roeck }
432839ef3112SGuenter Roeck
4329bbc780f8SDavid Herrmann device_initialize(dev);
433039ef3112SGuenter Roeck dev->devt = devt;
433139ef3112SGuenter Roeck dev->class = class;
433239ef3112SGuenter Roeck dev->parent = parent;
433339ef3112SGuenter Roeck dev->groups = groups;
433439ef3112SGuenter Roeck dev->release = device_create_release;
433539ef3112SGuenter Roeck dev_set_drvdata(dev, drvdata);
433639ef3112SGuenter Roeck
433739ef3112SGuenter Roeck retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
433839ef3112SGuenter Roeck if (retval)
433939ef3112SGuenter Roeck goto error;
434039ef3112SGuenter Roeck
4341bbc780f8SDavid Herrmann retval = device_add(dev);
434239ef3112SGuenter Roeck if (retval)
434339ef3112SGuenter Roeck goto error;
434439ef3112SGuenter Roeck
434539ef3112SGuenter Roeck return dev;
434639ef3112SGuenter Roeck
434739ef3112SGuenter Roeck error:
434839ef3112SGuenter Roeck put_device(dev);
434939ef3112SGuenter Roeck return ERR_PTR(retval);
435039ef3112SGuenter Roeck }
435139ef3112SGuenter Roeck
435223681e47SGreg Kroah-Hartman /**
43534e106739SGreg Kroah-Hartman * device_create - creates a device and registers it with sysfs
43548882b394SGreg Kroah-Hartman * @class: pointer to the struct class that this device should be registered to
43558882b394SGreg Kroah-Hartman * @parent: pointer to the parent struct device of this new device, if any
43568882b394SGreg Kroah-Hartman * @devt: the dev_t for the char device to be added
43578882b394SGreg Kroah-Hartman * @drvdata: the data to be added to the device for callbacks
43588882b394SGreg Kroah-Hartman * @fmt: string for the device's name
43598882b394SGreg Kroah-Hartman *
43608882b394SGreg Kroah-Hartman * This function can be used by char device classes. A struct device
43618882b394SGreg Kroah-Hartman * will be created in sysfs, registered to the specified class.
43628882b394SGreg Kroah-Hartman *
43638882b394SGreg Kroah-Hartman * A "dev" file will be created, showing the dev_t for the device, if
43648882b394SGreg Kroah-Hartman * the dev_t is not 0,0.
43658882b394SGreg Kroah-Hartman * If a pointer to a parent struct device is passed in, the newly created
43668882b394SGreg Kroah-Hartman * struct device will be a child of that device in sysfs.
43678882b394SGreg Kroah-Hartman * The pointer to the struct device will be returned from the call.
43688882b394SGreg Kroah-Hartman * Any further sysfs files that might be required can be created using this
43698882b394SGreg Kroah-Hartman * pointer.
43708882b394SGreg Kroah-Hartman *
4371f0eae0edSJani Nikula * Returns &struct device pointer on success, or ERR_PTR() on error.
43728882b394SGreg Kroah-Hartman */
device_create(const struct class * class,struct device * parent,dev_t devt,void * drvdata,const char * fmt,...)43732bd5c639SGreg Kroah-Hartman struct device *device_create(const struct class *class, struct device *parent,
43744e106739SGreg Kroah-Hartman dev_t devt, void *drvdata, const char *fmt, ...)
43758882b394SGreg Kroah-Hartman {
43768882b394SGreg Kroah-Hartman va_list vargs;
43778882b394SGreg Kroah-Hartman struct device *dev;
43788882b394SGreg Kroah-Hartman
43798882b394SGreg Kroah-Hartman va_start(vargs, fmt);
43804c747466SChristoph Hellwig dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL,
43814c747466SChristoph Hellwig fmt, vargs);
43828882b394SGreg Kroah-Hartman va_end(vargs);
43838882b394SGreg Kroah-Hartman return dev;
43848882b394SGreg Kroah-Hartman }
43854e106739SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_create);
43868882b394SGreg Kroah-Hartman
438739ef3112SGuenter Roeck /**
438839ef3112SGuenter Roeck * device_create_with_groups - creates a device and registers it with sysfs
438939ef3112SGuenter Roeck * @class: pointer to the struct class that this device should be registered to
439039ef3112SGuenter Roeck * @parent: pointer to the parent struct device of this new device, if any
439139ef3112SGuenter Roeck * @devt: the dev_t for the char device to be added
439239ef3112SGuenter Roeck * @drvdata: the data to be added to the device for callbacks
439339ef3112SGuenter Roeck * @groups: NULL-terminated list of attribute groups to be created
439439ef3112SGuenter Roeck * @fmt: string for the device's name
439539ef3112SGuenter Roeck *
439639ef3112SGuenter Roeck * This function can be used by char device classes. A struct device
439739ef3112SGuenter Roeck * will be created in sysfs, registered to the specified class.
439839ef3112SGuenter Roeck * Additional attributes specified in the groups parameter will also
439939ef3112SGuenter Roeck * be created automatically.
440039ef3112SGuenter Roeck *
440139ef3112SGuenter Roeck * A "dev" file will be created, showing the dev_t for the device, if
440239ef3112SGuenter Roeck * the dev_t is not 0,0.
440339ef3112SGuenter Roeck * If a pointer to a parent struct device is passed in, the newly created
440439ef3112SGuenter Roeck * struct device will be a child of that device in sysfs.
440539ef3112SGuenter Roeck * The pointer to the struct device will be returned from the call.
440639ef3112SGuenter Roeck * Any further sysfs files that might be required can be created using this
440739ef3112SGuenter Roeck * pointer.
440839ef3112SGuenter Roeck *
440939ef3112SGuenter Roeck * Returns &struct device pointer on success, or ERR_PTR() on error.
441039ef3112SGuenter Roeck */
device_create_with_groups(const struct class * class,struct device * parent,dev_t devt,void * drvdata,const struct attribute_group ** groups,const char * fmt,...)44112bd5c639SGreg Kroah-Hartman struct device *device_create_with_groups(const struct class *class,
441239ef3112SGuenter Roeck struct device *parent, dev_t devt,
441339ef3112SGuenter Roeck void *drvdata,
441439ef3112SGuenter Roeck const struct attribute_group **groups,
441539ef3112SGuenter Roeck const char *fmt, ...)
441639ef3112SGuenter Roeck {
441739ef3112SGuenter Roeck va_list vargs;
441839ef3112SGuenter Roeck struct device *dev;
441939ef3112SGuenter Roeck
442039ef3112SGuenter Roeck va_start(vargs, fmt);
442139ef3112SGuenter Roeck dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
442239ef3112SGuenter Roeck fmt, vargs);
442339ef3112SGuenter Roeck va_end(vargs);
442439ef3112SGuenter Roeck return dev;
442539ef3112SGuenter Roeck }
442639ef3112SGuenter Roeck EXPORT_SYMBOL_GPL(device_create_with_groups);
442739ef3112SGuenter Roeck
4428775b64d2SRafael J. Wysocki /**
4429775b64d2SRafael J. Wysocki * device_destroy - removes a device that was created with device_create()
4430775b64d2SRafael J. Wysocki * @class: pointer to the struct class that this device was registered with
4431775b64d2SRafael J. Wysocki * @devt: the dev_t of the device that was previously registered
4432775b64d2SRafael J. Wysocki *
4433775b64d2SRafael J. Wysocki * This call unregisters and cleans up a device that was created with a
4434775b64d2SRafael J. Wysocki * call to device_create().
4435775b64d2SRafael J. Wysocki */
device_destroy(const struct class * class,dev_t devt)4436d2fff096SGreg Kroah-Hartman void device_destroy(const struct class *class, dev_t devt)
4437775b64d2SRafael J. Wysocki {
4438775b64d2SRafael J. Wysocki struct device *dev;
4439775b64d2SRafael J. Wysocki
44404495dfddSSuzuki K Poulose dev = class_find_device_by_devt(class, devt);
4441cd35449bSDave Young if (dev) {
4442cd35449bSDave Young put_device(dev);
444323681e47SGreg Kroah-Hartman device_unregister(dev);
444423681e47SGreg Kroah-Hartman }
4445cd35449bSDave Young }
444623681e47SGreg Kroah-Hartman EXPORT_SYMBOL_GPL(device_destroy);
4447a2de48caSGreg Kroah-Hartman
4448a2de48caSGreg Kroah-Hartman /**
4449a2de48caSGreg Kroah-Hartman * device_rename - renames a device
4450a2de48caSGreg Kroah-Hartman * @dev: the pointer to the struct device to be renamed
4451a2de48caSGreg Kroah-Hartman * @new_name: the new name of the device
4452030c1d2bSEric W. Biederman *
4453030c1d2bSEric W. Biederman * It is the responsibility of the caller to provide mutual
4454030c1d2bSEric W. Biederman * exclusion between two different calls of device_rename
4455030c1d2bSEric W. Biederman * on the same device to ensure that new_name is valid and
4456030c1d2bSEric W. Biederman * won't conflict with other devices.
4457c6c0ac66SMichael Ellerman *
445811a96703SWedson Almeida Filho * Note: given that some subsystems (networking and infiniband) use this
445911a96703SWedson Almeida Filho * function, with no immediate plans for this to change, we cannot assume or
446011a96703SWedson Almeida Filho * require that this function not be called at all.
446111a96703SWedson Almeida Filho *
446211a96703SWedson Almeida Filho * However, if you're writing new code, do not call this function. The following
446311a96703SWedson Almeida Filho * text from Kay Sievers offers some insight:
4464a5462516STimur Tabi *
4465a5462516STimur Tabi * Renaming devices is racy at many levels, symlinks and other stuff are not
4466a5462516STimur Tabi * replaced atomically, and you get a "move" uevent, but it's not easy to
4467a5462516STimur Tabi * connect the event to the old and new device. Device nodes are not renamed at
4468a5462516STimur Tabi * all, there isn't even support for that in the kernel now.
4469a5462516STimur Tabi *
4470a5462516STimur Tabi * In the meantime, during renaming, your target name might be taken by another
4471a5462516STimur Tabi * driver, creating conflicts. Or the old name is taken directly after you
4472a5462516STimur Tabi * renamed it -- then you get events for the same DEVPATH, before you even see
4473a5462516STimur Tabi * the "move" event. It's just a mess, and nothing new should ever rely on
4474a5462516STimur Tabi * kernel device renaming. Besides that, it's not even implemented now for
4475a5462516STimur Tabi * other things than (driver-core wise very simple) network devices.
4476a5462516STimur Tabi *
4477a5462516STimur Tabi * Make up a "real" name in the driver before you register anything, or add
4478a5462516STimur Tabi * some other attributes for userspace to find the device, or use udev to add
4479a5462516STimur Tabi * symlinks -- but never rename kernel devices later, it's a complete mess. We
4480a5462516STimur Tabi * don't even want to get into that and try to implement the missing pieces in
4481a5462516STimur Tabi * the core. We really have other pieces to fix in the driver core mess. :)
4482a2de48caSGreg Kroah-Hartman */
device_rename(struct device * dev,const char * new_name)44836937e8f8SJohannes Berg int device_rename(struct device *dev, const char *new_name)
4484a2de48caSGreg Kroah-Hartman {
44854b30ee58STejun Heo struct kobject *kobj = &dev->kobj;
44862ee97cafSCornelia Huck char *old_device_name = NULL;
4487a2de48caSGreg Kroah-Hartman int error;
4488a2de48caSGreg Kroah-Hartman
4489a2de48caSGreg Kroah-Hartman dev = get_device(dev);
4490a2de48caSGreg Kroah-Hartman if (!dev)
4491a2de48caSGreg Kroah-Hartman return -EINVAL;
4492a2de48caSGreg Kroah-Hartman
449369df7533Sethan.zhao dev_dbg(dev, "renaming to %s\n", new_name);
4494a2de48caSGreg Kroah-Hartman
44951fa5ae85SKay Sievers old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
44962ee97cafSCornelia Huck if (!old_device_name) {
4497952ab431SJesper Juhl error = -ENOMEM;
44982ee97cafSCornelia Huck goto out;
4499952ab431SJesper Juhl }
4500a2de48caSGreg Kroah-Hartman
4501f349cf34SEric W. Biederman if (dev->class) {
45027d90e81aSGreg Kroah-Hartman struct subsys_private *sp = class_to_subsys(dev->class);
45037d90e81aSGreg Kroah-Hartman
45047d90e81aSGreg Kroah-Hartman if (!sp) {
45057d90e81aSGreg Kroah-Hartman error = -EINVAL;
45067d90e81aSGreg Kroah-Hartman goto out;
45077d90e81aSGreg Kroah-Hartman }
45087d90e81aSGreg Kroah-Hartman
45097d90e81aSGreg Kroah-Hartman error = sysfs_rename_link_ns(&sp->subsys.kobj, kobj, old_device_name,
45104b30ee58STejun Heo new_name, kobject_namespace(kobj));
45117d90e81aSGreg Kroah-Hartman subsys_put(sp);
4512f349cf34SEric W. Biederman if (error)
4513f349cf34SEric W. Biederman goto out;
4514f349cf34SEric W. Biederman }
451539aba963SKay Sievers
45164b30ee58STejun Heo error = kobject_rename(kobj, new_name);
45171fa5ae85SKay Sievers if (error)
45182ee97cafSCornelia Huck goto out;
4519a2de48caSGreg Kroah-Hartman
45202ee97cafSCornelia Huck out:
4521a2de48caSGreg Kroah-Hartman put_device(dev);
4522a2de48caSGreg Kroah-Hartman
45232ee97cafSCornelia Huck kfree(old_device_name);
4524a2de48caSGreg Kroah-Hartman
4525a2de48caSGreg Kroah-Hartman return error;
4526a2de48caSGreg Kroah-Hartman }
4527a2807dbcSJohannes Berg EXPORT_SYMBOL_GPL(device_rename);
45288a82472fSCornelia Huck
device_move_class_links(struct device * dev,struct device * old_parent,struct device * new_parent)45298a82472fSCornelia Huck static int device_move_class_links(struct device *dev,
45308a82472fSCornelia Huck struct device *old_parent,
45318a82472fSCornelia Huck struct device *new_parent)
45328a82472fSCornelia Huck {
4533f7f3461dSGreg Kroah-Hartman int error = 0;
45348a82472fSCornelia Huck
4535f7f3461dSGreg Kroah-Hartman if (old_parent)
4536f7f3461dSGreg Kroah-Hartman sysfs_remove_link(&dev->kobj, "device");
4537f7f3461dSGreg Kroah-Hartman if (new_parent)
4538f7f3461dSGreg Kroah-Hartman error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
4539f7f3461dSGreg Kroah-Hartman "device");
4540f7f3461dSGreg Kroah-Hartman return error;
45418a82472fSCornelia Huck }
45428a82472fSCornelia Huck
45438a82472fSCornelia Huck /**
45448a82472fSCornelia Huck * device_move - moves a device to a new parent
45458a82472fSCornelia Huck * @dev: the pointer to the struct device to be moved
454613509860SWolfram Sang * @new_parent: the new parent of the device (can be NULL)
4547ffa6a705SCornelia Huck * @dpm_order: how to reorder the dpm_list
45488a82472fSCornelia Huck */
device_move(struct device * dev,struct device * new_parent,enum dpm_order dpm_order)4549ffa6a705SCornelia Huck int device_move(struct device *dev, struct device *new_parent,
4550ffa6a705SCornelia Huck enum dpm_order dpm_order)
45518a82472fSCornelia Huck {
45528a82472fSCornelia Huck int error;
45538a82472fSCornelia Huck struct device *old_parent;
4554c744aeaeSCornelia Huck struct kobject *new_parent_kobj;
45558a82472fSCornelia Huck
45568a82472fSCornelia Huck dev = get_device(dev);
45578a82472fSCornelia Huck if (!dev)
45588a82472fSCornelia Huck return -EINVAL;
45598a82472fSCornelia Huck
4560ffa6a705SCornelia Huck device_pm_lock();
45618a82472fSCornelia Huck new_parent = get_device(new_parent);
4562c744aeaeSCornelia Huck new_parent_kobj = get_device_parent(dev, new_parent);
456384d0c27dSTetsuo Handa if (IS_ERR(new_parent_kobj)) {
456484d0c27dSTetsuo Handa error = PTR_ERR(new_parent_kobj);
456584d0c27dSTetsuo Handa put_device(new_parent);
456684d0c27dSTetsuo Handa goto out;
456784d0c27dSTetsuo Handa }
456863b6971aSCornelia Huck
45691e0b2cf9SKay Sievers pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
45701e0b2cf9SKay Sievers __func__, new_parent ? dev_name(new_parent) : "<NULL>");
4571c744aeaeSCornelia Huck error = kobject_move(&dev->kobj, new_parent_kobj);
45728a82472fSCornelia Huck if (error) {
457363b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj);
45748a82472fSCornelia Huck put_device(new_parent);
45758a82472fSCornelia Huck goto out;
45768a82472fSCornelia Huck }
45778a82472fSCornelia Huck old_parent = dev->parent;
45788a82472fSCornelia Huck dev->parent = new_parent;
45798a82472fSCornelia Huck if (old_parent)
4580f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent);
45810d358f22SYinghai Lu if (new_parent) {
4582f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent,
4583f791b8c8SGreg Kroah-Hartman &new_parent->p->klist_children);
45840d358f22SYinghai Lu set_dev_node(dev, dev_to_node(new_parent));
45850d358f22SYinghai Lu }
45860d358f22SYinghai Lu
4587bdd4034dSRabin Vincent if (dev->class) {
45888a82472fSCornelia Huck error = device_move_class_links(dev, old_parent, new_parent);
45898a82472fSCornelia Huck if (error) {
45908a82472fSCornelia Huck /* We ignore errors on cleanup since we're hosed anyway... */
45918a82472fSCornelia Huck device_move_class_links(dev, new_parent, old_parent);
45928a82472fSCornelia Huck if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
4593c744aeaeSCornelia Huck if (new_parent)
4594f791b8c8SGreg Kroah-Hartman klist_remove(&dev->p->knode_parent);
45950d358f22SYinghai Lu dev->parent = old_parent;
45960d358f22SYinghai Lu if (old_parent) {
4597f791b8c8SGreg Kroah-Hartman klist_add_tail(&dev->p->knode_parent,
4598f791b8c8SGreg Kroah-Hartman &old_parent->p->klist_children);
45990d358f22SYinghai Lu set_dev_node(dev, dev_to_node(old_parent));
46000d358f22SYinghai Lu }
46018a82472fSCornelia Huck }
460263b6971aSCornelia Huck cleanup_glue_dir(dev, new_parent_kobj);
46038a82472fSCornelia Huck put_device(new_parent);
46048a82472fSCornelia Huck goto out;
46058a82472fSCornelia Huck }
4606bdd4034dSRabin Vincent }
4607ffa6a705SCornelia Huck switch (dpm_order) {
4608ffa6a705SCornelia Huck case DPM_ORDER_NONE:
4609ffa6a705SCornelia Huck break;
4610ffa6a705SCornelia Huck case DPM_ORDER_DEV_AFTER_PARENT:
4611ffa6a705SCornelia Huck device_pm_move_after(dev, new_parent);
461252cdbdd4SGrygorii Strashko devices_kset_move_after(dev, new_parent);
4613ffa6a705SCornelia Huck break;
4614ffa6a705SCornelia Huck case DPM_ORDER_PARENT_BEFORE_DEV:
4615ffa6a705SCornelia Huck device_pm_move_before(new_parent, dev);
461652cdbdd4SGrygorii Strashko devices_kset_move_before(new_parent, dev);
4617ffa6a705SCornelia Huck break;
4618ffa6a705SCornelia Huck case DPM_ORDER_DEV_LAST:
4619ffa6a705SCornelia Huck device_pm_move_last(dev);
462052cdbdd4SGrygorii Strashko devices_kset_move_last(dev);
4621ffa6a705SCornelia Huck break;
4622ffa6a705SCornelia Huck }
4623bdd4034dSRabin Vincent
46248a82472fSCornelia Huck put_device(old_parent);
46258a82472fSCornelia Huck out:
4626ffa6a705SCornelia Huck device_pm_unlock();
46278a82472fSCornelia Huck put_device(dev);
46288a82472fSCornelia Huck return error;
46298a82472fSCornelia Huck }
46308a82472fSCornelia Huck EXPORT_SYMBOL_GPL(device_move);
463137b0c020SGreg Kroah-Hartman
device_attrs_change_owner(struct device * dev,kuid_t kuid,kgid_t kgid)4632b8f33e5dSChristian Brauner static int device_attrs_change_owner(struct device *dev, kuid_t kuid,
4633b8f33e5dSChristian Brauner kgid_t kgid)
4634b8f33e5dSChristian Brauner {
4635b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj;
46369fa120fbSGreg Kroah-Hartman const struct class *class = dev->class;
4637b8f33e5dSChristian Brauner const struct device_type *type = dev->type;
4638b8f33e5dSChristian Brauner int error;
4639b8f33e5dSChristian Brauner
4640b8f33e5dSChristian Brauner if (class) {
4641b8f33e5dSChristian Brauner /*
4642b8f33e5dSChristian Brauner * Change the device groups of the device class for @dev to
4643b8f33e5dSChristian Brauner * @kuid/@kgid.
4644b8f33e5dSChristian Brauner */
4645b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, class->dev_groups, kuid,
4646b8f33e5dSChristian Brauner kgid);
4647b8f33e5dSChristian Brauner if (error)
4648b8f33e5dSChristian Brauner return error;
4649b8f33e5dSChristian Brauner }
4650b8f33e5dSChristian Brauner
4651b8f33e5dSChristian Brauner if (type) {
4652b8f33e5dSChristian Brauner /*
4653b8f33e5dSChristian Brauner * Change the device groups of the device type for @dev to
4654b8f33e5dSChristian Brauner * @kuid/@kgid.
4655b8f33e5dSChristian Brauner */
4656b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, type->groups, kuid,
4657b8f33e5dSChristian Brauner kgid);
4658b8f33e5dSChristian Brauner if (error)
4659b8f33e5dSChristian Brauner return error;
4660b8f33e5dSChristian Brauner }
4661b8f33e5dSChristian Brauner
4662b8f33e5dSChristian Brauner /* Change the device groups of @dev to @kuid/@kgid. */
4663b8f33e5dSChristian Brauner error = sysfs_groups_change_owner(kobj, dev->groups, kuid, kgid);
4664b8f33e5dSChristian Brauner if (error)
4665b8f33e5dSChristian Brauner return error;
4666b8f33e5dSChristian Brauner
4667b8f33e5dSChristian Brauner if (device_supports_offline(dev) && !dev->offline_disabled) {
4668b8f33e5dSChristian Brauner /* Change online device attributes of @dev to @kuid/@kgid. */
4669b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_online.attr.name,
4670b8f33e5dSChristian Brauner kuid, kgid);
4671b8f33e5dSChristian Brauner if (error)
4672b8f33e5dSChristian Brauner return error;
4673b8f33e5dSChristian Brauner }
4674b8f33e5dSChristian Brauner
4675b8f33e5dSChristian Brauner return 0;
4676b8f33e5dSChristian Brauner }
4677b8f33e5dSChristian Brauner
4678b8f33e5dSChristian Brauner /**
4679b8f33e5dSChristian Brauner * device_change_owner - change the owner of an existing device.
4680b8f33e5dSChristian Brauner * @dev: device.
4681b8f33e5dSChristian Brauner * @kuid: new owner's kuid
4682b8f33e5dSChristian Brauner * @kgid: new owner's kgid
4683b8f33e5dSChristian Brauner *
4684b8f33e5dSChristian Brauner * This changes the owner of @dev and its corresponding sysfs entries to
4685b8f33e5dSChristian Brauner * @kuid/@kgid. This function closely mirrors how @dev was added via driver
4686b8f33e5dSChristian Brauner * core.
4687b8f33e5dSChristian Brauner *
4688b8f33e5dSChristian Brauner * Returns 0 on success or error code on failure.
4689b8f33e5dSChristian Brauner */
device_change_owner(struct device * dev,kuid_t kuid,kgid_t kgid)4690b8f33e5dSChristian Brauner int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
4691b8f33e5dSChristian Brauner {
4692b8f33e5dSChristian Brauner int error;
4693b8f33e5dSChristian Brauner struct kobject *kobj = &dev->kobj;
46947d90e81aSGreg Kroah-Hartman struct subsys_private *sp;
4695b8f33e5dSChristian Brauner
4696b8f33e5dSChristian Brauner dev = get_device(dev);
4697b8f33e5dSChristian Brauner if (!dev)
4698b8f33e5dSChristian Brauner return -EINVAL;
4699b8f33e5dSChristian Brauner
4700b8f33e5dSChristian Brauner /*
4701b8f33e5dSChristian Brauner * Change the kobject and the default attributes and groups of the
4702b8f33e5dSChristian Brauner * ktype associated with it to @kuid/@kgid.
4703b8f33e5dSChristian Brauner */
4704b8f33e5dSChristian Brauner error = sysfs_change_owner(kobj, kuid, kgid);
4705b8f33e5dSChristian Brauner if (error)
4706b8f33e5dSChristian Brauner goto out;
4707b8f33e5dSChristian Brauner
4708b8f33e5dSChristian Brauner /*
4709b8f33e5dSChristian Brauner * Change the uevent file for @dev to the new owner. The uevent file
4710b8f33e5dSChristian Brauner * was created in a separate step when @dev got added and we mirror
4711b8f33e5dSChristian Brauner * that step here.
4712b8f33e5dSChristian Brauner */
4713b8f33e5dSChristian Brauner error = sysfs_file_change_owner(kobj, dev_attr_uevent.attr.name, kuid,
4714b8f33e5dSChristian Brauner kgid);
4715b8f33e5dSChristian Brauner if (error)
4716b8f33e5dSChristian Brauner goto out;
4717b8f33e5dSChristian Brauner
4718b8f33e5dSChristian Brauner /*
4719b8f33e5dSChristian Brauner * Change the device groups, the device groups associated with the
4720b8f33e5dSChristian Brauner * device class, and the groups associated with the device type of @dev
4721b8f33e5dSChristian Brauner * to @kuid/@kgid.
4722b8f33e5dSChristian Brauner */
4723b8f33e5dSChristian Brauner error = device_attrs_change_owner(dev, kuid, kgid);
4724b8f33e5dSChristian Brauner if (error)
4725b8f33e5dSChristian Brauner goto out;
4726b8f33e5dSChristian Brauner
47273b52fc5dSChristian Brauner error = dpm_sysfs_change_owner(dev, kuid, kgid);
47283b52fc5dSChristian Brauner if (error)
47293b52fc5dSChristian Brauner goto out;
47303b52fc5dSChristian Brauner
4731b8f33e5dSChristian Brauner /*
4732b8f33e5dSChristian Brauner * Change the owner of the symlink located in the class directory of
4733b8f33e5dSChristian Brauner * the device class associated with @dev which points to the actual
4734b8f33e5dSChristian Brauner * directory entry for @dev to @kuid/@kgid. This ensures that the
4735b8f33e5dSChristian Brauner * symlink shows the same permissions as its target.
4736b8f33e5dSChristian Brauner */
47377d90e81aSGreg Kroah-Hartman sp = class_to_subsys(dev->class);
47387d90e81aSGreg Kroah-Hartman if (!sp) {
47397d90e81aSGreg Kroah-Hartman error = -EINVAL;
4740b8f33e5dSChristian Brauner goto out;
47417d90e81aSGreg Kroah-Hartman }
47427d90e81aSGreg Kroah-Hartman error = sysfs_link_change_owner(&sp->subsys.kobj, &dev->kobj, dev_name(dev), kuid, kgid);
47437d90e81aSGreg Kroah-Hartman subsys_put(sp);
4744b8f33e5dSChristian Brauner
4745b8f33e5dSChristian Brauner out:
4746b8f33e5dSChristian Brauner put_device(dev);
4747b8f33e5dSChristian Brauner return error;
4748b8f33e5dSChristian Brauner }
4749b8f33e5dSChristian Brauner EXPORT_SYMBOL_GPL(device_change_owner);
4750b8f33e5dSChristian Brauner
475137b0c020SGreg Kroah-Hartman /**
475237b0c020SGreg Kroah-Hartman * device_shutdown - call ->shutdown() on each device to shutdown.
475337b0c020SGreg Kroah-Hartman */
device_shutdown(void)475437b0c020SGreg Kroah-Hartman void device_shutdown(void)
475537b0c020SGreg Kroah-Hartman {
4756f123db8eSBenson Leung struct device *dev, *parent;
475737b0c020SGreg Kroah-Hartman
47583297c8fcSPingfan Liu wait_for_device_probe();
47593297c8fcSPingfan Liu device_block_probing();
47603297c8fcSPingfan Liu
476165650b35SRafael J. Wysocki cpufreq_suspend();
476265650b35SRafael J. Wysocki
47636245838fSHugh Daschbach spin_lock(&devices_kset->list_lock);
47646245838fSHugh Daschbach /*
47656245838fSHugh Daschbach * Walk the devices list backward, shutting down each in turn.
47666245838fSHugh Daschbach * Beware that device unplug events may also start pulling
47676245838fSHugh Daschbach * devices offline, even as the system is shutting down.
47686245838fSHugh Daschbach */
47696245838fSHugh Daschbach while (!list_empty(&devices_kset->list)) {
47706245838fSHugh Daschbach dev = list_entry(devices_kset->list.prev, struct device,
47716245838fSHugh Daschbach kobj.entry);
4772d1c6c030SMing Lei
4773d1c6c030SMing Lei /*
4774d1c6c030SMing Lei * hold reference count of device's parent to
4775d1c6c030SMing Lei * prevent it from being freed because parent's
4776d1c6c030SMing Lei * lock is to be held
4777d1c6c030SMing Lei */
4778f123db8eSBenson Leung parent = get_device(dev->parent);
47796245838fSHugh Daschbach get_device(dev);
47806245838fSHugh Daschbach /*
47816245838fSHugh Daschbach * Make sure the device is off the kset list, in the
47826245838fSHugh Daschbach * event that dev->*->shutdown() doesn't remove it.
47836245838fSHugh Daschbach */
47846245838fSHugh Daschbach list_del_init(&dev->kobj.entry);
47856245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock);
4786fe6b91f4SAlan Stern
4787d1c6c030SMing Lei /* hold lock to avoid race with probe/release */
4788f123db8eSBenson Leung if (parent)
4789f123db8eSBenson Leung device_lock(parent);
4790d1c6c030SMing Lei device_lock(dev);
4791d1c6c030SMing Lei
4792fe6b91f4SAlan Stern /* Don't allow any more runtime suspends */
4793fe6b91f4SAlan Stern pm_runtime_get_noresume(dev);
4794fe6b91f4SAlan Stern pm_runtime_barrier(dev);
47956245838fSHugh Daschbach
47967521621eSMichal Suchanek if (dev->class && dev->class->shutdown_pre) {
4797f77af151SJosh Zimmerman if (initcall_debug)
47987521621eSMichal Suchanek dev_info(dev, "shutdown_pre\n");
47997521621eSMichal Suchanek dev->class->shutdown_pre(dev);
48007521621eSMichal Suchanek }
48017521621eSMichal Suchanek if (dev->bus && dev->bus->shutdown) {
48020246c4faSShuoX Liu if (initcall_debug)
48030246c4faSShuoX Liu dev_info(dev, "shutdown\n");
480437b0c020SGreg Kroah-Hartman dev->bus->shutdown(dev);
480537b0c020SGreg Kroah-Hartman } else if (dev->driver && dev->driver->shutdown) {
48060246c4faSShuoX Liu if (initcall_debug)
48070246c4faSShuoX Liu dev_info(dev, "shutdown\n");
480837b0c020SGreg Kroah-Hartman dev->driver->shutdown(dev);
480937b0c020SGreg Kroah-Hartman }
4810d1c6c030SMing Lei
4811d1c6c030SMing Lei device_unlock(dev);
4812f123db8eSBenson Leung if (parent)
4813f123db8eSBenson Leung device_unlock(parent);
4814d1c6c030SMing Lei
48156245838fSHugh Daschbach put_device(dev);
4816f123db8eSBenson Leung put_device(parent);
48176245838fSHugh Daschbach
48186245838fSHugh Daschbach spin_lock(&devices_kset->list_lock);
481937b0c020SGreg Kroah-Hartman }
48206245838fSHugh Daschbach spin_unlock(&devices_kset->list_lock);
482137b0c020SGreg Kroah-Hartman }
482299bcf217SJoe Perches
482399bcf217SJoe Perches /*
482499bcf217SJoe Perches * Device logging functions
482599bcf217SJoe Perches */
482699bcf217SJoe Perches
482799bcf217SJoe Perches #ifdef CONFIG_PRINTK
482874caba7fSJohn Ogness static void
set_dev_info(const struct device * dev,struct dev_printk_info * dev_info)482974caba7fSJohn Ogness set_dev_info(const struct device *dev, struct dev_printk_info *dev_info)
483099bcf217SJoe Perches {
4831c4e00daaSKay Sievers const char *subsys;
483274caba7fSJohn Ogness
483374caba7fSJohn Ogness memset(dev_info, 0, sizeof(*dev_info));
483499bcf217SJoe Perches
4835c4e00daaSKay Sievers if (dev->class)
4836c4e00daaSKay Sievers subsys = dev->class->name;
4837c4e00daaSKay Sievers else if (dev->bus)
4838c4e00daaSKay Sievers subsys = dev->bus->name;
4839c4e00daaSKay Sievers else
484074caba7fSJohn Ogness return;
4841c4e00daaSKay Sievers
484274caba7fSJohn Ogness strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem));
4843c4e00daaSKay Sievers
4844c4e00daaSKay Sievers /*
4845c4e00daaSKay Sievers * Add device identifier DEVICE=:
4846c4e00daaSKay Sievers * b12:8 block dev_t
4847c4e00daaSKay Sievers * c127:3 char dev_t
4848c4e00daaSKay Sievers * n8 netdev ifindex
4849c4e00daaSKay Sievers * +sound:card0 subsystem:devname
4850c4e00daaSKay Sievers */
4851c4e00daaSKay Sievers if (MAJOR(dev->devt)) {
4852c4e00daaSKay Sievers char c;
4853c4e00daaSKay Sievers
4854c4e00daaSKay Sievers if (strcmp(subsys, "block") == 0)
4855c4e00daaSKay Sievers c = 'b';
4856c4e00daaSKay Sievers else
4857c4e00daaSKay Sievers c = 'c';
485874caba7fSJohn Ogness
485974caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device),
486074caba7fSJohn Ogness "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt));
4861c4e00daaSKay Sievers } else if (strcmp(subsys, "net") == 0) {
4862c4e00daaSKay Sievers struct net_device *net = to_net_dev(dev);
4863c4e00daaSKay Sievers
486474caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device),
486574caba7fSJohn Ogness "n%u", net->ifindex);
4866c4e00daaSKay Sievers } else {
486774caba7fSJohn Ogness snprintf(dev_info->device, sizeof(dev_info->device),
486874caba7fSJohn Ogness "+%s:%s", subsys, dev_name(dev));
4869c4e00daaSKay Sievers }
487099bcf217SJoe Perches }
4871798efc60SJoe Perches
dev_vprintk_emit(int level,const struct device * dev,const char * fmt,va_list args)487205e4e5b8SJoe Perches int dev_vprintk_emit(int level, const struct device *dev,
487305e4e5b8SJoe Perches const char *fmt, va_list args)
487405e4e5b8SJoe Perches {
487574caba7fSJohn Ogness struct dev_printk_info dev_info;
487605e4e5b8SJoe Perches
487774caba7fSJohn Ogness set_dev_info(dev, &dev_info);
487805e4e5b8SJoe Perches
487974caba7fSJohn Ogness return vprintk_emit(0, level, &dev_info, fmt, args);
488005e4e5b8SJoe Perches }
488105e4e5b8SJoe Perches EXPORT_SYMBOL(dev_vprintk_emit);
488205e4e5b8SJoe Perches
dev_printk_emit(int level,const struct device * dev,const char * fmt,...)488305e4e5b8SJoe Perches int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
488405e4e5b8SJoe Perches {
488505e4e5b8SJoe Perches va_list args;
488605e4e5b8SJoe Perches int r;
488705e4e5b8SJoe Perches
488805e4e5b8SJoe Perches va_start(args, fmt);
488905e4e5b8SJoe Perches
489005e4e5b8SJoe Perches r = dev_vprintk_emit(level, dev, fmt, args);
489105e4e5b8SJoe Perches
489205e4e5b8SJoe Perches va_end(args);
489305e4e5b8SJoe Perches
489405e4e5b8SJoe Perches return r;
489505e4e5b8SJoe Perches }
489605e4e5b8SJoe Perches EXPORT_SYMBOL(dev_printk_emit);
489705e4e5b8SJoe Perches
__dev_printk(const char * level,const struct device * dev,struct va_format * vaf)4898d1f1052cSJoe Perches static void __dev_printk(const char *level, const struct device *dev,
4899798efc60SJoe Perches struct va_format *vaf)
4900798efc60SJoe Perches {
4901d1f1052cSJoe Perches if (dev)
4902d1f1052cSJoe Perches dev_printk_emit(level[1] - '0', dev, "%s %s: %pV",
4903798efc60SJoe Perches dev_driver_string(dev), dev_name(dev), vaf);
4904d1f1052cSJoe Perches else
4905d1f1052cSJoe Perches printk("%s(NULL device *): %pV", level, vaf);
4906798efc60SJoe Perches }
490799bcf217SJoe Perches
_dev_printk(const char * level,const struct device * dev,const char * fmt,...)4908ad7d61f1SChris Down void _dev_printk(const char *level, const struct device *dev,
490999bcf217SJoe Perches const char *fmt, ...)
491099bcf217SJoe Perches {
491199bcf217SJoe Perches struct va_format vaf;
491299bcf217SJoe Perches va_list args;
491399bcf217SJoe Perches
491499bcf217SJoe Perches va_start(args, fmt);
491599bcf217SJoe Perches
491699bcf217SJoe Perches vaf.fmt = fmt;
491799bcf217SJoe Perches vaf.va = &args;
491899bcf217SJoe Perches
4919d1f1052cSJoe Perches __dev_printk(level, dev, &vaf);
4920798efc60SJoe Perches
492199bcf217SJoe Perches va_end(args);
492299bcf217SJoe Perches }
4923ad7d61f1SChris Down EXPORT_SYMBOL(_dev_printk);
492499bcf217SJoe Perches
492599bcf217SJoe Perches #define define_dev_printk_level(func, kern_level) \
4926d1f1052cSJoe Perches void func(const struct device *dev, const char *fmt, ...) \
492799bcf217SJoe Perches { \
492899bcf217SJoe Perches struct va_format vaf; \
492999bcf217SJoe Perches va_list args; \
493099bcf217SJoe Perches \
493199bcf217SJoe Perches va_start(args, fmt); \
493299bcf217SJoe Perches \
493399bcf217SJoe Perches vaf.fmt = fmt; \
493499bcf217SJoe Perches vaf.va = &args; \
493599bcf217SJoe Perches \
4936d1f1052cSJoe Perches __dev_printk(kern_level, dev, &vaf); \
4937798efc60SJoe Perches \
493899bcf217SJoe Perches va_end(args); \
493999bcf217SJoe Perches } \
494099bcf217SJoe Perches EXPORT_SYMBOL(func);
494199bcf217SJoe Perches
4942663336eeSJoe Perches define_dev_printk_level(_dev_emerg, KERN_EMERG);
4943663336eeSJoe Perches define_dev_printk_level(_dev_alert, KERN_ALERT);
4944663336eeSJoe Perches define_dev_printk_level(_dev_crit, KERN_CRIT);
4945663336eeSJoe Perches define_dev_printk_level(_dev_err, KERN_ERR);
4946663336eeSJoe Perches define_dev_printk_level(_dev_warn, KERN_WARNING);
4947663336eeSJoe Perches define_dev_printk_level(_dev_notice, KERN_NOTICE);
494899bcf217SJoe Perches define_dev_printk_level(_dev_info, KERN_INFO);
494999bcf217SJoe Perches
495099bcf217SJoe Perches #endif
495197badf87SRafael J. Wysocki
4952a787e540SAndrzej Hajda /**
4953a787e540SAndrzej Hajda * dev_err_probe - probe error check and log helper
4954a787e540SAndrzej Hajda * @dev: the pointer to the struct device
4955a787e540SAndrzej Hajda * @err: error value to test
4956a787e540SAndrzej Hajda * @fmt: printf-style format string
4957a787e540SAndrzej Hajda * @...: arguments as specified in the format string
4958a787e540SAndrzej Hajda *
4959a787e540SAndrzej Hajda * This helper implements common pattern present in probe functions for error
4960a787e540SAndrzej Hajda * checking: print debug or error message depending if the error value is
4961a787e540SAndrzej Hajda * -EPROBE_DEFER and propagate error upwards.
4962d090b70eSAndrzej Hajda * In case of -EPROBE_DEFER it sets also defer probe reason, which can be
4963d090b70eSAndrzej Hajda * checked later by reading devices_deferred debugfs attribute.
4964074b3aadSMauro Carvalho Chehab * It replaces code sequence::
4965074b3aadSMauro Carvalho Chehab *
4966a787e540SAndrzej Hajda * if (err != -EPROBE_DEFER)
4967a787e540SAndrzej Hajda * dev_err(dev, ...);
4968a787e540SAndrzej Hajda * else
4969a787e540SAndrzej Hajda * dev_dbg(dev, ...);
4970a787e540SAndrzej Hajda * return err;
4971074b3aadSMauro Carvalho Chehab *
4972074b3aadSMauro Carvalho Chehab * with::
4973074b3aadSMauro Carvalho Chehab *
4974a787e540SAndrzej Hajda * return dev_err_probe(dev, err, ...);
4975a787e540SAndrzej Hajda *
49767065f922SDouglas Anderson * Note that it is deemed acceptable to use this function for error
49777065f922SDouglas Anderson * prints during probe even if the @err is known to never be -EPROBE_DEFER.
49787065f922SDouglas Anderson * The benefit compared to a normal dev_err() is the standardized format
49797065f922SDouglas Anderson * of the error code and the fact that the error code is returned.
49807065f922SDouglas Anderson *
4981a787e540SAndrzej Hajda * Returns @err.
4982a787e540SAndrzej Hajda *
4983a787e540SAndrzej Hajda */
dev_err_probe(const struct device * dev,int err,const char * fmt,...)4984a787e540SAndrzej Hajda int dev_err_probe(const struct device *dev, int err, const char *fmt, ...)
4985a787e540SAndrzej Hajda {
4986a787e540SAndrzej Hajda struct va_format vaf;
4987a787e540SAndrzej Hajda va_list args;
4988a787e540SAndrzej Hajda
4989a787e540SAndrzej Hajda va_start(args, fmt);
4990a787e540SAndrzej Hajda vaf.fmt = fmt;
4991a787e540SAndrzej Hajda vaf.va = &args;
4992a787e540SAndrzej Hajda
4993d090b70eSAndrzej Hajda if (err != -EPROBE_DEFER) {
4994693a8e93SMichał Mirosław dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf);
4995d090b70eSAndrzej Hajda } else {
4996d090b70eSAndrzej Hajda device_set_deferred_probe_reason(dev, &vaf);
4997693a8e93SMichał Mirosław dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf);
4998d090b70eSAndrzej Hajda }
4999a787e540SAndrzej Hajda
5000a787e540SAndrzej Hajda va_end(args);
5001a787e540SAndrzej Hajda
5002a787e540SAndrzej Hajda return err;
5003a787e540SAndrzej Hajda }
5004a787e540SAndrzej Hajda EXPORT_SYMBOL_GPL(dev_err_probe);
5005a787e540SAndrzej Hajda
fwnode_is_primary(struct fwnode_handle * fwnode)500697badf87SRafael J. Wysocki static inline bool fwnode_is_primary(struct fwnode_handle *fwnode)
500797badf87SRafael J. Wysocki {
500897badf87SRafael J. Wysocki return fwnode && !IS_ERR(fwnode->secondary);
500997badf87SRafael J. Wysocki }
501097badf87SRafael J. Wysocki
501197badf87SRafael J. Wysocki /**
501297badf87SRafael J. Wysocki * set_primary_fwnode - Change the primary firmware node of a given device.
501397badf87SRafael J. Wysocki * @dev: Device to handle.
501497badf87SRafael J. Wysocki * @fwnode: New primary firmware node of the device.
501597badf87SRafael J. Wysocki *
501697badf87SRafael J. Wysocki * Set the device's firmware node pointer to @fwnode, but if a secondary
501797badf87SRafael J. Wysocki * firmware node of the device is present, preserve it.
50183f7bddafSBard Liao *
50193f7bddafSBard Liao * Valid fwnode cases are:
50203f7bddafSBard Liao * - primary --> secondary --> -ENODEV
50213f7bddafSBard Liao * - primary --> NULL
50223f7bddafSBard Liao * - secondary --> -ENODEV
50233f7bddafSBard Liao * - NULL
502497badf87SRafael J. Wysocki */
set_primary_fwnode(struct device * dev,struct fwnode_handle * fwnode)502597badf87SRafael J. Wysocki void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
502697badf87SRafael J. Wysocki {
502799aed922SAndy Shevchenko struct device *parent = dev->parent;
502897badf87SRafael J. Wysocki struct fwnode_handle *fn = dev->fwnode;
502997badf87SRafael J. Wysocki
5030c15e1bddSHeikki Krogerus if (fwnode) {
503197badf87SRafael J. Wysocki if (fwnode_is_primary(fn))
503297badf87SRafael J. Wysocki fn = fn->secondary;
503397badf87SRafael J. Wysocki
503455f89a8aSMika Westerberg if (fn) {
503555f89a8aSMika Westerberg WARN_ON(fwnode->secondary);
503697badf87SRafael J. Wysocki fwnode->secondary = fn;
503755f89a8aSMika Westerberg }
503897badf87SRafael J. Wysocki dev->fwnode = fwnode;
503997badf87SRafael J. Wysocki } else {
5040c15e1bddSHeikki Krogerus if (fwnode_is_primary(fn)) {
5041c15e1bddSHeikki Krogerus dev->fwnode = fn->secondary;
50422f9e87f5SAndy Shevchenko
50432f9e87f5SAndy Shevchenko /* Skip nullifying fn->secondary if the primary is shared */
50442f9e87f5SAndy Shevchenko if (parent && fn == parent->fwnode)
50452f9e87f5SAndy Shevchenko return;
50462f9e87f5SAndy Shevchenko
50473f7bddafSBard Liao /* Set fn->secondary = NULL, so fn remains the primary fwnode */
504847f44699SBard Liao fn->secondary = NULL;
5049c15e1bddSHeikki Krogerus } else {
5050c15e1bddSHeikki Krogerus dev->fwnode = NULL;
5051c15e1bddSHeikki Krogerus }
505297badf87SRafael J. Wysocki }
505397badf87SRafael J. Wysocki }
505497badf87SRafael J. Wysocki EXPORT_SYMBOL_GPL(set_primary_fwnode);
505597badf87SRafael J. Wysocki
505697badf87SRafael J. Wysocki /**
505797badf87SRafael J. Wysocki * set_secondary_fwnode - Change the secondary firmware node of a given device.
505897badf87SRafael J. Wysocki * @dev: Device to handle.
505997badf87SRafael J. Wysocki * @fwnode: New secondary firmware node of the device.
506097badf87SRafael J. Wysocki *
506197badf87SRafael J. Wysocki * If a primary firmware node of the device is present, set its secondary
506297badf87SRafael J. Wysocki * pointer to @fwnode. Otherwise, set the device's firmware node pointer to
506397badf87SRafael J. Wysocki * @fwnode.
506497badf87SRafael J. Wysocki */
set_secondary_fwnode(struct device * dev,struct fwnode_handle * fwnode)506597badf87SRafael J. Wysocki void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
506697badf87SRafael J. Wysocki {
506797badf87SRafael J. Wysocki if (fwnode)
506897badf87SRafael J. Wysocki fwnode->secondary = ERR_PTR(-ENODEV);
506997badf87SRafael J. Wysocki
507097badf87SRafael J. Wysocki if (fwnode_is_primary(dev->fwnode))
507197badf87SRafael J. Wysocki dev->fwnode->secondary = fwnode;
507297badf87SRafael J. Wysocki else
507397badf87SRafael J. Wysocki dev->fwnode = fwnode;
507497badf87SRafael J. Wysocki }
507596489ae1SAndy Shevchenko EXPORT_SYMBOL_GPL(set_secondary_fwnode);
50764e75e1d7SJohan Hovold
50774e75e1d7SJohan Hovold /**
50784e75e1d7SJohan Hovold * device_set_of_node_from_dev - reuse device-tree node of another device
50794e75e1d7SJohan Hovold * @dev: device whose device-tree node is being set
50804e75e1d7SJohan Hovold * @dev2: device whose device-tree node is being reused
50814e75e1d7SJohan Hovold *
50824e75e1d7SJohan Hovold * Takes another reference to the new device-tree node after first dropping
50834e75e1d7SJohan Hovold * any reference held to the old node.
50844e75e1d7SJohan Hovold */
device_set_of_node_from_dev(struct device * dev,const struct device * dev2)50854e75e1d7SJohan Hovold void device_set_of_node_from_dev(struct device *dev, const struct device *dev2)
50864e75e1d7SJohan Hovold {
50874e75e1d7SJohan Hovold of_node_put(dev->of_node);
50884e75e1d7SJohan Hovold dev->of_node = of_node_get(dev2->of_node);
50894e75e1d7SJohan Hovold dev->of_node_reused = true;
50904e75e1d7SJohan Hovold }
50914e75e1d7SJohan Hovold EXPORT_SYMBOL_GPL(device_set_of_node_from_dev);
509265b66682SSuzuki K Poulose
device_set_node(struct device * dev,struct fwnode_handle * fwnode)509343e76d46SIoana Ciornei void device_set_node(struct device *dev, struct fwnode_handle *fwnode)
509443e76d46SIoana Ciornei {
509543e76d46SIoana Ciornei dev->fwnode = fwnode;
509643e76d46SIoana Ciornei dev->of_node = to_of_node(fwnode);
509743e76d46SIoana Ciornei }
509843e76d46SIoana Ciornei EXPORT_SYMBOL_GPL(device_set_node);
509943e76d46SIoana Ciornei
device_match_name(struct device * dev,const void * name)51006cda08a2SSuzuki K Poulose int device_match_name(struct device *dev, const void *name)
51016cda08a2SSuzuki K Poulose {
51026cda08a2SSuzuki K Poulose return sysfs_streq(dev_name(dev), name);
51036cda08a2SSuzuki K Poulose }
51046cda08a2SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_name);
51056cda08a2SSuzuki K Poulose
device_match_of_node(struct device * dev,const void * np)510665b66682SSuzuki K Poulose int device_match_of_node(struct device *dev, const void *np)
510765b66682SSuzuki K Poulose {
510865b66682SSuzuki K Poulose return dev->of_node == np;
510965b66682SSuzuki K Poulose }
511065b66682SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_of_node);
511167843bbaSSuzuki K Poulose
device_match_fwnode(struct device * dev,const void * fwnode)511267843bbaSSuzuki K Poulose int device_match_fwnode(struct device *dev, const void *fwnode)
511367843bbaSSuzuki K Poulose {
511467843bbaSSuzuki K Poulose return dev_fwnode(dev) == fwnode;
511567843bbaSSuzuki K Poulose }
511667843bbaSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_fwnode);
51174495dfddSSuzuki K Poulose
device_match_devt(struct device * dev,const void * pdevt)51184495dfddSSuzuki K Poulose int device_match_devt(struct device *dev, const void *pdevt)
51194495dfddSSuzuki K Poulose {
51204495dfddSSuzuki K Poulose return dev->devt == *(dev_t *)pdevt;
51214495dfddSSuzuki K Poulose }
51224495dfddSSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_devt);
512300500147SSuzuki K Poulose
device_match_acpi_dev(struct device * dev,const void * adev)512400500147SSuzuki K Poulose int device_match_acpi_dev(struct device *dev, const void *adev)
512500500147SSuzuki K Poulose {
512600500147SSuzuki K Poulose return ACPI_COMPANION(dev) == adev;
512700500147SSuzuki K Poulose }
512800500147SSuzuki K Poulose EXPORT_SYMBOL(device_match_acpi_dev);
51296bf85ba9SSuzuki K Poulose
device_match_acpi_handle(struct device * dev,const void * handle)5130a164ff53SAndy Shevchenko int device_match_acpi_handle(struct device *dev, const void *handle)
5131a164ff53SAndy Shevchenko {
5132a164ff53SAndy Shevchenko return ACPI_HANDLE(dev) == handle;
5133a164ff53SAndy Shevchenko }
5134a164ff53SAndy Shevchenko EXPORT_SYMBOL(device_match_acpi_handle);
5135a164ff53SAndy Shevchenko
device_match_any(struct device * dev,const void * unused)51366bf85ba9SSuzuki K Poulose int device_match_any(struct device *dev, const void *unused)
51376bf85ba9SSuzuki K Poulose {
51386bf85ba9SSuzuki K Poulose return 1;
51396bf85ba9SSuzuki K Poulose }
51406bf85ba9SSuzuki K Poulose EXPORT_SYMBOL_GPL(device_match_any);
5141