4 * Copyright (c) 2013 Google, Inc
7 * Pavel Herrmann <morpheus.ibis@gmail.com>
9 * SPDX-License-Identifier: GPL-2.0+
15 #include <fdt_support.h>
17 #include <dm/device.h>
18 #include <dm/device-internal.h>
20 #include <dm/pinctrl.h>
21 #include <dm/platdata.h>
22 #include <dm/uclass.h>
23 #include <dm/uclass-internal.h>
25 #include <linux/err.h>
26 #include <linux/list.h>
28 DECLARE_GLOBAL_DATA_PTR
;
30 static int device_bind_common(struct udevice
*parent
, const struct driver
*drv
,
31 const char *name
, void *platdata
,
32 ulong driver_data
, int of_offset
,
33 uint of_platdata_size
, struct udevice
**devp
)
44 ret
= uclass_get(drv
->id
, &uc
);
46 debug("Missing uclass for driver %s\n", drv
->name
);
50 dev
= calloc(1, sizeof(struct udevice
));
54 INIT_LIST_HEAD(&dev
->sibling_node
);
55 INIT_LIST_HEAD(&dev
->child_head
);
56 INIT_LIST_HEAD(&dev
->uclass_node
);
58 INIT_LIST_HEAD(&dev
->devres_head
);
60 dev
->platdata
= platdata
;
61 dev
->driver_data
= driver_data
;
63 dev
->of_offset
= of_offset
;
70 if (CONFIG_IS_ENABLED(OF_CONTROL
) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS
)) {
72 * Some devices, such as a SPI bus, I2C bus and serial ports
73 * are numbered using aliases.
75 * This is just a 'requested' sequence, and will be
76 * resolved (and ->seq updated) when the device is probed.
78 if (uc
->uc_drv
->flags
& DM_UC_FLAG_SEQ_ALIAS
) {
79 if (uc
->uc_drv
->name
&& of_offset
!= -1) {
80 fdtdec_get_alias_seq(gd
->fdt_blob
,
81 uc
->uc_drv
->name
, of_offset
,
87 if (drv
->platdata_auto_alloc_size
) {
88 bool alloc
= !platdata
;
90 if (CONFIG_IS_ENABLED(OF_PLATDATA
)) {
91 if (of_platdata_size
) {
92 dev
->flags
|= DM_FLAG_OF_PLATDATA
;
93 if (of_platdata_size
<
94 drv
->platdata_auto_alloc_size
)
99 dev
->flags
|= DM_FLAG_ALLOC_PDATA
;
100 dev
->platdata
= calloc(1,
101 drv
->platdata_auto_alloc_size
);
102 if (!dev
->platdata
) {
106 if (CONFIG_IS_ENABLED(OF_PLATDATA
) && platdata
) {
107 memcpy(dev
->platdata
, platdata
,
113 size
= uc
->uc_drv
->per_device_platdata_auto_alloc_size
;
115 dev
->flags
|= DM_FLAG_ALLOC_UCLASS_PDATA
;
116 dev
->uclass_platdata
= calloc(1, size
);
117 if (!dev
->uclass_platdata
) {
124 size
= parent
->driver
->per_child_platdata_auto_alloc_size
;
126 size
= parent
->uclass
->uc_drv
->
127 per_child_platdata_auto_alloc_size
;
130 dev
->flags
|= DM_FLAG_ALLOC_PARENT_PDATA
;
131 dev
->parent_platdata
= calloc(1, size
);
132 if (!dev
->parent_platdata
) {
139 /* put dev into parent's successor list */
141 list_add_tail(&dev
->sibling_node
, &parent
->child_head
);
143 ret
= uclass_bind_device(dev
);
145 goto fail_uclass_bind
;
147 /* if we fail to bind we remove device from successors and free it */
149 ret
= drv
->bind(dev
);
153 if (parent
&& parent
->driver
->child_post_bind
) {
154 ret
= parent
->driver
->child_post_bind(dev
);
156 goto fail_child_post_bind
;
158 if (uc
->uc_drv
->post_bind
) {
159 ret
= uc
->uc_drv
->post_bind(dev
);
161 goto fail_uclass_post_bind
;
165 dm_dbg("Bound device %s to %s\n", dev
->name
, parent
->name
);
169 dev
->flags
|= DM_FLAG_BOUND
;
173 fail_uclass_post_bind
:
174 /* There is no child unbind() method, so no clean-up required */
175 fail_child_post_bind
:
176 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE
)) {
177 if (drv
->unbind
&& drv
->unbind(dev
)) {
178 dm_warn("unbind() method failed on dev '%s' on error path\n",
184 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE
)) {
185 if (uclass_unbind_device(dev
)) {
186 dm_warn("Failed to unbind dev '%s' on error path\n",
191 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE
)) {
192 list_del(&dev
->sibling_node
);
193 if (dev
->flags
& DM_FLAG_ALLOC_PARENT_PDATA
) {
194 free(dev
->parent_platdata
);
195 dev
->parent_platdata
= NULL
;
199 if (dev
->flags
& DM_FLAG_ALLOC_UCLASS_PDATA
) {
200 free(dev
->uclass_platdata
);
201 dev
->uclass_platdata
= NULL
;
204 if (dev
->flags
& DM_FLAG_ALLOC_PDATA
) {
206 dev
->platdata
= NULL
;
209 devres_release_all(dev
);
216 int device_bind_with_driver_data(struct udevice
*parent
,
217 const struct driver
*drv
, const char *name
,
218 ulong driver_data
, int of_offset
,
219 struct udevice
**devp
)
221 return device_bind_common(parent
, drv
, name
, NULL
, driver_data
,
225 int device_bind(struct udevice
*parent
, const struct driver
*drv
,
226 const char *name
, void *platdata
, int of_offset
,
227 struct udevice
**devp
)
229 return device_bind_common(parent
, drv
, name
, platdata
, 0, of_offset
, 0,
233 int device_bind_by_name(struct udevice
*parent
, bool pre_reloc_only
,
234 const struct driver_info
*info
, struct udevice
**devp
)
237 uint platdata_size
= 0;
239 drv
= lists_driver_lookup_name(info
->name
);
242 if (pre_reloc_only
&& !(drv
->flags
& DM_FLAG_PRE_RELOC
))
245 #if CONFIG_IS_ENABLED(OF_PLATDATA)
246 platdata_size
= info
->platdata_size
;
248 return device_bind_common(parent
, drv
, info
->name
,
249 (void *)info
->platdata
, 0, -1, platdata_size
, devp
);
252 static void *alloc_priv(int size
, uint flags
)
256 if (flags
& DM_FLAG_ALLOC_PRIV_DMA
) {
257 priv
= memalign(ARCH_DMA_MINALIGN
, size
);
259 memset(priv
, '\0', size
);
261 priv
= calloc(1, size
);
267 int device_probe(struct udevice
*dev
)
269 const struct driver
*drv
;
277 if (dev
->flags
& DM_FLAG_ACTIVATED
)
283 /* Allocate private data if requested and not reentered */
284 if (drv
->priv_auto_alloc_size
&& !dev
->priv
) {
285 dev
->priv
= alloc_priv(drv
->priv_auto_alloc_size
, drv
->flags
);
291 /* Allocate private data if requested and not reentered */
292 size
= dev
->uclass
->uc_drv
->per_device_auto_alloc_size
;
293 if (size
&& !dev
->uclass_priv
) {
294 dev
->uclass_priv
= calloc(1, size
);
295 if (!dev
->uclass_priv
) {
301 /* Ensure all parents are probed */
303 size
= dev
->parent
->driver
->per_child_auto_alloc_size
;
305 size
= dev
->parent
->uclass
->uc_drv
->
306 per_child_auto_alloc_size
;
308 if (size
&& !dev
->parent_priv
) {
309 dev
->parent_priv
= alloc_priv(size
, drv
->flags
);
310 if (!dev
->parent_priv
) {
316 ret
= device_probe(dev
->parent
);
321 * The device might have already been probed during
322 * the call to device_probe() on its parent device
323 * (e.g. PCI bridge devices). Test the flags again
324 * so that we don't mess up the device.
326 if (dev
->flags
& DM_FLAG_ACTIVATED
)
330 seq
= uclass_resolve_seq(dev
);
337 dev
->flags
|= DM_FLAG_ACTIVATED
;
340 * Process pinctrl for everything except the root device, and
341 * continue regardless of the result of pinctrl. Don't process pinctrl
342 * settings for pinctrl devices since the device may not yet be
345 if (dev
->parent
&& device_get_uclass_id(dev
) != UCLASS_PINCTRL
)
346 pinctrl_select_state(dev
, "default");
348 ret
= uclass_pre_probe_device(dev
);
352 if (dev
->parent
&& dev
->parent
->driver
->child_pre_probe
) {
353 ret
= dev
->parent
->driver
->child_pre_probe(dev
);
358 if (drv
->ofdata_to_platdata
&& dev
->of_offset
>= 0) {
359 ret
= drv
->ofdata_to_platdata(dev
);
365 ret
= drv
->probe(dev
);
367 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
372 ret
= uclass_post_probe_device(dev
);
376 if (dev
->parent
&& device_get_uclass_id(dev
) == UCLASS_PINCTRL
)
377 pinctrl_select_state(dev
, "default");
381 if (device_remove(dev
)) {
382 dm_warn("%s: Device '%s' failed to remove on error path\n",
383 __func__
, dev
->name
);
386 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
394 void *dev_get_platdata(struct udevice
*dev
)
397 dm_warn("%s: null device\n", __func__
);
401 return dev
->platdata
;
404 void *dev_get_parent_platdata(struct udevice
*dev
)
407 dm_warn("%s: null device\n", __func__
);
411 return dev
->parent_platdata
;
414 void *dev_get_uclass_platdata(struct udevice
*dev
)
417 dm_warn("%s: null device\n", __func__
);
421 return dev
->uclass_platdata
;
424 void *dev_get_priv(struct udevice
*dev
)
427 dm_warn("%s: null device\n", __func__
);
434 void *dev_get_uclass_priv(struct udevice
*dev
)
437 dm_warn("%s: null device\n", __func__
);
441 return dev
->uclass_priv
;
444 void *dev_get_parent_priv(struct udevice
*dev
)
447 dm_warn("%s: null device\n", __func__
);
451 return dev
->parent_priv
;
454 static int device_get_device_tail(struct udevice
*dev
, int ret
,
455 struct udevice
**devp
)
460 ret
= device_probe(dev
);
469 int device_get_child(struct udevice
*parent
, int index
, struct udevice
**devp
)
473 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
475 return device_get_device_tail(dev
, 0, devp
);
481 int device_find_child_by_seq(struct udevice
*parent
, int seq_or_req_seq
,
482 bool find_req_seq
, struct udevice
**devp
)
487 if (seq_or_req_seq
== -1)
490 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
491 if ((find_req_seq
? dev
->req_seq
: dev
->seq
) ==
501 int device_get_child_by_seq(struct udevice
*parent
, int seq
,
502 struct udevice
**devp
)
508 ret
= device_find_child_by_seq(parent
, seq
, false, &dev
);
509 if (ret
== -ENODEV
) {
511 * We didn't find it in probed devices. See if there is one
512 * that will request this seq if probed.
514 ret
= device_find_child_by_seq(parent
, seq
, true, &dev
);
516 return device_get_device_tail(dev
, ret
, devp
);
519 int device_find_child_by_of_offset(struct udevice
*parent
, int of_offset
,
520 struct udevice
**devp
)
526 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
527 if (dev
->of_offset
== of_offset
) {
536 int device_get_child_by_of_offset(struct udevice
*parent
, int node
,
537 struct udevice
**devp
)
543 ret
= device_find_child_by_of_offset(parent
, node
, &dev
);
544 return device_get_device_tail(dev
, ret
, devp
);
547 static struct udevice
*_device_find_global_by_of_offset(struct udevice
*parent
,
550 struct udevice
*dev
, *found
;
552 if (parent
->of_offset
== of_offset
)
555 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
556 found
= _device_find_global_by_of_offset(dev
, of_offset
);
564 int device_get_global_by_of_offset(int of_offset
, struct udevice
**devp
)
568 dev
= _device_find_global_by_of_offset(gd
->dm_root
, of_offset
);
569 return device_get_device_tail(dev
, dev
? 0 : -ENOENT
, devp
);
572 int device_find_first_child(struct udevice
*parent
, struct udevice
**devp
)
574 if (list_empty(&parent
->child_head
)) {
577 *devp
= list_first_entry(&parent
->child_head
, struct udevice
,
584 int device_find_next_child(struct udevice
**devp
)
586 struct udevice
*dev
= *devp
;
587 struct udevice
*parent
= dev
->parent
;
589 if (list_is_last(&dev
->sibling_node
, &parent
->child_head
)) {
592 *devp
= list_entry(dev
->sibling_node
.next
, struct udevice
,
599 struct udevice
*dev_get_parent(struct udevice
*child
)
601 return child
->parent
;
604 ulong
dev_get_driver_data(struct udevice
*dev
)
606 return dev
->driver_data
;
609 const void *dev_get_driver_ops(struct udevice
*dev
)
611 if (!dev
|| !dev
->driver
->ops
)
614 return dev
->driver
->ops
;
617 enum uclass_id
device_get_uclass_id(struct udevice
*dev
)
619 return dev
->uclass
->uc_drv
->id
;
622 const char *dev_get_uclass_name(struct udevice
*dev
)
627 return dev
->uclass
->uc_drv
->name
;
630 fdt_addr_t
dev_get_addr_index(struct udevice
*dev
, int index
)
632 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
635 if (CONFIG_IS_ENABLED(OF_TRANSLATE
)) {
640 na
= fdt_address_cells(gd
->fdt_blob
, dev
->parent
->of_offset
);
642 debug("bad #address-cells\n");
643 return FDT_ADDR_T_NONE
;
646 ns
= fdt_size_cells(gd
->fdt_blob
, dev
->parent
->of_offset
);
648 debug("bad #size-cells\n");
649 return FDT_ADDR_T_NONE
;
652 reg
= fdt_getprop(gd
->fdt_blob
, dev
->of_offset
, "reg", &len
);
653 if (!reg
|| (len
<= (index
* sizeof(fdt32_t
) * (na
+ ns
)))) {
654 debug("Req index out of range\n");
655 return FDT_ADDR_T_NONE
;
658 reg
+= index
* (na
+ ns
);
661 * Use the full-fledged translate function for complex
664 addr
= fdt_translate_address((void *)gd
->fdt_blob
,
665 dev
->of_offset
, reg
);
668 * Use the "simple" translate function for less complex
671 addr
= fdtdec_get_addr_size_auto_parent(gd
->fdt_blob
,
672 dev
->parent
->of_offset
,
673 dev
->of_offset
, "reg",
675 if (CONFIG_IS_ENABLED(SIMPLE_BUS
) && addr
!= FDT_ADDR_T_NONE
) {
676 if (device_get_uclass_id(dev
->parent
) ==
678 addr
= simple_bus_translate(dev
->parent
, addr
);
683 * Some platforms need a special address translation. Those
684 * platforms (e.g. mvebu in SPL) can configure a translation
685 * offset in the DM by calling dm_set_translation_offset() that
686 * will get added to all addresses returned by dev_get_addr().
688 addr
+= dm_get_translation_offset();
692 return FDT_ADDR_T_NONE
;
696 fdt_addr_t
dev_get_addr_size_index(struct udevice
*dev
, int index
,
699 #if CONFIG_IS_ENABLED(OF_CONTROL)
701 * Only get the size in this first call. We'll get the addr in the
702 * next call to the exisiting dev_get_xxx function which handles
703 * all config options.
705 fdtdec_get_addr_size_auto_noparent(gd
->fdt_blob
, dev
->of_offset
,
706 "reg", index
, size
, false);
709 * Get the base address via the existing function which handles
712 return dev_get_addr_index(dev
, index
);
714 return FDT_ADDR_T_NONE
;
718 fdt_addr_t
dev_get_addr_name(struct udevice
*dev
, const char *name
)
720 #if CONFIG_IS_ENABLED(OF_CONTROL)
723 index
= fdt_stringlist_search(gd
->fdt_blob
, dev
->of_offset
,
728 return dev_get_addr_index(dev
, index
);
730 return FDT_ADDR_T_NONE
;
734 fdt_addr_t
dev_get_addr(struct udevice
*dev
)
736 return dev_get_addr_index(dev
, 0);
739 void *dev_get_addr_ptr(struct udevice
*dev
)
741 return (void *)(uintptr_t)dev_get_addr_index(dev
, 0);
744 void *dev_map_physmem(struct udevice
*dev
, unsigned long size
)
746 fdt_addr_t addr
= dev_get_addr(dev
);
748 if (addr
== FDT_ADDR_T_NONE
)
751 return map_physmem(addr
, size
, MAP_NOCACHE
);
754 bool device_has_children(struct udevice
*dev
)
756 return !list_empty(&dev
->child_head
);
759 bool device_has_active_children(struct udevice
*dev
)
761 struct udevice
*child
;
763 for (device_find_first_child(dev
, &child
);
765 device_find_next_child(&child
)) {
766 if (device_active(child
))
773 bool device_is_last_sibling(struct udevice
*dev
)
775 struct udevice
*parent
= dev
->parent
;
779 return list_is_last(&dev
->sibling_node
, &parent
->child_head
);
782 void device_set_name_alloced(struct udevice
*dev
)
784 dev
->flags
|= DM_FLAG_NAME_ALLOCED
;
787 int device_set_name(struct udevice
*dev
, const char *name
)
793 device_set_name_alloced(dev
);
798 bool of_device_is_compatible(struct udevice
*dev
, const char *compat
)
800 const void *fdt
= gd
->fdt_blob
;
802 return !fdt_node_check_compatible(fdt
, dev
->of_offset
, compat
);
805 bool of_machine_is_compatible(const char *compat
)
807 const void *fdt
= gd
->fdt_blob
;
809 return !fdt_node_check_compatible(fdt
, 0, compat
);