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