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