xref: /openbmc/u-boot/drivers/core/device.c (revision 48263504)
1 /*
2  * Device manager
3  *
4  * Copyright (c) 2013 Google, Inc
5  *
6  * (C) Copyright 2012
7  * Pavel Herrmann <morpheus.ibis@gmail.com>
8  *
9  * SPDX-License-Identifier:	GPL-2.0+
10  */
11 
12 #include <common.h>
13 #include <asm/io.h>
14 #include <fdtdec.h>
15 #include <fdt_support.h>
16 #include <malloc.h>
17 #include <dm/device.h>
18 #include <dm/device-internal.h>
19 #include <dm/lists.h>
20 #include <dm/pinctrl.h>
21 #include <dm/platdata.h>
22 #include <dm/read.h>
23 #include <dm/uclass.h>
24 #include <dm/uclass-internal.h>
25 #include <dm/util.h>
26 #include <linux/err.h>
27 #include <linux/list.h>
28 
29 DECLARE_GLOBAL_DATA_PTR;
30 
31 static int device_bind_common(struct udevice *parent, const struct driver *drv,
32 			      const char *name, void *platdata,
33 			      ulong driver_data, ofnode node,
34 			      uint of_platdata_size, struct udevice **devp)
35 {
36 	struct udevice *dev;
37 	struct uclass *uc;
38 	int size, ret = 0;
39 
40 	if (devp)
41 		*devp = NULL;
42 	if (!name)
43 		return -EINVAL;
44 
45 	ret = uclass_get(drv->id, &uc);
46 	if (ret) {
47 		debug("Missing uclass for driver %s\n", drv->name);
48 		return ret;
49 	}
50 
51 	dev = calloc(1, sizeof(struct udevice));
52 	if (!dev)
53 		return -ENOMEM;
54 
55 	INIT_LIST_HEAD(&dev->sibling_node);
56 	INIT_LIST_HEAD(&dev->child_head);
57 	INIT_LIST_HEAD(&dev->uclass_node);
58 #ifdef CONFIG_DEVRES
59 	INIT_LIST_HEAD(&dev->devres_head);
60 #endif
61 	dev->platdata = platdata;
62 	dev->driver_data = driver_data;
63 	dev->name = name;
64 	dev->node = node;
65 	dev->parent = parent;
66 	dev->driver = drv;
67 	dev->uclass = uc;
68 
69 	dev->seq = -1;
70 	dev->req_seq = -1;
71 	if (CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS)) {
72 		/*
73 		 * Some devices, such as a SPI bus, I2C bus and serial ports
74 		 * are numbered using aliases.
75 		 *
76 		 * This is just a 'requested' sequence, and will be
77 		 * resolved (and ->seq updated) when the device is probed.
78 		 */
79 		if (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS) {
80 			if (uc->uc_drv->name && ofnode_valid(node)) {
81 				dev_read_alias_seq(dev, &dev->req_seq);
82 			}
83 		}
84 	}
85 
86 	if (drv->platdata_auto_alloc_size) {
87 		bool alloc = !platdata;
88 
89 		if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
90 			if (of_platdata_size) {
91 				dev->flags |= DM_FLAG_OF_PLATDATA;
92 				if (of_platdata_size <
93 						drv->platdata_auto_alloc_size)
94 					alloc = true;
95 			}
96 		}
97 		if (alloc) {
98 			dev->flags |= DM_FLAG_ALLOC_PDATA;
99 			dev->platdata = calloc(1,
100 					       drv->platdata_auto_alloc_size);
101 			if (!dev->platdata) {
102 				ret = -ENOMEM;
103 				goto fail_alloc1;
104 			}
105 			if (CONFIG_IS_ENABLED(OF_PLATDATA) && platdata) {
106 				memcpy(dev->platdata, platdata,
107 				       of_platdata_size);
108 			}
109 		}
110 	}
111 
112 	size = uc->uc_drv->per_device_platdata_auto_alloc_size;
113 	if (size) {
114 		dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA;
115 		dev->uclass_platdata = calloc(1, size);
116 		if (!dev->uclass_platdata) {
117 			ret = -ENOMEM;
118 			goto fail_alloc2;
119 		}
120 	}
121 
122 	if (parent) {
123 		size = parent->driver->per_child_platdata_auto_alloc_size;
124 		if (!size) {
125 			size = parent->uclass->uc_drv->
126 					per_child_platdata_auto_alloc_size;
127 		}
128 		if (size) {
129 			dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA;
130 			dev->parent_platdata = calloc(1, size);
131 			if (!dev->parent_platdata) {
132 				ret = -ENOMEM;
133 				goto fail_alloc3;
134 			}
135 		}
136 	}
137 
138 	/* put dev into parent's successor list */
139 	if (parent)
140 		list_add_tail(&dev->sibling_node, &parent->child_head);
141 
142 	ret = uclass_bind_device(dev);
143 	if (ret)
144 		goto fail_uclass_bind;
145 
146 	/* if we fail to bind we remove device from successors and free it */
147 	if (drv->bind) {
148 		ret = drv->bind(dev);
149 		if (ret)
150 			goto fail_bind;
151 	}
152 	if (parent && parent->driver->child_post_bind) {
153 		ret = parent->driver->child_post_bind(dev);
154 		if (ret)
155 			goto fail_child_post_bind;
156 	}
157 	if (uc->uc_drv->post_bind) {
158 		ret = uc->uc_drv->post_bind(dev);
159 		if (ret)
160 			goto fail_uclass_post_bind;
161 	}
162 
163 	if (parent)
164 		pr_debug("Bound device %s to %s\n", dev->name, parent->name);
165 	if (devp)
166 		*devp = dev;
167 
168 	dev->flags |= DM_FLAG_BOUND;
169 
170 	return 0;
171 
172 fail_uclass_post_bind:
173 	/* There is no child unbind() method, so no clean-up required */
174 fail_child_post_bind:
175 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
176 		if (drv->unbind && drv->unbind(dev)) {
177 			dm_warn("unbind() method failed on dev '%s' on error path\n",
178 				dev->name);
179 		}
180 	}
181 
182 fail_bind:
183 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
184 		if (uclass_unbind_device(dev)) {
185 			dm_warn("Failed to unbind dev '%s' on error path\n",
186 				dev->name);
187 		}
188 	}
189 fail_uclass_bind:
190 	if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
191 		list_del(&dev->sibling_node);
192 		if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
193 			free(dev->parent_platdata);
194 			dev->parent_platdata = NULL;
195 		}
196 	}
197 fail_alloc3:
198 	if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
199 		free(dev->uclass_platdata);
200 		dev->uclass_platdata = NULL;
201 	}
202 fail_alloc2:
203 	if (dev->flags & DM_FLAG_ALLOC_PDATA) {
204 		free(dev->platdata);
205 		dev->platdata = NULL;
206 	}
207 fail_alloc1:
208 	devres_release_all(dev);
209 
210 	free(dev);
211 
212 	return ret;
213 }
214 
215 int device_bind_with_driver_data(struct udevice *parent,
216 				 const struct driver *drv, const char *name,
217 				 ulong driver_data, ofnode node,
218 				 struct udevice **devp)
219 {
220 	return device_bind_common(parent, drv, name, NULL, driver_data, node,
221 				  0, devp);
222 }
223 
224 int device_bind(struct udevice *parent, const struct driver *drv,
225 		const char *name, void *platdata, int of_offset,
226 		struct udevice **devp)
227 {
228 	return device_bind_common(parent, drv, name, platdata, 0,
229 				  offset_to_ofnode(of_offset), 0, devp);
230 }
231 
232 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
233 			const struct driver_info *info, struct udevice **devp)
234 {
235 	struct driver *drv;
236 	uint platdata_size = 0;
237 
238 	drv = lists_driver_lookup_name(info->name);
239 	if (!drv)
240 		return -ENOENT;
241 	if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
242 		return -EPERM;
243 
244 #if CONFIG_IS_ENABLED(OF_PLATDATA)
245 	platdata_size = info->platdata_size;
246 #endif
247 	return device_bind_common(parent, drv, info->name,
248 			(void *)info->platdata, 0, ofnode_null(), platdata_size,
249 			devp);
250 }
251 
252 static void *alloc_priv(int size, uint flags)
253 {
254 	void *priv;
255 
256 	if (flags & DM_FLAG_ALLOC_PRIV_DMA) {
257 		size = ROUND(size, ARCH_DMA_MINALIGN);
258 		priv = memalign(ARCH_DMA_MINALIGN, size);
259 		if (priv) {
260 			memset(priv, '\0', size);
261 
262 			/*
263 			 * Ensure that the zero bytes are flushed to memory.
264 			 * This prevents problems if the driver uses this as
265 			 * both an input and an output buffer:
266 			 *
267 			 * 1. Zeroes written to buffer (here) and sit in the
268 			 *	cache
269 			 * 2. Driver issues a read command to DMA
270 			 * 3. CPU runs out of cache space and evicts some cache
271 			 *	data in the buffer, writing zeroes to RAM from
272 			 *	the memset() above
273 			 * 4. DMA completes
274 			 * 5. Buffer now has some DMA data and some zeroes
275 			 * 6. Data being read is now incorrect
276 			 *
277 			 * To prevent this, ensure that the cache is clean
278 			 * within this range at the start. The driver can then
279 			 * use normal flush-after-write, invalidate-before-read
280 			 * procedures.
281 			 *
282 			 * TODO(sjg@chromium.org): Drop this microblaze
283 			 * exception.
284 			 */
285 #ifndef CONFIG_MICROBLAZE
286 			flush_dcache_range((ulong)priv, (ulong)priv + size);
287 #endif
288 		}
289 	} else {
290 		priv = calloc(1, size);
291 	}
292 
293 	return priv;
294 }
295 
296 int device_probe(struct udevice *dev)
297 {
298 	const struct driver *drv;
299 	int size = 0;
300 	int ret;
301 	int seq;
302 
303 	if (!dev)
304 		return -EINVAL;
305 
306 	if (dev->flags & DM_FLAG_ACTIVATED)
307 		return 0;
308 
309 	drv = dev->driver;
310 	assert(drv);
311 
312 	/* Allocate private data if requested and not reentered */
313 	if (drv->priv_auto_alloc_size && !dev->priv) {
314 		dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags);
315 		if (!dev->priv) {
316 			ret = -ENOMEM;
317 			goto fail;
318 		}
319 	}
320 	/* Allocate private data if requested and not reentered */
321 	size = dev->uclass->uc_drv->per_device_auto_alloc_size;
322 	if (size && !dev->uclass_priv) {
323 		dev->uclass_priv = calloc(1, size);
324 		if (!dev->uclass_priv) {
325 			ret = -ENOMEM;
326 			goto fail;
327 		}
328 	}
329 
330 	/* Ensure all parents are probed */
331 	if (dev->parent) {
332 		size = dev->parent->driver->per_child_auto_alloc_size;
333 		if (!size) {
334 			size = dev->parent->uclass->uc_drv->
335 					per_child_auto_alloc_size;
336 		}
337 		if (size && !dev->parent_priv) {
338 			dev->parent_priv = alloc_priv(size, drv->flags);
339 			if (!dev->parent_priv) {
340 				ret = -ENOMEM;
341 				goto fail;
342 			}
343 		}
344 
345 		ret = device_probe(dev->parent);
346 		if (ret)
347 			goto fail;
348 
349 		/*
350 		 * The device might have already been probed during
351 		 * the call to device_probe() on its parent device
352 		 * (e.g. PCI bridge devices). Test the flags again
353 		 * so that we don't mess up the device.
354 		 */
355 		if (dev->flags & DM_FLAG_ACTIVATED)
356 			return 0;
357 	}
358 
359 	seq = uclass_resolve_seq(dev);
360 	if (seq < 0) {
361 		ret = seq;
362 		goto fail;
363 	}
364 	dev->seq = seq;
365 
366 	dev->flags |= DM_FLAG_ACTIVATED;
367 
368 	/*
369 	 * Process pinctrl for everything except the root device, and
370 	 * continue regardless of the result of pinctrl. Don't process pinctrl
371 	 * settings for pinctrl devices since the device may not yet be
372 	 * probed.
373 	 */
374 	if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL)
375 		pinctrl_select_state(dev, "default");
376 
377 	ret = uclass_pre_probe_device(dev);
378 	if (ret)
379 		goto fail;
380 
381 	if (dev->parent && dev->parent->driver->child_pre_probe) {
382 		ret = dev->parent->driver->child_pre_probe(dev);
383 		if (ret)
384 			goto fail;
385 	}
386 
387 	if (drv->ofdata_to_platdata && dev_has_of_node(dev)) {
388 		ret = drv->ofdata_to_platdata(dev);
389 		if (ret)
390 			goto fail;
391 	}
392 
393 	if (drv->probe) {
394 		ret = drv->probe(dev);
395 		if (ret) {
396 			dev->flags &= ~DM_FLAG_ACTIVATED;
397 			goto fail;
398 		}
399 	}
400 
401 	ret = uclass_post_probe_device(dev);
402 	if (ret)
403 		goto fail_uclass;
404 
405 	if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL)
406 		pinctrl_select_state(dev, "default");
407 
408 	return 0;
409 fail_uclass:
410 	if (device_remove(dev, DM_REMOVE_NORMAL)) {
411 		dm_warn("%s: Device '%s' failed to remove on error path\n",
412 			__func__, dev->name);
413 	}
414 fail:
415 	dev->flags &= ~DM_FLAG_ACTIVATED;
416 
417 	dev->seq = -1;
418 	device_free(dev);
419 
420 	return ret;
421 }
422 
423 void *dev_get_platdata(struct udevice *dev)
424 {
425 	if (!dev) {
426 		dm_warn("%s: null device\n", __func__);
427 		return NULL;
428 	}
429 
430 	return dev->platdata;
431 }
432 
433 void *dev_get_parent_platdata(struct udevice *dev)
434 {
435 	if (!dev) {
436 		dm_warn("%s: null device\n", __func__);
437 		return NULL;
438 	}
439 
440 	return dev->parent_platdata;
441 }
442 
443 void *dev_get_uclass_platdata(struct udevice *dev)
444 {
445 	if (!dev) {
446 		dm_warn("%s: null device\n", __func__);
447 		return NULL;
448 	}
449 
450 	return dev->uclass_platdata;
451 }
452 
453 void *dev_get_priv(struct udevice *dev)
454 {
455 	if (!dev) {
456 		dm_warn("%s: null device\n", __func__);
457 		return NULL;
458 	}
459 
460 	return dev->priv;
461 }
462 
463 void *dev_get_uclass_priv(struct udevice *dev)
464 {
465 	if (!dev) {
466 		dm_warn("%s: null device\n", __func__);
467 		return NULL;
468 	}
469 
470 	return dev->uclass_priv;
471 }
472 
473 void *dev_get_parent_priv(struct udevice *dev)
474 {
475 	if (!dev) {
476 		dm_warn("%s: null device\n", __func__);
477 		return NULL;
478 	}
479 
480 	return dev->parent_priv;
481 }
482 
483 static int device_get_device_tail(struct udevice *dev, int ret,
484 				  struct udevice **devp)
485 {
486 	if (ret)
487 		return ret;
488 
489 	ret = device_probe(dev);
490 	if (ret)
491 		return ret;
492 
493 	*devp = dev;
494 
495 	return 0;
496 }
497 
498 int device_get_child(struct udevice *parent, int index, struct udevice **devp)
499 {
500 	struct udevice *dev;
501 
502 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
503 		if (!index--)
504 			return device_get_device_tail(dev, 0, devp);
505 	}
506 
507 	return -ENODEV;
508 }
509 
510 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
511 			     bool find_req_seq, struct udevice **devp)
512 {
513 	struct udevice *dev;
514 
515 	*devp = NULL;
516 	if (seq_or_req_seq == -1)
517 		return -ENODEV;
518 
519 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
520 		if ((find_req_seq ? dev->req_seq : dev->seq) ==
521 				seq_or_req_seq) {
522 			*devp = dev;
523 			return 0;
524 		}
525 	}
526 
527 	return -ENODEV;
528 }
529 
530 int device_get_child_by_seq(struct udevice *parent, int seq,
531 			    struct udevice **devp)
532 {
533 	struct udevice *dev;
534 	int ret;
535 
536 	*devp = NULL;
537 	ret = device_find_child_by_seq(parent, seq, false, &dev);
538 	if (ret == -ENODEV) {
539 		/*
540 		 * We didn't find it in probed devices. See if there is one
541 		 * that will request this seq if probed.
542 		 */
543 		ret = device_find_child_by_seq(parent, seq, true, &dev);
544 	}
545 	return device_get_device_tail(dev, ret, devp);
546 }
547 
548 int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
549 				   struct udevice **devp)
550 {
551 	struct udevice *dev;
552 
553 	*devp = NULL;
554 
555 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
556 		if (dev_of_offset(dev) == of_offset) {
557 			*devp = dev;
558 			return 0;
559 		}
560 	}
561 
562 	return -ENODEV;
563 }
564 
565 int device_get_child_by_of_offset(struct udevice *parent, int node,
566 				  struct udevice **devp)
567 {
568 	struct udevice *dev;
569 	int ret;
570 
571 	*devp = NULL;
572 	ret = device_find_child_by_of_offset(parent, node, &dev);
573 	return device_get_device_tail(dev, ret, devp);
574 }
575 
576 static struct udevice *_device_find_global_by_of_offset(struct udevice *parent,
577 							int of_offset)
578 {
579 	struct udevice *dev, *found;
580 
581 	if (dev_of_offset(parent) == of_offset)
582 		return parent;
583 
584 	list_for_each_entry(dev, &parent->child_head, sibling_node) {
585 		found = _device_find_global_by_of_offset(dev, of_offset);
586 		if (found)
587 			return found;
588 	}
589 
590 	return NULL;
591 }
592 
593 int device_get_global_by_of_offset(int of_offset, struct udevice **devp)
594 {
595 	struct udevice *dev;
596 
597 	dev = _device_find_global_by_of_offset(gd->dm_root, of_offset);
598 	return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
599 }
600 
601 int device_find_first_child(struct udevice *parent, struct udevice **devp)
602 {
603 	if (list_empty(&parent->child_head)) {
604 		*devp = NULL;
605 	} else {
606 		*devp = list_first_entry(&parent->child_head, struct udevice,
607 					 sibling_node);
608 	}
609 
610 	return 0;
611 }
612 
613 int device_find_next_child(struct udevice **devp)
614 {
615 	struct udevice *dev = *devp;
616 	struct udevice *parent = dev->parent;
617 
618 	if (list_is_last(&dev->sibling_node, &parent->child_head)) {
619 		*devp = NULL;
620 	} else {
621 		*devp = list_entry(dev->sibling_node.next, struct udevice,
622 				   sibling_node);
623 	}
624 
625 	return 0;
626 }
627 
628 struct udevice *dev_get_parent(struct udevice *child)
629 {
630 	return child->parent;
631 }
632 
633 ulong dev_get_driver_data(struct udevice *dev)
634 {
635 	return dev->driver_data;
636 }
637 
638 const void *dev_get_driver_ops(struct udevice *dev)
639 {
640 	if (!dev || !dev->driver->ops)
641 		return NULL;
642 
643 	return dev->driver->ops;
644 }
645 
646 enum uclass_id device_get_uclass_id(struct udevice *dev)
647 {
648 	return dev->uclass->uc_drv->id;
649 }
650 
651 const char *dev_get_uclass_name(struct udevice *dev)
652 {
653 	if (!dev)
654 		return NULL;
655 
656 	return dev->uclass->uc_drv->name;
657 }
658 
659 bool device_has_children(struct udevice *dev)
660 {
661 	return !list_empty(&dev->child_head);
662 }
663 
664 bool device_has_active_children(struct udevice *dev)
665 {
666 	struct udevice *child;
667 
668 	for (device_find_first_child(dev, &child);
669 	     child;
670 	     device_find_next_child(&child)) {
671 		if (device_active(child))
672 			return true;
673 	}
674 
675 	return false;
676 }
677 
678 bool device_is_last_sibling(struct udevice *dev)
679 {
680 	struct udevice *parent = dev->parent;
681 
682 	if (!parent)
683 		return false;
684 	return list_is_last(&dev->sibling_node, &parent->child_head);
685 }
686 
687 void device_set_name_alloced(struct udevice *dev)
688 {
689 	dev->flags |= DM_FLAG_NAME_ALLOCED;
690 }
691 
692 int device_set_name(struct udevice *dev, const char *name)
693 {
694 	name = strdup(name);
695 	if (!name)
696 		return -ENOMEM;
697 	dev->name = name;
698 	device_set_name_alloced(dev);
699 
700 	return 0;
701 }
702 
703 bool device_is_compatible(struct udevice *dev, const char *compat)
704 {
705 	const void *fdt = gd->fdt_blob;
706 
707 	return !fdt_node_check_compatible(fdt, dev_of_offset(dev), compat);
708 }
709 
710 bool of_machine_is_compatible(const char *compat)
711 {
712 	const void *fdt = gd->fdt_blob;
713 
714 	return !fdt_node_check_compatible(fdt, 0, compat);
715 }
716