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