1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* drivers/base/core.c - core driver model code (device registration, etc)
4	*
5	* Copyright (c) 2002-3 Patrick Mochel
6	* Copyright (c) 2002-3 Open Source Development Labs
7	* Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
8	* Copyright (c) 2006 Novell, Inc.
9	*/
10
11	#include <linux/acpi.h>
12	#include <linux/cpufreq.h>
13	#include <linux/device.h>
14	#include <linux/err.h>
15	#include <linux/fwnode.h>
16	#include <linux/init.h>
17	#include <linux/kstrtox.h>
18	#include <linux/module.h>
19	#include <linux/slab.h>
20	#include <linux/kdev_t.h>
21	#include <linux/notifier.h>
22	#include <linux/of.h>
23	#include <linux/of_device.h>
24	#include <linux/blkdev.h>
25	#include <linux/mutex.h>
26	#include <linux/pm_runtime.h>
27	#include <linux/netdevice.h>
28	#include <linux/sched/signal.h>
29	#include <linux/sched/mm.h>
30	#include <linux/string_helpers.h>
31	#include <linux/swiotlb.h>
32	#include <linux/sysfs.h>
33	#include <linux/dma-map-ops.h> /* for dma_default_coherent */
34
35	#include "base.h"
36	#include "physical_location.h"
37	#include "power/power.h"
38
39	/* Device links support. */
40	static LIST_HEAD(deferred_sync);
41	static unsigned int defer_sync_state_count = 1;
42	static DEFINE_MUTEX(fwnode_link_lock);
43	static bool fw_devlink_is_permissive(void);
44	static void __fw_devlink_link_to_consumers(struct device *dev);
45	static bool fw_devlink_drv_reg_done;
46	static bool fw_devlink_best_effort;
47	static struct workqueue_struct *device_link_wq;
48
49	/**
50	* __fwnode_link_add - Create a link between two fwnode_handles.
51	* @con: Consumer end of the link.
52	* @sup: Supplier end of the link.
53	* @flags: Link flags.
54	*
55	* Create a fwnode link between fwnode handles @con and @sup. The fwnode link
56	* represents the detail that the firmware lists @sup fwnode as supplying a
57	* resource to @con.
58	*
59	* The driver core will use the fwnode link to create a device link between the
60	* two device objects corresponding to @con and @sup when they are created. The
61	* driver core will automatically delete the fwnode link between @con and @sup
62	* after doing that.
63	*
64	* Attempts to create duplicate links between the same pair of fwnode handles
65	* are ignored and there is no reference counting.
66	*/
67	static int __fwnode_link_add(struct fwnode_handle *con,
68	struct fwnode_handle *sup, u8 flags)
69	{
70	struct fwnode_link *link;
71
72	list_for_each_entry(link, &sup->consumers, s_hook)
73	if (link->consumer == con) {
74	link->flags |= flags;
75	return 0;
76	}
77
78	link = kzalloc(size: sizeof(*link), GFP_KERNEL);
79	if (!link)
80	return -ENOMEM;
81
82	link->supplier = sup;
83	INIT_LIST_HEAD(list: &link->s_hook);
84	link->consumer = con;
85	INIT_LIST_HEAD(list: &link->c_hook);
86	link->flags = flags;
87
88	list_add(new: &link->s_hook, head: &sup->consumers);
89	list_add(new: &link->c_hook, head: &con->suppliers);
90	pr_debug("%pfwf Linked as a fwnode consumer to %pfwf\n",
91	con, sup);
92
93	return 0;
94	}
95
96	int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup,
97	u8 flags)
98	{
99	int ret;
100
101	mutex_lock(&fwnode_link_lock);
102	ret = __fwnode_link_add(con, sup, flags);
103	mutex_unlock(lock: &fwnode_link_lock);
104	return ret;
105	}
106
107	/**
108	* __fwnode_link_del - Delete a link between two fwnode_handles.
109	* @link: the fwnode_link to be deleted
110	*
111	* The fwnode_link_lock needs to be held when this function is called.
112	*/
113	static void __fwnode_link_del(struct fwnode_link *link)
114	{
115	pr_debug("%pfwf Dropping the fwnode link to %pfwf\n",
116	link->consumer, link->supplier);
117	list_del(entry: &link->s_hook);
118	list_del(entry: &link->c_hook);
119	kfree(objp: link);
120	}
121
122	/**
123	* __fwnode_link_cycle - Mark a fwnode link as being part of a cycle.
124	* @link: the fwnode_link to be marked
125	*
126	* The fwnode_link_lock needs to be held when this function is called.
127	*/
128	static void __fwnode_link_cycle(struct fwnode_link *link)
129	{
130	pr_debug("%pfwf: cycle: depends on %pfwf\n",
131	link->consumer, link->supplier);
132	link->flags |= FWLINK_FLAG_CYCLE;
133	}
134
135	/**
136	* fwnode_links_purge_suppliers - Delete all supplier links of fwnode_handle.
137	* @fwnode: fwnode whose supplier links need to be deleted
138	*
139	* Deletes all supplier links connecting directly to @fwnode.
140	*/
141	static void fwnode_links_purge_suppliers(struct fwnode_handle *fwnode)
142	{
143	struct fwnode_link *link, *tmp;
144
145	mutex_lock(&fwnode_link_lock);
146	list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook)
147	__fwnode_link_del(link);
148	mutex_unlock(lock: &fwnode_link_lock);
149	}
150
151	/**
152	* fwnode_links_purge_consumers - Delete all consumer links of fwnode_handle.
153	* @fwnode: fwnode whose consumer links need to be deleted
154	*
155	* Deletes all consumer links connecting directly to @fwnode.
156	*/
157	static void fwnode_links_purge_consumers(struct fwnode_handle *fwnode)
158	{
159	struct fwnode_link *link, *tmp;
160
161	mutex_lock(&fwnode_link_lock);
162	list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook)
163	__fwnode_link_del(link);
164	mutex_unlock(lock: &fwnode_link_lock);
165	}
166
167	/**
168	* fwnode_links_purge - Delete all links connected to a fwnode_handle.
169	* @fwnode: fwnode whose links needs to be deleted
170	*
171	* Deletes all links connecting directly to a fwnode.
172	*/
173	void fwnode_links_purge(struct fwnode_handle *fwnode)
174	{
175	fwnode_links_purge_suppliers(fwnode);
176	fwnode_links_purge_consumers(fwnode);
177	}
178
179	void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode)
180	{
181	struct fwnode_handle *child;
182
183	/* Don't purge consumer links of an added child */
184	if (fwnode->dev)
185	return;
186
187	fwnode->flags |= FWNODE_FLAG_NOT_DEVICE;
188	fwnode_links_purge_consumers(fwnode);
189
190	fwnode_for_each_available_child_node(fwnode, child)
191	fw_devlink_purge_absent_suppliers(fwnode: child);
192	}
193	EXPORT_SYMBOL_GPL(fw_devlink_purge_absent_suppliers);
194
195	/**
196	* __fwnode_links_move_consumers - Move consumer from @from to @to fwnode_handle
197	* @from: move consumers away from this fwnode
198	* @to: move consumers to this fwnode
199	*
200	* Move all consumer links from @from fwnode to @to fwnode.
201	*/
202	static void __fwnode_links_move_consumers(struct fwnode_handle *from,
203	struct fwnode_handle *to)
204	{
205	struct fwnode_link *link, *tmp;
206
207	list_for_each_entry_safe(link, tmp, &from->consumers, s_hook) {
208	__fwnode_link_add(con: link->consumer, sup: to, flags: link->flags);
209	__fwnode_link_del(link);
210	}
211	}
212
213	/**
214	* __fw_devlink_pickup_dangling_consumers - Pick up dangling consumers
215	* @fwnode: fwnode from which to pick up dangling consumers
216	* @new_sup: fwnode of new supplier
217	*
218	* If the @fwnode has a corresponding struct device and the device supports
219	* probing (that is, added to a bus), then we want to let fw_devlink create
220	* MANAGED device links to this device, so leave @fwnode and its descendant's
221	* fwnode links alone.
222	*
223	* Otherwise, move its consumers to the new supplier @new_sup.
224	*/
225	static void __fw_devlink_pickup_dangling_consumers(struct fwnode_handle *fwnode,
226	struct fwnode_handle *new_sup)
227	{
228	struct fwnode_handle *child;
229
230	if (fwnode->dev && fwnode->dev->bus)
231	return;
232
233	fwnode->flags |= FWNODE_FLAG_NOT_DEVICE;
234	__fwnode_links_move_consumers(from: fwnode, to: new_sup);
235
236	fwnode_for_each_available_child_node(fwnode, child)
237	__fw_devlink_pickup_dangling_consumers(fwnode: child, new_sup);
238	}
239
240	static DEFINE_MUTEX(device_links_lock);
241	DEFINE_STATIC_SRCU(device_links_srcu);
242
243	static inline void device_links_write_lock(void)
244	{
245	mutex_lock(&device_links_lock);
246	}
247
248	static inline void device_links_write_unlock(void)
249	{
250	mutex_unlock(lock: &device_links_lock);
251	}
252
253	int device_links_read_lock(void) __acquires(&device_links_srcu)
254	{
255	return srcu_read_lock(ssp: &device_links_srcu);
256	}
257
258	void device_links_read_unlock(int idx) __releases(&device_links_srcu)
259	{
260	srcu_read_unlock(ssp: &device_links_srcu, idx);
261	}
262
263	int device_links_read_lock_held(void)
264	{
265	return srcu_read_lock_held(ssp: &device_links_srcu);
266	}
267
268	static void device_link_synchronize_removal(void)
269	{
270	synchronize_srcu(ssp: &device_links_srcu);
271	}
272
273	static void device_link_remove_from_lists(struct device_link *link)
274	{
275	list_del_rcu(entry: &link->s_node);
276	list_del_rcu(entry: &link->c_node);
277	}
278
279	static bool device_is_ancestor(struct device *dev, struct device *target)
280	{
281	while (target->parent) {
282	target = target->parent;
283	if (dev == target)
284	return true;
285	}
286	return false;
287	}
288
289	#define DL_MARKER_FLAGS (DL_FLAG_INFERRED | \
290	DL_FLAG_CYCLE | \
291	DL_FLAG_MANAGED)
292	static inline bool device_link_flag_is_sync_state_only(u32 flags)
293	{
294	return (flags & ~DL_MARKER_FLAGS) == DL_FLAG_SYNC_STATE_ONLY;
295	}
296
297	/**
298	* device_is_dependent - Check if one device depends on another one
299	* @dev: Device to check dependencies for.
300	* @target: Device to check against.
301	*
302	* Check if @target depends on @dev or any device dependent on it (its child or
303	* its consumer etc). Return 1 if that is the case or 0 otherwise.
304	*/
305	static int device_is_dependent(struct device *dev, void *target)
306	{
307	struct device_link *link;
308	int ret;
309
310	/*
311	* The "ancestors" check is needed to catch the case when the target
312	* device has not been completely initialized yet and it is still
313	* missing from the list of children of its parent device.
314	*/
315	if (dev == target || device_is_ancestor(dev, target))
316	return 1;
317
318	ret = device_for_each_child(dev, data: target, fn: device_is_dependent);
319	if (ret)
320	return ret;
321
322	list_for_each_entry(link, &dev->links.consumers, s_node) {
323	if (device_link_flag_is_sync_state_only(flags: link->flags))
324	continue;
325
326	if (link->consumer == target)
327	return 1;
328
329	ret = device_is_dependent(dev: link->consumer, target);
330	if (ret)
331	break;
332	}
333	return ret;
334	}
335
336	static void device_link_init_status(struct device_link *link,
337	struct device *consumer,
338	struct device *supplier)
339	{
340	switch (supplier->links.status) {
341	case DL_DEV_PROBING:
342	switch (consumer->links.status) {
343	case DL_DEV_PROBING:
344	/*
345	* A consumer driver can create a link to a supplier
346	* that has not completed its probing yet as long as it
347	* knows that the supplier is already functional (for
348	* example, it has just acquired some resources from the
349	* supplier).
350	*/
351	link->status = DL_STATE_CONSUMER_PROBE;
352	break;
353	default:
354	link->status = DL_STATE_DORMANT;
355	break;
356	}
357	break;
358	case DL_DEV_DRIVER_BOUND:
359	switch (consumer->links.status) {
360	case DL_DEV_PROBING:
361	link->status = DL_STATE_CONSUMER_PROBE;
362	break;
363	case DL_DEV_DRIVER_BOUND:
364	link->status = DL_STATE_ACTIVE;
365	break;
366	default:
367	link->status = DL_STATE_AVAILABLE;
368	break;
369	}
370	break;
371	case DL_DEV_UNBINDING:
372	link->status = DL_STATE_SUPPLIER_UNBIND;
373	break;
374	default:
375	link->status = DL_STATE_DORMANT;
376	break;
377	}
378	}
379
380	static int device_reorder_to_tail(struct device *dev, void *not_used)
381	{
382	struct device_link *link;
383
384	/*
385	* Devices that have not been registered yet will be put to the ends
386	* of the lists during the registration, so skip them here.
387	*/
388	if (device_is_registered(dev))
389	devices_kset_move_last(dev);
390
391	if (device_pm_initialized(dev))
392	device_pm_move_last(dev);
393
394	device_for_each_child(dev, NULL, fn: device_reorder_to_tail);
395	list_for_each_entry(link, &dev->links.consumers, s_node) {
396	if (device_link_flag_is_sync_state_only(flags: link->flags))
397	continue;
398	device_reorder_to_tail(dev: link->consumer, NULL);
399	}
400
401	return 0;
402	}
403
404	/**
405	* device_pm_move_to_tail - Move set of devices to the end of device lists
406	* @dev: Device to move
407	*
408	* This is a device_reorder_to_tail() wrapper taking the requisite locks.
409	*
410	* It moves the @dev along with all of its children and all of its consumers
411	* to the ends of the device_kset and dpm_list, recursively.
412	*/
413	void device_pm_move_to_tail(struct device *dev)
414	{
415	int idx;
416
417	idx = device_links_read_lock();
418	device_pm_lock();
419	device_reorder_to_tail(dev, NULL);
420	device_pm_unlock();
421	device_links_read_unlock(idx);
422	}
423
424	#define to_devlink(dev) container_of((dev), struct device_link, link_dev)
425
426	static ssize_t status_show(struct device *dev,
427	struct device_attribute *attr, char *buf)
428	{
429	const char *output;
430
431	switch (to_devlink(dev)->status) {
432	case DL_STATE_NONE:
433	output = "not tracked";
434	break;
435	case DL_STATE_DORMANT:
436	output = "dormant";
437	break;
438	case DL_STATE_AVAILABLE:
439	output = "available";
440	break;
441	case DL_STATE_CONSUMER_PROBE:
442	output = "consumer probing";
443	break;
444	case DL_STATE_ACTIVE:
445	output = "active";
446	break;
447	case DL_STATE_SUPPLIER_UNBIND:
448	output = "supplier unbinding";
449	break;
450	default:
451	output = "unknown";
452	break;
453	}
454
455	return sysfs_emit(buf, fmt: "%s\n", output);
456	}
457	static DEVICE_ATTR_RO(status);
458
459	static ssize_t auto_remove_on_show(struct device *dev,
460	struct device_attribute *attr, char *buf)
461	{
462	struct device_link *link = to_devlink(dev);
463	const char *output;
464
465	if (link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
466	output = "supplier unbind";
467	else if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER)
468	output = "consumer unbind";
469	else
470	output = "never";
471
472	return sysfs_emit(buf, fmt: "%s\n", output);
473	}
474	static DEVICE_ATTR_RO(auto_remove_on);
475
476	static ssize_t runtime_pm_show(struct device *dev,
477	struct device_attribute *attr, char *buf)
478	{
479	struct device_link *link = to_devlink(dev);
480
481	return sysfs_emit(buf, fmt: "%d\n", !!(link->flags & DL_FLAG_PM_RUNTIME));
482	}
483	static DEVICE_ATTR_RO(runtime_pm);
484
485	static ssize_t sync_state_only_show(struct device *dev,
486	struct device_attribute *attr, char *buf)
487	{
488	struct device_link *link = to_devlink(dev);
489
490	return sysfs_emit(buf, fmt: "%d\n",
491	!!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
492	}
493	static DEVICE_ATTR_RO(sync_state_only);
494
495	static struct attribute *devlink_attrs[] = {
496	&dev_attr_status.attr,
497	&dev_attr_auto_remove_on.attr,
498	&dev_attr_runtime_pm.attr,
499	&dev_attr_sync_state_only.attr,
500	NULL,
501	};
502	ATTRIBUTE_GROUPS(devlink);
503
504	static void device_link_release_fn(struct work_struct *work)
505	{
506	struct device_link *link = container_of(work, struct device_link, rm_work);
507
508	/* Ensure that all references to the link object have been dropped. */
509	device_link_synchronize_removal();
510
511	pm_runtime_release_supplier(link);
512	/*
513	* If supplier_preactivated is set, the link has been dropped between
514	* the pm_runtime_get_suppliers() and pm_runtime_put_suppliers() calls
515	* in __driver_probe_device(). In that case, drop the supplier's
516	* PM-runtime usage counter to remove the reference taken by
517	* pm_runtime_get_suppliers().
518	*/
519	if (link->supplier_preactivated)
520	pm_runtime_put_noidle(dev: link->supplier);
521
522	pm_request_idle(dev: link->supplier);
523
524	put_device(dev: link->consumer);
525	put_device(dev: link->supplier);
526	kfree(objp: link);
527	}
528
529	static void devlink_dev_release(struct device *dev)
530	{
531	struct device_link *link = to_devlink(dev);
532
533	INIT_WORK(&link->rm_work, device_link_release_fn);
534	/*
535	* It may take a while to complete this work because of the SRCU
536	* synchronization in device_link_release_fn() and if the consumer or
537	* supplier devices get deleted when it runs, so put it into the
538	* dedicated workqueue.
539	*/
540	queue_work(wq: device_link_wq, work: &link->rm_work);
541	}
542
543	/**
544	* device_link_wait_removal - Wait for ongoing devlink removal jobs to terminate
545	*/
546	void device_link_wait_removal(void)
547	{
548	/*
549	* devlink removal jobs are queued in the dedicated work queue.
550	* To be sure that all removal jobs are terminated, ensure that any
551	* scheduled work has run to completion.
552	*/
553	flush_workqueue(device_link_wq);
554	}
555	EXPORT_SYMBOL_GPL(device_link_wait_removal);
556
557	static struct class devlink_class = {
558	.name = "devlink",
559	.dev_groups = devlink_groups,
560	.dev_release = devlink_dev_release,
561	};
562
563	static int devlink_add_symlinks(struct device *dev)
564	{
565	int ret;
566	size_t len;
567	struct device_link *link = to_devlink(dev);
568	struct device *sup = link->supplier;
569	struct device *con = link->consumer;
570	char *buf;
571
572	len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)),
573	strlen(dev_bus_name(con)) + strlen(dev_name(con)));
574	len += strlen(":");
575	len += strlen("supplier:") + 1;
576	buf = kzalloc(size: len, GFP_KERNEL);
577	if (!buf)
578	return -ENOMEM;
579
580	ret = sysfs_create_link(kobj: &link->link_dev.kobj, target: &sup->kobj, name: "supplier");
581	if (ret)
582	goto out;
583
584	ret = sysfs_create_link(kobj: &link->link_dev.kobj, target: &con->kobj, name: "consumer");
585	if (ret)
586	goto err_con;
587
588	snprintf(buf, size: len, fmt: "consumer:%s:%s", dev_bus_name(dev: con), dev_name(dev: con));
589	ret = sysfs_create_link(kobj: &sup->kobj, target: &link->link_dev.kobj, name: buf);
590	if (ret)
591	goto err_con_dev;
592
593	snprintf(buf, size: len, fmt: "supplier:%s:%s", dev_bus_name(dev: sup), dev_name(dev: sup));
594	ret = sysfs_create_link(kobj: &con->kobj, target: &link->link_dev.kobj, name: buf);
595	if (ret)
596	goto err_sup_dev;
597
598	goto out;
599
600	err_sup_dev:
601	snprintf(buf, size: len, fmt: "consumer:%s:%s", dev_bus_name(dev: con), dev_name(dev: con));
602	sysfs_remove_link(kobj: &sup->kobj, name: buf);
603	err_con_dev:
604	sysfs_remove_link(kobj: &link->link_dev.kobj, name: "consumer");
605	err_con:
606	sysfs_remove_link(kobj: &link->link_dev.kobj, name: "supplier");
607	out:
608	kfree(objp: buf);
609	return ret;
610	}
611
612	static void devlink_remove_symlinks(struct device *dev)
613	{
614	struct device_link *link = to_devlink(dev);
615	size_t len;
616	struct device *sup = link->supplier;
617	struct device *con = link->consumer;
618	char *buf;
619
620	sysfs_remove_link(kobj: &link->link_dev.kobj, name: "consumer");
621	sysfs_remove_link(kobj: &link->link_dev.kobj, name: "supplier");
622
623	len = max(strlen(dev_bus_name(sup)) + strlen(dev_name(sup)),
624	strlen(dev_bus_name(con)) + strlen(dev_name(con)));
625	len += strlen(":");
626	len += strlen("supplier:") + 1;
627	buf = kzalloc(size: len, GFP_KERNEL);
628	if (!buf) {
629	WARN(1, "Unable to properly free device link symlinks!\n");
630	return;
631	}
632
633	if (device_is_registered(dev: con)) {
634	snprintf(buf, size: len, fmt: "supplier:%s:%s", dev_bus_name(dev: sup), dev_name(dev: sup));
635	sysfs_remove_link(kobj: &con->kobj, name: buf);
636	}
637	snprintf(buf, size: len, fmt: "consumer:%s:%s", dev_bus_name(dev: con), dev_name(dev: con));
638	sysfs_remove_link(kobj: &sup->kobj, name: buf);
639	kfree(objp: buf);
640	}
641
642	static struct class_interface devlink_class_intf = {
643	.class = &devlink_class,
644	.add_dev = devlink_add_symlinks,
645	.remove_dev = devlink_remove_symlinks,
646	};
647
648	static int __init devlink_class_init(void)
649	{
650	int ret;
651
652	ret = class_register(class: &devlink_class);
653	if (ret)
654	return ret;
655
656	ret = class_interface_register(&devlink_class_intf);
657	if (ret)
658	class_unregister(class: &devlink_class);
659
660	return ret;
661	}
662	postcore_initcall(devlink_class_init);
663
664	#define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \
665	DL_FLAG_AUTOREMOVE_SUPPLIER | \
666	DL_FLAG_AUTOPROBE_CONSUMER | \
667	DL_FLAG_SYNC_STATE_ONLY | \
668	DL_FLAG_INFERRED | \
669	DL_FLAG_CYCLE)
670
671	#define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \
672	DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE)
673
674	/**
675	* device_link_add - Create a link between two devices.
676	* @consumer: Consumer end of the link.
677	* @supplier: Supplier end of the link.
678	* @flags: Link flags.
679	*
680	* The caller is responsible for the proper synchronization of the link creation
681	* with runtime PM. First, setting the DL_FLAG_PM_RUNTIME flag will cause the
682	* runtime PM framework to take the link into account. Second, if the
683	* DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will
684	* be forced into the active meta state and reference-counted upon the creation
685	* of the link. If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be
686	* ignored.
687	*
688	* If DL_FLAG_STATELESS is set in @flags, the caller of this function is
689	* expected to release the link returned by it directly with the help of either
690	* device_link_del() or device_link_remove().
691	*
692	* If that flag is not set, however, the caller of this function is handing the
693	* management of the link over to the driver core entirely and its return value
694	* can only be used to check whether or not the link is present. In that case,
695	* the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link
696	* flags can be used to indicate to the driver core when the link can be safely
697	* deleted. Namely, setting one of them in @flags indicates to the driver core
698	* that the link is not going to be used (by the given caller of this function)
699	* after unbinding the consumer or supplier driver, respectively, from its
700	* device, so the link can be deleted at that point. If none of them is set,
701	* the link will be maintained until one of the devices pointed to by it (either
702	* the consumer or the supplier) is unregistered.
703	*
704	* Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and
705	* DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent
706	* managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can
707	* be used to request the driver core to automatically probe for a consumer
708	* driver after successfully binding a driver to the supplier device.
709	*
710	* The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER,
711	* DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at
712	* the same time is invalid and will cause NULL to be returned upfront.
713	* However, if a device link between the given @consumer and @supplier pair
714	* exists already when this function is called for them, the existing link will
715	* be returned regardless of its current type and status (the link's flags may
716	* be modified then). The caller of this function is then expected to treat
717	* the link as though it has just been created, so (in particular) if
718	* DL_FLAG_STATELESS was passed in @flags, the link needs to be released
719	* explicitly when not needed any more (as stated above).
720	*
721	* A side effect of the link creation is re-ordering of dpm_list and the
722	* devices_kset list by moving the consumer device and all devices depending
723	* on it to the ends of these lists (that does not happen to devices that have
724	* not been registered when this function is called).
725	*
726	* The supplier device is required to be registered when this function is called
727	* and NULL will be returned if that is not the case. The consumer device need
728	* not be registered, however.
729	*/
730	struct device_link *device_link_add(struct device *consumer,
731	struct device *supplier, u32 flags)
732	{
733	struct device_link *link;
734
735	if (!consumer || !supplier || consumer == supplier ||
736	flags & ~DL_ADD_VALID_FLAGS ||
737	(flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) ||
738	(flags & DL_FLAG_AUTOPROBE_CONSUMER &&
739	flags & (DL_FLAG_AUTOREMOVE_CONSUMER |
740	DL_FLAG_AUTOREMOVE_SUPPLIER)))
741	return NULL;
742
743	if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) {
744	if (pm_runtime_get_sync(dev: supplier) < 0) {
745	pm_runtime_put_noidle(dev: supplier);
746	return NULL;
747	}
748	}
749
750	if (!(flags & DL_FLAG_STATELESS))
751	flags |= DL_FLAG_MANAGED;
752
753	if (flags & DL_FLAG_SYNC_STATE_ONLY &&
754	!device_link_flag_is_sync_state_only(flags))
755	return NULL;
756
757	device_links_write_lock();
758	device_pm_lock();
759
760	/*
761	* If the supplier has not been fully registered yet or there is a
762	* reverse (non-SYNC_STATE_ONLY) dependency between the consumer and
763	* the supplier already in the graph, return NULL. If the link is a
764	* SYNC_STATE_ONLY link, we don't check for reverse dependencies
765	* because it only affects sync_state() callbacks.
766	*/
767	if (!device_pm_initialized(dev: supplier)
768	|| (!(flags & DL_FLAG_SYNC_STATE_ONLY) &&
769	device_is_dependent(dev: consumer, target: supplier))) {
770	link = NULL;
771	goto out;
772	}
773
774	/*
775	* SYNC_STATE_ONLY links are useless once a consumer device has probed.
776	* So, only create it if the consumer hasn't probed yet.
777	*/
778	if (flags & DL_FLAG_SYNC_STATE_ONLY &&
779	consumer->links.status != DL_DEV_NO_DRIVER &&
780	consumer->links.status != DL_DEV_PROBING) {
781	link = NULL;
782	goto out;
783	}
784
785	/*
786	* DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed
787	* longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both
788	* together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER.
789	*/
790	if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
791	flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
792
793	list_for_each_entry(link, &supplier->links.consumers, s_node) {
794	if (link->consumer != consumer)
795	continue;
796
797	if (link->flags & DL_FLAG_INFERRED &&
798	!(flags & DL_FLAG_INFERRED))
799	link->flags &= ~DL_FLAG_INFERRED;
800
801	if (flags & DL_FLAG_PM_RUNTIME) {
802	if (!(link->flags & DL_FLAG_PM_RUNTIME)) {
803	pm_runtime_new_link(dev: consumer);
804	link->flags |= DL_FLAG_PM_RUNTIME;
805	}
806	if (flags & DL_FLAG_RPM_ACTIVE)
807	refcount_inc(r: &link->rpm_active);
808	}
809
810	if (flags & DL_FLAG_STATELESS) {
811	kref_get(kref: &link->kref);
812	if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&
813	!(link->flags & DL_FLAG_STATELESS)) {
814	link->flags |= DL_FLAG_STATELESS;
815	goto reorder;
816	} else {
817	link->flags |= DL_FLAG_STATELESS;
818	goto out;
819	}
820	}
821
822	/*
823	* If the life time of the link following from the new flags is
824	* longer than indicated by the flags of the existing link,
825	* update the existing link to stay around longer.
826	*/
827	if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) {
828	if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {
829	link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;
830	link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER;
831	}
832	} else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) {
833	link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER |
834	DL_FLAG_AUTOREMOVE_SUPPLIER);
835	}
836	if (!(link->flags & DL_FLAG_MANAGED)) {
837	kref_get(kref: &link->kref);
838	link->flags |= DL_FLAG_MANAGED;
839	device_link_init_status(link, consumer, supplier);
840	}
841	if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&
842	!(flags & DL_FLAG_SYNC_STATE_ONLY)) {
843	link->flags &= ~DL_FLAG_SYNC_STATE_ONLY;
844	goto reorder;
845	}
846
847	goto out;
848	}
849
850	link = kzalloc(size: sizeof(*link), GFP_KERNEL);
851	if (!link)
852	goto out;
853
854	refcount_set(r: &link->rpm_active, n: 1);
855
856	get_device(dev: supplier);
857	link->supplier = supplier;
858	INIT_LIST_HEAD(list: &link->s_node);
859	get_device(dev: consumer);
860	link->consumer = consumer;
861	INIT_LIST_HEAD(list: &link->c_node);
862	link->flags = flags;
863	kref_init(kref: &link->kref);
864
865	link->link_dev.class = &devlink_class;
866	device_set_pm_not_required(dev: &link->link_dev);
867	dev_set_name(dev: &link->link_dev, name: "%s:%s--%s:%s",
868	dev_bus_name(dev: supplier), dev_name(dev: supplier),
869	dev_bus_name(dev: consumer), dev_name(dev: consumer));
870	if (device_register(dev: &link->link_dev)) {
871	put_device(dev: &link->link_dev);
872	link = NULL;
873	goto out;
874	}
875
876	if (flags & DL_FLAG_PM_RUNTIME) {
877	if (flags & DL_FLAG_RPM_ACTIVE)
878	refcount_inc(r: &link->rpm_active);
879
880	pm_runtime_new_link(dev: consumer);
881	}
882
883	/* Determine the initial link state. */
884	if (flags & DL_FLAG_STATELESS)
885	link->status = DL_STATE_NONE;
886	else
887	device_link_init_status(link, consumer, supplier);
888
889	/*
890	* Some callers expect the link creation during consumer driver probe to
891	* resume the supplier even without DL_FLAG_RPM_ACTIVE.
892	*/
893	if (link->status == DL_STATE_CONSUMER_PROBE &&
894	flags & DL_FLAG_PM_RUNTIME)
895	pm_runtime_resume(dev: supplier);
896
897	list_add_tail_rcu(new: &link->s_node, head: &supplier->links.consumers);
898	list_add_tail_rcu(new: &link->c_node, head: &consumer->links.suppliers);
899
900	if (flags & DL_FLAG_SYNC_STATE_ONLY) {
901	dev_dbg(consumer,
902	"Linked as a sync state only consumer to %s\n",
903	dev_name(supplier));
904	goto out;
905	}
906
907	reorder:
908	/*
909	* Move the consumer and all of the devices depending on it to the end
910	* of dpm_list and the devices_kset list.
911	*
912	* It is necessary to hold dpm_list locked throughout all that or else
913	* we may end up suspending with a wrong ordering of it.
914	*/
915	device_reorder_to_tail(dev: consumer, NULL);
916
917	dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier));
918
919	out:
920	device_pm_unlock();
921	device_links_write_unlock();
922
923	if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link)
924	pm_runtime_put(dev: supplier);
925
926	return link;
927	}
928	EXPORT_SYMBOL_GPL(device_link_add);
929
930	static void __device_link_del(struct kref *kref)
931	{
932	struct device_link *link = container_of(kref, struct device_link, kref);
933
934	dev_dbg(link->consumer, "Dropping the link to %s\n",
935	dev_name(link->supplier));
936
937	pm_runtime_drop_link(link);
938
939	device_link_remove_from_lists(link);
940	device_unregister(dev: &link->link_dev);
941	}
942
943	static void device_link_put_kref(struct device_link *link)
944	{
945	if (link->flags & DL_FLAG_STATELESS)
946	kref_put(kref: &link->kref, release: __device_link_del);
947	else if (!device_is_registered(dev: link->consumer))
948	__device_link_del(kref: &link->kref);
949	else
950	WARN(1, "Unable to drop a managed device link reference\n");
951	}
952
953	/**
954	* device_link_del - Delete a stateless link between two devices.
955	* @link: Device link to delete.
956	*
957	* The caller must ensure proper synchronization of this function with runtime
958	* PM. If the link was added multiple times, it needs to be deleted as often.
959	* Care is required for hotplugged devices: Their links are purged on removal
960	* and calling device_link_del() is then no longer allowed.
961	*/
962	void device_link_del(struct device_link *link)
963	{
964	device_links_write_lock();
965	device_link_put_kref(link);
966	device_links_write_unlock();
967	}
968	EXPORT_SYMBOL_GPL(device_link_del);
969
970	/**
971	* device_link_remove - Delete a stateless link between two devices.
972	* @consumer: Consumer end of the link.
973	* @supplier: Supplier end of the link.
974	*
975	* The caller must ensure proper synchronization of this function with runtime
976	* PM.
977	*/
978	void device_link_remove(void *consumer, struct device *supplier)
979	{
980	struct device_link *link;
981
982	if (WARN_ON(consumer == supplier))
983	return;
984
985	device_links_write_lock();
986
987	list_for_each_entry(link, &supplier->links.consumers, s_node) {
988	if (link->consumer == consumer) {
989	device_link_put_kref(link);
990	break;
991	}
992	}
993
994	device_links_write_unlock();
995	}
996	EXPORT_SYMBOL_GPL(device_link_remove);
997
998	static void device_links_missing_supplier(struct device *dev)
999	{
1000	struct device_link *link;
1001
1002	list_for_each_entry(link, &dev->links.suppliers, c_node) {
1003	if (link->status != DL_STATE_CONSUMER_PROBE)
1004	continue;
1005
1006	if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) {
1007	WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
1008	} else {
1009	WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
1010	WRITE_ONCE(link->status, DL_STATE_DORMANT);
1011	}
1012	}
1013	}
1014
1015	static bool dev_is_best_effort(struct device *dev)
1016	{
1017	return (fw_devlink_best_effort && dev->can_match) ||
1018	(dev->fwnode && (dev->fwnode->flags & FWNODE_FLAG_BEST_EFFORT));
1019	}
1020
1021	static struct fwnode_handle *fwnode_links_check_suppliers(
1022	struct fwnode_handle *fwnode)
1023	{
1024	struct fwnode_link *link;
1025
1026	if (!fwnode || fw_devlink_is_permissive())
1027	return NULL;
1028
1029	list_for_each_entry(link, &fwnode->suppliers, c_hook)
1030	if (!(link->flags &
1031	(FWLINK_FLAG_CYCLE | FWLINK_FLAG_IGNORE)))
1032	return link->supplier;
1033
1034	return NULL;
1035	}
1036
1037	/**
1038	* device_links_check_suppliers - Check presence of supplier drivers.
1039	* @dev: Consumer device.
1040	*
1041	* Check links from this device to any suppliers. Walk the list of the device's
1042	* links to suppliers and see if all of them are available. If not, simply
1043	* return -EPROBE_DEFER.
1044	*
1045	* We need to guarantee that the supplier will not go away after the check has
1046	* been positive here. It only can go away in __device_release_driver() and
1047	* that function checks the device's links to consumers. This means we need to
1048	* mark the link as "consumer probe in progress" to make the supplier removal
1049	* wait for us to complete (or bad things may happen).
1050	*
1051	* Links without the DL_FLAG_MANAGED flag set are ignored.
1052	*/
1053	int device_links_check_suppliers(struct device *dev)
1054	{
1055	struct device_link *link;
1056	int ret = 0, fwnode_ret = 0;
1057	struct fwnode_handle *sup_fw;
1058
1059	/*
1060	* Device waiting for supplier to become available is not allowed to
1061	* probe.
1062	*/
1063	mutex_lock(&fwnode_link_lock);
1064	sup_fw = fwnode_links_check_suppliers(fwnode: dev->fwnode);
1065	if (sup_fw) {
1066	if (!dev_is_best_effort(dev)) {
1067	fwnode_ret = -EPROBE_DEFER;
1068	dev_err_probe(dev, err: -EPROBE_DEFER,
1069	fmt: "wait for supplier %pfwf\n", sup_fw);
1070	} else {
1071	fwnode_ret = -EAGAIN;
1072	}
1073	}
1074	mutex_unlock(lock: &fwnode_link_lock);
1075	if (fwnode_ret == -EPROBE_DEFER)
1076	return fwnode_ret;
1077
1078	device_links_write_lock();
1079
1080	list_for_each_entry(link, &dev->links.suppliers, c_node) {
1081	if (!(link->flags & DL_FLAG_MANAGED))
1082	continue;
1083
1084	if (link->status != DL_STATE_AVAILABLE &&
1085	!(link->flags & DL_FLAG_SYNC_STATE_ONLY)) {
1086
1087	if (dev_is_best_effort(dev) &&
1088	link->flags & DL_FLAG_INFERRED &&
1089	!link->supplier->can_match) {
1090	ret = -EAGAIN;
1091	continue;
1092	}
1093
1094	device_links_missing_supplier(dev);
1095	dev_err_probe(dev, err: -EPROBE_DEFER,
1096	fmt: "supplier %s not ready\n",
1097	dev_name(dev: link->supplier));
1098	ret = -EPROBE_DEFER;
1099	break;
1100	}
1101	WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
1102	}
1103	dev->links.status = DL_DEV_PROBING;
1104
1105	device_links_write_unlock();
1106
1107	return ret ? ret : fwnode_ret;
1108	}
1109
1110	/**
1111	* __device_links_queue_sync_state - Queue a device for sync_state() callback
1112	* @dev: Device to call sync_state() on
1113	* @list: List head to queue the @dev on
1114	*
1115	* Queues a device for a sync_state() callback when the device links write lock
1116	* isn't held. This allows the sync_state() execution flow to use device links
1117	* APIs. The caller must ensure this function is called with
1118	* device_links_write_lock() held.
1119	*
1120	* This function does a get_device() to make sure the device is not freed while
1121	* on this list.
1122	*
1123	* So the caller must also ensure that device_links_flush_sync_list() is called
1124	* as soon as the caller releases device_links_write_lock(). This is necessary
1125	* to make sure the sync_state() is called in a timely fashion and the
1126	* put_device() is called on this device.
1127	*/
1128	static void __device_links_queue_sync_state(struct device *dev,
1129	struct list_head *list)
1130	{
1131	struct device_link *link;
1132
1133	if (!dev_has_sync_state(dev))
1134	return;
1135	if (dev->state_synced)
1136	return;
1137
1138	list_for_each_entry(link, &dev->links.consumers, s_node) {
1139	if (!(link->flags & DL_FLAG_MANAGED))
1140	continue;
1141	if (link->status != DL_STATE_ACTIVE)
1142	return;
1143	}
1144
1145	/*
1146	* Set the flag here to avoid adding the same device to a list more
1147	* than once. This can happen if new consumers get added to the device
1148	* and probed before the list is flushed.
1149	*/
1150	dev->state_synced = true;
1151
1152	if (WARN_ON(!list_empty(&dev->links.defer_sync)))
1153	return;
1154
1155	get_device(dev);
1156	list_add_tail(new: &dev->links.defer_sync, head: list);
1157	}
1158
1159	/**
1160	* device_links_flush_sync_list - Call sync_state() on a list of devices
1161	* @list: List of devices to call sync_state() on
1162	* @dont_lock_dev: Device for which lock is already held by the caller
1163	*
1164	* Calls sync_state() on all the devices that have been queued for it. This
1165	* function is used in conjunction with __device_links_queue_sync_state(). The
1166	* @dont_lock_dev parameter is useful when this function is called from a
1167	* context where a device lock is already held.
1168	*/
1169	static void device_links_flush_sync_list(struct list_head *list,
1170	struct device *dont_lock_dev)
1171	{
1172	struct device *dev, *tmp;
1173
1174	list_for_each_entry_safe(dev, tmp, list, links.defer_sync) {
1175	list_del_init(entry: &dev->links.defer_sync);
1176
1177	if (dev != dont_lock_dev)
1178	device_lock(dev);
1179
1180	dev_sync_state(dev);
1181
1182	if (dev != dont_lock_dev)
1183	device_unlock(dev);
1184
1185	put_device(dev);
1186	}
1187	}
1188
1189	void device_links_supplier_sync_state_pause(void)
1190	{
1191	device_links_write_lock();
1192	defer_sync_state_count++;
1193	device_links_write_unlock();
1194	}
1195
1196	void device_links_supplier_sync_state_resume(void)
1197	{
1198	struct device *dev, *tmp;
1199	LIST_HEAD(sync_list);
1200
1201	device_links_write_lock();
1202	if (!defer_sync_state_count) {
1203	WARN(true, "Unmatched sync_state pause/resume!");
1204	goto out;
1205	}
1206	defer_sync_state_count--;
1207	if (defer_sync_state_count)
1208	goto out;
1209
1210	list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) {
1211	/*
1212	* Delete from deferred_sync list before queuing it to
1213	* sync_list because defer_sync is used for both lists.
1214	*/
1215	list_del_init(entry: &dev->links.defer_sync);
1216	__device_links_queue_sync_state(dev, list: &sync_list);
1217	}
1218	out:
1219	device_links_write_unlock();
1220
1221	device_links_flush_sync_list(list: &sync_list, NULL);
1222	}
1223
1224	static int sync_state_resume_initcall(void)
1225	{
1226	device_links_supplier_sync_state_resume();
1227	return 0;
1228	}
1229	late_initcall(sync_state_resume_initcall);
1230
1231	static void __device_links_supplier_defer_sync(struct device *sup)
1232	{
1233	if (list_empty(head: &sup->links.defer_sync) && dev_has_sync_state(dev: sup))
1234	list_add_tail(new: &sup->links.defer_sync, head: &deferred_sync);
1235	}
1236
1237	static void device_link_drop_managed(struct device_link *link)
1238	{
1239	link->flags &= ~DL_FLAG_MANAGED;
1240	WRITE_ONCE(link->status, DL_STATE_NONE);
1241	kref_put(kref: &link->kref, release: __device_link_del);
1242	}
1243
1244	static ssize_t waiting_for_supplier_show(struct device *dev,
1245	struct device_attribute *attr,
1246	char *buf)
1247	{
1248	bool val;
1249
1250	device_lock(dev);
1251	mutex_lock(&fwnode_link_lock);
1252	val = !!fwnode_links_check_suppliers(fwnode: dev->fwnode);
1253	mutex_unlock(lock: &fwnode_link_lock);
1254	device_unlock(dev);
1255	return sysfs_emit(buf, fmt: "%u\n", val);
1256	}
1257	static DEVICE_ATTR_RO(waiting_for_supplier);
1258
1259	/**
1260	* device_links_force_bind - Prepares device to be force bound
1261	* @dev: Consumer device.
1262	*
1263	* device_bind_driver() force binds a device to a driver without calling any
1264	* driver probe functions. So the consumer really isn't going to wait for any
1265	* supplier before it's bound to the driver. We still want the device link
1266	* states to be sensible when this happens.
1267	*
1268	* In preparation for device_bind_driver(), this function goes through each
1269	* supplier device links and checks if the supplier is bound. If it is, then
1270	* the device link status is set to CONSUMER_PROBE. Otherwise, the device link
1271	* is dropped. Links without the DL_FLAG_MANAGED flag set are ignored.
1272	*/
1273	void device_links_force_bind(struct device *dev)
1274	{
1275	struct device_link *link, *ln;
1276
1277	device_links_write_lock();
1278
1279	list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) {
1280	if (!(link->flags & DL_FLAG_MANAGED))
1281	continue;
1282
1283	if (link->status != DL_STATE_AVAILABLE) {
1284	device_link_drop_managed(link);
1285	continue;
1286	}
1287	WRITE_ONCE(link->status, DL_STATE_CONSUMER_PROBE);
1288	}
1289	dev->links.status = DL_DEV_PROBING;
1290
1291	device_links_write_unlock();
1292	}
1293
1294	/**
1295	* device_links_driver_bound - Update device links after probing its driver.
1296	* @dev: Device to update the links for.
1297	*
1298	* The probe has been successful, so update links from this device to any
1299	* consumers by changing their status to "available".
1300	*
1301	* Also change the status of @dev's links to suppliers to "active".
1302	*
1303	* Links without the DL_FLAG_MANAGED flag set are ignored.
1304	*/
1305	void device_links_driver_bound(struct device *dev)
1306	{
1307	struct device_link *link, *ln;
1308	LIST_HEAD(sync_list);
1309
1310	/*
1311	* If a device binds successfully, it's expected to have created all
1312	* the device links it needs to or make new device links as it needs
1313	* them. So, fw_devlink no longer needs to create device links to any
1314	* of the device's suppliers.
1315	*
1316	* Also, if a child firmware node of this bound device is not added as a
1317	* device by now, assume it is never going to be added. Make this bound
1318	* device the fallback supplier to the dangling consumers of the child
1319	* firmware node because this bound device is probably implementing the
1320	* child firmware node functionality and we don't want the dangling
1321	* consumers to defer probe indefinitely waiting for a device for the
1322	* child firmware node.
1323	*/
1324	if (dev->fwnode && dev->fwnode->dev == dev) {
1325	struct fwnode_handle *child;
1326	fwnode_links_purge_suppliers(fwnode: dev->fwnode);
1327	mutex_lock(&fwnode_link_lock);
1328	fwnode_for_each_available_child_node(dev->fwnode, child)
1329	__fw_devlink_pickup_dangling_consumers(fwnode: child,
1330	new_sup: dev->fwnode);
1331	__fw_devlink_link_to_consumers(dev);
1332	mutex_unlock(lock: &fwnode_link_lock);
1333	}
1334	device_remove_file(dev, attr: &dev_attr_waiting_for_supplier);
1335
1336	device_links_write_lock();
1337
1338	list_for_each_entry(link, &dev->links.consumers, s_node) {
1339	if (!(link->flags & DL_FLAG_MANAGED))
1340	continue;
1341
1342	/*
1343	* Links created during consumer probe may be in the "consumer
1344	* probe" state to start with if the supplier is still probing
1345	* when they are created and they may become "active" if the
1346	* consumer probe returns first. Skip them here.
1347	*/
1348	if (link->status == DL_STATE_CONSUMER_PROBE ||
1349	link->status == DL_STATE_ACTIVE)
1350	continue;
1351
1352	WARN_ON(link->status != DL_STATE_DORMANT);
1353	WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
1354
1355	if (link->flags & DL_FLAG_AUTOPROBE_CONSUMER)
1356	driver_deferred_probe_add(dev: link->consumer);
1357	}
1358
1359	if (defer_sync_state_count)
1360	__device_links_supplier_defer_sync(sup: dev);
1361	else
1362	__device_links_queue_sync_state(dev, list: &sync_list);
1363
1364	list_for_each_entry_safe(link, ln, &dev->links.suppliers, c_node) {
1365	struct device *supplier;
1366
1367	if (!(link->flags & DL_FLAG_MANAGED))
1368	continue;
1369
1370	supplier = link->supplier;
1371	if (link->flags & DL_FLAG_SYNC_STATE_ONLY) {
1372	/*
1373	* When DL_FLAG_SYNC_STATE_ONLY is set, it means no
1374	* other DL_MANAGED_LINK_FLAGS have been set. So, it's
1375	* save to drop the managed link completely.
1376	*/
1377	device_link_drop_managed(link);
1378	} else if (dev_is_best_effort(dev) &&
1379	link->flags & DL_FLAG_INFERRED &&
1380	link->status != DL_STATE_CONSUMER_PROBE &&
1381	!link->supplier->can_match) {
1382	/*
1383	* When dev_is_best_effort() is true, we ignore device
1384	* links to suppliers that don't have a driver. If the
1385	* consumer device still managed to probe, there's no
1386	* point in maintaining a device link in a weird state
1387	* (consumer probed before supplier). So delete it.
1388	*/
1389	device_link_drop_managed(link);
1390	} else {
1391	WARN_ON(link->status != DL_STATE_CONSUMER_PROBE);
1392	WRITE_ONCE(link->status, DL_STATE_ACTIVE);
1393	}
1394
1395	/*
1396	* This needs to be done even for the deleted
1397	* DL_FLAG_SYNC_STATE_ONLY device link in case it was the last
1398	* device link that was preventing the supplier from getting a
1399	* sync_state() call.
1400	*/
1401	if (defer_sync_state_count)
1402	__device_links_supplier_defer_sync(sup: supplier);
1403	else
1404	__device_links_queue_sync_state(dev: supplier, list: &sync_list);
1405	}
1406
1407	dev->links.status = DL_DEV_DRIVER_BOUND;
1408
1409	device_links_write_unlock();
1410
1411	device_links_flush_sync_list(list: &sync_list, dont_lock_dev: dev);
1412	}
1413
1414	/**
1415	* __device_links_no_driver - Update links of a device without a driver.
1416	* @dev: Device without a drvier.
1417	*
1418	* Delete all non-persistent links from this device to any suppliers.
1419	*
1420	* Persistent links stay around, but their status is changed to "available",
1421	* unless they already are in the "supplier unbind in progress" state in which
1422	* case they need not be updated.
1423	*
1424	* Links without the DL_FLAG_MANAGED flag set are ignored.
1425	*/
1426	static void __device_links_no_driver(struct device *dev)
1427	{
1428	struct device_link *link, *ln;
1429
1430	list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
1431	if (!(link->flags & DL_FLAG_MANAGED))
1432	continue;
1433
1434	if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {
1435	device_link_drop_managed(link);
1436	continue;
1437	}
1438
1439	if (link->status != DL_STATE_CONSUMER_PROBE &&
1440	link->status != DL_STATE_ACTIVE)
1441	continue;
1442
1443	if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) {
1444	WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
1445	} else {
1446	WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
1447	WRITE_ONCE(link->status, DL_STATE_DORMANT);
1448	}
1449	}
1450
1451	dev->links.status = DL_DEV_NO_DRIVER;
1452	}
1453
1454	/**
1455	* device_links_no_driver - Update links after failing driver probe.
1456	* @dev: Device whose driver has just failed to probe.
1457	*
1458	* Clean up leftover links to consumers for @dev and invoke
1459	* %__device_links_no_driver() to update links to suppliers for it as
1460	* appropriate.
1461	*
1462	* Links without the DL_FLAG_MANAGED flag set are ignored.
1463	*/
1464	void device_links_no_driver(struct device *dev)
1465	{
1466	struct device_link *link;
1467
1468	device_links_write_lock();
1469
1470	list_for_each_entry(link, &dev->links.consumers, s_node) {
1471	if (!(link->flags & DL_FLAG_MANAGED))
1472	continue;
1473
1474	/*
1475	* The probe has failed, so if the status of the link is
1476	* "consumer probe" or "active", it must have been added by
1477	* a probing consumer while this device was still probing.
1478	* Change its state to "dormant", as it represents a valid
1479	* relationship, but it is not functionally meaningful.
1480	*/
1481	if (link->status == DL_STATE_CONSUMER_PROBE ||
1482	link->status == DL_STATE_ACTIVE)
1483	WRITE_ONCE(link->status, DL_STATE_DORMANT);
1484	}
1485
1486	__device_links_no_driver(dev);
1487
1488	device_links_write_unlock();
1489	}
1490
1491	/**
1492	* device_links_driver_cleanup - Update links after driver removal.
1493	* @dev: Device whose driver has just gone away.
1494	*
1495	* Update links to consumers for @dev by changing their status to "dormant" and
1496	* invoke %__device_links_no_driver() to update links to suppliers for it as
1497	* appropriate.
1498	*
1499	* Links without the DL_FLAG_MANAGED flag set are ignored.
1500	*/
1501	void device_links_driver_cleanup(struct device *dev)
1502	{
1503	struct device_link *link, *ln;
1504
1505	device_links_write_lock();
1506
1507	list_for_each_entry_safe(link, ln, &dev->links.consumers, s_node) {
1508	if (!(link->flags & DL_FLAG_MANAGED))
1509	continue;
1510
1511	WARN_ON(link->flags & DL_FLAG_AUTOREMOVE_CONSUMER);
1512	WARN_ON(link->status != DL_STATE_SUPPLIER_UNBIND);
1513
1514	/*
1515	* autoremove the links between this @dev and its consumer
1516	* devices that are not active, i.e. where the link state
1517	* has moved to DL_STATE_SUPPLIER_UNBIND.
1518	*/
1519	if (link->status == DL_STATE_SUPPLIER_UNBIND &&
1520	link->flags & DL_FLAG_AUTOREMOVE_SUPPLIER)
1521	device_link_drop_managed(link);
1522
1523	WRITE_ONCE(link->status, DL_STATE_DORMANT);
1524	}
1525
1526	list_del_init(entry: &dev->links.defer_sync);
1527	__device_links_no_driver(dev);
1528
1529	device_links_write_unlock();
1530	}
1531
1532	/**
1533	* device_links_busy - Check if there are any busy links to consumers.
1534	* @dev: Device to check.
1535	*
1536	* Check each consumer of the device and return 'true' if its link's status
1537	* is one of "consumer probe" or "active" (meaning that the given consumer is
1538	* probing right now or its driver is present). Otherwise, change the link
1539	* state to "supplier unbind" to prevent the consumer from being probed
1540	* successfully going forward.
1541	*
1542	* Return 'false' if there are no probing or active consumers.
1543	*
1544	* Links without the DL_FLAG_MANAGED flag set are ignored.
1545	*/
1546	bool device_links_busy(struct device *dev)
1547	{
1548	struct device_link *link;
1549	bool ret = false;
1550
1551	device_links_write_lock();
1552
1553	list_for_each_entry(link, &dev->links.consumers, s_node) {
1554	if (!(link->flags & DL_FLAG_MANAGED))
1555	continue;
1556
1557	if (link->status == DL_STATE_CONSUMER_PROBE
1558	|| link->status == DL_STATE_ACTIVE) {
1559	ret = true;
1560	break;
1561	}
1562	WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
1563	}
1564
1565	dev->links.status = DL_DEV_UNBINDING;
1566
1567	device_links_write_unlock();
1568	return ret;
1569	}
1570
1571	/**
1572	* device_links_unbind_consumers - Force unbind consumers of the given device.
1573	* @dev: Device to unbind the consumers of.
1574	*
1575	* Walk the list of links to consumers for @dev and if any of them is in the
1576	* "consumer probe" state, wait for all device probes in progress to complete
1577	* and start over.
1578	*
1579	* If that's not the case, change the status of the link to "supplier unbind"
1580	* and check if the link was in the "active" state. If so, force the consumer
1581	* driver to unbind and start over (the consumer will not re-probe as we have
1582	* changed the state of the link already).
1583	*
1584	* Links without the DL_FLAG_MANAGED flag set are ignored.
1585	*/
1586	void device_links_unbind_consumers(struct device *dev)
1587	{
1588	struct device_link *link;
1589
1590	start:
1591	device_links_write_lock();
1592
1593	list_for_each_entry(link, &dev->links.consumers, s_node) {
1594	enum device_link_state status;
1595
1596	if (!(link->flags & DL_FLAG_MANAGED) ||
1597	link->flags & DL_FLAG_SYNC_STATE_ONLY)
1598	continue;
1599
1600	status = link->status;
1601	if (status == DL_STATE_CONSUMER_PROBE) {
1602	device_links_write_unlock();
1603
1604	wait_for_device_probe();
1605	goto start;
1606	}
1607	WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND);
1608	if (status == DL_STATE_ACTIVE) {
1609	struct device *consumer = link->consumer;
1610
1611	get_device(dev: consumer);
1612
1613	device_links_write_unlock();
1614
1615	device_release_driver_internal(dev: consumer, NULL,
1616	parent: consumer->parent);
1617	put_device(dev: consumer);
1618	goto start;
1619	}
1620	}
1621
1622	device_links_write_unlock();
1623	}
1624
1625	/**
1626	* device_links_purge - Delete existing links to other devices.
1627	* @dev: Target device.
1628	*/
1629	static void device_links_purge(struct device *dev)
1630	{
1631	struct device_link *link, *ln;
1632
1633	if (dev->class == &devlink_class)
1634	return;
1635
1636	/*
1637	* Delete all of the remaining links from this device to any other
1638	* devices (either consumers or suppliers).
1639	*/
1640	device_links_write_lock();
1641
1642	list_for_each_entry_safe_reverse(link, ln, &dev->links.suppliers, c_node) {
1643	WARN_ON(link->status == DL_STATE_ACTIVE);
1644	__device_link_del(kref: &link->kref);
1645	}
1646
1647	list_for_each_entry_safe_reverse(link, ln, &dev->links.consumers, s_node) {
1648	WARN_ON(link->status != DL_STATE_DORMANT &&
1649	link->status != DL_STATE_NONE);
1650	__device_link_del(kref: &link->kref);
1651	}
1652
1653	device_links_write_unlock();
1654	}
1655
1656	#define FW_DEVLINK_FLAGS_PERMISSIVE (DL_FLAG_INFERRED | \
1657	DL_FLAG_SYNC_STATE_ONLY)
1658	#define FW_DEVLINK_FLAGS_ON (DL_FLAG_INFERRED | \
1659	DL_FLAG_AUTOPROBE_CONSUMER)
1660	#define FW_DEVLINK_FLAGS_RPM (FW_DEVLINK_FLAGS_ON | \
1661	DL_FLAG_PM_RUNTIME)
1662
1663	static u32 fw_devlink_flags = FW_DEVLINK_FLAGS_RPM;
1664	static int __init fw_devlink_setup(char *arg)
1665	{
1666	if (!arg)
1667	return -EINVAL;
1668
1669	if (strcmp(arg, "off") == 0) {
1670	fw_devlink_flags = 0;
1671	} else if (strcmp(arg, "permissive") == 0) {
1672	fw_devlink_flags = FW_DEVLINK_FLAGS_PERMISSIVE;
1673	} else if (strcmp(arg, "on") == 0) {
1674	fw_devlink_flags = FW_DEVLINK_FLAGS_ON;
1675	} else if (strcmp(arg, "rpm") == 0) {
1676	fw_devlink_flags = FW_DEVLINK_FLAGS_RPM;
1677	}
1678	return 0;
1679	}
1680	early_param("fw_devlink", fw_devlink_setup);
1681
1682	static bool fw_devlink_strict;
1683	static int __init fw_devlink_strict_setup(char *arg)
1684	{
1685	return kstrtobool(s: arg, res: &fw_devlink_strict);
1686	}
1687	early_param("fw_devlink.strict", fw_devlink_strict_setup);
1688
1689	#define FW_DEVLINK_SYNC_STATE_STRICT 0
1690	#define FW_DEVLINK_SYNC_STATE_TIMEOUT 1
1691
1692	#ifndef CONFIG_FW_DEVLINK_SYNC_STATE_TIMEOUT
1693	static int fw_devlink_sync_state;
1694	#else
1695	static int fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_TIMEOUT;
1696	#endif
1697
1698	static int __init fw_devlink_sync_state_setup(char *arg)
1699	{
1700	if (!arg)
1701	return -EINVAL;
1702
1703	if (strcmp(arg, "strict") == 0) {
1704	fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_STRICT;
1705	return 0;
1706	} else if (strcmp(arg, "timeout") == 0) {
1707	fw_devlink_sync_state = FW_DEVLINK_SYNC_STATE_TIMEOUT;
1708	return 0;
1709	}
1710	return -EINVAL;
1711	}
1712	early_param("fw_devlink.sync_state", fw_devlink_sync_state_setup);
1713
1714	static inline u32 fw_devlink_get_flags(u8 fwlink_flags)
1715	{
1716	if (fwlink_flags & FWLINK_FLAG_CYCLE)
1717	return FW_DEVLINK_FLAGS_PERMISSIVE | DL_FLAG_CYCLE;
1718
1719	return fw_devlink_flags;
1720	}
1721
1722	static bool fw_devlink_is_permissive(void)
1723	{
1724	return fw_devlink_flags == FW_DEVLINK_FLAGS_PERMISSIVE;
1725	}
1726
1727	bool fw_devlink_is_strict(void)
1728	{
1729	return fw_devlink_strict && !fw_devlink_is_permissive();
1730	}
1731
1732	static void fw_devlink_parse_fwnode(struct fwnode_handle *fwnode)
1733	{
1734	if (fwnode->flags & FWNODE_FLAG_LINKS_ADDED)
1735	return;
1736
1737	fwnode_call_int_op(fwnode, add_links);
1738	fwnode->flags |= FWNODE_FLAG_LINKS_ADDED;
1739	}
1740
1741	static void fw_devlink_parse_fwtree(struct fwnode_handle *fwnode)
1742	{
1743	struct fwnode_handle *child = NULL;
1744
1745	fw_devlink_parse_fwnode(fwnode);
1746
1747	while ((child = fwnode_get_next_available_child_node(fwnode, child)))
1748	fw_devlink_parse_fwtree(fwnode: child);
1749	}
1750
1751	static void fw_devlink_relax_link(struct device_link *link)
1752	{
1753	if (!(link->flags & DL_FLAG_INFERRED))
1754	return;
1755
1756	if (device_link_flag_is_sync_state_only(flags: link->flags))
1757	return;
1758
1759	pm_runtime_drop_link(link);
1760	link->flags = DL_FLAG_MANAGED | FW_DEVLINK_FLAGS_PERMISSIVE;
1761	dev_dbg(link->consumer, "Relaxing link with %s\n",
1762	dev_name(link->supplier));
1763	}
1764
1765	static int fw_devlink_no_driver(struct device *dev, void *data)
1766	{
1767	struct device_link *link = to_devlink(dev);
1768
1769	if (!link->supplier->can_match)
1770	fw_devlink_relax_link(link);
1771
1772	return 0;
1773	}
1774
1775	void fw_devlink_drivers_done(void)
1776	{
1777	fw_devlink_drv_reg_done = true;
1778	device_links_write_lock();
1779	class_for_each_device(class: &devlink_class, NULL, NULL,
1780	fn: fw_devlink_no_driver);
1781	device_links_write_unlock();
1782	}
1783
1784	static int fw_devlink_dev_sync_state(struct device *dev, void *data)
1785	{
1786	struct device_link *link = to_devlink(dev);
1787	struct device *sup = link->supplier;
1788
1789	if (!(link->flags & DL_FLAG_MANAGED) ||
1790	link->status == DL_STATE_ACTIVE || sup->state_synced ||
1791	!dev_has_sync_state(dev: sup))
1792	return 0;
1793
1794	if (fw_devlink_sync_state == FW_DEVLINK_SYNC_STATE_STRICT) {
1795	dev_warn(sup, "sync_state() pending due to %s\n",
1796	dev_name(link->consumer));
1797	return 0;
1798	}
1799
1800	if (!list_empty(head: &sup->links.defer_sync))
1801	return 0;
1802
1803	dev_warn(sup, "Timed out. Forcing sync_state()\n");
1804	sup->state_synced = true;
1805	get_device(dev: sup);
1806	list_add_tail(new: &sup->links.defer_sync, head: data);
1807
1808	return 0;
1809	}
1810
1811	void fw_devlink_probing_done(void)
1812	{
1813	LIST_HEAD(sync_list);
1814
1815	device_links_write_lock();
1816	class_for_each_device(class: &devlink_class, NULL, data: &sync_list,
1817	fn: fw_devlink_dev_sync_state);
1818	device_links_write_unlock();
1819	device_links_flush_sync_list(list: &sync_list, NULL);
1820	}
1821
1822	/**
1823	* wait_for_init_devices_probe - Try to probe any device needed for init
1824	*
1825	* Some devices might need to be probed and bound successfully before the kernel
1826	* boot sequence can finish and move on to init/userspace. For example, a
1827	* network interface might need to be bound to be able to mount a NFS rootfs.
1828	*
1829	* With fw_devlink=on by default, some of these devices might be blocked from
1830	* probing because they are waiting on a optional supplier that doesn't have a
1831	* driver. While fw_devlink will eventually identify such devices and unblock
1832	* the probing automatically, it might be too late by the time it unblocks the
1833	* probing of devices. For example, the IP4 autoconfig might timeout before
1834	* fw_devlink unblocks probing of the network interface.
1835	*
1836	* This function is available to temporarily try and probe all devices that have
1837	* a driver even if some of their suppliers haven't been added or don't have
1838	* drivers.
1839	*
1840	* The drivers can then decide which of the suppliers are optional vs mandatory
1841	* and probe the device if possible. By the time this function returns, all such
1842	* "best effort" probes are guaranteed to be completed. If a device successfully
1843	* probes in this mode, we delete all fw_devlink discovered dependencies of that
1844	* device where the supplier hasn't yet probed successfully because they have to
1845	* be optional dependencies.
1846	*
1847	* Any devices that didn't successfully probe go back to being treated as if
1848	* this function was never called.
1849	*
1850	* This also means that some devices that aren't needed for init and could have
1851	* waited for their optional supplier to probe (when the supplier's module is
1852	* loaded later on) would end up probing prematurely with limited functionality.
1853	* So call this function only when boot would fail without it.
1854	*/
1855	void __init wait_for_init_devices_probe(void)
1856	{
1857	if (!fw_devlink_flags || fw_devlink_is_permissive())
1858	return;
1859
1860	/*
1861	* Wait for all ongoing probes to finish so that the "best effort" is
1862	* only applied to devices that can't probe otherwise.
1863	*/
1864	wait_for_device_probe();
1865
1866	pr_info("Trying to probe devices needed for running init ...\n");
1867	fw_devlink_best_effort = true;
1868	driver_deferred_probe_trigger();
1869
1870	/*
1871	* Wait for all "best effort" probes to finish before going back to
1872	* normal enforcement.
1873	*/
1874	wait_for_device_probe();
1875	fw_devlink_best_effort = false;
1876	}
1877
1878	static void fw_devlink_unblock_consumers(struct device *dev)
1879	{
1880	struct device_link *link;
1881
1882	if (!fw_devlink_flags || fw_devlink_is_permissive())
1883	return;
1884
1885	device_links_write_lock();
1886	list_for_each_entry(link, &dev->links.consumers, s_node)
1887	fw_devlink_relax_link(link);
1888	device_links_write_unlock();
1889	}
1890
1891	#define get_dev_from_fwnode(fwnode) get_device((fwnode)->dev)
1892
1893	static bool fwnode_init_without_drv(struct fwnode_handle *fwnode)
1894	{
1895	struct device *dev;
1896	bool ret;
1897
1898	if (!(fwnode->flags & FWNODE_FLAG_INITIALIZED))
1899	return false;
1900
1901	dev = get_dev_from_fwnode(fwnode);
1902	ret = !dev || dev->links.status == DL_DEV_NO_DRIVER;
1903	put_device(dev);
1904
1905	return ret;
1906	}
1907
1908	static bool fwnode_ancestor_init_without_drv(struct fwnode_handle *fwnode)
1909	{
1910	struct fwnode_handle *parent;
1911
1912	fwnode_for_each_parent_node(fwnode, parent) {
1913	if (fwnode_init_without_drv(fwnode: parent)) {
1914	fwnode_handle_put(fwnode: parent);
1915	return true;
1916	}
1917	}
1918
1919	return false;
1920	}
1921
1922	/**
1923	* fwnode_is_ancestor_of - Test if @ancestor is ancestor of @child
1924	* @ancestor: Firmware which is tested for being an ancestor
1925	* @child: Firmware which is tested for being the child
1926	*
1927	* A node is considered an ancestor of itself too.
1928	*
1929	* Return: true if @ancestor is an ancestor of @child. Otherwise, returns false.
1930	*/
1931	static bool fwnode_is_ancestor_of(const struct fwnode_handle *ancestor,
1932	const struct fwnode_handle *child)
1933	{
1934	struct fwnode_handle *parent;
1935
1936	if (IS_ERR_OR_NULL(ptr: ancestor))
1937	return false;
1938
1939	if (child == ancestor)
1940	return true;
1941
1942	fwnode_for_each_parent_node(child, parent) {
1943	if (parent == ancestor) {
1944	fwnode_handle_put(fwnode: parent);
1945	return true;
1946	}
1947	}
1948	return false;
1949	}
1950
1951	/**
1952	* fwnode_get_next_parent_dev - Find device of closest ancestor fwnode
1953	* @fwnode: firmware node
1954	*
1955	* Given a firmware node (@fwnode), this function finds its closest ancestor
1956	* firmware node that has a corresponding struct device and returns that struct
1957	* device.
1958	*
1959	* The caller is responsible for calling put_device() on the returned device
1960	* pointer.
1961	*
1962	* Return: a pointer to the device of the @fwnode's closest ancestor.
1963	*/
1964	static struct device *fwnode_get_next_parent_dev(const struct fwnode_handle *fwnode)
1965	{
1966	struct fwnode_handle *parent;
1967	struct device *dev;
1968
1969	fwnode_for_each_parent_node(fwnode, parent) {
1970	dev = get_dev_from_fwnode(parent);
1971	if (dev) {
1972	fwnode_handle_put(fwnode: parent);
1973	return dev;
1974	}
1975	}
1976	return NULL;
1977	}
1978
1979	/**
1980	* __fw_devlink_relax_cycles - Relax and mark dependency cycles.
1981	* @con: Potential consumer device.
1982	* @sup_handle: Potential supplier's fwnode.
1983	*
1984	* Needs to be called with fwnode_lock and device link lock held.
1985	*
1986	* Check if @sup_handle or any of its ancestors or suppliers direct/indirectly
1987	* depend on @con. This function can detect multiple cyles between @sup_handle
1988	* and @con. When such dependency cycles are found, convert all device links
1989	* created solely by fw_devlink into SYNC_STATE_ONLY device links. Also, mark
1990	* all fwnode links in the cycle with FWLINK_FLAG_CYCLE so that when they are
1991	* converted into a device link in the future, they are created as
1992	* SYNC_STATE_ONLY device links. This is the equivalent of doing
1993	* fw_devlink=permissive just between the devices in the cycle. We need to do
1994	* this because, at this point, fw_devlink can't tell which of these
1995	* dependencies is not a real dependency.
1996	*
1997	* Return true if one or more cycles were found. Otherwise, return false.
1998	*/
1999	static bool __fw_devlink_relax_cycles(struct device *con,
2000	struct fwnode_handle *sup_handle)
2001	{
2002	struct device *sup_dev = NULL, *par_dev = NULL;
2003	struct fwnode_link *link;
2004	struct device_link *dev_link;
2005	bool ret = false;
2006
2007	if (!sup_handle)
2008	return false;
2009
2010	/*
2011	* We aren't trying to find all cycles. Just a cycle between con and
2012	* sup_handle.
2013	*/
2014	if (sup_handle->flags & FWNODE_FLAG_VISITED)
2015	return false;
2016
2017	sup_handle->flags |= FWNODE_FLAG_VISITED;
2018
2019	sup_dev = get_dev_from_fwnode(sup_handle);
2020
2021	/* Termination condition. */
2022	if (sup_dev == con) {
2023	pr_debug("----- cycle: start -----\n");
2024	ret = true;
2025	goto out;
2026	}
2027
2028	/*
2029	* If sup_dev is bound to a driver and @con hasn't started binding to a
2030	* driver, sup_dev can't be a consumer of @con. So, no need to check
2031	* further.
2032	*/
2033	if (sup_dev && sup_dev->links.status == DL_DEV_DRIVER_BOUND &&
2034	con->links.status == DL_DEV_NO_DRIVER) {
2035	ret = false;
2036	goto out;
2037	}
2038
2039	list_for_each_entry(link, &sup_handle->suppliers, c_hook) {
2040	if (link->flags & FWLINK_FLAG_IGNORE)
2041	continue;
2042
2043	if (__fw_devlink_relax_cycles(con, sup_handle: link->supplier)) {
2044	__fwnode_link_cycle(link);
2045	ret = true;
2046	}
2047	}
2048
2049	/*
2050	* Give priority to device parent over fwnode parent to account for any
2051	* quirks in how fwnodes are converted to devices.
2052	*/
2053	if (sup_dev)
2054	par_dev = get_device(dev: sup_dev->parent);
2055	else
2056	par_dev = fwnode_get_next_parent_dev(fwnode: sup_handle);
2057
2058	if (par_dev && __fw_devlink_relax_cycles(con, sup_handle: par_dev->fwnode)) {
2059	pr_debug("%pfwf: cycle: child of %pfwf\n", sup_handle,
2060	par_dev->fwnode);
2061	ret = true;
2062	}
2063
2064	if (!sup_dev)
2065	goto out;
2066
2067	list_for_each_entry(dev_link, &sup_dev->links.suppliers, c_node) {
2068	/*
2069	* Ignore a SYNC_STATE_ONLY flag only if it wasn't marked as
2070	* such due to a cycle.
2071	*/
2072	if (device_link_flag_is_sync_state_only(flags: dev_link->flags) &&
2073	!(dev_link->flags & DL_FLAG_CYCLE))
2074	continue;
2075
2076	if (__fw_devlink_relax_cycles(con,
2077	sup_handle: dev_link->supplier->fwnode)) {
2078	pr_debug("%pfwf: cycle: depends on %pfwf\n", sup_handle,
2079	dev_link->supplier->fwnode);
2080	fw_devlink_relax_link(link: dev_link);
2081	dev_link->flags |= DL_FLAG_CYCLE;
2082	ret = true;
2083	}
2084	}
2085
2086	out:
2087	sup_handle->flags &= ~FWNODE_FLAG_VISITED;
2088	put_device(dev: sup_dev);
2089	put_device(dev: par_dev);
2090	return ret;
2091	}
2092
2093	/**
2094	* fw_devlink_create_devlink - Create a device link from a consumer to fwnode
2095	* @con: consumer device for the device link
2096	* @sup_handle: fwnode handle of supplier
2097	* @link: fwnode link that's being converted to a device link
2098	*
2099	* This function will try to create a device link between the consumer device
2100	* @con and the supplier device represented by @sup_handle.
2101	*
2102	* The supplier has to be provided as a fwnode because incorrect cycles in
2103	* fwnode links can sometimes cause the supplier device to never be created.
2104	* This function detects such cases and returns an error if it cannot create a
2105	* device link from the consumer to a missing supplier.
2106	*
2107	* Returns,
2108	* 0 on successfully creating a device link
2109	* -EINVAL if the device link cannot be created as expected
2110	* -EAGAIN if the device link cannot be created right now, but it may be
2111	* possible to do that in the future
2112	*/
2113	static int fw_devlink_create_devlink(struct device *con,
2114	struct fwnode_handle *sup_handle,
2115	struct fwnode_link *link)
2116	{
2117	struct device *sup_dev;
2118	int ret = 0;
2119	u32 flags;
2120
2121	if (link->flags & FWLINK_FLAG_IGNORE)
2122	return 0;
2123
2124	if (con->fwnode == link->consumer)
2125	flags = fw_devlink_get_flags(fwlink_flags: link->flags);
2126	else
2127	flags = FW_DEVLINK_FLAGS_PERMISSIVE;
2128
2129	/*
2130	* In some cases, a device P might also be a supplier to its child node
2131	* C. However, this would defer the probe of C until the probe of P
2132	* completes successfully. This is perfectly fine in the device driver
2133	* model. device_add() doesn't guarantee probe completion of the device
2134	* by the time it returns.
2135	*
2136	* However, there are a few drivers that assume C will finish probing
2137	* as soon as it's added and before P finishes probing. So, we provide
2138	* a flag to let fw_devlink know not to delay the probe of C until the
2139	* probe of P completes successfully.
2140	*
2141	* When such a flag is set, we can't create device links where P is the
2142	* supplier of C as that would delay the probe of C.
2143	*/
2144	if (sup_handle->flags & FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD &&
2145	fwnode_is_ancestor_of(ancestor: sup_handle, child: con->fwnode))
2146	return -EINVAL;
2147
2148	/*
2149	* SYNC_STATE_ONLY device links don't block probing and supports cycles.
2150	* So, one might expect that cycle detection isn't necessary for them.
2151	* However, if the device link was marked as SYNC_STATE_ONLY because
2152	* it's part of a cycle, then we still need to do cycle detection. This
2153	* is because the consumer and supplier might be part of multiple cycles
2154	* and we need to detect all those cycles.
2155	*/
2156	if (!device_link_flag_is_sync_state_only(flags) ||
2157	flags & DL_FLAG_CYCLE) {
2158	device_links_write_lock();
2159	if (__fw_devlink_relax_cycles(con, sup_handle)) {
2160	__fwnode_link_cycle(link);
2161	flags = fw_devlink_get_flags(fwlink_flags: link->flags);
2162	pr_debug("----- cycle: end -----\n");
2163	dev_info(con, "Fixed dependency cycle(s) with %pfwf\n",
2164	sup_handle);
2165	}
2166	device_links_write_unlock();
2167	}
2168
2169	if (sup_handle->flags & FWNODE_FLAG_NOT_DEVICE)
2170	sup_dev = fwnode_get_next_parent_dev(fwnode: sup_handle);
2171	else
2172	sup_dev = get_dev_from_fwnode(sup_handle);
2173
2174	if (sup_dev) {
2175	/*
2176	* If it's one of those drivers that don't actually bind to
2177	* their device using driver core, then don't wait on this
2178	* supplier device indefinitely.
2179	*/
2180	if (sup_dev->links.status == DL_DEV_NO_DRIVER &&
2181	sup_handle->flags & FWNODE_FLAG_INITIALIZED) {
2182	dev_dbg(con,
2183	"Not linking %pfwf - dev might never probe\n",
2184	sup_handle);
2185	ret = -EINVAL;
2186	goto out;
2187	}
2188
2189	if (con != sup_dev && !device_link_add(con, sup_dev, flags)) {
2190	dev_err(con, "Failed to create device link (0x%x) with %s\n",
2191	flags, dev_name(sup_dev));
2192	ret = -EINVAL;
2193	}
2194
2195	goto out;
2196	}
2197
2198	/*
2199	* Supplier or supplier's ancestor already initialized without a struct
2200	* device or being probed by a driver.
2201	*/
2202	if (fwnode_init_without_drv(fwnode: sup_handle) ||
2203	fwnode_ancestor_init_without_drv(fwnode: sup_handle)) {
2204	dev_dbg(con, "Not linking %pfwf - might never become dev\n",
2205	sup_handle);
2206	return -EINVAL;
2207	}
2208
2209	ret = -EAGAIN;
2210	out:
2211	put_device(dev: sup_dev);
2212	return ret;
2213	}
2214
2215	/**
2216	* __fw_devlink_link_to_consumers - Create device links to consumers of a device
2217	* @dev: Device that needs to be linked to its consumers
2218	*
2219	* This function looks at all the consumer fwnodes of @dev and creates device
2220	* links between the consumer device and @dev (supplier).
2221	*
2222	* If the consumer device has not been added yet, then this function creates a
2223	* SYNC_STATE_ONLY link between @dev (supplier) and the closest ancestor device
2224	* of the consumer fwnode. This is necessary to make sure @dev doesn't get a
2225	* sync_state() callback before the real consumer device gets to be added and
2226	* then probed.
2227	*
2228	* Once device links are created from the real consumer to @dev (supplier), the
2229	* fwnode links are deleted.
2230	*/
2231	static void __fw_devlink_link_to_consumers(struct device *dev)
2232	{
2233	struct fwnode_handle *fwnode = dev->fwnode;
2234	struct fwnode_link *link, *tmp;
2235
2236	list_for_each_entry_safe(link, tmp, &fwnode->consumers, s_hook) {
2237	struct device *con_dev;
2238	bool own_link = true;
2239	int ret;
2240
2241	con_dev = get_dev_from_fwnode(link->consumer);
2242	/*
2243	* If consumer device is not available yet, make a "proxy"
2244	* SYNC_STATE_ONLY link from the consumer's parent device to
2245	* the supplier device. This is necessary to make sure the
2246	* supplier doesn't get a sync_state() callback before the real
2247	* consumer can create a device link to the supplier.
2248	*
2249	* This proxy link step is needed to handle the case where the
2250	* consumer's parent device is added before the supplier.
2251	*/
2252	if (!con_dev) {
2253	con_dev = fwnode_get_next_parent_dev(fwnode: link->consumer);
2254	/*
2255	* However, if the consumer's parent device is also the
2256	* parent of the supplier, don't create a
2257	* consumer-supplier link from the parent to its child
2258	* device. Such a dependency is impossible.
2259	*/
2260	if (con_dev &&
2261	fwnode_is_ancestor_of(ancestor: con_dev->fwnode, child: fwnode)) {
2262	put_device(dev: con_dev);
2263	con_dev = NULL;
2264	} else {
2265	own_link = false;
2266	}
2267	}
2268
2269	if (!con_dev)
2270	continue;
2271
2272	ret = fw_devlink_create_devlink(con: con_dev, sup_handle: fwnode, link);
2273	put_device(dev: con_dev);
2274	if (!own_link || ret == -EAGAIN)
2275	continue;
2276
2277	__fwnode_link_del(link);
2278	}
2279	}
2280
2281	/**
2282	* __fw_devlink_link_to_suppliers - Create device links to suppliers of a device
2283	* @dev: The consumer device that needs to be linked to its suppliers
2284	* @fwnode: Root of the fwnode tree that is used to create device links
2285	*
2286	* This function looks at all the supplier fwnodes of fwnode tree rooted at
2287	* @fwnode and creates device links between @dev (consumer) and all the
2288	* supplier devices of the entire fwnode tree at @fwnode.
2289	*
2290	* The function creates normal (non-SYNC_STATE_ONLY) device links between @dev
2291	* and the real suppliers of @dev. Once these device links are created, the
2292	* fwnode links are deleted.
2293	*
2294	* In addition, it also looks at all the suppliers of the entire fwnode tree
2295	* because some of the child devices of @dev that have not been added yet
2296	* (because @dev hasn't probed) might already have their suppliers added to
2297	* driver core. So, this function creates SYNC_STATE_ONLY device links between
2298	* @dev (consumer) and these suppliers to make sure they don't execute their
2299	* sync_state() callbacks before these child devices have a chance to create
2300	* their device links. The fwnode links that correspond to the child devices
2301	* aren't delete because they are needed later to create the device links
2302	* between the real consumer and supplier devices.
2303	*/
2304	static void __fw_devlink_link_to_suppliers(struct device *dev,
2305	struct fwnode_handle *fwnode)
2306	{
2307	bool own_link = (dev->fwnode == fwnode);
2308	struct fwnode_link *link, *tmp;
2309	struct fwnode_handle *child = NULL;
2310
2311	list_for_each_entry_safe(link, tmp, &fwnode->suppliers, c_hook) {
2312	int ret;
2313	struct fwnode_handle *sup = link->supplier;
2314
2315	ret = fw_devlink_create_devlink(con: dev, sup_handle: sup, link);
2316	if (!own_link || ret == -EAGAIN)
2317	continue;
2318
2319	__fwnode_link_del(link);
2320	}
2321
2322	/*
2323	* Make "proxy" SYNC_STATE_ONLY device links to represent the needs of
2324	* all the descendants. This proxy link step is needed to handle the
2325	* case where the supplier is added before the consumer's parent device
2326	* (@dev).
2327	*/
2328	while ((child = fwnode_get_next_available_child_node(fwnode, child)))
2329	__fw_devlink_link_to_suppliers(dev, fwnode: child);
2330	}
2331
2332	static void fw_devlink_link_device(struct device *dev)
2333	{
2334	struct fwnode_handle *fwnode = dev->fwnode;
2335
2336	if (!fw_devlink_flags)
2337	return;
2338
2339	fw_devlink_parse_fwtree(fwnode);
2340
2341	mutex_lock(&fwnode_link_lock);
2342	__fw_devlink_link_to_consumers(dev);
2343	__fw_devlink_link_to_suppliers(dev, fwnode);
2344	mutex_unlock(lock: &fwnode_link_lock);
2345	}
2346
2347	/* Device links support end. */
2348
2349	int (*platform_notify)(struct device *dev) = NULL;
2350	int (*platform_notify_remove)(struct device *dev) = NULL;
2351	static struct kobject *dev_kobj;
2352
2353	/* /sys/dev/char */
2354	static struct kobject *sysfs_dev_char_kobj;
2355
2356	/* /sys/dev/block */
2357	static struct kobject *sysfs_dev_block_kobj;
2358
2359	static DEFINE_MUTEX(device_hotplug_lock);
2360
2361	void lock_device_hotplug(void)
2362	{
2363	mutex_lock(&device_hotplug_lock);
2364	}
2365
2366	void unlock_device_hotplug(void)
2367	{
2368	mutex_unlock(lock: &device_hotplug_lock);
2369	}
2370
2371	int lock_device_hotplug_sysfs(void)
2372	{
2373	if (mutex_trylock(lock: &device_hotplug_lock))
2374	return 0;
2375
2376	/* Avoid busy looping (5 ms of sleep should do). */
2377	msleep(msecs: 5);
2378	return restart_syscall();
2379	}
2380
2381	#ifdef CONFIG_BLOCK
2382	static inline int device_is_not_partition(struct device *dev)
2383	{
2384	return !(dev->type == &part_type);
2385	}
2386	#else
2387	static inline int device_is_not_partition(struct device *dev)
2388	{
2389	return 1;
2390	}
2391	#endif
2392
2393	static void device_platform_notify(struct device *dev)
2394	{
2395	acpi_device_notify(dev);
2396
2397	software_node_notify(dev);
2398
2399	if (platform_notify)
2400	platform_notify(dev);
2401	}
2402
2403	static void device_platform_notify_remove(struct device *dev)
2404	{
2405	if (platform_notify_remove)
2406	platform_notify_remove(dev);
2407
2408	software_node_notify_remove(dev);
2409
2410	acpi_device_notify_remove(dev);
2411	}
2412
2413	/**
2414	* dev_driver_string - Return a device's driver name, if at all possible
2415	* @dev: struct device to get the name of
2416	*
2417	* Will return the device's driver's name if it is bound to a device. If
2418	* the device is not bound to a driver, it will return the name of the bus
2419	* it is attached to. If it is not attached to a bus either, an empty
2420	* string will be returned.
2421	*/
2422	const char *dev_driver_string(const struct device *dev)
2423	{
2424	struct device_driver *drv;
2425
2426	/* dev->driver can change to NULL underneath us because of unbinding,
2427	* so be careful about accessing it. dev->bus and dev->class should
2428	* never change once they are set, so they don't need special care.
2429	*/
2430	drv = READ_ONCE(dev->driver);
2431	return drv ? drv->name : dev_bus_name(dev);
2432	}
2433	EXPORT_SYMBOL(dev_driver_string);
2434
2435	#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
2436
2437	static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
2438	char *buf)
2439	{
2440	struct device_attribute *dev_attr = to_dev_attr(attr);
2441	struct device *dev = kobj_to_dev(kobj);
2442	ssize_t ret = -EIO;
2443
2444	if (dev_attr->show)
2445	ret = dev_attr->show(dev, dev_attr, buf);
2446	if (ret >= (ssize_t)PAGE_SIZE) {
2447	printk("dev_attr_show: %pS returned bad count\n",
2448	dev_attr->show);
2449	}
2450	return ret;
2451	}
2452
2453	static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
2454	const char *buf, size_t count)
2455	{
2456	struct device_attribute *dev_attr = to_dev_attr(attr);
2457	struct device *dev = kobj_to_dev(kobj);
2458	ssize_t ret = -EIO;
2459
2460	if (dev_attr->store)
2461	ret = dev_attr->store(dev, dev_attr, buf, count);
2462	return ret;
2463	}
2464
2465	static const struct sysfs_ops dev_sysfs_ops = {
2466	.show = dev_attr_show,
2467	.store = dev_attr_store,
2468	};
2469
2470	#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
2471
2472	ssize_t device_store_ulong(struct device *dev,
2473	struct device_attribute *attr,
2474	const char *buf, size_t size)
2475	{
2476	struct dev_ext_attribute *ea = to_ext_attr(attr);
2477	int ret;
2478	unsigned long new;
2479
2480	ret = kstrtoul(s: buf, base: 0, res: &new);
2481	if (ret)
2482	return ret;
2483	*(unsigned long *)(ea->var) = new;
2484	/* Always return full write size even if we didn't consume all */
2485	return size;
2486	}
2487	EXPORT_SYMBOL_GPL(device_store_ulong);
2488
2489	ssize_t device_show_ulong(struct device *dev,
2490	struct device_attribute *attr,
2491	char *buf)
2492	{
2493	struct dev_ext_attribute *ea = to_ext_attr(attr);
2494	return sysfs_emit(buf, fmt: "%lx\n", *(unsigned long *)(ea->var));
2495	}
2496	EXPORT_SYMBOL_GPL(device_show_ulong);
2497
2498	ssize_t device_store_int(struct device *dev,
2499	struct device_attribute *attr,
2500	const char *buf, size_t size)
2501	{
2502	struct dev_ext_attribute *ea = to_ext_attr(attr);
2503	int ret;
2504	long new;
2505
2506	ret = kstrtol(s: buf, base: 0, res: &new);
2507	if (ret)
2508	return ret;
2509
2510	if (new > INT_MAX || new < INT_MIN)
2511	return -EINVAL;
2512	*(int *)(ea->var) = new;
2513	/* Always return full write size even if we didn't consume all */
2514	return size;
2515	}
2516	EXPORT_SYMBOL_GPL(device_store_int);
2517
2518	ssize_t device_show_int(struct device *dev,
2519	struct device_attribute *attr,
2520	char *buf)
2521	{
2522	struct dev_ext_attribute *ea = to_ext_attr(attr);
2523
2524	return sysfs_emit(buf, fmt: "%d\n", *(int *)(ea->var));
2525	}
2526	EXPORT_SYMBOL_GPL(device_show_int);
2527
2528	ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
2529	const char *buf, size_t size)
2530	{
2531	struct dev_ext_attribute *ea = to_ext_attr(attr);
2532
2533	if (kstrtobool(s: buf, res: ea->var) < 0)
2534	return -EINVAL;
2535
2536	return size;
2537	}
2538	EXPORT_SYMBOL_GPL(device_store_bool);
2539
2540	ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
2541	char *buf)
2542	{
2543	struct dev_ext_attribute *ea = to_ext_attr(attr);
2544
2545	return sysfs_emit(buf, fmt: "%d\n", *(bool *)(ea->var));
2546	}
2547	EXPORT_SYMBOL_GPL(device_show_bool);
2548
2549	/**
2550	* device_release - free device structure.
2551	* @kobj: device's kobject.
2552	*
2553	* This is called once the reference count for the object
2554	* reaches 0. We forward the call to the device's release
2555	* method, which should handle actually freeing the structure.
2556	*/
2557	static void device_release(struct kobject *kobj)
2558	{
2559	struct device *dev = kobj_to_dev(kobj);
2560	struct device_private *p = dev->p;
2561
2562	/*
2563	* Some platform devices are driven without driver attached
2564	* and managed resources may have been acquired. Make sure
2565	* all resources are released.
2566	*
2567	* Drivers still can add resources into device after device
2568	* is deleted but alive, so release devres here to avoid
2569	* possible memory leak.
2570	*/
2571	devres_release_all(dev);
2572
2573	kfree(objp: dev->dma_range_map);
2574
2575	if (dev->release)
2576	dev->release(dev);
2577	else if (dev->type && dev->type->release)
2578	dev->type->release(dev);
2579	else if (dev->class && dev->class->dev_release)
2580	dev->class->dev_release(dev);
2581	else
2582	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",
2583	dev_name(dev));
2584	kfree(objp: p);
2585	}
2586
2587	static const void *device_namespace(const struct kobject *kobj)
2588	{
2589	const struct device *dev = kobj_to_dev(kobj);
2590	const void *ns = NULL;
2591
2592	if (dev->class && dev->class->ns_type)
2593	ns = dev->class->namespace(dev);
2594
2595	return ns;
2596	}
2597
2598	static void device_get_ownership(const struct kobject *kobj, kuid_t *uid, kgid_t *gid)
2599	{
2600	const struct device *dev = kobj_to_dev(kobj);
2601
2602	if (dev->class && dev->class->get_ownership)
2603	dev->class->get_ownership(dev, uid, gid);
2604	}
2605
2606	static const struct kobj_type device_ktype = {
2607	.release = device_release,
2608	.sysfs_ops = &dev_sysfs_ops,
2609	.namespace = device_namespace,
2610	.get_ownership = device_get_ownership,
2611	};
2612
2613
2614	static int dev_uevent_filter(const struct kobject *kobj)
2615	{
2616	const struct kobj_type *ktype = get_ktype(kobj);
2617
2618	if (ktype == &device_ktype) {
2619	const struct device *dev = kobj_to_dev(kobj);
2620	if (dev->bus)
2621	return 1;
2622	if (dev->class)
2623	return 1;
2624	}
2625	return 0;
2626	}
2627
2628	static const char *dev_uevent_name(const struct kobject *kobj)
2629	{
2630	const struct device *dev = kobj_to_dev(kobj);
2631
2632	if (dev->bus)
2633	return dev->bus->name;
2634	if (dev->class)
2635	return dev->class->name;
2636	return NULL;
2637	}
2638
2639	static int dev_uevent(const struct kobject *kobj, struct kobj_uevent_env *env)
2640	{
2641	const struct device *dev = kobj_to_dev(kobj);
2642	int retval = 0;
2643
2644	/* add device node properties if present */
2645	if (MAJOR(dev->devt)) {
2646	const char *tmp;
2647	const char *name;
2648	umode_t mode = 0;
2649	kuid_t uid = GLOBAL_ROOT_UID;
2650	kgid_t gid = GLOBAL_ROOT_GID;
2651
2652	add_uevent_var(env, format: "MAJOR=%u", MAJOR(dev->devt));
2653	add_uevent_var(env, format: "MINOR=%u", MINOR(dev->devt));
2654	name = device_get_devnode(dev, mode: &mode, uid: &uid, gid: &gid, tmp: &tmp);
2655	if (name) {
2656	add_uevent_var(env, format: "DEVNAME=%s", name);
2657	if (mode)
2658	add_uevent_var(env, format: "DEVMODE=%#o", mode & 0777);
2659	if (!uid_eq(left: uid, GLOBAL_ROOT_UID))
2660	add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
2661	if (!gid_eq(gid, GLOBAL_ROOT_GID))
2662	add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
2663	kfree(tmp);
2664	}
2665	}
2666
2667	if (dev->type && dev->type->name)
2668	add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
2669
2670	if (dev->driver)
2671	add_uevent_var(env, "DRIVER=%s", dev->driver->name);
2672
2673	/* Add common DT information about the device */
2674	of_device_uevent(dev, env);
2675
2676	/* have the bus specific function add its stuff */
2677	if (dev->bus && dev->bus->uevent) {
2678	retval = dev->bus->uevent(dev, env);
2679	if (retval)
2680	pr_debug("device: '%s': %s: bus uevent() returned %d\n",
2681	dev_name(dev), __func__, retval);
2682	}
2683
2684	/* have the class specific function add its stuff */
2685	if (dev->class && dev->class->dev_uevent) {
2686	retval = dev->class->dev_uevent(dev, env);
2687	if (retval)
2688	pr_debug("device: '%s': %s: class uevent() "
2689	"returned %d\n", dev_name(dev),
2690	__func__, retval);
2691	}
2692
2693	/* have the device type specific function add its stuff */
2694	if (dev->type && dev->type->uevent) {
2695	retval = dev->type->uevent(dev, env);
2696	if (retval)
2697	pr_debug("device: '%s': %s: dev_type uevent() "
2698	"returned %d\n", dev_name(dev),
2699	__func__, retval);
2700	}
2701
2702	return retval;
2703	}
2704
2705	static const struct kset_uevent_ops device_uevent_ops = {
2706	.filter = dev_uevent_filter,
2707	.name = dev_uevent_name,
2708	.uevent = dev_uevent,
2709	};
2710
2711	static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
2712	char *buf)
2713	{
2714	struct kobject *top_kobj;
2715	struct kset *kset;
2716	struct kobj_uevent_env *env = NULL;
2717	int i;
2718	int len = 0;
2719	int retval;
2720
2721	/* search the kset, the device belongs to */
2722	top_kobj = &dev->kobj;
2723	while (!top_kobj->kset && top_kobj->parent)
2724	top_kobj = top_kobj->parent;
2725	if (!top_kobj->kset)
2726	goto out;
2727
2728	kset = top_kobj->kset;
2729	if (!kset->uevent_ops || !kset->uevent_ops->uevent)
2730	goto out;
2731
2732	/* respect filter */
2733	if (kset->uevent_ops && kset->uevent_ops->filter)
2734	if (!kset->uevent_ops->filter(&dev->kobj))
2735	goto out;
2736
2737	env = kzalloc(size: sizeof(struct kobj_uevent_env), GFP_KERNEL);
2738	if (!env)
2739	return -ENOMEM;
2740
2741	/* let the kset specific function add its keys */
2742	retval = kset->uevent_ops->uevent(&dev->kobj, env);
2743	if (retval)
2744	goto out;
2745
2746	/* copy keys to file */
2747	for (i = 0; i < env->envp_idx; i++)
2748	len += sysfs_emit_at(buf, at: len, fmt: "%s\n", env->envp[i]);
2749	out:
2750	kfree(objp: env);
2751	return len;
2752	}
2753
2754	static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
2755	const char *buf, size_t count)
2756	{
2757	int rc;
2758
2759	rc = kobject_synth_uevent(kobj: &dev->kobj, buf, count);
2760
2761	if (rc) {
2762	dev_err(dev, "uevent: failed to send synthetic uevent: %d\n", rc);
2763	return rc;
2764	}
2765
2766	return count;
2767	}
2768	static DEVICE_ATTR_RW(uevent);
2769
2770	static ssize_t online_show(struct device *dev, struct device_attribute *attr,
2771	char *buf)
2772	{
2773	bool val;
2774
2775	device_lock(dev);
2776	val = !dev->offline;
2777	device_unlock(dev);
2778	return sysfs_emit(buf, fmt: "%u\n", val);
2779	}
2780
2781	static ssize_t online_store(struct device *dev, struct device_attribute *attr,
2782	const char *buf, size_t count)
2783	{
2784	bool val;
2785	int ret;
2786
2787	ret = kstrtobool(s: buf, res: &val);
2788	if (ret < 0)
2789	return ret;
2790
2791	ret = lock_device_hotplug_sysfs();
2792	if (ret)
2793	return ret;
2794
2795	ret = val ? device_online(dev) : device_offline(dev);
2796	unlock_device_hotplug();
2797	return ret < 0 ? ret : count;
2798	}
2799	static DEVICE_ATTR_RW(online);
2800
2801	static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
2802	char *buf)
2803	{
2804	const char *loc;
2805
2806	switch (dev->removable) {
2807	case DEVICE_REMOVABLE:
2808	loc = "removable";
2809	break;
2810	case DEVICE_FIXED:
2811	loc = "fixed";
2812	break;
2813	default:
2814	loc = "unknown";
2815	}
2816	return sysfs_emit(buf, fmt: "%s\n", loc);
2817	}
2818	static DEVICE_ATTR_RO(removable);
2819
2820	int device_add_groups(struct device *dev, const struct attribute_group **groups)
2821	{
2822	return sysfs_create_groups(kobj: &dev->kobj, groups);
2823	}
2824	EXPORT_SYMBOL_GPL(device_add_groups);
2825
2826	void device_remove_groups(struct device *dev,
2827	const struct attribute_group **groups)
2828	{
2829	sysfs_remove_groups(kobj: &dev->kobj, groups);
2830	}
2831	EXPORT_SYMBOL_GPL(device_remove_groups);
2832
2833	union device_attr_group_devres {
2834	const struct attribute_group *group;
2835	const struct attribute_group **groups;
2836	};
2837
2838	static void devm_attr_group_remove(struct device *dev, void *res)
2839	{
2840	union device_attr_group_devres *devres = res;
2841	const struct attribute_group *group = devres->group;
2842
2843	dev_dbg(dev, "%s: removing group %p\n", __func__, group);
2844	sysfs_remove_group(kobj: &dev->kobj, grp: group);
2845	}
2846
2847	static void devm_attr_groups_remove(struct device *dev, void *res)
2848	{
2849	union device_attr_group_devres *devres = res;
2850	const struct attribute_group **groups = devres->groups;
2851
2852	dev_dbg(dev, "%s: removing groups %p\n", __func__, groups);
2853	sysfs_remove_groups(kobj: &dev->kobj, groups);
2854	}
2855
2856	/**
2857	* devm_device_add_group - given a device, create a managed attribute group
2858	* @dev: The device to create the group for
2859	* @grp: The attribute group to create
2860	*
2861	* This function creates a group for the first time. It will explicitly
2862	* warn and error if any of the attribute files being created already exist.
2863	*
2864	* Returns 0 on success or error code on failure.
2865	*/
2866	int devm_device_add_group(struct device *dev, const struct attribute_group *grp)
2867	{
2868	union device_attr_group_devres *devres;
2869	int error;
2870
2871	devres = devres_alloc(devm_attr_group_remove,
2872	sizeof(*devres), GFP_KERNEL);
2873	if (!devres)
2874	return -ENOMEM;
2875
2876	error = sysfs_create_group(kobj: &dev->kobj, grp);
2877	if (error) {
2878	devres_free(res: devres);
2879	return error;
2880	}
2881
2882	devres->group = grp;
2883	devres_add(dev, res: devres);
2884	return 0;
2885	}
2886	EXPORT_SYMBOL_GPL(devm_device_add_group);
2887
2888	/**
2889	* devm_device_add_groups - create a bunch of managed attribute groups
2890	* @dev: The device to create the group for
2891	* @groups: The attribute groups to create, NULL terminated
2892	*
2893	* This function creates a bunch of managed attribute groups. If an error
2894	* occurs when creating a group, all previously created groups will be
2895	* removed, unwinding everything back to the original state when this
2896	* function was called. It will explicitly warn and error if any of the
2897	* attribute files being created already exist.
2898	*
2899	* Returns 0 on success or error code from sysfs_create_group on failure.
2900	*/
2901	int devm_device_add_groups(struct device *dev,
2902	const struct attribute_group **groups)
2903	{
2904	union device_attr_group_devres *devres;
2905	int error;
2906
2907	devres = devres_alloc(devm_attr_groups_remove,
2908	sizeof(*devres), GFP_KERNEL);
2909	if (!devres)
2910	return -ENOMEM;
2911
2912	error = sysfs_create_groups(kobj: &dev->kobj, groups);
2913	if (error) {
2914	devres_free(res: devres);
2915	return error;
2916	}
2917
2918	devres->groups = groups;
2919	devres_add(dev, res: devres);
2920	return 0;
2921	}
2922	EXPORT_SYMBOL_GPL(devm_device_add_groups);
2923
2924	static int device_add_attrs(struct device *dev)
2925	{
2926	const struct class *class = dev->class;
2927	const struct device_type *type = dev->type;
2928	int error;
2929
2930	if (class) {
2931	error = device_add_groups(dev, class->dev_groups);
2932	if (error)
2933	return error;
2934	}
2935
2936	if (type) {
2937	error = device_add_groups(dev, type->groups);
2938	if (error)
2939	goto err_remove_class_groups;
2940	}
2941
2942	error = device_add_groups(dev, dev->groups);
2943	if (error)
2944	goto err_remove_type_groups;
2945
2946	if (device_supports_offline(dev) && !dev->offline_disabled) {
2947	error = device_create_file(device: dev, entry: &dev_attr_online);
2948	if (error)
2949	goto err_remove_dev_groups;
2950	}
2951
2952	if (fw_devlink_flags && !fw_devlink_is_permissive() && dev->fwnode) {
2953	error = device_create_file(device: dev, entry: &dev_attr_waiting_for_supplier);
2954	if (error)
2955	goto err_remove_dev_online;
2956	}
2957
2958	if (dev_removable_is_valid(dev)) {
2959	error = device_create_file(device: dev, entry: &dev_attr_removable);
2960	if (error)
2961	goto err_remove_dev_waiting_for_supplier;
2962	}
2963
2964	if (dev_add_physical_location(dev)) {
2965	error = device_add_group(dev,
2966	grp: &dev_attr_physical_location_group);
2967	if (error)
2968	goto err_remove_dev_removable;
2969	}
2970
2971	return 0;
2972
2973	err_remove_dev_removable:
2974	device_remove_file(dev, attr: &dev_attr_removable);
2975	err_remove_dev_waiting_for_supplier:
2976	device_remove_file(dev, attr: &dev_attr_waiting_for_supplier);
2977	err_remove_dev_online:
2978	device_remove_file(dev, attr: &dev_attr_online);
2979	err_remove_dev_groups:
2980	device_remove_groups(dev, dev->groups);
2981	err_remove_type_groups:
2982	if (type)
2983	device_remove_groups(dev, type->groups);
2984	err_remove_class_groups:
2985	if (class)
2986	device_remove_groups(dev, class->dev_groups);
2987
2988	return error;
2989	}
2990
2991	static void device_remove_attrs(struct device *dev)
2992	{
2993	const struct class *class = dev->class;
2994	const struct device_type *type = dev->type;
2995
2996	if (dev->physical_location) {
2997	device_remove_group(dev, grp: &dev_attr_physical_location_group);
2998	kfree(objp: dev->physical_location);
2999	}
3000
3001	device_remove_file(dev, attr: &dev_attr_removable);
3002	device_remove_file(dev, attr: &dev_attr_waiting_for_supplier);
3003	device_remove_file(dev, attr: &dev_attr_online);
3004	device_remove_groups(dev, dev->groups);
3005
3006	if (type)
3007	device_remove_groups(dev, type->groups);
3008
3009	if (class)
3010	device_remove_groups(dev, class->dev_groups);
3011	}
3012
3013	static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
3014	char *buf)
3015	{
3016	return print_dev_t(buf, dev->devt);
3017	}
3018	static DEVICE_ATTR_RO(dev);
3019
3020	/* /sys/devices/ */
3021	struct kset *devices_kset;
3022
3023	/**
3024	* devices_kset_move_before - Move device in the devices_kset's list.
3025	* @deva: Device to move.
3026	* @devb: Device @deva should come before.
3027	*/
3028	static void devices_kset_move_before(struct device *deva, struct device *devb)
3029	{
3030	if (!devices_kset)
3031	return;
3032	pr_debug("devices_kset: Moving %s before %s\n",
3033	dev_name(deva), dev_name(devb));
3034	spin_lock(lock: &devices_kset->list_lock);
3035	list_move_tail(list: &deva->kobj.entry, head: &devb->kobj.entry);
3036	spin_unlock(lock: &devices_kset->list_lock);
3037	}
3038
3039	/**
3040	* devices_kset_move_after - Move device in the devices_kset's list.
3041	* @deva: Device to move
3042	* @devb: Device @deva should come after.
3043	*/
3044	static void devices_kset_move_after(struct device *deva, struct device *devb)
3045	{
3046	if (!devices_kset)
3047	return;
3048	pr_debug("devices_kset: Moving %s after %s\n",
3049	dev_name(deva), dev_name(devb));
3050	spin_lock(lock: &devices_kset->list_lock);
3051	list_move(list: &deva->kobj.entry, head: &devb->kobj.entry);
3052	spin_unlock(lock: &devices_kset->list_lock);
3053	}
3054
3055	/**
3056	* devices_kset_move_last - move the device to the end of devices_kset's list.
3057	* @dev: device to move
3058	*/
3059	void devices_kset_move_last(struct device *dev)
3060	{
3061	if (!devices_kset)
3062	return;
3063	pr_debug("devices_kset: Moving %s to end of list\n", dev_name(dev));
3064	spin_lock(lock: &devices_kset->list_lock);
3065	list_move_tail(list: &dev->kobj.entry, head: &devices_kset->list);
3066	spin_unlock(lock: &devices_kset->list_lock);
3067	}
3068
3069	/**
3070	* device_create_file - create sysfs attribute file for device.
3071	* @dev: device.
3072	* @attr: device attribute descriptor.
3073	*/
3074	int device_create_file(struct device *dev,
3075	const struct device_attribute *attr)
3076	{
3077	int error = 0;
3078
3079	if (dev) {
3080	WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
3081	"Attribute %s: write permission without 'store'\n",
3082	attr->attr.name);
3083	WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
3084	"Attribute %s: read permission without 'show'\n",
3085	attr->attr.name);
3086	error = sysfs_create_file(kobj: &dev->kobj, attr: &attr->attr);
3087	}
3088
3089	return error;
3090	}
3091	EXPORT_SYMBOL_GPL(device_create_file);
3092
3093	/**
3094	* device_remove_file - remove sysfs attribute file.
3095	* @dev: device.
3096	* @attr: device attribute descriptor.
3097	*/
3098	void device_remove_file(struct device *dev,
3099	const struct device_attribute *attr)
3100	{
3101	if (dev)
3102	sysfs_remove_file(kobj: &dev->kobj, attr: &attr->attr);
3103	}
3104	EXPORT_SYMBOL_GPL(device_remove_file);
3105
3106	/**
3107	* device_remove_file_self - remove sysfs attribute file from its own method.
3108	* @dev: device.
3109	* @attr: device attribute descriptor.
3110	*
3111	* See kernfs_remove_self() for details.
3112	*/
3113	bool device_remove_file_self(struct device *dev,
3114	const struct device_attribute *attr)
3115	{
3116	if (dev)
3117	return sysfs_remove_file_self(kobj: &dev->kobj, attr: &attr->attr);
3118	else
3119	return false;
3120	}
3121	EXPORT_SYMBOL_GPL(device_remove_file_self);
3122
3123	/**
3124	* device_create_bin_file - create sysfs binary attribute file for device.
3125	* @dev: device.
3126	* @attr: device binary attribute descriptor.
3127	*/
3128	int device_create_bin_file(struct device *dev,
3129	const struct bin_attribute *attr)
3130	{
3131	int error = -EINVAL;
3132	if (dev)
3133	error = sysfs_create_bin_file(kobj: &dev->kobj, attr);
3134	return error;
3135	}
3136	EXPORT_SYMBOL_GPL(device_create_bin_file);
3137
3138	/**
3139	* device_remove_bin_file - remove sysfs binary attribute file
3140	* @dev: device.
3141	* @attr: device binary attribute descriptor.
3142	*/
3143	void device_remove_bin_file(struct device *dev,
3144	const struct bin_attribute *attr)
3145	{
3146	if (dev)
3147	sysfs_remove_bin_file(kobj: &dev->kobj, attr);
3148	}
3149	EXPORT_SYMBOL_GPL(device_remove_bin_file);
3150
3151	static void klist_children_get(struct klist_node *n)
3152	{
3153	struct device_private *p = to_device_private_parent(n);
3154	struct device *dev = p->device;
3155
3156	get_device(dev);
3157	}
3158
3159	static void klist_children_put(struct klist_node *n)
3160	{
3161	struct device_private *p = to_device_private_parent(n);
3162	struct device *dev = p->device;
3163
3164	put_device(dev);
3165	}
3166
3167	/**
3168	* device_initialize - init device structure.
3169	* @dev: device.
3170	*
3171	* This prepares the device for use by other layers by initializing
3172	* its fields.
3173	* It is the first half of device_register(), if called by
3174	* that function, though it can also be called separately, so one
3175	* may use @dev's fields. In particular, get_device()/put_device()
3176	* may be used for reference counting of @dev after calling this
3177	* function.
3178	*
3179	* All fields in @dev must be initialized by the caller to 0, except
3180	* for those explicitly set to some other value. The simplest
3181	* approach is to use kzalloc() to allocate the structure containing
3182	* @dev.
3183	*
3184	* NOTE: Use put_device() to give up your reference instead of freeing
3185	* @dev directly once you have called this function.
3186	*/
3187	void device_initialize(struct device *dev)
3188	{
3189	dev->kobj.kset = devices_kset;
3190	kobject_init(kobj: &dev->kobj, ktype: &device_ktype);
3191	INIT_LIST_HEAD(list: &dev->dma_pools);
3192	mutex_init(&dev->mutex);
3193	lockdep_set_novalidate_class(&dev->mutex);
3194	spin_lock_init(&dev->devres_lock);
3195	INIT_LIST_HEAD(list: &dev->devres_head);
3196	device_pm_init(dev);
3197	set_dev_node(dev, NUMA_NO_NODE);
3198	INIT_LIST_HEAD(list: &dev->links.consumers);
3199	INIT_LIST_HEAD(list: &dev->links.suppliers);
3200	INIT_LIST_HEAD(list: &dev->links.defer_sync);
3201	dev->links.status = DL_DEV_NO_DRIVER;
3202	#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
3203	defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
3204	defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
3205	dev->dma_coherent = dma_default_coherent;
3206	#endif
3207	swiotlb_dev_init(dev);
3208	}
3209	EXPORT_SYMBOL_GPL(device_initialize);
3210
3211	struct kobject *virtual_device_parent(struct device *dev)
3212	{
3213	static struct kobject *virtual_dir = NULL;
3214
3215	if (!virtual_dir)
3216	virtual_dir = kobject_create_and_add(name: "virtual",
3217	parent: &devices_kset->kobj);
3218
3219	return virtual_dir;
3220	}
3221
3222	struct class_dir {
3223	struct kobject kobj;
3224	const struct class *class;
3225	};
3226
3227	#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
3228
3229	static void class_dir_release(struct kobject *kobj)
3230	{
3231	struct class_dir *dir = to_class_dir(kobj);
3232	kfree(objp: dir);
3233	}
3234
3235	static const
3236	struct kobj_ns_type_operations *class_dir_child_ns_type(const struct kobject *kobj)
3237	{
3238	const struct class_dir *dir = to_class_dir(kobj);
3239	return dir->class->ns_type;
3240	}
3241
3242	static const struct kobj_type class_dir_ktype = {
3243	.release = class_dir_release,
3244	.sysfs_ops = &kobj_sysfs_ops,
3245	.child_ns_type = class_dir_child_ns_type
3246	};
3247
3248	static struct kobject *class_dir_create_and_add(struct subsys_private *sp,
3249	struct kobject *parent_kobj)
3250	{
3251	struct class_dir *dir;
3252	int retval;
3253
3254	dir = kzalloc(size: sizeof(*dir), GFP_KERNEL);
3255	if (!dir)
3256	return ERR_PTR(error: -ENOMEM);
3257
3258	dir->class = sp->class;
3259	kobject_init(kobj: &dir->kobj, ktype: &class_dir_ktype);
3260
3261	dir->kobj.kset = &sp->glue_dirs;
3262
3263	retval = kobject_add(kobj: &dir->kobj, parent: parent_kobj, fmt: "%s", sp->class->name);
3264	if (retval < 0) {
3265	kobject_put(kobj: &dir->kobj);
3266	return ERR_PTR(error: retval);
3267	}
3268	return &dir->kobj;
3269	}
3270
3271	static DEFINE_MUTEX(gdp_mutex);
3272
3273	static struct kobject *get_device_parent(struct device *dev,
3274	struct device *parent)
3275	{
3276	struct subsys_private *sp = class_to_subsys(class: dev->class);
3277	struct kobject *kobj = NULL;
3278
3279	if (sp) {
3280	struct kobject *parent_kobj;
3281	struct kobject *k;
3282
3283	/*
3284	* If we have no parent, we live in "virtual".
3285	* Class-devices with a non class-device as parent, live
3286	* in a "glue" directory to prevent namespace collisions.
3287	*/
3288	if (parent == NULL)
3289	parent_kobj = virtual_device_parent(dev);
3290	else if (parent->class && !dev->class->ns_type) {
3291	subsys_put(sp);
3292	return &parent->kobj;
3293	} else {
3294	parent_kobj = &parent->kobj;
3295	}
3296
3297	mutex_lock(&gdp_mutex);
3298
3299	/* find our class-directory at the parent and reference it */
3300	spin_lock(lock: &sp->glue_dirs.list_lock);
3301	list_for_each_entry(k, &sp->glue_dirs.list, entry)
3302	if (k->parent == parent_kobj) {
3303	kobj = kobject_get(kobj: k);
3304	break;
3305	}
3306	spin_unlock(lock: &sp->glue_dirs.list_lock);
3307	if (kobj) {
3308	mutex_unlock(lock: &gdp_mutex);
3309	subsys_put(sp);
3310	return kobj;
3311	}
3312
3313	/* or create a new class-directory at the parent device */
3314	k = class_dir_create_and_add(sp, parent_kobj);
3315	/* do not emit an uevent for this simple "glue" directory */
3316	mutex_unlock(lock: &gdp_mutex);
3317	subsys_put(sp);
3318	return k;
3319	}
3320
3321	/* subsystems can specify a default root directory for their devices */
3322	if (!parent && dev->bus) {
3323	struct device *dev_root = bus_get_dev_root(bus: dev->bus);
3324
3325	if (dev_root) {
3326	kobj = &dev_root->kobj;
3327	put_device(dev: dev_root);
3328	return kobj;
3329	}
3330	}
3331
3332	if (parent)
3333	return &parent->kobj;
3334	return NULL;
3335	}
3336
3337	static inline bool live_in_glue_dir(struct kobject *kobj,
3338	struct device *dev)
3339	{
3340	struct subsys_private *sp;
3341	bool retval;
3342
3343	if (!kobj || !dev->class)
3344	return false;
3345
3346	sp = class_to_subsys(class: dev->class);
3347	if (!sp)
3348	return false;
3349
3350	if (kobj->kset == &sp->glue_dirs)
3351	retval = true;
3352	else
3353	retval = false;
3354
3355	subsys_put(sp);
3356	return retval;
3357	}
3358
3359	static inline struct kobject *get_glue_dir(struct device *dev)
3360	{
3361	return dev->kobj.parent;
3362	}
3363
3364	/**
3365	* kobject_has_children - Returns whether a kobject has children.
3366	* @kobj: the object to test
3367	*
3368	* This will return whether a kobject has other kobjects as children.
3369	*
3370	* It does NOT account for the presence of attribute files, only sub
3371	* directories. It also assumes there is no concurrent addition or
3372	* removal of such children, and thus relies on external locking.
3373	*/
3374	static inline bool kobject_has_children(struct kobject *kobj)
3375	{
3376	WARN_ON_ONCE(kref_read(&kobj->kref) == 0);
3377
3378	return kobj->sd && kobj->sd->dir.subdirs;
3379	}
3380
3381	/*
3382	* make sure cleaning up dir as the last step, we need to make
3383	* sure .release handler of kobject is run with holding the
3384	* global lock
3385	*/
3386	static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
3387	{
3388	unsigned int ref;
3389
3390	/* see if we live in a "glue" directory */
3391	if (!live_in_glue_dir(kobj: glue_dir, dev))
3392	return;
3393
3394	mutex_lock(&gdp_mutex);
3395	/**
3396	* There is a race condition between removing glue directory
3397	* and adding a new device under the glue directory.
3398	*
3399	* CPU1: CPU2:
3400	*
3401	* device_add()
3402	* get_device_parent()
3403	* class_dir_create_and_add()
3404	* kobject_add_internal()
3405	* create_dir() // create glue_dir
3406	*
3407	* device_add()
3408	* get_device_parent()
3409	* kobject_get() // get glue_dir
3410	*
3411	* device_del()
3412	* cleanup_glue_dir()
3413	* kobject_del(glue_dir)
3414	*
3415	* kobject_add()
3416	* kobject_add_internal()
3417	* create_dir() // in glue_dir
3418	* sysfs_create_dir_ns()
3419	* kernfs_create_dir_ns(sd)
3420	*
3421	* sysfs_remove_dir() // glue_dir->sd=NULL
3422	* sysfs_put() // free glue_dir->sd
3423	*
3424	* // sd is freed
3425	* kernfs_new_node(sd)
3426	* kernfs_get(glue_dir)
3427	* kernfs_add_one()
3428	* kernfs_put()
3429	*
3430	* Before CPU1 remove last child device under glue dir, if CPU2 add
3431	* a new device under glue dir, the glue_dir kobject reference count
3432	* will be increase to 2 in kobject_get(k). And CPU2 has been called
3433	* kernfs_create_dir_ns(). Meanwhile, CPU1 call sysfs_remove_dir()
3434	* and sysfs_put(). This result in glue_dir->sd is freed.
3435	*
3436	* Then the CPU2 will see a stale "empty" but still potentially used
3437	* glue dir around in kernfs_new_node().
3438	*
3439	* In order to avoid this happening, we also should make sure that
3440	* kernfs_node for glue_dir is released in CPU1 only when refcount
3441	* for glue_dir kobj is 1.
3442	*/
3443	ref = kref_read(kref: &glue_dir->kref);
3444	if (!kobject_has_children(kobj: glue_dir) && !--ref)
3445	kobject_del(kobj: glue_dir);
3446	kobject_put(kobj: glue_dir);
3447	mutex_unlock(lock: &gdp_mutex);
3448	}
3449
3450	static int device_add_class_symlinks(struct device *dev)
3451	{
3452	struct device_node *of_node = dev_of_node(dev);
3453	struct subsys_private *sp;
3454	int error;
3455
3456	if (of_node) {
3457	error = sysfs_create_link(kobj: &dev->kobj, of_node_kobj(of_node), name: "of_node");
3458	if (error)
3459	dev_warn(dev, "Error %d creating of_node link\n",error);
3460	/* An error here doesn't warrant bringing down the device */
3461	}
3462
3463	sp = class_to_subsys(class: dev->class);
3464	if (!sp)
3465	return 0;
3466
3467	error = sysfs_create_link(kobj: &dev->kobj, target: &sp->subsys.kobj, name: "subsystem");
3468	if (error)
3469	goto out_devnode;
3470
3471	if (dev->parent && device_is_not_partition(dev)) {
3472	error = sysfs_create_link(kobj: &dev->kobj, target: &dev->parent->kobj,
3473	name: "device");
3474	if (error)
3475	goto out_subsys;
3476	}
3477
3478	/* link in the class directory pointing to the device */
3479	error = sysfs_create_link(kobj: &sp->subsys.kobj, target: &dev->kobj, name: dev_name(dev));
3480	if (error)
3481	goto out_device;
3482	goto exit;
3483
3484	out_device:
3485	sysfs_remove_link(kobj: &dev->kobj, name: "device");
3486	out_subsys:
3487	sysfs_remove_link(kobj: &dev->kobj, name: "subsystem");
3488	out_devnode:
3489	sysfs_remove_link(kobj: &dev->kobj, name: "of_node");
3490	exit:
3491	subsys_put(sp);
3492	return error;
3493	}
3494
3495	static void device_remove_class_symlinks(struct device *dev)
3496	{
3497	struct subsys_private *sp = class_to_subsys(class: dev->class);
3498
3499	if (dev_of_node(dev))
3500	sysfs_remove_link(kobj: &dev->kobj, name: "of_node");
3501
3502	if (!sp)
3503	return;
3504
3505	if (dev->parent && device_is_not_partition(dev))
3506	sysfs_remove_link(kobj: &dev->kobj, name: "device");
3507	sysfs_remove_link(kobj: &dev->kobj, name: "subsystem");
3508	sysfs_delete_link(dir: &sp->subsys.kobj, targ: &dev->kobj, name: dev_name(dev));
3509	subsys_put(sp);
3510	}
3511
3512	/**
3513	* dev_set_name - set a device name
3514	* @dev: device
3515	* @fmt: format string for the device's name
3516	*/
3517	int dev_set_name(struct device *dev, const char *fmt, ...)
3518	{
3519	va_list vargs;
3520	int err;
3521
3522	va_start(vargs, fmt);
3523	err = kobject_set_name_vargs(kobj: &dev->kobj, fmt, vargs);
3524	va_end(vargs);
3525	return err;
3526	}
3527	EXPORT_SYMBOL_GPL(dev_set_name);
3528
3529	/* select a /sys/dev/ directory for the device */
3530	static struct kobject *device_to_dev_kobj(struct device *dev)
3531	{
3532	if (is_blockdev(dev))
3533	return sysfs_dev_block_kobj;
3534	else
3535	return sysfs_dev_char_kobj;
3536	}
3537
3538	static int device_create_sys_dev_entry(struct device *dev)
3539	{
3540	struct kobject *kobj = device_to_dev_kobj(dev);
3541	int error = 0;
3542	char devt_str[15];
3543
3544	if (kobj) {
3545	format_dev_t(devt_str, dev->devt);
3546	error = sysfs_create_link(kobj, target: &dev->kobj, name: devt_str);
3547	}
3548
3549	return error;
3550	}
3551
3552	static void device_remove_sys_dev_entry(struct device *dev)
3553	{
3554	struct kobject *kobj = device_to_dev_kobj(dev);
3555	char devt_str[15];
3556
3557	if (kobj) {
3558	format_dev_t(devt_str, dev->devt);
3559	sysfs_remove_link(kobj, name: devt_str);
3560	}
3561	}
3562
3563	static int device_private_init(struct device *dev)
3564	{
3565	dev->p = kzalloc(size: sizeof(*dev->p), GFP_KERNEL);
3566	if (!dev->p)
3567	return -ENOMEM;
3568	dev->p->device = dev;
3569	klist_init(k: &dev->p->klist_children, get: klist_children_get,
3570	put: klist_children_put);
3571	INIT_LIST_HEAD(list: &dev->p->deferred_probe);
3572	return 0;
3573	}
3574
3575	/**
3576	* device_add - add device to device hierarchy.
3577	* @dev: device.
3578	*
3579	* This is part 2 of device_register(), though may be called
3580	* separately _iff_ device_initialize() has been called separately.
3581	*
3582	* This adds @dev to the kobject hierarchy via kobject_add(), adds it
3583	* to the global and sibling lists for the device, then
3584	* adds it to the other relevant subsystems of the driver model.
3585	*
3586	* Do not call this routine or device_register() more than once for
3587	* any device structure. The driver model core is not designed to work
3588	* with devices that get unregistered and then spring back to life.
3589	* (Among other things, it's very hard to guarantee that all references
3590	* to the previous incarnation of @dev have been dropped.) Allocate
3591	* and register a fresh new struct device instead.
3592	*
3593	* NOTE: _Never_ directly free @dev after calling this function, even
3594	* if it returned an error! Always use put_device() to give up your
3595	* reference instead.
3596	*
3597	* Rule of thumb is: if device_add() succeeds, you should call
3598	* device_del() when you want to get rid of it. If device_add() has
3599	* *not* succeeded, use *only* put_device() to drop the reference
3600	* count.
3601	*/
3602	int device_add(struct device *dev)
3603	{
3604	struct subsys_private *sp;
3605	struct device *parent;
3606	struct kobject *kobj;
3607	struct class_interface *class_intf;
3608	int error = -EINVAL;
3609	struct kobject *glue_dir = NULL;
3610
3611	dev = get_device(dev);
3612	if (!dev)
3613	goto done;
3614
3615	if (!dev->p) {
3616	error = device_private_init(dev);
3617	if (error)
3618	goto done;
3619	}
3620
3621	/*
3622	* for statically allocated devices, which should all be converted
3623	* some day, we need to initialize the name. We prevent reading back
3624	* the name, and force the use of dev_name()
3625	*/
3626	if (dev->init_name) {
3627	error = dev_set_name(dev, "%s", dev->init_name);
3628	dev->init_name = NULL;
3629	}
3630
3631	if (dev_name(dev))
3632	error = 0;
3633	/* subsystems can specify simple device enumeration */
3634	else if (dev->bus && dev->bus->dev_name)
3635	error = dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
3636	else
3637	error = -EINVAL;
3638	if (error)
3639	goto name_error;
3640
3641	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3642
3643	parent = get_device(dev: dev->parent);
3644	kobj = get_device_parent(dev, parent);
3645	if (IS_ERR(ptr: kobj)) {
3646	error = PTR_ERR(ptr: kobj);
3647	goto parent_error;
3648	}
3649	if (kobj)
3650	dev->kobj.parent = kobj;
3651
3652	/* use parent numa_node */
3653	if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
3654	set_dev_node(dev, node: dev_to_node(dev: parent));
3655
3656	/* first, register with generic layer. */
3657	/* we require the name to be set before, and pass NULL */
3658	error = kobject_add(kobj: &dev->kobj, parent: dev->kobj.parent, NULL);
3659	if (error) {
3660	glue_dir = kobj;
3661	goto Error;
3662	}
3663
3664	/* notify platform of device entry */
3665	device_platform_notify(dev);
3666
3667	error = device_create_file(dev, &dev_attr_uevent);
3668	if (error)
3669	goto attrError;
3670
3671	error = device_add_class_symlinks(dev);
3672	if (error)
3673	goto SymlinkError;
3674	error = device_add_attrs(dev);
3675	if (error)
3676	goto AttrsError;
3677	error = bus_add_device(dev);
3678	if (error)
3679	goto BusError;
3680	error = dpm_sysfs_add(dev);
3681	if (error)
3682	goto DPMError;
3683	device_pm_add(dev);
3684
3685	if (MAJOR(dev->devt)) {
3686	error = device_create_file(dev, &dev_attr_dev);
3687	if (error)
3688	goto DevAttrError;
3689
3690	error = device_create_sys_dev_entry(dev);
3691	if (error)
3692	goto SysEntryError;
3693
3694	devtmpfs_create_node(dev);
3695	}
3696
3697	/* Notify clients of device addition. This call must come
3698	* after dpm_sysfs_add() and before kobject_uevent().
3699	*/
3700	bus_notify(dev, value: BUS_NOTIFY_ADD_DEVICE);
3701	kobject_uevent(kobj: &dev->kobj, action: KOBJ_ADD);
3702
3703	/*
3704	* Check if any of the other devices (consumers) have been waiting for
3705	* this device (supplier) to be added so that they can create a device
3706	* link to it.
3707	*
3708	* This needs to happen after device_pm_add() because device_link_add()
3709	* requires the supplier be registered before it's called.
3710	*
3711	* But this also needs to happen before bus_probe_device() to make sure
3712	* waiting consumers can link to it before the driver is bound to the
3713	* device and the driver sync_state callback is called for this device.
3714	*/
3715	if (dev->fwnode && !dev->fwnode->dev) {
3716	dev->fwnode->dev = dev;
3717	fw_devlink_link_device(dev);
3718	}
3719
3720	bus_probe_device(dev);
3721
3722	/*
3723	* If all driver registration is done and a newly added device doesn't
3724	* match with any driver, don't block its consumers from probing in
3725	* case the consumer device is able to operate without this supplier.
3726	*/
3727	if (dev->fwnode && fw_devlink_drv_reg_done && !dev->can_match)
3728	fw_devlink_unblock_consumers(dev);
3729
3730	if (parent)
3731	klist_add_tail(n: &dev->p->knode_parent,
3732	k: &parent->p->klist_children);
3733
3734	sp = class_to_subsys(class: dev->class);
3735	if (sp) {
3736	mutex_lock(&sp->mutex);
3737	/* tie the class to the device */
3738	klist_add_tail(n: &dev->p->knode_class, k: &sp->klist_devices);
3739
3740	/* notify any interfaces that the device is here */
3741	list_for_each_entry(class_intf, &sp->interfaces, node)
3742	if (class_intf->add_dev)
3743	class_intf->add_dev(dev);
3744	mutex_unlock(lock: &sp->mutex);
3745	subsys_put(sp);
3746	}
3747	done:
3748	put_device(dev);
3749	return error;
3750	SysEntryError:
3751	if (MAJOR(dev->devt))
3752	device_remove_file(dev, &dev_attr_dev);
3753	DevAttrError:
3754	device_pm_remove(dev);
3755	dpm_sysfs_remove(dev);
3756	DPMError:
3757	dev->driver = NULL;
3758	bus_remove_device(dev);
3759	BusError:
3760	device_remove_attrs(dev);
3761	AttrsError:
3762	device_remove_class_symlinks(dev);
3763	SymlinkError:
3764	device_remove_file(dev, &dev_attr_uevent);
3765	attrError:
3766	device_platform_notify_remove(dev);
3767	kobject_uevent(kobj: &dev->kobj, action: KOBJ_REMOVE);
3768	glue_dir = get_glue_dir(dev);
3769	kobject_del(kobj: &dev->kobj);
3770	Error:
3771	cleanup_glue_dir(dev, glue_dir);
3772	parent_error:
3773	put_device(dev: parent);
3774	name_error:
3775	kfree(objp: dev->p);
3776	dev->p = NULL;
3777	goto done;
3778	}
3779	EXPORT_SYMBOL_GPL(device_add);
3780
3781	/**
3782	* device_register - register a device with the system.
3783	* @dev: pointer to the device structure
3784	*
3785	* This happens in two clean steps - initialize the device
3786	* and add it to the system. The two steps can be called
3787	* separately, but this is the easiest and most common.
3788	* I.e. you should only call the two helpers separately if
3789	* have a clearly defined need to use and refcount the device
3790	* before it is added to the hierarchy.
3791	*
3792	* For more information, see the kerneldoc for device_initialize()
3793	* and device_add().
3794	*
3795	* NOTE: _Never_ directly free @dev after calling this function, even
3796	* if it returned an error! Always use put_device() to give up the
3797	* reference initialized in this function instead.
3798	*/
3799	int device_register(struct device *dev)
3800	{
3801	device_initialize(dev);
3802	return device_add(dev);
3803	}
3804	EXPORT_SYMBOL_GPL(device_register);
3805
3806	/**
3807	* get_device - increment reference count for device.
3808	* @dev: device.
3809	*
3810	* This simply forwards the call to kobject_get(), though
3811	* we do take care to provide for the case that we get a NULL
3812	* pointer passed in.
3813	*/
3814	struct device *get_device(struct device *dev)
3815	{
3816	return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
3817	}
3818	EXPORT_SYMBOL_GPL(get_device);
3819
3820	/**
3821	* put_device - decrement reference count.
3822	* @dev: device in question.
3823	*/
3824	void put_device(struct device *dev)
3825	{
3826	/* might_sleep(); */
3827	if (dev)
3828	kobject_put(kobj: &dev->kobj);
3829	}
3830	EXPORT_SYMBOL_GPL(put_device);
3831
3832	bool kill_device(struct device *dev)
3833	{
3834	/*
3835	* Require the device lock and set the "dead" flag to guarantee that
3836	* the update behavior is consistent with the other bitfields near
3837	* it and that we cannot have an asynchronous probe routine trying
3838	* to run while we are tearing out the bus/class/sysfs from
3839	* underneath the device.
3840	*/
3841	device_lock_assert(dev);
3842
3843	if (dev->p->dead)
3844	return false;
3845	dev->p->dead = true;
3846	return true;
3847	}
3848	EXPORT_SYMBOL_GPL(kill_device);
3849
3850	/**
3851	* device_del - delete device from system.
3852	* @dev: device.
3853	*
3854	* This is the first part of the device unregistration
3855	* sequence. This removes the device from the lists we control
3856	* from here, has it removed from the other driver model
3857	* subsystems it was added to in device_add(), and removes it
3858	* from the kobject hierarchy.
3859	*
3860	* NOTE: this should be called manually _iff_ device_add() was
3861	* also called manually.
3862	*/
3863	void device_del(struct device *dev)
3864	{
3865	struct subsys_private *sp;
3866	struct device *parent = dev->parent;
3867	struct kobject *glue_dir = NULL;
3868	struct class_interface *class_intf;
3869	unsigned int noio_flag;
3870
3871	device_lock(dev);
3872	kill_device(dev);
3873	device_unlock(dev);
3874
3875	if (dev->fwnode && dev->fwnode->dev == dev)
3876	dev->fwnode->dev = NULL;
3877
3878	/* Notify clients of device removal. This call must come
3879	* before dpm_sysfs_remove().
3880	*/
3881	noio_flag = memalloc_noio_save();
3882	bus_notify(dev, value: BUS_NOTIFY_DEL_DEVICE);
3883
3884	dpm_sysfs_remove(dev);
3885	if (parent)
3886	klist_del(n: &dev->p->knode_parent);
3887	if (MAJOR(dev->devt)) {
3888	devtmpfs_delete_node(dev);
3889	device_remove_sys_dev_entry(dev);
3890	device_remove_file(dev, &dev_attr_dev);
3891	}
3892
3893	sp = class_to_subsys(class: dev->class);
3894	if (sp) {
3895	device_remove_class_symlinks(dev);
3896
3897	mutex_lock(&sp->mutex);
3898	/* notify any interfaces that the device is now gone */
3899	list_for_each_entry(class_intf, &sp->interfaces, node)
3900	if (class_intf->remove_dev)
3901	class_intf->remove_dev(dev);
3902	/* remove the device from the class list */
3903	klist_del(n: &dev->p->knode_class);
3904	mutex_unlock(lock: &sp->mutex);
3905	subsys_put(sp);
3906	}
3907	device_remove_file(dev, &dev_attr_uevent);
3908	device_remove_attrs(dev);
3909	bus_remove_device(dev);
3910	device_pm_remove(dev);
3911	driver_deferred_probe_del(dev);
3912	device_platform_notify_remove(dev);
3913	device_links_purge(dev);
3914
3915	/*
3916	* If a device does not have a driver attached, we need to clean
3917	* up any managed resources. We do this in device_release(), but
3918	* it's never called (and we leak the device) if a managed
3919	* resource holds a reference to the device. So release all
3920	* managed resources here, like we do in driver_detach(). We
3921	* still need to do so again in device_release() in case someone
3922	* adds a new resource after this point, though.
3923	*/
3924	devres_release_all(dev);
3925
3926	bus_notify(dev, value: BUS_NOTIFY_REMOVED_DEVICE);
3927	kobject_uevent(kobj: &dev->kobj, action: KOBJ_REMOVE);
3928	glue_dir = get_glue_dir(dev);
3929	kobject_del(kobj: &dev->kobj);
3930	cleanup_glue_dir(dev, glue_dir);
3931	memalloc_noio_restore(flags: noio_flag);
3932	put_device(parent);
3933	}
3934	EXPORT_SYMBOL_GPL(device_del);
3935
3936	/**
3937	* device_unregister - unregister device from system.
3938	* @dev: device going away.
3939	*
3940	* We do this in two parts, like we do device_register(). First,
3941	* we remove it from all the subsystems with device_del(), then
3942	* we decrement the reference count via put_device(). If that
3943	* is the final reference count, the device will be cleaned up
3944	* via device_release() above. Otherwise, the structure will
3945	* stick around until the final reference to the device is dropped.
3946	*/
3947	void device_unregister(struct device *dev)
3948	{
3949	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3950	device_del(dev);
3951	put_device(dev);
3952	}
3953	EXPORT_SYMBOL_GPL(device_unregister);
3954
3955	static struct device *prev_device(struct klist_iter *i)
3956	{
3957	struct klist_node *n = klist_prev(i);
3958	struct device *dev = NULL;
3959	struct device_private *p;
3960
3961	if (n) {
3962	p = to_device_private_parent(n);
3963	dev = p->device;
3964	}
3965	return dev;
3966	}
3967
3968	static struct device *next_device(struct klist_iter *i)
3969	{
3970	struct klist_node *n = klist_next(i);
3971	struct device *dev = NULL;
3972	struct device_private *p;
3973
3974	if (n) {
3975	p = to_device_private_parent(n);
3976	dev = p->device;
3977	}
3978	return dev;
3979	}
3980
3981	/**
3982	* device_get_devnode - path of device node file
3983	* @dev: device
3984	* @mode: returned file access mode
3985	* @uid: returned file owner
3986	* @gid: returned file group
3987	* @tmp: possibly allocated string
3988	*
3989	* Return the relative path of a possible device node.
3990	* Non-default names may need to allocate a memory to compose
3991	* a name. This memory is returned in tmp and needs to be
3992	* freed by the caller.
3993	*/
3994	const char *device_get_devnode(const struct device *dev,
3995	umode_t *mode, kuid_t *uid, kgid_t *gid,
3996	const char **tmp)
3997	{
3998	char *s;
3999
4000	*tmp = NULL;
4001
4002	/* the device type may provide a specific name */
4003	if (dev->type && dev->type->devnode)
4004	*tmp = dev->type->devnode(dev, mode, uid, gid);
4005	if (*tmp)
4006	return *tmp;
4007
4008	/* the class may provide a specific name */
4009	if (dev->class && dev->class->devnode)
4010	*tmp = dev->class->devnode(dev, mode);
4011	if (*tmp)
4012	return *tmp;
4013
4014	/* return name without allocation, tmp == NULL */
4015	if (strchr(dev_name(dev), '!') == NULL)
4016	return dev_name(dev);
4017
4018	/* replace '!' in the name with '/' */
4019	s = kstrdup_and_replace(src: dev_name(dev), old: '!', new: '/', GFP_KERNEL);
4020	if (!s)
4021	return NULL;
4022	return *tmp = s;
4023	}
4024
4025	/**
4026	* device_for_each_child - device child iterator.
4027	* @parent: parent struct device.
4028	* @fn: function to be called for each device.
4029	* @data: data for the callback.
4030	*
4031	* Iterate over @parent's child devices, and call @fn for each,
4032	* passing it @data.
4033	*
4034	* We check the return of @fn each time. If it returns anything
4035	* other than 0, we break out and return that value.
4036	*/
4037	int device_for_each_child(struct device *parent, void *data,
4038	int (*fn)(struct device *dev, void *data))
4039	{
4040	struct klist_iter i;
4041	struct device *child;
4042	int error = 0;
4043
4044	if (!parent->p)
4045	return 0;
4046
4047	klist_iter_init(k: &parent->p->klist_children, i: &i);
4048	while (!error && (child = next_device(i: &i)))
4049	error = fn(child, data);
4050	klist_iter_exit(i: &i);
4051	return error;
4052	}
4053	EXPORT_SYMBOL_GPL(device_for_each_child);
4054
4055	/**
4056	* device_for_each_child_reverse - device child iterator in reversed order.
4057	* @parent: parent struct device.
4058	* @fn: function to be called for each device.
4059	* @data: data for the callback.
4060	*
4061	* Iterate over @parent's child devices, and call @fn for each,
4062	* passing it @data.
4063	*
4064	* We check the return of @fn each time. If it returns anything
4065	* other than 0, we break out and return that value.
4066	*/
4067	int device_for_each_child_reverse(struct device *parent, void *data,
4068	int (*fn)(struct device *dev, void *data))
4069	{
4070	struct klist_iter i;
4071	struct device *child;
4072	int error = 0;
4073
4074	if (!parent->p)
4075	return 0;
4076
4077	klist_iter_init(k: &parent->p->klist_children, i: &i);
4078	while ((child = prev_device(i: &i)) && !error)
4079	error = fn(child, data);
4080	klist_iter_exit(i: &i);
4081	return error;
4082	}
4083	EXPORT_SYMBOL_GPL(device_for_each_child_reverse);
4084
4085	/**
4086	* device_find_child - device iterator for locating a particular device.
4087	* @parent: parent struct device
4088	* @match: Callback function to check device
4089	* @data: Data to pass to match function
4090	*
4091	* This is similar to the device_for_each_child() function above, but it
4092	* returns a reference to a device that is 'found' for later use, as
4093	* determined by the @match callback.
4094	*
4095	* The callback should return 0 if the device doesn't match and non-zero
4096	* if it does. If the callback returns non-zero and a reference to the
4097	* current device can be obtained, this function will return to the caller
4098	* and not iterate over any more devices.
4099	*
4100	* NOTE: you will need to drop the reference with put_device() after use.
4101	*/
4102	struct device *device_find_child(struct device *parent, void *data,
4103	int (*match)(struct device *dev, void *data))
4104	{
4105	struct klist_iter i;
4106	struct device *child;
4107
4108	if (!parent)
4109	return NULL;
4110
4111	klist_iter_init(k: &parent->p->klist_children, i: &i);
4112	while ((child = next_device(i: &i)))
4113	if (match(child, data) && get_device(child))
4114	break;
4115	klist_iter_exit(i: &i);
4116	return child;
4117	}
4118	EXPORT_SYMBOL_GPL(device_find_child);
4119
4120	/**
4121	* device_find_child_by_name - device iterator for locating a child device.
4122	* @parent: parent struct device
4123	* @name: name of the child device
4124	*
4125	* This is similar to the device_find_child() function above, but it
4126	* returns a reference to a device that has the name @name.
4127	*
4128	* NOTE: you will need to drop the reference with put_device() after use.
4129	*/
4130	struct device *device_find_child_by_name(struct device *parent,
4131	const char *name)
4132	{
4133	struct klist_iter i;
4134	struct device *child;
4135
4136	if (!parent)
4137	return NULL;
4138
4139	klist_iter_init(k: &parent->p->klist_children, i: &i);
4140	while ((child = next_device(i: &i)))
4141	if (sysfs_streq(s1: dev_name(dev: child), s2: name) && get_device(child))
4142	break;
4143	klist_iter_exit(i: &i);
4144	return child;
4145	}
4146	EXPORT_SYMBOL_GPL(device_find_child_by_name);
4147
4148	static int match_any(struct device *dev, void *unused)
4149	{
4150	return 1;
4151	}
4152
4153	/**
4154	* device_find_any_child - device iterator for locating a child device, if any.
4155	* @parent: parent struct device
4156	*
4157	* This is similar to the device_find_child() function above, but it
4158	* returns a reference to a child device, if any.
4159	*
4160	* NOTE: you will need to drop the reference with put_device() after use.
4161	*/
4162	struct device *device_find_any_child(struct device *parent)
4163	{
4164	return device_find_child(parent, NULL, match_any);
4165	}
4166	EXPORT_SYMBOL_GPL(device_find_any_child);
4167
4168	int __init devices_init(void)
4169	{
4170	devices_kset = kset_create_and_add(name: "devices", u: &device_uevent_ops, NULL);
4171	if (!devices_kset)
4172	return -ENOMEM;
4173	dev_kobj = kobject_create_and_add(name: "dev", NULL);
4174	if (!dev_kobj)
4175	goto dev_kobj_err;
4176	sysfs_dev_block_kobj = kobject_create_and_add(name: "block", parent: dev_kobj);
4177	if (!sysfs_dev_block_kobj)
4178	goto block_kobj_err;
4179	sysfs_dev_char_kobj = kobject_create_and_add(name: "char", parent: dev_kobj);
4180	if (!sysfs_dev_char_kobj)
4181	goto char_kobj_err;
4182	device_link_wq = alloc_workqueue(fmt: "device_link_wq", flags: 0, max_active: 0);
4183	if (!device_link_wq)
4184	goto wq_err;
4185
4186	return 0;
4187
4188	wq_err:
4189	kobject_put(kobj: sysfs_dev_char_kobj);
4190	char_kobj_err:
4191	kobject_put(kobj: sysfs_dev_block_kobj);
4192	block_kobj_err:
4193	kobject_put(kobj: dev_kobj);
4194	dev_kobj_err:
4195	kset_unregister(kset: devices_kset);
4196	return -ENOMEM;
4197	}
4198
4199	static int device_check_offline(struct device *dev, void *not_used)
4200	{
4201	int ret;
4202
4203	ret = device_for_each_child(dev, NULL, device_check_offline);
4204	if (ret)
4205	return ret;
4206
4207	return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
4208	}
4209
4210	/**
4211	* device_offline - Prepare the device for hot-removal.
4212	* @dev: Device to be put offline.
4213	*
4214	* Execute the device bus type's .offline() callback, if present, to prepare
4215	* the device for a subsequent hot-removal. If that succeeds, the device must
4216	* not be used until either it is removed or its bus type's .online() callback
4217	* is executed.
4218	*
4219	* Call under device_hotplug_lock.
4220	*/
4221	int device_offline(struct device *dev)
4222	{
4223	int ret;
4224
4225	if (dev->offline_disabled)
4226	return -EPERM;
4227
4228	ret = device_for_each_child(dev, NULL, device_check_offline);
4229	if (ret)
4230	return ret;
4231
4232	device_lock(dev);
4233	if (device_supports_offline(dev)) {
4234	if (dev->offline) {
4235	ret = 1;
4236	} else {
4237	ret = dev->bus->offline(dev);
4238	if (!ret) {
4239	kobject_uevent(kobj: &dev->kobj, action: KOBJ_OFFLINE);
4240	dev->offline = true;
4241	}
4242	}
4243	}
4244	device_unlock(dev);
4245
4246	return ret;
4247	}
4248
4249	/**
4250	* device_online - Put the device back online after successful device_offline().
4251	* @dev: Device to be put back online.
4252	*
4253	* If device_offline() has been successfully executed for @dev, but the device
4254	* has not been removed subsequently, execute its bus type's .online() callback
4255	* to indicate that the device can be used again.
4256	*
4257	* Call under device_hotplug_lock.
4258	*/
4259	int device_online(struct device *dev)
4260	{
4261	int ret = 0;
4262
4263	device_lock(dev);
4264	if (device_supports_offline(dev)) {
4265	if (dev->offline) {
4266	ret = dev->bus->online(dev);
4267	if (!ret) {
4268	kobject_uevent(kobj: &dev->kobj, action: KOBJ_ONLINE);
4269	dev->offline = false;
4270	}
4271	} else {
4272	ret = 1;
4273	}
4274	}
4275	device_unlock(dev);
4276
4277	return ret;
4278	}
4279
4280	struct root_device {
4281	struct device dev;
4282	struct module *owner;
4283	};
4284
4285	static inline struct root_device *to_root_device(struct device *d)
4286	{
4287	return container_of(d, struct root_device, dev);
4288	}
4289
4290	static void root_device_release(struct device *dev)
4291	{
4292	kfree(objp: to_root_device(d: dev));
4293	}
4294
4295	/**
4296	* __root_device_register - allocate and register a root device
4297	* @name: root device name
4298	* @owner: owner module of the root device, usually THIS_MODULE
4299	*
4300	* This function allocates a root device and registers it
4301	* using device_register(). In order to free the returned
4302	* device, use root_device_unregister().
4303	*
4304	* Root devices are dummy devices which allow other devices
4305	* to be grouped under /sys/devices. Use this function to
4306	* allocate a root device and then use it as the parent of
4307	* any device which should appear under /sys/devices/{name}
4308	*
4309	* The /sys/devices/{name} directory will also contain a
4310	* 'module' symlink which points to the @owner directory
4311	* in sysfs.
4312	*
4313	* Returns &struct device pointer on success, or ERR_PTR() on error.
4314	*
4315	* Note: You probably want to use root_device_register().
4316	*/
4317	struct device *__root_device_register(const char *name, struct module *owner)
4318	{
4319	struct root_device *root;
4320	int err = -ENOMEM;
4321
4322	root = kzalloc(size: sizeof(struct root_device), GFP_KERNEL);
4323	if (!root)
4324	return ERR_PTR(error: err);
4325
4326	err = dev_set_name(&root->dev, "%s", name);
4327	if (err) {
4328	kfree(objp: root);
4329	return ERR_PTR(error: err);
4330	}
4331
4332	root->dev.release = root_device_release;
4333
4334	err = device_register(&root->dev);
4335	if (err) {
4336	put_device(&root->dev);
4337	return ERR_PTR(error: err);
4338	}
4339
4340	#ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */
4341	if (owner) {
4342	struct module_kobject *mk = &owner->mkobj;
4343
4344	err = sysfs_create_link(kobj: &root->dev.kobj, target: &mk->kobj, name: "module");
4345	if (err) {
4346	device_unregister(&root->dev);
4347	return ERR_PTR(error: err);
4348	}
4349	root->owner = owner;
4350	}
4351	#endif
4352
4353	return &root->dev;
4354	}
4355	EXPORT_SYMBOL_GPL(__root_device_register);
4356
4357	/**
4358	* root_device_unregister - unregister and free a root device
4359	* @dev: device going away
4360	*
4361	* This function unregisters and cleans up a device that was created by
4362	* root_device_register().
4363	*/
4364	void root_device_unregister(struct device *dev)
4365	{
4366	struct root_device *root = to_root_device(d: dev);
4367
4368	if (root->owner)
4369	sysfs_remove_link(kobj: &root->dev.kobj, name: "module");
4370
4371	device_unregister(dev);
4372	}
4373	EXPORT_SYMBOL_GPL(root_device_unregister);
4374
4375
4376	static void device_create_release(struct device *dev)
4377	{
4378	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
4379	kfree(objp: dev);
4380	}
4381
4382	static __printf(6, 0) struct device *
4383	device_create_groups_vargs(const struct class *class, struct device *parent,
4384	dev_t devt, void *drvdata,
4385	const struct attribute_group **groups,
4386	const char *fmt, va_list args)
4387	{
4388	struct device *dev = NULL;
4389	int retval = -ENODEV;
4390
4391	if (IS_ERR_OR_NULL(ptr: class))
4392	goto error;
4393
4394	dev = kzalloc(size: sizeof(*dev), GFP_KERNEL);
4395	if (!dev) {
4396	retval = -ENOMEM;
4397	goto error;
4398	}
4399
4400	device_initialize(dev);
4401	dev->devt = devt;
4402	dev->class = class;
4403	dev->parent = parent;
4404	dev->groups = groups;
4405	dev->release = device_create_release;
4406	dev_set_drvdata(dev, data: drvdata);
4407
4408	retval = kobject_set_name_vargs(kobj: &dev->kobj, fmt, vargs: args);
4409	if (retval)
4410	goto error;
4411
4412	retval = device_add(dev);
4413	if (retval)
4414	goto error;
4415
4416	return dev;
4417
4418	error:
4419	put_device(dev);
4420	return ERR_PTR(error: retval);
4421	}
4422
4423	/**
4424	* device_create - creates a device and registers it with sysfs
4425	* @class: pointer to the struct class that this device should be registered to
4426	* @parent: pointer to the parent struct device of this new device, if any
4427	* @devt: the dev_t for the char device to be added
4428	* @drvdata: the data to be added to the device for callbacks
4429	* @fmt: string for the device's name
4430	*
4431	* This function can be used by char device classes. A struct device
4432	* will be created in sysfs, registered to the specified class.
4433	*
4434	* A "dev" file will be created, showing the dev_t for the device, if
4435	* the dev_t is not 0,0.
4436	* If a pointer to a parent struct device is passed in, the newly created
4437	* struct device will be a child of that device in sysfs.
4438	* The pointer to the struct device will be returned from the call.
4439	* Any further sysfs files that might be required can be created using this
4440	* pointer.
4441	*
4442	* Returns &struct device pointer on success, or ERR_PTR() on error.
4443	*/
4444	struct device *device_create(const struct class *class, struct device *parent,
4445	dev_t devt, void *drvdata, const char *fmt, ...)
4446	{
4447	va_list vargs;
4448	struct device *dev;
4449
4450	va_start(vargs, fmt);
4451	dev = device_create_groups_vargs(class, parent, devt, drvdata, NULL,
4452	fmt, args: vargs);
4453	va_end(vargs);
4454	return dev;
4455	}
4456	EXPORT_SYMBOL_GPL(device_create);
4457
4458	/**
4459	* device_create_with_groups - creates a device and registers it with sysfs
4460	* @class: pointer to the struct class that this device should be registered to
4461	* @parent: pointer to the parent struct device of this new device, if any
4462	* @devt: the dev_t for the char device to be added
4463	* @drvdata: the data to be added to the device for callbacks
4464	* @groups: NULL-terminated list of attribute groups to be created
4465	* @fmt: string for the device's name
4466	*
4467	* This function can be used by char device classes. A struct device
4468	* will be created in sysfs, registered to the specified class.
4469	* Additional attributes specified in the groups parameter will also
4470	* be created automatically.
4471	*
4472	* A "dev" file will be created, showing the dev_t for the device, if
4473	* the dev_t is not 0,0.
4474	* If a pointer to a parent struct device is passed in, the newly created
4475	* struct device will be a child of that device in sysfs.
4476	* The pointer to the struct device will be returned from the call.
4477	* Any further sysfs files that might be required can be created using this
4478	* pointer.
4479	*
4480	* Returns &struct device pointer on success, or ERR_PTR() on error.
4481	*/
4482	struct device *device_create_with_groups(const struct class *class,
4483	struct device *parent, dev_t devt,
4484	void *drvdata,
4485	const struct attribute_group **groups,
4486	const char *fmt, ...)
4487	{
4488	va_list vargs;
4489	struct device *dev;
4490
4491	va_start(vargs, fmt);
4492	dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
4493	fmt, args: vargs);
4494	va_end(vargs);
4495	return dev;
4496	}
4497	EXPORT_SYMBOL_GPL(device_create_with_groups);
4498
4499	/**
4500	* device_destroy - removes a device that was created with device_create()
4501	* @class: pointer to the struct class that this device was registered with
4502	* @devt: the dev_t of the device that was previously registered
4503	*
4504	* This call unregisters and cleans up a device that was created with a
4505	* call to device_create().
4506	*/
4507	void device_destroy(const struct class *class, dev_t devt)
4508	{
4509	struct device *dev;
4510
4511	dev = class_find_device_by_devt(class, devt);
4512	if (dev) {
4513	put_device(dev);
4514	device_unregister(dev);
4515	}
4516	}
4517	EXPORT_SYMBOL_GPL(device_destroy);
4518
4519	/**
4520	* device_rename - renames a device
4521	* @dev: the pointer to the struct device to be renamed
4522	* @new_name: the new name of the device
4523	*
4524	* It is the responsibility of the caller to provide mutual
4525	* exclusion between two different calls of device_rename
4526	* on the same device to ensure that new_name is valid and
4527	* won't conflict with other devices.
4528	*
4529	* Note: given that some subsystems (networking and infiniband) use this
4530	* function, with no immediate plans for this to change, we cannot assume or
4531	* require that this function not be called at all.
4532	*
4533	* However, if you're writing new code, do not call this function. The following
4534	* text from Kay Sievers offers some insight:
4535	*
4536	* Renaming devices is racy at many levels, symlinks and other stuff are not
4537	* replaced atomically, and you get a "move" uevent, but it's not easy to
4538	* connect the event to the old and new device. Device nodes are not renamed at
4539	* all, there isn't even support for that in the kernel now.
4540	*
4541	* In the meantime, during renaming, your target name might be taken by another
4542	* driver, creating conflicts. Or the old name is taken directly after you
4543	* renamed it -- then you get events for the same DEVPATH, before you even see
4544	* the "move" event. It's just a mess, and nothing new should ever rely on
4545	* kernel device renaming. Besides that, it's not even implemented now for
4546	* other things than (driver-core wise very simple) network devices.
4547	*
4548	* Make up a "real" name in the driver before you register anything, or add
4549	* some other attributes for userspace to find the device, or use udev to add
4550	* symlinks -- but never rename kernel devices later, it's a complete mess. We
4551	* don't even want to get into that and try to implement the missing pieces in
4552	* the core. We really have other pieces to fix in the driver core mess. :)
4553	*/
4554	int device_rename(struct device *dev, const char *new_name)
4555	{
4556	struct kobject *kobj = &dev->kobj;
4557	char *old_device_name = NULL;
4558	int error;
4559
4560	dev = get_device(dev);
4561	if (!dev)
4562	return -EINVAL;
4563
4564	dev_dbg(dev, "renaming to %s\n", new_name);
4565
4566	old_device_name = kstrdup(s: dev_name(dev), GFP_KERNEL);
4567	if (!old_device_name) {
4568	error = -ENOMEM;
4569	goto out;
4570	}
4571
4572	if (dev->class) {
4573	struct subsys_private *sp = class_to_subsys(class: dev->class);
4574
4575	if (!sp) {
4576	error = -EINVAL;
4577	goto out;
4578	}
4579
4580	error = sysfs_rename_link_ns(kobj: &sp->subsys.kobj, target: kobj, old_name: old_device_name,
4581	new_name, new_ns: kobject_namespace(kobj));
4582	subsys_put(sp);
4583	if (error)
4584	goto out;
4585	}
4586
4587	error = kobject_rename(kobj, new_name);
4588	if (error)
4589	goto out;
4590
4591	out:
4592	put_device(dev);
4593
4594	kfree(objp: old_device_name);
4595
4596	return error;
4597	}
4598	EXPORT_SYMBOL_GPL(device_rename);
4599
4600	static int device_move_class_links(struct device *dev,
4601	struct device *old_parent,
4602	struct device *new_parent)
4603	{
4604	int error = 0;
4605
4606	if (old_parent)
4607	sysfs_remove_link(kobj: &dev->kobj, name: "device");
4608	if (new_parent)
4609	error = sysfs_create_link(kobj: &dev->kobj, target: &new_parent->kobj,
4610	name: "device");
4611	return error;
4612	}
4613
4614	/**
4615	* device_move - moves a device to a new parent
4616	* @dev: the pointer to the struct device to be moved
4617	* @new_parent: the new parent of the device (can be NULL)
4618	* @dpm_order: how to reorder the dpm_list
4619	*/
4620	int device_move(struct device *dev, struct device *new_parent,
4621	enum dpm_order dpm_order)
4622	{
4623	int error;
4624	struct device *old_parent;
4625	struct kobject *new_parent_kobj;
4626
4627	dev = get_device(dev);
4628	if (!dev)
4629	return -EINVAL;
4630
4631	device_pm_lock();
4632	new_parent = get_device(new_parent);
4633	new_parent_kobj = get_device_parent(dev, parent: new_parent);
4634	if (IS_ERR(ptr: new_parent_kobj)) {
4635	error = PTR_ERR(ptr: new_parent_kobj);
4636	put_device(new_parent);
4637	goto out;
4638	}
4639
4640	pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
4641	__func__, new_parent ? dev_name(new_parent) : "<NULL>");
4642	error = kobject_move(&dev->kobj, new_parent_kobj);
4643	if (error) {
4644	cleanup_glue_dir(dev, glue_dir: new_parent_kobj);
4645	put_device(new_parent);
4646	goto out;
4647	}
4648	old_parent = dev->parent;
4649	dev->parent = new_parent;
4650	if (old_parent)
4651	klist_remove(n: &dev->p->knode_parent);
4652	if (new_parent) {
4653	klist_add_tail(n: &dev->p->knode_parent,
4654	k: &new_parent->p->klist_children);
4655	set_dev_node(dev, node: dev_to_node(dev: new_parent));
4656	}
4657
4658	if (dev->class) {
4659	error = device_move_class_links(dev, old_parent, new_parent);
4660	if (error) {
4661	/* We ignore errors on cleanup since we're hosed anyway... */
4662	device_move_class_links(dev, old_parent: new_parent, new_parent: old_parent);
4663	if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
4664	if (new_parent)
4665	klist_remove(n: &dev->p->knode_parent);
4666	dev->parent = old_parent;
4667	if (old_parent) {
4668	klist_add_tail(n: &dev->p->knode_parent,
4669	k: &old_parent->p->klist_children);
4670	set_dev_node(dev, node: dev_to_node(dev: old_parent));
4671	}
4672	}
4673	cleanup_glue_dir(dev, glue_dir: new_parent_kobj);
4674	put_device(new_parent);
4675	goto out;
4676	}
4677	}
4678	switch (dpm_order) {
4679	case DPM_ORDER_NONE:
4680	break;
4681	case DPM_ORDER_DEV_AFTER_PARENT:
4682	device_pm_move_after(dev, new_parent);
4683	devices_kset_move_after(deva: dev, devb: new_parent);
4684	break;
4685	case DPM_ORDER_PARENT_BEFORE_DEV:
4686	device_pm_move_before(new_parent, dev);
4687	devices_kset_move_before(deva: new_parent, devb: dev);
4688	break;
4689	case DPM_ORDER_DEV_LAST:
4690	device_pm_move_last(dev);
4691	devices_kset_move_last(dev);
4692	break;
4693	}
4694
4695	put_device(old_parent);
4696	out:
4697	device_pm_unlock();
4698	put_device(dev);
4699	return error;
4700	}
4701	EXPORT_SYMBOL_GPL(device_move);
4702
4703	static int device_attrs_change_owner(struct device *dev, kuid_t kuid,
4704	kgid_t kgid)
4705	{
4706	struct kobject *kobj = &dev->kobj;
4707	const struct class *class = dev->class;
4708	const struct device_type *type = dev->type;
4709	int error;
4710
4711	if (class) {
4712	/*
4713	* Change the device groups of the device class for @dev to
4714	* @kuid/@kgid.
4715	*/
4716	error = sysfs_groups_change_owner(kobj, groups: class->dev_groups, kuid,
4717	kgid);
4718	if (error)
4719	return error;
4720	}
4721
4722	if (type) {
4723	/*
4724	* Change the device groups of the device type for @dev to
4725	* @kuid/@kgid.
4726	*/
4727	error = sysfs_groups_change_owner(kobj, groups: type->groups, kuid,
4728	kgid);
4729	if (error)
4730	return error;
4731	}
4732
4733	/* Change the device groups of @dev to @kuid/@kgid. */
4734	error = sysfs_groups_change_owner(kobj, groups: dev->groups, kuid, kgid);
4735	if (error)
4736	return error;
4737
4738	if (device_supports_offline(dev) && !dev->offline_disabled) {
4739	/* Change online device attributes of @dev to @kuid/@kgid. */
4740	error = sysfs_file_change_owner(kobj, name: dev_attr_online.attr.name,
4741	kuid, kgid);
4742	if (error)
4743	return error;
4744	}
4745
4746	return 0;
4747	}
4748
4749	/**
4750	* device_change_owner - change the owner of an existing device.
4751	* @dev: device.
4752	* @kuid: new owner's kuid
4753	* @kgid: new owner's kgid
4754	*
4755	* This changes the owner of @dev and its corresponding sysfs entries to
4756	* @kuid/@kgid. This function closely mirrors how @dev was added via driver
4757	* core.
4758	*
4759	* Returns 0 on success or error code on failure.
4760	*/
4761	int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid)
4762	{
4763	int error;
4764	struct kobject *kobj = &dev->kobj;
4765	struct subsys_private *sp;
4766
4767	dev = get_device(dev);
4768	if (!dev)
4769	return -EINVAL;
4770
4771	/*
4772	* Change the kobject and the default attributes and groups of the
4773	* ktype associated with it to @kuid/@kgid.
4774	*/
4775	error = sysfs_change_owner(kobj, kuid, kgid);
4776	if (error)
4777	goto out;
4778
4779	/*
4780	* Change the uevent file for @dev to the new owner. The uevent file
4781	* was created in a separate step when @dev got added and we mirror
4782	* that step here.
4783	*/
4784	error = sysfs_file_change_owner(kobj, name: dev_attr_uevent.attr.name, kuid,
4785	kgid);
4786	if (error)
4787	goto out;
4788
4789	/*
4790	* Change the device groups, the device groups associated with the
4791	* device class, and the groups associated with the device type of @dev
4792	* to @kuid/@kgid.
4793	*/
4794	error = device_attrs_change_owner(dev, kuid, kgid);
4795	if (error)
4796	goto out;
4797
4798	error = dpm_sysfs_change_owner(dev, kuid, kgid);
4799	if (error)
4800	goto out;
4801
4802	/*
4803	* Change the owner of the symlink located in the class directory of
4804	* the device class associated with @dev which points to the actual
4805	* directory entry for @dev to @kuid/@kgid. This ensures that the
4806	* symlink shows the same permissions as its target.
4807	*/
4808	sp = class_to_subsys(class: dev->class);
4809	if (!sp) {
4810	error = -EINVAL;
4811	goto out;
4812	}
4813	error = sysfs_link_change_owner(kobj: &sp->subsys.kobj, targ: &dev->kobj, name: dev_name(dev), kuid, kgid);
4814	subsys_put(sp);
4815
4816	out:
4817	put_device(dev);
4818	return error;
4819	}
4820	EXPORT_SYMBOL_GPL(device_change_owner);
4821
4822	/**
4823	* device_shutdown - call ->shutdown() on each device to shutdown.
4824	*/
4825	void device_shutdown(void)
4826	{
4827	struct device *dev, *parent;
4828
4829	wait_for_device_probe();
4830	device_block_probing();
4831
4832	cpufreq_suspend();
4833
4834	spin_lock(lock: &devices_kset->list_lock);
4835	/*
4836	* Walk the devices list backward, shutting down each in turn.
4837	* Beware that device unplug events may also start pulling
4838	* devices offline, even as the system is shutting down.
4839	*/
4840	while (!list_empty(head: &devices_kset->list)) {
4841	dev = list_entry(devices_kset->list.prev, struct device,
4842	kobj.entry);
4843
4844	/*
4845	* hold reference count of device's parent to
4846	* prevent it from being freed because parent's
4847	* lock is to be held
4848	*/
4849	parent = get_device(dev->parent);
4850	get_device(dev);
4851	/*
4852	* Make sure the device is off the kset list, in the
4853	* event that dev->*->shutdown() doesn't remove it.
4854	*/
4855	list_del_init(entry: &dev->kobj.entry);
4856	spin_unlock(lock: &devices_kset->list_lock);
4857
4858	/* hold lock to avoid race with probe/release */
4859	if (parent)
4860	device_lock(dev: parent);
4861	device_lock(dev);
4862
4863	/* Don't allow any more runtime suspends */
4864	pm_runtime_get_noresume(dev);
4865	pm_runtime_barrier(dev);
4866
4867	if (dev->class && dev->class->shutdown_pre) {
4868	if (initcall_debug)
4869	dev_info(dev, "shutdown_pre\n");
4870	dev->class->shutdown_pre(dev);
4871	}
4872	if (dev->bus && dev->bus->shutdown) {
4873	if (initcall_debug)
4874	dev_info(dev, "shutdown\n");
4875	dev->bus->shutdown(dev);
4876	} else if (dev->driver && dev->driver->shutdown) {
4877	if (initcall_debug)
4878	dev_info(dev, "shutdown\n");
4879	dev->driver->shutdown(dev);
4880	}
4881
4882	device_unlock(dev);
4883	if (parent)
4884	device_unlock(dev: parent);
4885
4886	put_device(dev);
4887	put_device(parent);
4888
4889	spin_lock(lock: &devices_kset->list_lock);
4890	}
4891	spin_unlock(lock: &devices_kset->list_lock);
4892	}
4893
4894	/*
4895	* Device logging functions
4896	*/
4897
4898	#ifdef CONFIG_PRINTK
4899	static void
4900	set_dev_info(const struct device *dev, struct dev_printk_info *dev_info)
4901	{
4902	const char *subsys;
4903
4904	memset(dev_info, 0, sizeof(*dev_info));
4905
4906	if (dev->class)
4907	subsys = dev->class->name;
4908	else if (dev->bus)
4909	subsys = dev->bus->name;
4910	else
4911	return;
4912
4913	strscpy(dev_info->subsystem, subsys, sizeof(dev_info->subsystem));
4914
4915	/*
4916	* Add device identifier DEVICE=:
4917	* b12:8 block dev_t
4918	* c127:3 char dev_t
4919	* n8 netdev ifindex
4920	* +sound:card0 subsystem:devname
4921	*/
4922	if (MAJOR(dev->devt)) {
4923	char c;
4924
4925	if (strcmp(subsys, "block") == 0)
4926	c = 'b';
4927	else
4928	c = 'c';
4929
4930	snprintf(buf: dev_info->device, size: sizeof(dev_info->device),
4931	fmt: "%c%u:%u", c, MAJOR(dev->devt), MINOR(dev->devt));
4932	} else if (strcmp(subsys, "net") == 0) {
4933	struct net_device *net = to_net_dev(dev);
4934
4935	snprintf(buf: dev_info->device, size: sizeof(dev_info->device),
4936	fmt: "n%u", net->ifindex);
4937	} else {
4938	snprintf(buf: dev_info->device, size: sizeof(dev_info->device),
4939	fmt: "+%s:%s", subsys, dev_name(dev));
4940	}
4941	}
4942
4943	int dev_vprintk_emit(int level, const struct device *dev,
4944	const char *fmt, va_list args)
4945	{
4946	struct dev_printk_info dev_info;
4947
4948	set_dev_info(dev, dev_info: &dev_info);
4949
4950	return vprintk_emit(facility: 0, level, dev_info: &dev_info, fmt, args);
4951	}
4952	EXPORT_SYMBOL(dev_vprintk_emit);
4953
4954	int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
4955	{
4956	va_list args;
4957	int r;
4958
4959	va_start(args, fmt);
4960
4961	r = dev_vprintk_emit(level, dev, fmt, args);
4962
4963	va_end(args);
4964
4965	return r;
4966	}
4967	EXPORT_SYMBOL(dev_printk_emit);
4968
4969	static void __dev_printk(const char *level, const struct device *dev,
4970	struct va_format *vaf)
4971	{
4972	if (dev)
4973	dev_printk_emit(level[1] - '0', dev, "%s %s: %pV",
4974	dev_driver_string(dev), dev_name(dev), vaf);
4975	else
4976	printk("%s(NULL device *): %pV", level, vaf);
4977	}
4978
4979	void _dev_printk(const char *level, const struct device *dev,
4980	const char *fmt, ...)
4981	{
4982	struct va_format vaf;
4983	va_list args;
4984
4985	va_start(args, fmt);
4986
4987	vaf.fmt = fmt;
4988	vaf.va = &args;
4989
4990	__dev_printk(level, dev, vaf: &vaf);
4991
4992	va_end(args);
4993	}
4994	EXPORT_SYMBOL(_dev_printk);
4995
4996	#define define_dev_printk_level(func, kern_level) \
4997	void func(const struct device *dev, const char *fmt, ...) \
4998	{ \
4999	struct va_format vaf; \
5000	va_list args; \
5001	\
5002	va_start(args, fmt); \
5003	\
5004	vaf.fmt = fmt; \
5005	vaf.va = &args; \
5006	\
5007	__dev_printk(kern_level, dev, &vaf); \
5008	\
5009	va_end(args); \
5010	} \
5011	EXPORT_SYMBOL(func);
5012
5013	define_dev_printk_level(_dev_emerg, KERN_EMERG);
5014	define_dev_printk_level(_dev_alert, KERN_ALERT);
5015	define_dev_printk_level(_dev_crit, KERN_CRIT);
5016	define_dev_printk_level(_dev_err, KERN_ERR);
5017	define_dev_printk_level(_dev_warn, KERN_WARNING);
5018	define_dev_printk_level(_dev_notice, KERN_NOTICE);
5019	define_dev_printk_level(_dev_info, KERN_INFO);
5020
5021	#endif
5022
5023	/**
5024	* dev_err_probe - probe error check and log helper
5025	* @dev: the pointer to the struct device
5026	* @err: error value to test
5027	* @fmt: printf-style format string
5028	* @...: arguments as specified in the format string
5029	*
5030	* This helper implements common pattern present in probe functions for error
5031	* checking: print debug or error message depending if the error value is
5032	* -EPROBE_DEFER and propagate error upwards.
5033	* In case of -EPROBE_DEFER it sets also defer probe reason, which can be
5034	* checked later by reading devices_deferred debugfs attribute.
5035	* It replaces code sequence::
5036	*
5037	* if (err != -EPROBE_DEFER)
5038	* dev_err(dev, ...);
5039	* else
5040	* dev_dbg(dev, ...);
5041	* return err;
5042	*
5043	* with::
5044	*
5045	* return dev_err_probe(dev, err, ...);
5046	*
5047	* Using this helper in your probe function is totally fine even if @err is
5048	* known to never be -EPROBE_DEFER.
5049	* The benefit compared to a normal dev_err() is the standardized format
5050	* of the error code, it being emitted symbolically (i.e. you get "EAGAIN"
5051	* instead of "-35") and the fact that the error code is returned which allows
5052	* more compact error paths.
5053	*
5054	* Returns @err.
5055	*/
5056	int dev_err_probe(const struct device *dev, int err, const char *fmt, ...)
5057	{
5058	struct va_format vaf;
5059	va_list args;
5060
5061	va_start(args, fmt);
5062	vaf.fmt = fmt;
5063	vaf.va = &args;
5064
5065	if (err != -EPROBE_DEFER) {
5066	dev_err(dev, "error %pe: %pV", ERR_PTR(err), &vaf);
5067	} else {
5068	device_set_deferred_probe_reason(dev, vaf: &vaf);
5069	dev_dbg(dev, "error %pe: %pV", ERR_PTR(err), &vaf);
5070	}
5071
5072	va_end(args);
5073
5074	return err;
5075	}
5076	EXPORT_SYMBOL_GPL(dev_err_probe);
5077
5078	static inline bool fwnode_is_primary(struct fwnode_handle *fwnode)
5079	{
5080	return fwnode && !IS_ERR(ptr: fwnode->secondary);
5081	}
5082
5083	/**
5084	* set_primary_fwnode - Change the primary firmware node of a given device.
5085	* @dev: Device to handle.
5086	* @fwnode: New primary firmware node of the device.
5087	*
5088	* Set the device's firmware node pointer to @fwnode, but if a secondary
5089	* firmware node of the device is present, preserve it.
5090	*
5091	* Valid fwnode cases are:
5092	* - primary --> secondary --> -ENODEV
5093	* - primary --> NULL
5094	* - secondary --> -ENODEV
5095	* - NULL
5096	*/
5097	void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
5098	{
5099	struct device *parent = dev->parent;
5100	struct fwnode_handle *fn = dev->fwnode;
5101
5102	if (fwnode) {
5103	if (fwnode_is_primary(fwnode: fn))
5104	fn = fn->secondary;
5105
5106	if (fn) {
5107	WARN_ON(fwnode->secondary);
5108	fwnode->secondary = fn;
5109	}
5110	dev->fwnode = fwnode;
5111	} else {
5112	if (fwnode_is_primary(fwnode: fn)) {
5113	dev->fwnode = fn->secondary;
5114
5115	/* Skip nullifying fn->secondary if the primary is shared */
5116	if (parent && fn == parent->fwnode)
5117	return;
5118
5119	/* Set fn->secondary = NULL, so fn remains the primary fwnode */
5120	fn->secondary = NULL;
5121	} else {
5122	dev->fwnode = NULL;
5123	}
5124	}
5125	}
5126	EXPORT_SYMBOL_GPL(set_primary_fwnode);
5127
5128	/**
5129	* set_secondary_fwnode - Change the secondary firmware node of a given device.
5130	* @dev: Device to handle.
5131	* @fwnode: New secondary firmware node of the device.
5132	*
5133	* If a primary firmware node of the device is present, set its secondary
5134	* pointer to @fwnode. Otherwise, set the device's firmware node pointer to
5135	* @fwnode.
5136	*/
5137	void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
5138	{
5139	if (fwnode)
5140	fwnode->secondary = ERR_PTR(error: -ENODEV);
5141
5142	if (fwnode_is_primary(fwnode: dev->fwnode))
5143	dev->fwnode->secondary = fwnode;
5144	else
5145	dev->fwnode = fwnode;
5146	}
5147	EXPORT_SYMBOL_GPL(set_secondary_fwnode);
5148
5149	/**
5150	* device_set_of_node_from_dev - reuse device-tree node of another device
5151	* @dev: device whose device-tree node is being set
5152	* @dev2: device whose device-tree node is being reused
5153	*
5154	* Takes another reference to the new device-tree node after first dropping
5155	* any reference held to the old node.
5156	*/
5157	void device_set_of_node_from_dev(struct device *dev, const struct device *dev2)
5158	{
5159	of_node_put(node: dev->of_node);
5160	dev->of_node = of_node_get(node: dev2->of_node);
5161	dev->of_node_reused = true;
5162	}
5163	EXPORT_SYMBOL_GPL(device_set_of_node_from_dev);
5164
5165	void device_set_node(struct device *dev, struct fwnode_handle *fwnode)
5166	{
5167	dev->fwnode = fwnode;
5168	dev->of_node = to_of_node(fwnode);
5169	}
5170	EXPORT_SYMBOL_GPL(device_set_node);
5171
5172	int device_match_name(struct device *dev, const void *name)
5173	{
5174	return sysfs_streq(s1: dev_name(dev), s2: name);
5175	}
5176	EXPORT_SYMBOL_GPL(device_match_name);
5177
5178	int device_match_of_node(struct device *dev, const void *np)
5179	{
5180	return dev->of_node == np;
5181	}
5182	EXPORT_SYMBOL_GPL(device_match_of_node);
5183
5184	int device_match_fwnode(struct device *dev, const void *fwnode)
5185	{
5186	return dev_fwnode(dev) == fwnode;
5187	}
5188	EXPORT_SYMBOL_GPL(device_match_fwnode);
5189
5190	int device_match_devt(struct device *dev, const void *pdevt)
5191	{
5192	return dev->devt == *(dev_t *)pdevt;
5193	}
5194	EXPORT_SYMBOL_GPL(device_match_devt);
5195
5196	int device_match_acpi_dev(struct device *dev, const void *adev)
5197	{
5198	return ACPI_COMPANION(dev) == adev;
5199	}
5200	EXPORT_SYMBOL(device_match_acpi_dev);
5201
5202	int device_match_acpi_handle(struct device *dev, const void *handle)
5203	{
5204	return ACPI_HANDLE(dev) == handle;
5205	}
5206	EXPORT_SYMBOL(device_match_acpi_handle);
5207
5208	int device_match_any(struct device *dev, const void *unused)
5209	{
5210	return 1;
5211	}
5212	EXPORT_SYMBOL_GPL(device_match_any);
5213