xref: /linux/drivers/base/core.c (revision 4b911a9690d72641879ea6d13cce1de31d346d79)
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(sizeof(*link), GFP_KERNEL);
79 	if (!link)
80 		return -ENOMEM;
81 
82 	link->supplier = sup;
83 	INIT_LIST_HEAD(&link->s_hook);
84 	link->consumer = con;
85 	INIT_LIST_HEAD(&link->c_hook);
86 	link->flags = flags;
87 
88 	list_add(&link->s_hook, &sup->consumers);
89 	list_add(&link->c_hook, &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(&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(&link->s_hook);
118 	list_del(&link->c_hook);
119 	kfree(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(&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(&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(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(link->consumer, to, 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(fwnode, new_sup);
235 
236 	fwnode_for_each_available_child_node(fwnode, child)
237 		__fw_devlink_pickup_dangling_consumers(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(&device_links_lock);
251 }
252 
253 int device_links_read_lock(void) __acquires(&device_links_srcu)
254 {
255 	return srcu_read_lock(&device_links_srcu);
256 }
257 
258 void device_links_read_unlock(int idx) __releases(&device_links_srcu)
259 {
260 	srcu_read_unlock(&device_links_srcu, idx);
261 }
262 
263 int device_links_read_lock_held(void)
264 {
265 	return srcu_read_lock_held(&device_links_srcu);
266 }
267 
268 static void device_link_synchronize_removal(void)
269 {
270 	synchronize_srcu(&device_links_srcu);
271 }
272 
273 static void device_link_remove_from_lists(struct device_link *link)
274 {
275 	list_del_rcu(&link->s_node);
276 	list_del_rcu(&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, target, 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(link->flags))
324 			continue;
325 
326 		if (link->consumer == target)
327 			return 1;
328 
329 		ret = device_is_dependent(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, device_reorder_to_tail);
395 	list_for_each_entry(link, &dev->links.consumers, s_node) {
396 		if (device_link_flag_is_sync_state_only(link->flags))
397 			continue;
398 		device_reorder_to_tail(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, "%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, "%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, "%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, "%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(link->supplier);
521 
522 	pm_request_idle(link->supplier);
523 
524 	put_device(link->consumer);
525 	put_device(link->supplier);
526 	kfree(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(device_link_wq, &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(len, GFP_KERNEL);
577 	if (!buf)
578 		return -ENOMEM;
579 
580 	ret = sysfs_create_link(&link->link_dev.kobj, &sup->kobj, "supplier");
581 	if (ret)
582 		goto out;
583 
584 	ret = sysfs_create_link(&link->link_dev.kobj, &con->kobj, "consumer");
585 	if (ret)
586 		goto err_con;
587 
588 	snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con));
589 	ret = sysfs_create_link(&sup->kobj, &link->link_dev.kobj, buf);
590 	if (ret)
591 		goto err_con_dev;
592 
593 	snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup));
594 	ret = sysfs_create_link(&con->kobj, &link->link_dev.kobj, buf);
595 	if (ret)
596 		goto err_sup_dev;
597 
598 	goto out;
599 
600 err_sup_dev:
601 	snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con));
602 	sysfs_remove_link(&sup->kobj, buf);
603 err_con_dev:
604 	sysfs_remove_link(&link->link_dev.kobj, "consumer");
605 err_con:
606 	sysfs_remove_link(&link->link_dev.kobj, "supplier");
607 out:
608 	kfree(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(&link->link_dev.kobj, "consumer");
621 	sysfs_remove_link(&link->link_dev.kobj, "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(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(con)) {
634 		snprintf(buf, len, "supplier:%s:%s", dev_bus_name(sup), dev_name(sup));
635 		sysfs_remove_link(&con->kobj, buf);
636 	}
637 	snprintf(buf, len, "consumer:%s:%s", dev_bus_name(con), dev_name(con));
638 	sysfs_remove_link(&sup->kobj, buf);
639 	kfree(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(&devlink_class);
653 	if (ret)
654 		return ret;
655 
656 	ret = class_interface_register(&devlink_class_intf);
657 	if (ret)
658 		class_unregister(&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(supplier) < 0) {
745 			pm_runtime_put_noidle(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(supplier)
768 	    || (!(flags & DL_FLAG_SYNC_STATE_ONLY) &&
769 		  device_is_dependent(consumer, 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(consumer);
804 				link->flags |= DL_FLAG_PM_RUNTIME;
805 			}
806 			if (flags & DL_FLAG_RPM_ACTIVE)
807 				refcount_inc(&link->rpm_active);
808 		}
809 
810 		if (flags & DL_FLAG_STATELESS) {
811 			kref_get(&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(&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(sizeof(*link), GFP_KERNEL);
851 	if (!link)
852 		goto out;
853 
854 	refcount_set(&link->rpm_active, 1);
855 
856 	get_device(supplier);
857 	link->supplier = supplier;
858 	INIT_LIST_HEAD(&link->s_node);
859 	get_device(consumer);
860 	link->consumer = consumer;
861 	INIT_LIST_HEAD(&link->c_node);
862 	link->flags = flags;
863 	kref_init(&link->kref);
864 
865 	link->link_dev.class = &devlink_class;
866 	device_set_pm_not_required(&link->link_dev);
867 	dev_set_name(&link->link_dev, "%s:%s--%s:%s",
868 		     dev_bus_name(supplier), dev_name(supplier),
869 		     dev_bus_name(consumer), dev_name(consumer));
870 	if (device_register(&link->link_dev)) {
871 		put_device(&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(&link->rpm_active);
879 
880 		pm_runtime_new_link(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(supplier);
896 
897 	list_add_tail_rcu(&link->s_node, &supplier->links.consumers);
898 	list_add_tail_rcu(&link->c_node, &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(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(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(&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(&link->kref, __device_link_del);
947 	else if (!device_is_registered(link->consumer))
948 		__device_link_del(&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(dev->fwnode);
1065 	if (sup_fw) {
1066 		if (!dev_is_best_effort(dev)) {
1067 			fwnode_ret = -EPROBE_DEFER;
1068 			dev_err_probe(dev, -EPROBE_DEFER,
1069 				    "wait for supplier %pfwf\n", sup_fw);
1070 		} else {
1071 			fwnode_ret = -EAGAIN;
1072 		}
1073 	}
1074 	mutex_unlock(&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, -EPROBE_DEFER,
1096 				      "supplier %s not ready\n",
1097 				      dev_name(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(&dev->links.defer_sync, 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(&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(&dev->links.defer_sync);
1216 		__device_links_queue_sync_state(dev, &sync_list);
1217 	}
1218 out:
1219 	device_links_write_unlock();
1220 
1221 	device_links_flush_sync_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(&sup->links.defer_sync) && dev_has_sync_state(sup))
1234 		list_add_tail(&sup->links.defer_sync, &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(&link->kref, __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(dev->fwnode);
1253 	mutex_unlock(&fwnode_link_lock);
1254 	device_unlock(dev);
1255 	return sysfs_emit(buf, "%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(dev->fwnode);
1327 		mutex_lock(&fwnode_link_lock);
1328 		fwnode_for_each_available_child_node(dev->fwnode, child)
1329 			__fw_devlink_pickup_dangling_consumers(child,
1330 							       dev->fwnode);
1331 		__fw_devlink_link_to_consumers(dev);
1332 		mutex_unlock(&fwnode_link_lock);
1333 	}
1334 	device_remove_file(dev, &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(link->consumer);
1357 	}
1358 
1359 	if (defer_sync_state_count)
1360 		__device_links_supplier_defer_sync(dev);
1361 	else
1362 		__device_links_queue_sync_state(dev, &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(supplier);
1403 		else
1404 			__device_links_queue_sync_state(supplier, &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(&sync_list, 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(&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(consumer);
1612 
1613 			device_links_write_unlock();
1614 
1615 			device_release_driver_internal(consumer, NULL,
1616 						       consumer->parent);
1617 			put_device(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(&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(&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(arg, &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(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(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(&devlink_class, NULL, NULL,
1780 			      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(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(&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(sup);
1806 	list_add_tail(&sup->links.defer_sync, 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(&devlink_class, NULL, &sync_list,
1817 			      fw_devlink_dev_sync_state);
1818 	device_links_write_unlock();
1819 	device_links_flush_sync_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(parent)) {
1914 			fwnode_handle_put(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(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(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(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, 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(sup_dev->parent);
2055 	else
2056 		par_dev = fwnode_get_next_parent_dev(sup_handle);
2057 
2058 	if (par_dev && __fw_devlink_relax_cycles(con, 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(dev_link->flags) &&
2073 		    !(dev_link->flags & DL_FLAG_CYCLE))
2074 			continue;
2075 
2076 		if (__fw_devlink_relax_cycles(con,
2077 					      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(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(sup_dev);
2089 	put_device(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(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(sup_handle, 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(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(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(sup_handle) ||
2203 	    fwnode_ancestor_init_without_drv(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(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(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(con_dev->fwnode, fwnode)) {
2262 				put_device(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_dev, fwnode, link);
2273 		put_device(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(dev, 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, 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(&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(&device_hotplug_lock);
2369 }
2370 
2371 int lock_device_hotplug_sysfs(void)
2372 {
2373 	if (mutex_trylock(&device_hotplug_lock))
2374 		return 0;
2375 
2376 	/* Avoid busy looping (5 ms of sleep should do). */
2377 	msleep(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(buf, 0, &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, "%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(buf, 0, &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, "%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(buf, 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, "%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(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(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, "MAJOR=%u", MAJOR(dev->devt));
2653 		add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
2654 		name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
2655 		if (name) {
2656 			add_uevent_var(env, "DEVNAME=%s", name);
2657 			if (mode)
2658 				add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
2659 			if (!uid_eq(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(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, len, "%s\n", env->envp[i]);
2749 out:
2750 	kfree(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(&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, "%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(buf, &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, "%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(&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(&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(&dev->kobj, 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(&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(&dev->kobj, grp);
2877 	if (error) {
2878 		devres_free(devres);
2879 		return error;
2880 	}
2881 
2882 	devres->group = grp;
2883 	devres_add(dev, 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(&dev->kobj, groups);
2913 	if (error) {
2914 		devres_free(devres);
2915 		return error;
2916 	}
2917 
2918 	devres->groups = groups;
2919 	devres_add(dev, 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(dev, &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(dev, &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(dev, &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 			&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, &dev_attr_removable);
2975  err_remove_dev_waiting_for_supplier:
2976 	device_remove_file(dev, &dev_attr_waiting_for_supplier);
2977  err_remove_dev_online:
2978 	device_remove_file(dev, &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, &dev_attr_physical_location_group);
2998 		kfree(dev->physical_location);
2999 	}
3000 
3001 	device_remove_file(dev, &dev_attr_removable);
3002 	device_remove_file(dev, &dev_attr_waiting_for_supplier);
3003 	device_remove_file(dev, &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(&devices_kset->list_lock);
3035 	list_move_tail(&deva->kobj.entry, &devb->kobj.entry);
3036 	spin_unlock(&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(&devices_kset->list_lock);
3051 	list_move(&deva->kobj.entry, &devb->kobj.entry);
3052 	spin_unlock(&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(&devices_kset->list_lock);
3065 	list_move_tail(&dev->kobj.entry, &devices_kset->list);
3066 	spin_unlock(&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(&dev->kobj, &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(&dev->kobj, &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(&dev->kobj, &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(&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(&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(&dev->kobj, &device_ktype);
3191 	INIT_LIST_HEAD(&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(&dev->devres_head);
3196 	device_pm_init(dev);
3197 	set_dev_node(dev, NUMA_NO_NODE);
3198 	INIT_LIST_HEAD(&dev->links.consumers);
3199 	INIT_LIST_HEAD(&dev->links.suppliers);
3200 	INIT_LIST_HEAD(&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("virtual",
3217 						     &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(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(sizeof(*dir), GFP_KERNEL);
3255 	if (!dir)
3256 		return ERR_PTR(-ENOMEM);
3257 
3258 	dir->class = sp->class;
3259 	kobject_init(&dir->kobj, &class_dir_ktype);
3260 
3261 	dir->kobj.kset = &sp->glue_dirs;
3262 
3263 	retval = kobject_add(&dir->kobj, parent_kobj, "%s", sp->class->name);
3264 	if (retval < 0) {
3265 		kobject_put(&dir->kobj);
3266 		return ERR_PTR(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(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(&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(k);
3304 				break;
3305 			}
3306 		spin_unlock(&sp->glue_dirs.list_lock);
3307 		if (kobj) {
3308 			mutex_unlock(&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(&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(dev->bus);
3324 
3325 		if (dev_root) {
3326 			kobj = &dev_root->kobj;
3327 			put_device(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(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(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(&glue_dir->kref);
3444 	if (!kobject_has_children(glue_dir) && !--ref)
3445 		kobject_del(glue_dir);
3446 	kobject_put(glue_dir);
3447 	mutex_unlock(&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(&dev->kobj, of_node_kobj(of_node), "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(dev->class);
3464 	if (!sp)
3465 		return 0;
3466 
3467 	error = sysfs_create_link(&dev->kobj, &sp->subsys.kobj, "subsystem");
3468 	if (error)
3469 		goto out_devnode;
3470 
3471 	if (dev->parent && device_is_not_partition(dev)) {
3472 		error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
3473 					  "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(&sp->subsys.kobj, &dev->kobj, dev_name(dev));
3480 	if (error)
3481 		goto out_device;
3482 	goto exit;
3483 
3484 out_device:
3485 	sysfs_remove_link(&dev->kobj, "device");
3486 out_subsys:
3487 	sysfs_remove_link(&dev->kobj, "subsystem");
3488 out_devnode:
3489 	sysfs_remove_link(&dev->kobj, "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(dev->class);
3498 
3499 	if (dev_of_node(dev))
3500 		sysfs_remove_link(&dev->kobj, "of_node");
3501 
3502 	if (!sp)
3503 		return;
3504 
3505 	if (dev->parent && device_is_not_partition(dev))
3506 		sysfs_remove_link(&dev->kobj, "device");
3507 	sysfs_remove_link(&dev->kobj, "subsystem");
3508 	sysfs_delete_link(&sp->subsys.kobj, &dev->kobj, 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(&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, &dev->kobj, 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, devt_str);
3560 	}
3561 }
3562 
3563 static int device_private_init(struct device *dev)
3564 {
3565 	dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
3566 	if (!dev->p)
3567 		return -ENOMEM;
3568 	dev->p->device = dev;
3569 	klist_init(&dev->p->klist_children, klist_children_get,
3570 		   klist_children_put);
3571 	INIT_LIST_HEAD(&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->parent);
3644 	kobj = get_device_parent(dev, parent);
3645 	if (IS_ERR(kobj)) {
3646 		error = PTR_ERR(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, dev_to_node(parent));
3655 
3656 	/* first, register with generic layer. */
3657 	/* we require the name to be set before, and pass NULL */
3658 	error = kobject_add(&dev->kobj, 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, BUS_NOTIFY_ADD_DEVICE);
3701 	kobject_uevent(&dev->kobj, 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(&dev->p->knode_parent,
3732 			       &parent->p->klist_children);
3733 
3734 	sp = class_to_subsys(dev->class);
3735 	if (sp) {
3736 		mutex_lock(&sp->mutex);
3737 		/* tie the class to the device */
3738 		klist_add_tail(&dev->p->knode_class, &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(&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(&dev->kobj, KOBJ_REMOVE);
3768 	glue_dir = get_glue_dir(dev);
3769 	kobject_del(&dev->kobj);
3770  Error:
3771 	cleanup_glue_dir(dev, glue_dir);
3772 parent_error:
3773 	put_device(parent);
3774 name_error:
3775 	kfree(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(&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, BUS_NOTIFY_DEL_DEVICE);
3883 
3884 	dpm_sysfs_remove(dev);
3885 	if (parent)
3886 		klist_del(&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(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(&dev->p->knode_class);
3904 		mutex_unlock(&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, BUS_NOTIFY_REMOVED_DEVICE);
3927 	kobject_uevent(&dev->kobj, KOBJ_REMOVE);
3928 	glue_dir = get_glue_dir(dev);
3929 	kobject_del(&dev->kobj);
3930 	cleanup_glue_dir(dev, glue_dir);
3931 	memalloc_noio_restore(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(dev_name(dev), '!', '/', 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(&parent->p->klist_children, &i);
4048 	while (!error && (child = next_device(&i)))
4049 		error = fn(child, data);
4050 	klist_iter_exit(&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(&parent->p->klist_children, &i);
4078 	while ((child = prev_device(&i)) && !error)
4079 		error = fn(child, data);
4080 	klist_iter_exit(&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(&parent->p->klist_children, &i);
4112 	while ((child = next_device(&i)))
4113 		if (match(child, data) && get_device(child))
4114 			break;
4115 	klist_iter_exit(&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(&parent->p->klist_children, &i);
4140 	while ((child = next_device(&i)))
4141 		if (sysfs_streq(dev_name(child), name) && get_device(child))
4142 			break;
4143 	klist_iter_exit(&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("devices", &device_uevent_ops, NULL);
4171 	if (!devices_kset)
4172 		return -ENOMEM;
4173 	dev_kobj = kobject_create_and_add("dev", NULL);
4174 	if (!dev_kobj)
4175 		goto dev_kobj_err;
4176 	sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
4177 	if (!sysfs_dev_block_kobj)
4178 		goto block_kobj_err;
4179 	sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
4180 	if (!sysfs_dev_char_kobj)
4181 		goto char_kobj_err;
4182 	device_link_wq = alloc_workqueue("device_link_wq", 0, 0);
4183 	if (!device_link_wq)
4184 		goto wq_err;
4185 
4186 	return 0;
4187 
4188  wq_err:
4189 	kobject_put(sysfs_dev_char_kobj);
4190  char_kobj_err:
4191 	kobject_put(sysfs_dev_block_kobj);
4192  block_kobj_err:
4193 	kobject_put(dev_kobj);
4194  dev_kobj_err:
4195 	kset_unregister(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(&dev->kobj, 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(&dev->kobj, 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(to_root_device(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(sizeof(struct root_device), GFP_KERNEL);
4323 	if (!root)
4324 		return ERR_PTR(err);
4325 
4326 	err = dev_set_name(&root->dev, "%s", name);
4327 	if (err) {
4328 		kfree(root);
4329 		return ERR_PTR(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(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(&root->dev.kobj, &mk->kobj, "module");
4345 		if (err) {
4346 			device_unregister(&root->dev);
4347 			return ERR_PTR(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(dev);
4367 
4368 	if (root->owner)
4369 		sysfs_remove_link(&root->dev.kobj, "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(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(class))
4392 		goto error;
4393 
4394 	dev = kzalloc(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, drvdata);
4407 
4408 	retval = kobject_set_name_vargs(&dev->kobj, fmt, 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(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, 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, 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(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(dev->class);
4574 
4575 		if (!sp) {
4576 			error = -EINVAL;
4577 			goto out;
4578 		}
4579 
4580 		error = sysfs_rename_link_ns(&sp->subsys.kobj, kobj, old_device_name,
4581 					     new_name, 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(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(&dev->kobj, "device");
4608 	if (new_parent)
4609 		error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
4610 					  "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, new_parent);
4634 	if (IS_ERR(new_parent_kobj)) {
4635 		error = PTR_ERR(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, 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(&dev->p->knode_parent);
4652 	if (new_parent) {
4653 		klist_add_tail(&dev->p->knode_parent,
4654 			       &new_parent->p->klist_children);
4655 		set_dev_node(dev, dev_to_node(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, new_parent, old_parent);
4663 			if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
4664 				if (new_parent)
4665 					klist_remove(&dev->p->knode_parent);
4666 				dev->parent = old_parent;
4667 				if (old_parent) {
4668 					klist_add_tail(&dev->p->knode_parent,
4669 						       &old_parent->p->klist_children);
4670 					set_dev_node(dev, dev_to_node(old_parent));
4671 				}
4672 			}
4673 			cleanup_glue_dir(dev, 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(dev, new_parent);
4684 		break;
4685 	case DPM_ORDER_PARENT_BEFORE_DEV:
4686 		device_pm_move_before(new_parent, dev);
4687 		devices_kset_move_before(new_parent, 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, 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, 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, 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, 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, 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(dev->class);
4809 	if (!sp) {
4810 		error = -EINVAL;
4811 		goto out;
4812 	}
4813 	error = sysfs_link_change_owner(&sp->subsys.kobj, &dev->kobj, 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(&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(&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(&dev->kobj.entry);
4856 		spin_unlock(&devices_kset->list_lock);
4857 
4858 		/* hold lock to avoid race with probe/release */
4859 		if (parent)
4860 			device_lock(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(parent);
4885 
4886 		put_device(dev);
4887 		put_device(parent);
4888 
4889 		spin_lock(&devices_kset->list_lock);
4890 	}
4891 	spin_unlock(&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(dev_info->device, sizeof(dev_info->device),
4931 			 "%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(dev_info->device, sizeof(dev_info->device),
4936 			 "n%u", net->ifindex);
4937 	} else {
4938 		snprintf(dev_info->device, sizeof(dev_info->device),
4939 			 "+%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);
4949 
4950 	return vprintk_emit(0, level, &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);
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);
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(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(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(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(-ENODEV);
5141 
5142 	if (fwnode_is_primary(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(dev->of_node);
5160 	dev->of_node = of_node_get(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(dev_name(dev), 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