• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <asm/io.h>
14 #include <clk.h>
15 #include <fdtdec.h>
16 #include <fdt_support.h>
17 #include <malloc.h>
18 #include <dm/device.h>
19 #include <dm/device-internal.h>
20 #include <dm/lists.h>
21 #include <dm/of_access.h>
22 #include <dm/pinctrl.h>
23 #include <dm/platdata.h>
24 #include <dm/read.h>
25 #include <dm/uclass.h>
26 #include <dm/uclass-internal.h>
27 #include <dm/util.h>
28 #include <linux/err.h>
29 #include <linux/list.h>
30 #include <power-domain.h>
31 
32 DECLARE_GLOBAL_DATA_PTR;
33 
device_bind_common(struct udevice * parent,const struct driver * drv,const char * name,void * platdata,ulong driver_data,ofnode node,uint of_platdata_size,struct udevice ** devp)34 static int device_bind_common(struct udevice *parent, const struct driver *drv,
35 			      const char *name, void *platdata,
36 			      ulong driver_data, ofnode node,
37 			      uint of_platdata_size, struct udevice **devp)
38 {
39 	struct udevice *dev;
40 	struct uclass *uc;
41 	int size, ret = 0;
42 
43 	if (devp)
44 		*devp = NULL;
45 	if (!name)
46 		return -EINVAL;
47 
48 	ret = uclass_get(drv->id, &uc);
49 	if (ret) {
50 		debug("Missing uclass for driver %s\n", drv->name);
51 		return ret;
52 	}
53 
54 	dev = calloc(1, sizeof(struct udevice));
55 	if (!dev)
56 		return -ENOMEM;
57 
58 	INIT_LIST_HEAD(&dev->sibling_node);
59 	INIT_LIST_HEAD(&dev->child_head);
60 	INIT_LIST_HEAD(&dev->uclass_node);
61 #ifdef CONFIG_DEVRES
62 	INIT_LIST_HEAD(&dev->devres_head);
63 #endif
64 	dev->platdata = platdata;
65 	dev->driver_data = driver_data;
66 	dev->name = name;
67 	dev->node = node;
68 	dev->parent = parent;
69 	dev->driver = drv;
70 	dev->uclass = uc;
71 
72 	dev->seq = -1;
73 	dev->req_seq = -1;
74 	if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
75 	    (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) {
76 		/*
77 		 * Some devices, such as a SPI bus, I2C bus and serial ports
78 		 * are numbered using aliases.
79 		 *
80 		 * This is just a 'requested' sequence, and will be
81 		 * resolved (and ->seq updated) when the device is probed.
82 		 */
83 		if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
84 			if (uc->uc_drv->name && ofnode_valid(node))
85 				dev_read_alias_seq(dev, &dev->req_seq);
86 #if CONFIG_IS_ENABLED(OF_PRIOR_STAGE)
87 			if (dev->req_seq == -1)
88 				dev->req_seq =
89 					uclass_find_next_free_req_seq(drv->id);
90 #endif
91 		} else {
92 			dev->req_seq = uclass_find_next_free_req_seq(drv->id);
93 		}
94 	}
95 
96 	if (drv->platdata_auto_alloc_size) {
97 		bool alloc = !platdata;
98 
99 		if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
100 			if (of_platdata_size) {
101 				dev->flags |= DM_FLAG_OF_PLATDATA;
102 				if (of_platdata_size <
103 						drv->platdata_auto_alloc_size)
104 					alloc = true;
105 			}
106 		}
107 		if (alloc) {
108 			dev->flags |= DM_FLAG_ALLOC_PDATA;
109 			dev->platdata = calloc(1,
110 					       drv->platdata_auto_alloc_size);
111 			if (!dev->platdata) {
112 				ret = -ENOMEM;
113 				goto fail_alloc1;
114 			}
115 			if (CONFIG_IS_ENABLED(OF_PLATDATA) && platdata) {
116 				memcpy(dev->platdata, platdata,
117 				       of_platdata_size);
118 			}
119 		}
120 	}
121 
122 	size = uc->uc_drv->per_device_platdata_auto_alloc_size;
123 	if (size) {
124 		dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA;
125 		dev->uclass_platdata = calloc(1, size);
126 		if (!dev->uclass_platdata) {
127 			ret = -ENOMEM;
128 			goto fail_alloc2;
129 		}
130 	}
131 
132 	if (parent) {
133 		size = parent->driver->per_child_platdata_auto_alloc_size;
134 		if (!size) {
135 			size = parent->uclass->uc_drv->
136 					per_child_platdata_auto_alloc_size;
137 		}
138 		if (size) {
139 			dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA;
140 			dev->parent_platdata = calloc(1, size);
141 			if (!dev->parent_platdata) {
142 				ret = -ENOMEM;
143 				goto fail_alloc3;
144 			}
145 		}
146 	}
147 
148 	/* put dev into parent's successor list */
149 	if (parent)
150 		list_add_tail(&dev->sibling_node, &parent->child_head);
151 
152 	ret = uclass_bind_device(dev);
153 	if (ret)
154 		goto fail_uclass_bind;
155 
156 	/* if we fail to bind we remove device from successors and free it */
157 	if (drv->bind) {
158 		ret = drv->bind(dev);
159 		if (ret)
160 			goto fail_bind;
161 	}
162 	if (parent && parent->driver->child_post_bind) {
163 		ret = parent->driver->child_post_bind(dev);
164 		if (ret)
165 			goto fail_child_post_bind;
166 	}
167 	if (uc->uc_drv->post_bind) {
168 		ret = uc->uc_drv->post_bind(dev);
169 		if (ret)
170 			goto fail_uclass_post_bind;
171 	}
172 
173 	if (parent)
174 		pr_debug("Bound device %s to %s\n", dev->name, parent->name);
175 	if (devp)
176 		*devp = dev;
177 
178 	dev->flags |= DM_FLAG_BOUND;
179 
180 	return 0;
181 
182 fail_uclass_post_bind:
183 	/* There is no child unbind() method, so no clean-up required */
184 fail_child_post_bind:
185 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
186 		if (drv->unbind && drv->unbind(dev)) {
187 			dm_warn("unbind() method failed on dev '%s' on error path\n",
188 				dev->name);
189 		}
190 	}
191 
192 fail_bind:
193 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
194 		if (uclass_unbind_device(dev)) {
195 			dm_warn("Failed to unbind dev '%s' on error path\n",
196 				dev->name);
197 		}
198 	}
199 fail_uclass_bind:
200 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
201 		list_del(&dev->sibling_node);
202 		if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
203 			free(dev->parent_platdata);
204 			dev->parent_platdata = NULL;
205 		}
206 	}
207 fail_alloc3:
208 	if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
209 		free(dev->uclass_platdata);
210 		dev->uclass_platdata = NULL;
211 	}
212 fail_alloc2:
213 	if (dev->flags & DM_FLAG_ALLOC_PDATA) {
214 		free(dev->platdata);
215 		dev->platdata = NULL;
216 	}
217 fail_alloc1:
218 	devres_release_all(dev);
219 
220 	free(dev);
221 
222 	return ret;
223 }
224 
device_bind_with_driver_data(struct udevice * parent,const struct driver * drv,const char * name,ulong driver_data,ofnode node,struct udevice ** devp)225 int device_bind_with_driver_data(struct udevice *parent,
226 				 const struct driver *drv, const char *name,
227 				 ulong driver_data, ofnode node,
228 				 struct udevice **devp)
229 {
230 	return device_bind_common(parent, drv, name, NULL, driver_data, node,
231 				  0, devp);
232 }
233 
device_bind(struct udevice * parent,const struct driver * drv,const char * name,void * platdata,int of_offset,struct udevice ** devp)234 int device_bind(struct udevice *parent, const struct driver *drv,
235 		const char *name, void *platdata, int of_offset,
236 		struct udevice **devp)
237 {
238 	return device_bind_common(parent, drv, name, platdata, 0,
239 				  offset_to_ofnode(of_offset), 0, devp);
240 }
241 
device_bind_ofnode(struct udevice * parent,const struct driver * drv,const char * name,void * platdata,ofnode node,struct udevice ** devp)242 int device_bind_ofnode(struct udevice *parent, const struct driver *drv,
243 		       const char *name, void *platdata, ofnode node,
244 		       struct udevice **devp)
245 {
246 	return device_bind_common(parent, drv, name, platdata, 0, node, 0,
247 				  devp);
248 }
249 
device_bind_by_name(struct udevice * parent,bool pre_reloc_only,const struct driver_info * info,struct udevice ** devp)250 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
251 			const struct driver_info *info, struct udevice **devp)
252 {
253 	struct driver *drv;
254 	uint platdata_size = 0;
255 
256 	drv = lists_driver_lookup_name(info->name);
257 	if (!drv)
258 		return -ENOENT;
259 	if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
260 		return -EPERM;
261 
262 #if CONFIG_IS_ENABLED(OF_PLATDATA)
263 	platdata_size = info->platdata_size;
264 #endif
265 	return device_bind_common(parent, drv, info->name,
266 			(void *)info->platdata, 0, ofnode_null(), platdata_size,
267 			devp);
268 }
269 
alloc_priv(int size,uint flags)270 static void *alloc_priv(int size, uint flags)
271 {
272 	void *priv;
273 
274 	if (flags & DM_FLAG_ALLOC_PRIV_DMA) {
275 		size = ROUND(size, ARCH_DMA_MINALIGN);
276 		priv = memalign(ARCH_DMA_MINALIGN, size);
277 		if (priv) {
278 			memset(priv, '\0', size);
279 
280 			/*
281 			 * Ensure that the zero bytes are flushed to memory.
282 			 * This prevents problems if the driver uses this as
283 			 * both an input and an output buffer:
284 			 *
285 			 * 1. Zeroes written to buffer (here) and sit in the
286 			 *	cache
287 			 * 2. Driver issues a read command to DMA
288 			 * 3. CPU runs out of cache space and evicts some cache
289 			 *	data in the buffer, writing zeroes to RAM from
290 			 *	the memset() above
291 			 * 4. DMA completes
292 			 * 5. Buffer now has some DMA data and some zeroes
293 			 * 6. Data being read is now incorrect
294 			 *
295 			 * To prevent this, ensure that the cache is clean
296 			 * within this range at the start. The driver can then
297 			 * use normal flush-after-write, invalidate-before-read
298 			 * procedures.
299 			 *
300 			 * TODO(sjg@chromium.org): Drop this microblaze
301 			 * exception.
302 			 */
303 #ifndef CONFIG_MICROBLAZE
304 			flush_dcache_range((ulong)priv, (ulong)priv + size);
305 #endif
306 		}
307 	} else {
308 		priv = calloc(1, size);
309 	}
310 
311 	return priv;
312 }
313 
device_probe(struct udevice * dev)314 int device_probe(struct udevice *dev)
315 {
316 	const struct driver *drv;
317 	int size = 0;
318 	int ret;
319 	int seq;
320 
321 	if (!dev)
322 		return -EINVAL;
323 
324 	if (dev->flags & DM_FLAG_ACTIVATED)
325 		return 0;
326 
327 	drv = dev->driver;
328 	assert(drv);
329 
330 	/* Allocate private data if requested and not reentered */
331 	if (drv->priv_auto_alloc_size && !dev->priv) {
332 		dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags);
333 		if (!dev->priv) {
334 			ret = -ENOMEM;
335 			goto fail;
336 		}
337 	}
338 	/* Allocate private data if requested and not reentered */
339 	size = dev->uclass->uc_drv->per_device_auto_alloc_size;
340 	if (size && !dev->uclass_priv) {
341 		dev->uclass_priv = alloc_priv(size,
342 					      dev->uclass->uc_drv->flags);
343 		if (!dev->uclass_priv) {
344 			ret = -ENOMEM;
345 			goto fail;
346 		}
347 	}
348 
349 	/* Ensure all parents are probed */
350 	if (dev->parent) {
351 		size = dev->parent->driver->per_child_auto_alloc_size;
352 		if (!size) {
353 			size = dev->parent->uclass->uc_drv->
354 					per_child_auto_alloc_size;
355 		}
356 		if (size && !dev->parent_priv) {
357 			dev->parent_priv = alloc_priv(size, drv->flags);
358 			if (!dev->parent_priv) {
359 				ret = -ENOMEM;
360 				goto fail;
361 			}
362 		}
363 
364 		ret = device_probe(dev->parent);
365 		if (ret)
366 			goto fail;
367 
368 		/*
369 		 * The device might have already been probed during
370 		 * the call to device_probe() on its parent device
371 		 * (e.g. PCI bridge devices). Test the flags again
372 		 * so that we don't mess up the device.
373 		 */
374 		if (dev->flags & DM_FLAG_ACTIVATED)
375 			return 0;
376 	}
377 
378 	seq = uclass_resolve_seq(dev);
379 	if (seq < 0) {
380 		ret = seq;
381 		goto fail;
382 	}
383 	dev->seq = seq;
384 
385 	dev->flags |= DM_FLAG_ACTIVATED;
386 
387 	/*
388 	 * Process pinctrl for everything except the root device, and
389 	 * continue regardless of the result of pinctrl. Don't process pinctrl
390 	 * settings for pinctrl devices since the device may not yet be
391 	 * probed.
392 	 */
393 	if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL)
394 		pinctrl_select_state(dev, "default");
395 
396 	if (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent &&
397 	    (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) &&
398 	    !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) {
399 		ret = dev_power_domain_on(dev);
400 		if (ret)
401 			goto fail;
402 	}
403 
404 	ret = uclass_pre_probe_device(dev);
405 	if (ret)
406 		goto fail;
407 
408 	if (dev->parent && dev->parent->driver->child_pre_probe) {
409 		ret = dev->parent->driver->child_pre_probe(dev);
410 		if (ret)
411 			goto fail;
412 	}
413 
414 	if (drv->ofdata_to_platdata &&
415 	    (CONFIG_IS_ENABLED(OF_PLATDATA) || dev_has_of_node(dev))) {
416 		ret = drv->ofdata_to_platdata(dev);
417 		if (ret)
418 			goto fail;
419 	}
420 
421 	/* Only handle devices that have a valid ofnode */
422 	if (dev_of_valid(dev)) {
423 		/*
424 		 * Process 'assigned-{clocks/clock-parents/clock-rates}'
425 		 * properties
426 		 */
427 		ret = clk_set_defaults(dev, 0);
428 		if (ret)
429 			goto fail;
430 	}
431 
432 	if (drv->probe) {
433 		ret = drv->probe(dev);
434 		if (ret) {
435 			dev->flags &= ~DM_FLAG_ACTIVATED;
436 			goto fail;
437 		}
438 	}
439 
440 	ret = uclass_post_probe_device(dev);
441 	if (ret)
442 		goto fail_uclass;
443 
444 	if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL)
445 		pinctrl_select_state(dev, "default");
446 
447 	return 0;
448 fail_uclass:
449 	if (device_remove(dev, DM_REMOVE_NORMAL)) {
450 		dm_warn("%s: Device '%s' failed to remove on error path\n",
451 			__func__, dev->name);
452 	}
453 fail:
454 	dev->flags &= ~DM_FLAG_ACTIVATED;
455 
456 	dev->seq = -1;
457 	device_free(dev);
458 
459 	return ret;
460 }
461 
dev_get_platdata(const struct udevice * dev)462 void *dev_get_platdata(const struct udevice *dev)
463 {
464 	if (!dev) {
465 		dm_warn("%s: null device\n", __func__);
466 		return NULL;
467 	}
468 
469 	return dev->platdata;
470 }
471 
dev_get_parent_platdata(const struct udevice * dev)472 void *dev_get_parent_platdata(const struct udevice *dev)
473 {
474 	if (!dev) {
475 		dm_warn("%s: null device\n", __func__);
476 		return NULL;
477 	}
478 
479 	return dev->parent_platdata;
480 }
481 
dev_get_uclass_platdata(const struct udevice * dev)482 void *dev_get_uclass_platdata(const struct udevice *dev)
483 {
484 	if (!dev) {
485 		dm_warn("%s: null device\n", __func__);
486 		return NULL;
487 	}
488 
489 	return dev->uclass_platdata;
490 }
491 
dev_get_priv(const struct udevice * dev)492 void *dev_get_priv(const struct udevice *dev)
493 {
494 	if (!dev) {
495 		dm_warn("%s: null device\n", __func__);
496 		return NULL;
497 	}
498 
499 	return dev->priv;
500 }
501 
dev_get_uclass_priv(const struct udevice * dev)502 void *dev_get_uclass_priv(const struct udevice *dev)
503 {
504 	if (!dev) {
505 		dm_warn("%s: null device\n", __func__);
506 		return NULL;
507 	}
508 
509 	return dev->uclass_priv;
510 }
511 
dev_get_parent_priv(const struct udevice * dev)512 void *dev_get_parent_priv(const struct udevice *dev)
513 {
514 	if (!dev) {
515 		dm_warn("%s: null device\n", __func__);
516 		return NULL;
517 	}
518 
519 	return dev->parent_priv;
520 }
521 
device_get_device_tail(struct udevice * dev,int ret,struct udevice ** devp)522 static int device_get_device_tail(struct udevice *dev, int ret,
523 				  struct udevice **devp)
524 {
525 	if (ret)
526 		return ret;
527 
528 	ret = device_probe(dev);
529 	if (ret)
530 		return ret;
531 
532 	*devp = dev;
533 
534 	return 0;
535 }
536 
537 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
538 /**
539  * device_find_by_ofnode() - Return device associated with given ofnode
540  *
541  * The returned device is *not* activated.
542  *
543  * @node: The ofnode for which a associated device should be looked up
544  * @devp: Pointer to structure to hold the found device
545  * Return: 0 if OK, -ve on error
546  */
device_find_by_ofnode(ofnode node,struct udevice ** devp)547 static int device_find_by_ofnode(ofnode node, struct udevice **devp)
548 {
549 	struct uclass *uc;
550 	struct udevice *dev;
551 	int ret;
552 
553 	list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
554 		ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node,
555 						   &dev);
556 		if (!ret || dev) {
557 			*devp = dev;
558 			return 0;
559 		}
560 	}
561 
562 	return -ENODEV;
563 }
564 #endif
565 
device_get_child(struct udevice * parent,int index,struct udevice ** devp)566 int device_get_child(struct udevice *parent, int index, struct udevice **devp)
567 {
568 	struct udevice *dev;
569 
570 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
571 		if (!index--)
572 			return device_get_device_tail(dev, 0, devp);
573 	}
574 
575 	return -ENODEV;
576 }
577 
device_get_child_count(struct udevice * parent)578 int device_get_child_count(struct udevice *parent)
579 {
580 	struct udevice *dev;
581 	int count = 0;
582 
583 	list_for_each_entry(dev, &parent->child_head, sibling_node)
584 		count++;
585 
586 	return count;
587 }
588 
device_find_child_by_seq(struct udevice * parent,int seq_or_req_seq,bool find_req_seq,struct udevice ** devp)589 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
590 			     bool find_req_seq, struct udevice **devp)
591 {
592 	struct udevice *dev;
593 
594 	*devp = NULL;
595 	if (seq_or_req_seq == -1)
596 		return -ENODEV;
597 
598 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
599 		if ((find_req_seq ? dev->req_seq : dev->seq) ==
600 				seq_or_req_seq) {
601 			*devp = dev;
602 			return 0;
603 		}
604 	}
605 
606 	return -ENODEV;
607 }
608 
device_get_child_by_seq(struct udevice * parent,int seq,struct udevice ** devp)609 int device_get_child_by_seq(struct udevice *parent, int seq,
610 			    struct udevice **devp)
611 {
612 	struct udevice *dev;
613 	int ret;
614 
615 	*devp = NULL;
616 	ret = device_find_child_by_seq(parent, seq, false, &dev);
617 	if (ret == -ENODEV) {
618 		/*
619 		 * We didn't find it in probed devices. See if there is one
620 		 * that will request this seq if probed.
621 		 */
622 		ret = device_find_child_by_seq(parent, seq, true, &dev);
623 	}
624 	return device_get_device_tail(dev, ret, devp);
625 }
626 
device_find_child_by_of_offset(struct udevice * parent,int of_offset,struct udevice ** devp)627 int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
628 				   struct udevice **devp)
629 {
630 	struct udevice *dev;
631 
632 	*devp = NULL;
633 
634 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
635 		if (dev_of_offset(dev) == of_offset) {
636 			*devp = dev;
637 			return 0;
638 		}
639 	}
640 
641 	return -ENODEV;
642 }
643 
device_get_child_by_of_offset(struct udevice * parent,int node,struct udevice ** devp)644 int device_get_child_by_of_offset(struct udevice *parent, int node,
645 				  struct udevice **devp)
646 {
647 	struct udevice *dev;
648 	int ret;
649 
650 	*devp = NULL;
651 	ret = device_find_child_by_of_offset(parent, node, &dev);
652 	return device_get_device_tail(dev, ret, devp);
653 }
654 
_device_find_global_by_ofnode(struct udevice * parent,ofnode ofnode)655 static struct udevice *_device_find_global_by_ofnode(struct udevice *parent,
656 						     ofnode ofnode)
657 {
658 	struct udevice *dev, *found;
659 
660 	if (ofnode_equal(dev_ofnode(parent), ofnode))
661 		return parent;
662 
663 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
664 		found = _device_find_global_by_ofnode(dev, ofnode);
665 		if (found)
666 			return found;
667 	}
668 
669 	return NULL;
670 }
671 
device_find_global_by_ofnode(ofnode ofnode,struct udevice ** devp)672 int device_find_global_by_ofnode(ofnode ofnode, struct udevice **devp)
673 {
674 	*devp = _device_find_global_by_ofnode(gd->dm_root, ofnode);
675 
676 	return *devp ? 0 : -ENOENT;
677 }
678 
device_get_global_by_ofnode(ofnode ofnode,struct udevice ** devp)679 int device_get_global_by_ofnode(ofnode ofnode, struct udevice **devp)
680 {
681 	struct udevice *dev;
682 
683 	dev = _device_find_global_by_ofnode(gd->dm_root, ofnode);
684 	return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
685 }
686 
device_find_first_child(struct udevice * parent,struct udevice ** devp)687 int device_find_first_child(struct udevice *parent, struct udevice **devp)
688 {
689 	if (list_empty(&parent->child_head)) {
690 		*devp = NULL;
691 	} else {
692 		*devp = list_first_entry(&parent->child_head, struct udevice,
693 					 sibling_node);
694 	}
695 
696 	return 0;
697 }
698 
device_find_next_child(struct udevice ** devp)699 int device_find_next_child(struct udevice **devp)
700 {
701 	struct udevice *dev = *devp;
702 	struct udevice *parent = dev->parent;
703 
704 	if (list_is_last(&dev->sibling_node, &parent->child_head)) {
705 		*devp = NULL;
706 	} else {
707 		*devp = list_entry(dev->sibling_node.next, struct udevice,
708 				   sibling_node);
709 	}
710 
711 	return 0;
712 }
713 
device_find_first_inactive_child(struct udevice * parent,enum uclass_id uclass_id,struct udevice ** devp)714 int device_find_first_inactive_child(struct udevice *parent,
715 				     enum uclass_id uclass_id,
716 				     struct udevice **devp)
717 {
718 	struct udevice *dev;
719 
720 	*devp = NULL;
721 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
722 		if (!device_active(dev) &&
723 		    device_get_uclass_id(dev) == uclass_id) {
724 			*devp = dev;
725 			return 0;
726 		}
727 	}
728 
729 	return -ENODEV;
730 }
731 
device_find_first_child_by_uclass(struct udevice * parent,enum uclass_id uclass_id,struct udevice ** devp)732 int device_find_first_child_by_uclass(struct udevice *parent,
733 				      enum uclass_id uclass_id,
734 				      struct udevice **devp)
735 {
736 	struct udevice *dev;
737 
738 	*devp = NULL;
739 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
740 		if (device_get_uclass_id(dev) == uclass_id) {
741 			*devp = dev;
742 			return 0;
743 		}
744 	}
745 
746 	return -ENODEV;
747 }
748 
device_find_child_by_name(struct udevice * parent,const char * name,struct udevice ** devp)749 int device_find_child_by_name(struct udevice *parent, const char *name,
750 			      struct udevice **devp)
751 {
752 	struct udevice *dev;
753 
754 	*devp = NULL;
755 
756 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
757 		if (!strcmp(dev->name, name)) {
758 			*devp = dev;
759 			return 0;
760 		}
761 	}
762 
763 	return -ENODEV;
764 }
765 
dev_get_parent(const struct udevice * child)766 struct udevice *dev_get_parent(const struct udevice *child)
767 {
768 	return child->parent;
769 }
770 
dev_get_driver_data(const struct udevice * dev)771 ulong dev_get_driver_data(const struct udevice *dev)
772 {
773 	return dev->driver_data;
774 }
775 
dev_get_driver_ops(const struct udevice * dev)776 const void *dev_get_driver_ops(const struct udevice *dev)
777 {
778 	if (!dev || !dev->driver->ops)
779 		return NULL;
780 
781 	return dev->driver->ops;
782 }
783 
device_get_uclass_id(const struct udevice * dev)784 enum uclass_id device_get_uclass_id(const struct udevice *dev)
785 {
786 	return dev->uclass->uc_drv->id;
787 }
788 
dev_get_uclass_name(const struct udevice * dev)789 const char *dev_get_uclass_name(const struct udevice *dev)
790 {
791 	if (!dev)
792 		return NULL;
793 
794 	return dev->uclass->uc_drv->name;
795 }
796 
device_has_children(const struct udevice * dev)797 bool device_has_children(const struct udevice *dev)
798 {
799 	return !list_empty(&dev->child_head);
800 }
801 
device_has_active_children(struct udevice * dev)802 bool device_has_active_children(struct udevice *dev)
803 {
804 	struct udevice *child;
805 
806 	for (device_find_first_child(dev, &child);
807 	     child;
808 	     device_find_next_child(&child)) {
809 		if (device_active(child))
810 			return true;
811 	}
812 
813 	return false;
814 }
815 
device_is_last_sibling(struct udevice * dev)816 bool device_is_last_sibling(struct udevice *dev)
817 {
818 	struct udevice *parent = dev->parent;
819 
820 	if (!parent)
821 		return false;
822 	return list_is_last(&dev->sibling_node, &parent->child_head);
823 }
824 
device_set_name_alloced(struct udevice * dev)825 void device_set_name_alloced(struct udevice *dev)
826 {
827 	dev->flags |= DM_FLAG_NAME_ALLOCED;
828 }
829 
device_set_name(struct udevice * dev,const char * name)830 int device_set_name(struct udevice *dev, const char *name)
831 {
832 	name = strdup(name);
833 	if (!name)
834 		return -ENOMEM;
835 	dev->name = name;
836 	device_set_name_alloced(dev);
837 
838 	return 0;
839 }
840 
841 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
device_is_compatible(struct udevice * dev,const char * compat)842 bool device_is_compatible(struct udevice *dev, const char *compat)
843 {
844 	return ofnode_device_is_compatible(dev_ofnode(dev), compat);
845 }
846 
of_machine_is_compatible(const char * compat)847 bool of_machine_is_compatible(const char *compat)
848 {
849 	const void *fdt = gd->fdt_blob;
850 
851 	return !fdt_node_check_compatible(fdt, 0, compat);
852 }
853 
dev_disable_by_path(const char * path)854 int dev_disable_by_path(const char *path)
855 {
856 	struct uclass *uc;
857 	ofnode node = ofnode_path(path);
858 	struct udevice *dev;
859 	int ret = 1;
860 
861 	if (!of_live_active())
862 		return -ENOSYS;
863 
864 	list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
865 		ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, &dev);
866 		if (!ret)
867 			break;
868 	}
869 
870 	if (ret)
871 		return ret;
872 
873 	ret = device_remove(dev, DM_REMOVE_NORMAL);
874 	if (ret)
875 		return ret;
876 
877 	ret = device_unbind(dev);
878 	if (ret)
879 		return ret;
880 
881 	return ofnode_set_enabled(node, false);
882 }
883 
dev_enable_by_path(const char * path)884 int dev_enable_by_path(const char *path)
885 {
886 	ofnode node = ofnode_path(path);
887 	ofnode pnode = ofnode_get_parent(node);
888 	struct udevice *parent;
889 	int ret = 1;
890 
891 	if (!of_live_active())
892 		return -ENOSYS;
893 
894 	ret = device_find_by_ofnode(pnode, &parent);
895 	if (ret)
896 		return ret;
897 
898 	ret = ofnode_set_enabled(node, true);
899 	if (ret)
900 		return ret;
901 
902 	return lists_bind_fdt(parent, node, NULL, false);
903 }
904 #endif
905