1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Device manager
4 *
5 * Copyright (c) 2013 Google, Inc
6 *
7 * (C) Copyright 2012
8 * Pavel Herrmann <morpheus.ibis@gmail.com>
9 */
10
11 #include <common.h>
12 #include <cpu_func.h>
13 #include <event.h>
14 #include <log.h>
15 #include <asm/global_data.h>
16 #include <asm/io.h>
17 #include <clk.h>
18 #include <fdtdec.h>
19 #include <fdt_support.h>
20 #include <malloc.h>
21 #include <asm/cache.h>
22 #include <dm/device.h>
23 #include <dm/device-internal.h>
24 #include <dm/lists.h>
25 #include <dm/of_access.h>
26 #include <dm/pinctrl.h>
27 #include <dm/platdata.h>
28 #include <dm/read.h>
29 #include <dm/uclass.h>
30 #include <dm/uclass-internal.h>
31 #include <dm/util.h>
32 #include <iommu.h>
33 #include <linux/err.h>
34 #include <linux/list.h>
35 #include <power-domain.h>
36
37 DECLARE_GLOBAL_DATA_PTR;
38
device_bind_common(struct udevice * parent,const struct driver * drv,const char * name,void * plat,ulong driver_data,ofnode node,uint of_plat_size,struct udevice ** devp)39 static int device_bind_common(struct udevice *parent, const struct driver *drv,
40 const char *name, void *plat,
41 ulong driver_data, ofnode node,
42 uint of_plat_size, struct udevice **devp)
43 {
44 struct udevice *dev;
45 struct uclass *uc;
46 int size, ret = 0;
47 bool auto_seq = true;
48 void *ptr;
49
50 if (CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND))
51 return -ENOSYS;
52
53 if (devp)
54 *devp = NULL;
55 if (!name)
56 return -EINVAL;
57
58 ret = uclass_get(drv->id, &uc);
59 if (ret) {
60 debug("Missing uclass for driver %s\n", drv->name);
61 return ret;
62 }
63
64 dev = calloc(1, sizeof(struct udevice));
65 if (!dev)
66 return -ENOMEM;
67
68 INIT_LIST_HEAD(&dev->sibling_node);
69 INIT_LIST_HEAD(&dev->child_head);
70 INIT_LIST_HEAD(&dev->uclass_node);
71 #if CONFIG_IS_ENABLED(DEVRES)
72 INIT_LIST_HEAD(&dev->devres_head);
73 #endif
74 dev_set_plat(dev, plat);
75 dev->driver_data = driver_data;
76 dev->name = name;
77 dev_set_ofnode(dev, node);
78 dev->parent = parent;
79 dev->driver = drv;
80 dev->uclass = uc;
81
82 dev->seq_ = -1;
83 if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
84 (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) {
85 /*
86 * Some devices, such as a SPI bus, I2C bus and serial ports
87 * are numbered using aliases.
88 */
89 if (CONFIG_IS_ENABLED(OF_CONTROL) &&
90 !CONFIG_IS_ENABLED(OF_PLATDATA)) {
91 if (uc->uc_drv->name && ofnode_valid(node)) {
92 if (!dev_read_alias_seq(dev, &dev->seq_)) {
93 auto_seq = false;
94 log_debug(" - seq=%d\n", dev->seq_);
95 }
96 }
97 }
98 }
99 if (auto_seq && !(uc->uc_drv->flags & DM_UC_FLAG_NO_AUTO_SEQ))
100 dev->seq_ = uclass_find_next_free_seq(uc);
101
102 /* Check if we need to allocate plat */
103 if (drv->plat_auto) {
104 bool alloc = !plat;
105
106 /*
107 * For of-platdata, we try use the existing data, but if
108 * plat_auto is larger, we must allocate a new space
109 */
110 if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
111 if (of_plat_size)
112 dev_or_flags(dev, DM_FLAG_OF_PLATDATA);
113 if (of_plat_size < drv->plat_auto)
114 alloc = true;
115 }
116 if (alloc) {
117 dev_or_flags(dev, DM_FLAG_ALLOC_PDATA);
118 ptr = calloc(1, drv->plat_auto);
119 if (!ptr) {
120 ret = -ENOMEM;
121 goto fail_alloc1;
122 }
123
124 /*
125 * For of-platdata, copy the old plat into the new
126 * space
127 */
128 if (CONFIG_IS_ENABLED(OF_PLATDATA) && plat)
129 memcpy(ptr, plat, of_plat_size);
130 dev_set_plat(dev, ptr);
131 }
132 }
133
134 size = uc->uc_drv->per_device_plat_auto;
135 if (size) {
136 dev_or_flags(dev, DM_FLAG_ALLOC_UCLASS_PDATA);
137 ptr = calloc(1, size);
138 if (!ptr) {
139 ret = -ENOMEM;
140 goto fail_alloc2;
141 }
142 dev_set_uclass_plat(dev, ptr);
143 }
144
145 if (parent) {
146 size = parent->driver->per_child_plat_auto;
147 if (!size)
148 size = parent->uclass->uc_drv->per_child_plat_auto;
149 if (size) {
150 dev_or_flags(dev, DM_FLAG_ALLOC_PARENT_PDATA);
151 ptr = calloc(1, size);
152 if (!ptr) {
153 ret = -ENOMEM;
154 goto fail_alloc3;
155 }
156 dev_set_parent_plat(dev, ptr);
157 }
158 /* put dev into parent's successor list */
159 list_add_tail(&dev->sibling_node, &parent->child_head);
160 }
161
162 ret = uclass_bind_device(dev);
163 if (ret)
164 goto fail_uclass_bind;
165
166 /* if we fail to bind we remove device from successors and free it */
167 if (drv->bind) {
168 ret = drv->bind(dev);
169 if (ret)
170 goto fail_bind;
171 }
172 if (parent && parent->driver->child_post_bind) {
173 ret = parent->driver->child_post_bind(dev);
174 if (ret)
175 goto fail_child_post_bind;
176 }
177 if (uc->uc_drv->post_bind) {
178 ret = uc->uc_drv->post_bind(dev);
179 if (ret)
180 goto fail_uclass_post_bind;
181 }
182
183 if (parent)
184 pr_debug("Bound device %s to %s\n", dev->name, parent->name);
185 if (devp)
186 *devp = dev;
187
188 dev_or_flags(dev, DM_FLAG_BOUND);
189
190 return 0;
191
192 fail_uclass_post_bind:
193 /* There is no child unbind() method, so no clean-up required */
194 fail_child_post_bind:
195 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
196 if (drv->unbind && drv->unbind(dev)) {
197 dm_warn("unbind() method failed on dev '%s' on error path\n",
198 dev->name);
199 }
200 }
201
202 fail_bind:
203 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
204 if (uclass_unbind_device(dev)) {
205 dm_warn("Failed to unbind dev '%s' on error path\n",
206 dev->name);
207 }
208 }
209 fail_uclass_bind:
210 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
211 list_del(&dev->sibling_node);
212 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) {
213 free(dev_get_parent_plat(dev));
214 dev_set_parent_plat(dev, NULL);
215 }
216 }
217 fail_alloc3:
218 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
219 if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) {
220 free(dev_get_uclass_plat(dev));
221 dev_set_uclass_plat(dev, NULL);
222 }
223 }
224 fail_alloc2:
225 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
226 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) {
227 free(dev_get_plat(dev));
228 dev_set_plat(dev, NULL);
229 }
230 }
231 fail_alloc1:
232 devres_release_all(dev);
233
234 free(dev);
235
236 return ret;
237 }
238
device_bind_with_driver_data(struct udevice * parent,const struct driver * drv,const char * name,ulong driver_data,ofnode node,struct udevice ** devp)239 int device_bind_with_driver_data(struct udevice *parent,
240 const struct driver *drv, const char *name,
241 ulong driver_data, ofnode node,
242 struct udevice **devp)
243 {
244 return device_bind_common(parent, drv, name, NULL, driver_data, node,
245 0, devp);
246 }
247
device_bind(struct udevice * parent,const struct driver * drv,const char * name,void * plat,ofnode node,struct udevice ** devp)248 int device_bind(struct udevice *parent, const struct driver *drv,
249 const char *name, void *plat, ofnode node,
250 struct udevice **devp)
251 {
252 return device_bind_common(parent, drv, name, plat, 0, node, 0,
253 devp);
254 }
255
device_bind_by_name(struct udevice * parent,bool pre_reloc_only,const struct driver_info * info,struct udevice ** devp)256 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
257 const struct driver_info *info, struct udevice **devp)
258 {
259 struct driver *drv;
260 uint plat_size = 0;
261 int ret;
262
263 drv = lists_driver_lookup_name(info->name);
264 if (!drv)
265 return -ENOENT;
266 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
267 return -EPERM;
268
269 #if CONFIG_IS_ENABLED(OF_PLATDATA)
270 plat_size = info->plat_size;
271 #endif
272 ret = device_bind_common(parent, drv, info->name, (void *)info->plat, 0,
273 ofnode_null(), plat_size, devp);
274 if (ret)
275 return ret;
276
277 return ret;
278 }
279
device_reparent(struct udevice * dev,struct udevice * new_parent)280 int device_reparent(struct udevice *dev, struct udevice *new_parent)
281 {
282 struct udevice *pos, *n;
283
284 assert(dev);
285 assert(new_parent);
286
287 device_foreach_child_safe(pos, n, dev->parent) {
288 if (pos->driver != dev->driver)
289 continue;
290
291 list_del(&dev->sibling_node);
292 list_add_tail(&dev->sibling_node, &new_parent->child_head);
293 dev->parent = new_parent;
294
295 break;
296 }
297
298 return 0;
299 }
300
alloc_priv(int size,uint flags)301 static void *alloc_priv(int size, uint flags)
302 {
303 void *priv;
304
305 if (flags & DM_FLAG_ALLOC_PRIV_DMA) {
306 size = ROUND(size, ARCH_DMA_MINALIGN);
307 priv = memalign(ARCH_DMA_MINALIGN, size);
308 if (priv) {
309 memset(priv, '\0', size);
310
311 /*
312 * Ensure that the zero bytes are flushed to memory.
313 * This prevents problems if the driver uses this as
314 * both an input and an output buffer:
315 *
316 * 1. Zeroes written to buffer (here) and sit in the
317 * cache
318 * 2. Driver issues a read command to DMA
319 * 3. CPU runs out of cache space and evicts some cache
320 * data in the buffer, writing zeroes to RAM from
321 * the memset() above
322 * 4. DMA completes
323 * 5. Buffer now has some DMA data and some zeroes
324 * 6. Data being read is now incorrect
325 *
326 * To prevent this, ensure that the cache is clean
327 * within this range at the start. The driver can then
328 * use normal flush-after-write, invalidate-before-read
329 * procedures.
330 */
331 flush_dcache_range((ulong)priv, (ulong)priv + size);
332 }
333 } else {
334 priv = calloc(1, size);
335 }
336
337 return priv;
338 }
339
340 /**
341 * device_alloc_priv() - Allocate priv/plat data required by the device
342 *
343 * @dev: Device to process
344 * Return: 0 if OK, -ENOMEM if out of memory
345 */
device_alloc_priv(struct udevice * dev)346 static int device_alloc_priv(struct udevice *dev)
347 {
348 const struct driver *drv;
349 void *ptr;
350 int size;
351
352 drv = dev->driver;
353 assert(drv);
354
355 /* Allocate private data if requested and not reentered */
356 if (drv->priv_auto && !dev_get_priv(dev)) {
357 ptr = alloc_priv(drv->priv_auto, drv->flags);
358 if (!ptr)
359 return -ENOMEM;
360 dev_set_priv(dev, ptr);
361 }
362
363 /* Allocate private data if requested and not reentered */
364 size = dev->uclass->uc_drv->per_device_auto;
365 if (size && !dev_get_uclass_priv(dev)) {
366 ptr = alloc_priv(size, dev->uclass->uc_drv->flags);
367 if (!ptr)
368 return -ENOMEM;
369 dev_set_uclass_priv(dev, ptr);
370 }
371
372 /* Allocate parent data for this child */
373 if (dev->parent) {
374 size = dev->parent->driver->per_child_auto;
375 if (!size)
376 size = dev->parent->uclass->uc_drv->per_child_auto;
377 if (size && !dev_get_parent_priv(dev)) {
378 ptr = alloc_priv(size, drv->flags);
379 if (!ptr)
380 return -ENOMEM;
381 dev_set_parent_priv(dev, ptr);
382 }
383 }
384
385 return 0;
386 }
387
device_of_to_plat(struct udevice * dev)388 int device_of_to_plat(struct udevice *dev)
389 {
390 const struct driver *drv;
391 int ret;
392
393 if (!dev)
394 return -EINVAL;
395
396 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
397 return 0;
398
399 /*
400 * This is not needed if binding is disabled, since data is allocated
401 * at build time.
402 */
403 if (!CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND)) {
404 /* Ensure all parents have ofdata */
405 if (dev->parent) {
406 ret = device_of_to_plat(dev->parent);
407 if (ret)
408 goto fail;
409
410 /*
411 * The device might have already been probed during
412 * the call to device_probe() on its parent device
413 * (e.g. PCI bridge devices). Test the flags again
414 * so that we don't mess up the device.
415 */
416 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
417 return 0;
418 }
419
420 ret = device_alloc_priv(dev);
421 if (ret)
422 goto fail;
423 }
424 drv = dev->driver;
425 assert(drv);
426
427 if (drv->of_to_plat &&
428 (CONFIG_IS_ENABLED(OF_PLATDATA) || dev_has_ofnode(dev))) {
429 ret = drv->of_to_plat(dev);
430 if (ret)
431 goto fail;
432 }
433
434 dev_or_flags(dev, DM_FLAG_PLATDATA_VALID);
435
436 return 0;
437 fail:
438 device_free(dev);
439
440 return ret;
441 }
442
443 /**
444 * device_get_dma_constraints() - Populate device's DMA constraints
445 *
446 * Gets a device's DMA constraints from firmware. This information is later
447 * used by drivers to translate physcal addresses to the device's bus address
448 * space. For now only device-tree is supported.
449 *
450 * @dev: Pointer to target device
451 * Return: 0 if OK or if no DMA constraints were found, error otherwise
452 */
device_get_dma_constraints(struct udevice * dev)453 static int device_get_dma_constraints(struct udevice *dev)
454 {
455 struct udevice *parent = dev->parent;
456 phys_addr_t cpu = 0;
457 dma_addr_t bus = 0;
458 u64 size = 0;
459 int ret;
460
461 if (!CONFIG_IS_ENABLED(DM_DMA) || !parent || !dev_has_ofnode(parent))
462 return 0;
463
464 /*
465 * We start parsing for dma-ranges from the device's bus node. This is
466 * specially important on nested buses.
467 */
468 ret = dev_get_dma_range(parent, &cpu, &bus, &size);
469 /* Don't return an error if no 'dma-ranges' were found */
470 if (ret && ret != -ENOENT) {
471 dm_warn("%s: failed to get DMA range, %d\n", dev->name, ret);
472 return ret;
473 }
474
475 dev_set_dma_offset(dev, cpu - bus);
476
477 return 0;
478 }
479
device_probe(struct udevice * dev)480 int device_probe(struct udevice *dev)
481 {
482 const struct driver *drv;
483 int ret;
484
485 if (!dev)
486 return -EINVAL;
487
488 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
489 return 0;
490
491 ret = device_notify(dev, EVT_DM_PRE_PROBE);
492 if (ret)
493 return ret;
494
495 drv = dev->driver;
496 assert(drv);
497
498 ret = device_of_to_plat(dev);
499 if (ret)
500 goto fail;
501
502 /* Ensure all parents are probed */
503 if (dev->parent) {
504 ret = device_probe(dev->parent);
505 if (ret)
506 goto fail;
507
508 /*
509 * The device might have already been probed during
510 * the call to device_probe() on its parent device
511 * (e.g. PCI bridge devices). Test the flags again
512 * so that we don't mess up the device.
513 */
514 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
515 return 0;
516 }
517
518 dev_or_flags(dev, DM_FLAG_ACTIVATED);
519
520 if (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent &&
521 (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) &&
522 !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) {
523 ret = dev_power_domain_on(dev);
524 if (ret)
525 goto fail;
526 }
527
528 /*
529 * Process pinctrl for everything except the root device, and
530 * continue regardless of the result of pinctrl. Don't process pinctrl
531 * settings for pinctrl devices since the device may not yet be
532 * probed.
533 *
534 * This call can produce some non-intuitive results. For example, on an
535 * x86 device where dev is the main PCI bus, the pinctrl device may be
536 * child or grandchild of that bus, meaning that the child will be
537 * probed here. If the child happens to be the P2SB and the pinctrl
538 * device is a child of that, then both the pinctrl and P2SB will be
539 * probed by this call. This works because the DM_FLAG_ACTIVATED flag
540 * is set just above. However, the PCI bus' probe() method and
541 * associated uclass methods have not yet been called.
542 */
543 if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL) {
544 ret = pinctrl_select_state(dev, "default");
545 if (ret && ret != -ENOSYS)
546 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n",
547 dev->name, ret, errno_str(ret));
548 }
549
550 if (CONFIG_IS_ENABLED(IOMMU) && dev->parent &&
551 (device_get_uclass_id(dev) != UCLASS_IOMMU)) {
552 ret = dev_iommu_enable(dev);
553 if (ret)
554 goto fail;
555 }
556
557 ret = device_get_dma_constraints(dev);
558 if (ret)
559 goto fail;
560
561 ret = uclass_pre_probe_device(dev);
562 if (ret)
563 goto fail;
564
565 if (dev->parent && dev->parent->driver->child_pre_probe) {
566 ret = dev->parent->driver->child_pre_probe(dev);
567 if (ret)
568 goto fail;
569 }
570
571 /* Only handle devices that have a valid ofnode */
572 if (dev_has_ofnode(dev)) {
573 /*
574 * Process 'assigned-{clocks/clock-parents/clock-rates}'
575 * properties
576 */
577 ret = clk_set_defaults(dev, CLK_DEFAULTS_PRE);
578 if (ret)
579 goto fail;
580 }
581
582 if (drv->probe) {
583 ret = drv->probe(dev);
584 if (ret)
585 goto fail;
586 }
587
588 ret = uclass_post_probe_device(dev);
589 if (ret)
590 goto fail_uclass;
591
592 if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL) {
593 ret = pinctrl_select_state(dev, "default");
594 if (ret && ret != -ENOSYS)
595 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n",
596 dev->name, ret, errno_str(ret));
597 }
598
599 ret = device_notify(dev, EVT_DM_POST_PROBE);
600 if (ret)
601 return ret;
602
603 return 0;
604 fail_uclass:
605 if (device_remove(dev, DM_REMOVE_NORMAL)) {
606 dm_warn("%s: Device '%s' failed to remove on error path\n",
607 __func__, dev->name);
608 }
609 fail:
610 dev_bic_flags(dev, DM_FLAG_ACTIVATED);
611
612 device_free(dev);
613
614 return ret;
615 }
616
dev_get_plat(const struct udevice * dev)617 void *dev_get_plat(const struct udevice *dev)
618 {
619 if (!dev) {
620 dm_warn("%s: null device\n", __func__);
621 return NULL;
622 }
623
624 return dm_priv_to_rw(dev->plat_);
625 }
626
dev_get_parent_plat(const struct udevice * dev)627 void *dev_get_parent_plat(const struct udevice *dev)
628 {
629 if (!dev) {
630 dm_warn("%s: null device\n", __func__);
631 return NULL;
632 }
633
634 return dm_priv_to_rw(dev->parent_plat_);
635 }
636
dev_get_uclass_plat(const struct udevice * dev)637 void *dev_get_uclass_plat(const struct udevice *dev)
638 {
639 if (!dev) {
640 dm_warn("%s: null device\n", __func__);
641 return NULL;
642 }
643
644 return dm_priv_to_rw(dev->uclass_plat_);
645 }
646
dev_get_priv(const struct udevice * dev)647 void *dev_get_priv(const struct udevice *dev)
648 {
649 if (!dev) {
650 dm_warn("%s: null device\n", __func__);
651 return NULL;
652 }
653
654 return dm_priv_to_rw(dev->priv_);
655 }
656
657 /* notrace is needed as this is called by timer_get_rate() */
dev_get_uclass_priv(const struct udevice * dev)658 notrace void *dev_get_uclass_priv(const struct udevice *dev)
659 {
660 if (!dev) {
661 dm_warn("%s: null device\n", __func__);
662 return NULL;
663 }
664
665 return dm_priv_to_rw(dev->uclass_priv_);
666 }
667
dev_get_parent_priv(const struct udevice * dev)668 void *dev_get_parent_priv(const struct udevice *dev)
669 {
670 if (!dev) {
671 dm_warn("%s: null device\n", __func__);
672 return NULL;
673 }
674
675 return dm_priv_to_rw(dev->parent_priv_);
676 }
677
dev_get_attach_ptr(const struct udevice * dev,enum dm_tag_t tag)678 void *dev_get_attach_ptr(const struct udevice *dev, enum dm_tag_t tag)
679 {
680 switch (tag) {
681 case DM_TAG_PLAT:
682 return dev_get_plat(dev);
683 case DM_TAG_PARENT_PLAT:
684 return dev_get_parent_plat(dev);
685 case DM_TAG_UC_PLAT:
686 return dev_get_uclass_plat(dev);
687 case DM_TAG_PRIV:
688 return dev_get_priv(dev);
689 case DM_TAG_PARENT_PRIV:
690 return dev_get_parent_priv(dev);
691 case DM_TAG_UC_PRIV:
692 return dev_get_uclass_priv(dev);
693 default:
694 return NULL;
695 }
696 }
697
dev_get_attach_size(const struct udevice * dev,enum dm_tag_t tag)698 int dev_get_attach_size(const struct udevice *dev, enum dm_tag_t tag)
699 {
700 const struct udevice *parent = dev_get_parent(dev);
701 const struct uclass *uc = dev->uclass;
702 const struct uclass_driver *uc_drv = uc->uc_drv;
703 const struct driver *parent_drv = NULL;
704 int size = 0;
705
706 if (parent)
707 parent_drv = parent->driver;
708
709 switch (tag) {
710 case DM_TAG_PLAT:
711 size = dev->driver->plat_auto;
712 break;
713 case DM_TAG_PARENT_PLAT:
714 if (parent) {
715 size = parent_drv->per_child_plat_auto;
716 if (!size)
717 size = parent->uclass->uc_drv->per_child_plat_auto;
718 }
719 break;
720 case DM_TAG_UC_PLAT:
721 size = uc_drv->per_device_plat_auto;
722 break;
723 case DM_TAG_PRIV:
724 size = dev->driver->priv_auto;
725 break;
726 case DM_TAG_PARENT_PRIV:
727 if (parent) {
728 size = parent_drv->per_child_auto;
729 if (!size)
730 size = parent->uclass->uc_drv->per_child_auto;
731 }
732 break;
733 case DM_TAG_UC_PRIV:
734 size = uc_drv->per_device_auto;
735 break;
736 default:
737 break;
738 }
739
740 return size;
741 }
742
device_get_device_tail(struct udevice * dev,int ret,struct udevice ** devp)743 static int device_get_device_tail(struct udevice *dev, int ret,
744 struct udevice **devp)
745 {
746 if (ret)
747 return ret;
748
749 ret = device_probe(dev);
750 if (ret)
751 return ret;
752
753 *devp = dev;
754
755 return 0;
756 }
757
758 #if CONFIG_IS_ENABLED(OF_REAL)
759 /**
760 * device_find_by_ofnode() - Return device associated with given ofnode
761 *
762 * The returned device is *not* activated.
763 *
764 * @node: The ofnode for which a associated device should be looked up
765 * @devp: Pointer to structure to hold the found device
766 * Return: 0 if OK, -ve on error
767 */
device_find_by_ofnode(ofnode node,struct udevice ** devp)768 static int device_find_by_ofnode(ofnode node, struct udevice **devp)
769 {
770 struct uclass *uc;
771 struct udevice *dev;
772 int ret;
773
774 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
775 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node,
776 &dev);
777 if (!ret || dev) {
778 *devp = dev;
779 return 0;
780 }
781 }
782
783 return -ENODEV;
784 }
785 #endif
786
device_get_child(const struct udevice * parent,int index,struct udevice ** devp)787 int device_get_child(const struct udevice *parent, int index,
788 struct udevice **devp)
789 {
790 struct udevice *dev;
791
792 device_foreach_child(dev, parent) {
793 if (!index--)
794 return device_get_device_tail(dev, 0, devp);
795 }
796
797 return -ENODEV;
798 }
799
device_get_child_count(const struct udevice * parent)800 int device_get_child_count(const struct udevice *parent)
801 {
802 struct udevice *dev;
803 int count = 0;
804
805 device_foreach_child(dev, parent)
806 count++;
807
808 return count;
809 }
810
device_get_decendent_count(const struct udevice * parent)811 int device_get_decendent_count(const struct udevice *parent)
812 {
813 const struct udevice *dev;
814 int count = 1;
815
816 device_foreach_child(dev, parent)
817 count += device_get_decendent_count(dev);
818
819 return count;
820 }
821
device_find_child_by_seq(const struct udevice * parent,int seq,struct udevice ** devp)822 int device_find_child_by_seq(const struct udevice *parent, int seq,
823 struct udevice **devp)
824 {
825 struct udevice *dev;
826
827 *devp = NULL;
828
829 device_foreach_child(dev, parent) {
830 if (dev->seq_ == seq) {
831 *devp = dev;
832 return 0;
833 }
834 }
835
836 return -ENODEV;
837 }
838
device_get_child_by_seq(const struct udevice * parent,int seq,struct udevice ** devp)839 int device_get_child_by_seq(const struct udevice *parent, int seq,
840 struct udevice **devp)
841 {
842 struct udevice *dev;
843 int ret;
844
845 *devp = NULL;
846 ret = device_find_child_by_seq(parent, seq, &dev);
847
848 return device_get_device_tail(dev, ret, devp);
849 }
850
device_find_child_by_of_offset(const struct udevice * parent,int of_offset,struct udevice ** devp)851 int device_find_child_by_of_offset(const struct udevice *parent, int of_offset,
852 struct udevice **devp)
853 {
854 struct udevice *dev;
855
856 *devp = NULL;
857
858 device_foreach_child(dev, parent) {
859 if (dev_of_offset(dev) == of_offset) {
860 *devp = dev;
861 return 0;
862 }
863 }
864
865 return -ENODEV;
866 }
867
device_get_child_by_of_offset(const struct udevice * parent,int node,struct udevice ** devp)868 int device_get_child_by_of_offset(const struct udevice *parent, int node,
869 struct udevice **devp)
870 {
871 struct udevice *dev;
872 int ret;
873
874 *devp = NULL;
875 ret = device_find_child_by_of_offset(parent, node, &dev);
876 return device_get_device_tail(dev, ret, devp);
877 }
878
_device_find_global_by_ofnode(struct udevice * parent,ofnode ofnode)879 static struct udevice *_device_find_global_by_ofnode(struct udevice *parent,
880 ofnode ofnode)
881 {
882 struct udevice *dev, *found;
883
884 if (ofnode_equal(dev_ofnode(parent), ofnode))
885 return parent;
886
887 device_foreach_child(dev, parent) {
888 found = _device_find_global_by_ofnode(dev, ofnode);
889 if (found)
890 return found;
891 }
892
893 return NULL;
894 }
895
device_find_global_by_ofnode(ofnode ofnode,struct udevice ** devp)896 int device_find_global_by_ofnode(ofnode ofnode, struct udevice **devp)
897 {
898 *devp = _device_find_global_by_ofnode(gd->dm_root, ofnode);
899
900 return *devp ? 0 : -ENOENT;
901 }
902
device_get_global_by_ofnode(ofnode ofnode,struct udevice ** devp)903 int device_get_global_by_ofnode(ofnode ofnode, struct udevice **devp)
904 {
905 struct udevice *dev;
906
907 dev = _device_find_global_by_ofnode(gd->dm_root, ofnode);
908 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
909 }
910
911 #if CONFIG_IS_ENABLED(OF_PLATDATA)
device_get_by_ofplat_idx(uint idx,struct udevice ** devp)912 int device_get_by_ofplat_idx(uint idx, struct udevice **devp)
913 {
914 struct udevice *dev;
915
916 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST)) {
917 struct udevice *base = ll_entry_start(struct udevice, udevice);
918
919 dev = base + idx;
920 } else {
921 struct driver_rt *drt = gd_dm_driver_rt() + idx;
922
923 dev = drt->dev;
924 }
925 *devp = NULL;
926
927 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
928 }
929 #endif
930
device_find_first_child(const struct udevice * parent,struct udevice ** devp)931 int device_find_first_child(const struct udevice *parent, struct udevice **devp)
932 {
933 if (list_empty(&parent->child_head)) {
934 *devp = NULL;
935 } else {
936 *devp = list_first_entry(&parent->child_head, struct udevice,
937 sibling_node);
938 }
939
940 return 0;
941 }
942
device_find_next_child(struct udevice ** devp)943 int device_find_next_child(struct udevice **devp)
944 {
945 struct udevice *dev = *devp;
946 struct udevice *parent = dev->parent;
947
948 if (list_is_last(&dev->sibling_node, &parent->child_head)) {
949 *devp = NULL;
950 } else {
951 *devp = list_entry(dev->sibling_node.next, struct udevice,
952 sibling_node);
953 }
954
955 return 0;
956 }
957
device_find_first_inactive_child(const struct udevice * parent,enum uclass_id uclass_id,struct udevice ** devp)958 int device_find_first_inactive_child(const struct udevice *parent,
959 enum uclass_id uclass_id,
960 struct udevice **devp)
961 {
962 struct udevice *dev;
963
964 *devp = NULL;
965 device_foreach_child(dev, parent) {
966 if (!device_active(dev) &&
967 device_get_uclass_id(dev) == uclass_id) {
968 *devp = dev;
969 return 0;
970 }
971 }
972
973 return -ENODEV;
974 }
975
device_find_first_child_by_uclass(const struct udevice * parent,enum uclass_id uclass_id,struct udevice ** devp)976 int device_find_first_child_by_uclass(const struct udevice *parent,
977 enum uclass_id uclass_id,
978 struct udevice **devp)
979 {
980 struct udevice *dev;
981
982 *devp = NULL;
983 device_foreach_child(dev, parent) {
984 if (device_get_uclass_id(dev) == uclass_id) {
985 *devp = dev;
986 return 0;
987 }
988 }
989
990 return -ENODEV;
991 }
992
device_find_child_by_namelen(const struct udevice * parent,const char * name,int len,struct udevice ** devp)993 int device_find_child_by_namelen(const struct udevice *parent, const char *name,
994 int len, struct udevice **devp)
995 {
996 struct udevice *dev;
997
998 *devp = NULL;
999
1000 device_foreach_child(dev, parent) {
1001 if (!strncmp(dev->name, name, len) &&
1002 strlen(dev->name) == len) {
1003 *devp = dev;
1004 return 0;
1005 }
1006 }
1007
1008 return -ENODEV;
1009 }
1010
device_find_child_by_name(const struct udevice * parent,const char * name,struct udevice ** devp)1011 int device_find_child_by_name(const struct udevice *parent, const char *name,
1012 struct udevice **devp)
1013 {
1014 return device_find_child_by_namelen(parent, name, strlen(name), devp);
1015 }
1016
device_first_child_err(struct udevice * parent,struct udevice ** devp)1017 int device_first_child_err(struct udevice *parent, struct udevice **devp)
1018 {
1019 struct udevice *dev;
1020
1021 device_find_first_child(parent, &dev);
1022 if (!dev)
1023 return -ENODEV;
1024
1025 return device_get_device_tail(dev, 0, devp);
1026 }
1027
device_next_child_err(struct udevice ** devp)1028 int device_next_child_err(struct udevice **devp)
1029 {
1030 struct udevice *dev = *devp;
1031
1032 device_find_next_child(&dev);
1033 if (!dev)
1034 return -ENODEV;
1035
1036 return device_get_device_tail(dev, 0, devp);
1037 }
1038
device_first_child_ofdata_err(struct udevice * parent,struct udevice ** devp)1039 int device_first_child_ofdata_err(struct udevice *parent, struct udevice **devp)
1040 {
1041 struct udevice *dev;
1042 int ret;
1043
1044 device_find_first_child(parent, &dev);
1045 if (!dev)
1046 return -ENODEV;
1047
1048 ret = device_of_to_plat(dev);
1049 if (ret)
1050 return ret;
1051
1052 *devp = dev;
1053
1054 return 0;
1055 }
1056
device_next_child_ofdata_err(struct udevice ** devp)1057 int device_next_child_ofdata_err(struct udevice **devp)
1058 {
1059 struct udevice *dev = *devp;
1060 int ret;
1061
1062 device_find_next_child(&dev);
1063 if (!dev)
1064 return -ENODEV;
1065
1066 ret = device_of_to_plat(dev);
1067 if (ret)
1068 return ret;
1069
1070 *devp = dev;
1071
1072 return 0;
1073 }
1074
dev_get_parent(const struct udevice * child)1075 struct udevice *dev_get_parent(const struct udevice *child)
1076 {
1077 return child->parent;
1078 }
1079
dev_get_driver_data(const struct udevice * dev)1080 ulong dev_get_driver_data(const struct udevice *dev)
1081 {
1082 return dev->driver_data;
1083 }
1084
dev_get_driver_ops(const struct udevice * dev)1085 const void *dev_get_driver_ops(const struct udevice *dev)
1086 {
1087 if (!dev || !dev->driver->ops)
1088 return NULL;
1089
1090 return dev->driver->ops;
1091 }
1092
device_get_uclass_id(const struct udevice * dev)1093 enum uclass_id device_get_uclass_id(const struct udevice *dev)
1094 {
1095 return dev->uclass->uc_drv->id;
1096 }
1097
dev_get_uclass_name(const struct udevice * dev)1098 const char *dev_get_uclass_name(const struct udevice *dev)
1099 {
1100 if (!dev)
1101 return NULL;
1102
1103 return dev->uclass->uc_drv->name;
1104 }
1105
device_has_children(const struct udevice * dev)1106 bool device_has_children(const struct udevice *dev)
1107 {
1108 return !list_empty(&dev->child_head);
1109 }
1110
device_has_active_children(const struct udevice * dev)1111 bool device_has_active_children(const struct udevice *dev)
1112 {
1113 struct udevice *child;
1114
1115 for (device_find_first_child(dev, &child);
1116 child;
1117 device_find_next_child(&child)) {
1118 if (device_active(child))
1119 return true;
1120 }
1121
1122 return false;
1123 }
1124
device_is_last_sibling(const struct udevice * dev)1125 bool device_is_last_sibling(const struct udevice *dev)
1126 {
1127 struct udevice *parent = dev->parent;
1128
1129 if (!parent)
1130 return false;
1131 return list_is_last(&dev->sibling_node, &parent->child_head);
1132 }
1133
device_set_name_alloced(struct udevice * dev)1134 void device_set_name_alloced(struct udevice *dev)
1135 {
1136 dev_or_flags(dev, DM_FLAG_NAME_ALLOCED);
1137 }
1138
device_set_name(struct udevice * dev,const char * name)1139 int device_set_name(struct udevice *dev, const char *name)
1140 {
1141 name = strdup(name);
1142 if (!name)
1143 return -ENOMEM;
1144 dev->name = name;
1145 device_set_name_alloced(dev);
1146
1147 return 0;
1148 }
1149
dev_set_priv(struct udevice * dev,void * priv)1150 void dev_set_priv(struct udevice *dev, void *priv)
1151 {
1152 dev->priv_ = priv;
1153 }
1154
dev_set_parent_priv(struct udevice * dev,void * parent_priv)1155 void dev_set_parent_priv(struct udevice *dev, void *parent_priv)
1156 {
1157 dev->parent_priv_ = parent_priv;
1158 }
1159
dev_set_uclass_priv(struct udevice * dev,void * uclass_priv)1160 void dev_set_uclass_priv(struct udevice *dev, void *uclass_priv)
1161 {
1162 dev->uclass_priv_ = uclass_priv;
1163 }
1164
dev_set_plat(struct udevice * dev,void * plat)1165 void dev_set_plat(struct udevice *dev, void *plat)
1166 {
1167 dev->plat_ = plat;
1168 }
1169
dev_set_parent_plat(struct udevice * dev,void * parent_plat)1170 void dev_set_parent_plat(struct udevice *dev, void *parent_plat)
1171 {
1172 dev->parent_plat_ = parent_plat;
1173 }
1174
dev_set_uclass_plat(struct udevice * dev,void * uclass_plat)1175 void dev_set_uclass_plat(struct udevice *dev, void *uclass_plat)
1176 {
1177 dev->uclass_plat_ = uclass_plat;
1178 }
1179
1180 #if CONFIG_IS_ENABLED(OF_REAL)
device_is_compatible(const struct udevice * dev,const char * compat)1181 bool device_is_compatible(const struct udevice *dev, const char *compat)
1182 {
1183 return ofnode_device_is_compatible(dev_ofnode(dev), compat);
1184 }
1185
of_machine_is_compatible(const char * compat)1186 bool of_machine_is_compatible(const char *compat)
1187 {
1188 return ofnode_device_is_compatible(ofnode_root(), compat);
1189 }
1190
dev_disable_by_path(const char * path)1191 int dev_disable_by_path(const char *path)
1192 {
1193 struct uclass *uc;
1194 ofnode node = ofnode_path(path);
1195 struct udevice *dev;
1196 int ret = 1;
1197
1198 if (!of_live_active())
1199 return -ENOSYS;
1200
1201 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
1202 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, &dev);
1203 if (!ret)
1204 break;
1205 }
1206
1207 if (ret)
1208 return ret;
1209
1210 ret = device_remove(dev, DM_REMOVE_NORMAL);
1211 if (ret)
1212 return ret;
1213
1214 ret = device_unbind(dev);
1215 if (ret)
1216 return ret;
1217
1218 return ofnode_set_enabled(node, false);
1219 }
1220
dev_enable_by_path(const char * path)1221 int dev_enable_by_path(const char *path)
1222 {
1223 ofnode node = ofnode_path(path);
1224 ofnode pnode = ofnode_get_parent(node);
1225 struct udevice *parent;
1226 int ret = 1;
1227
1228 if (!of_live_active())
1229 return -ENOSYS;
1230
1231 ret = device_find_by_ofnode(pnode, &parent);
1232 if (ret)
1233 return ret;
1234
1235 ret = ofnode_set_enabled(node, true);
1236 if (ret)
1237 return ret;
1238
1239 return lists_bind_fdt(parent, node, NULL, NULL, false);
1240 }
1241 #endif
1242
1243 #if CONFIG_IS_ENABLED(OF_PLATDATA_RT)
dev_get_rt(const struct udevice * dev)1244 static struct udevice_rt *dev_get_rt(const struct udevice *dev)
1245 {
1246 struct udevice *base = ll_entry_start(struct udevice, udevice);
1247 uint each_size = dm_udevice_size();
1248 int idx = ((void *)dev - (void *)base) / each_size;
1249
1250 struct udevice_rt *urt = gd_dm_udevice_rt() + idx;
1251
1252 return urt;
1253 }
1254
dev_get_flags(const struct udevice * dev)1255 u32 dev_get_flags(const struct udevice *dev)
1256 {
1257 const struct udevice_rt *urt = dev_get_rt(dev);
1258
1259 return urt->flags_;
1260 }
1261
dev_or_flags(const struct udevice * dev,u32 or)1262 void dev_or_flags(const struct udevice *dev, u32 or)
1263 {
1264 struct udevice_rt *urt = dev_get_rt(dev);
1265
1266 urt->flags_ |= or;
1267 }
1268
dev_bic_flags(const struct udevice * dev,u32 bic)1269 void dev_bic_flags(const struct udevice *dev, u32 bic)
1270 {
1271 struct udevice_rt *urt = dev_get_rt(dev);
1272
1273 urt->flags_ &= ~bic;
1274 }
1275 #endif /* OF_PLATDATA_RT */
1276