4 * Copyright (c) 2013 Google, Inc
7 * Pavel Herrmann <morpheus.ibis@gmail.com>
9 * SPDX-License-Identifier: GPL-2.0+
14 #include <fdt_support.h>
16 #include <dm/device.h>
17 #include <dm/device-internal.h>
19 #include <dm/pinctrl.h>
20 #include <dm/platdata.h>
21 #include <dm/uclass.h>
22 #include <dm/uclass-internal.h>
24 #include <linux/err.h>
25 #include <linux/list.h>
27 DECLARE_GLOBAL_DATA_PTR
;
29 int device_bind(struct udevice
*parent
, const struct driver
*drv
,
30 const char *name
, void *platdata
, int of_offset
,
31 struct udevice
**devp
)
42 ret
= uclass_get(drv
->id
, &uc
);
44 debug("Missing uclass for driver %s\n", drv
->name
);
48 dev
= calloc(1, sizeof(struct udevice
));
52 INIT_LIST_HEAD(&dev
->sibling_node
);
53 INIT_LIST_HEAD(&dev
->child_head
);
54 INIT_LIST_HEAD(&dev
->uclass_node
);
56 INIT_LIST_HEAD(&dev
->devres_head
);
58 dev
->platdata
= platdata
;
60 dev
->of_offset
= of_offset
;
67 if (CONFIG_IS_ENABLED(OF_CONTROL
) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS
)) {
69 * Some devices, such as a SPI bus, I2C bus and serial ports
70 * are numbered using aliases.
72 * This is just a 'requested' sequence, and will be
73 * resolved (and ->seq updated) when the device is probed.
75 if (uc
->uc_drv
->flags
& DM_UC_FLAG_SEQ_ALIAS
) {
76 if (uc
->uc_drv
->name
&& of_offset
!= -1) {
77 fdtdec_get_alias_seq(gd
->fdt_blob
,
78 uc
->uc_drv
->name
, of_offset
,
84 if (!dev
->platdata
&& drv
->platdata_auto_alloc_size
) {
85 dev
->flags
|= DM_FLAG_ALLOC_PDATA
;
86 dev
->platdata
= calloc(1, drv
->platdata_auto_alloc_size
);
93 size
= uc
->uc_drv
->per_device_platdata_auto_alloc_size
;
95 dev
->flags
|= DM_FLAG_ALLOC_UCLASS_PDATA
;
96 dev
->uclass_platdata
= calloc(1, size
);
97 if (!dev
->uclass_platdata
) {
104 size
= parent
->driver
->per_child_platdata_auto_alloc_size
;
106 size
= parent
->uclass
->uc_drv
->
107 per_child_platdata_auto_alloc_size
;
110 dev
->flags
|= DM_FLAG_ALLOC_PARENT_PDATA
;
111 dev
->parent_platdata
= calloc(1, size
);
112 if (!dev
->parent_platdata
) {
119 /* put dev into parent's successor list */
121 list_add_tail(&dev
->sibling_node
, &parent
->child_head
);
123 ret
= uclass_bind_device(dev
);
125 goto fail_uclass_bind
;
127 /* if we fail to bind we remove device from successors and free it */
129 ret
= drv
->bind(dev
);
133 if (parent
&& parent
->driver
->child_post_bind
) {
134 ret
= parent
->driver
->child_post_bind(dev
);
136 goto fail_child_post_bind
;
138 if (uc
->uc_drv
->post_bind
) {
139 ret
= uc
->uc_drv
->post_bind(dev
);
141 goto fail_uclass_post_bind
;
145 dm_dbg("Bound device %s to %s\n", dev
->name
, parent
->name
);
149 dev
->flags
|= DM_FLAG_BOUND
;
153 fail_uclass_post_bind
:
154 /* There is no child unbind() method, so no clean-up required */
155 fail_child_post_bind
:
156 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE
)) {
157 if (drv
->unbind
&& drv
->unbind(dev
)) {
158 dm_warn("unbind() method failed on dev '%s' on error path\n",
164 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE
)) {
165 if (uclass_unbind_device(dev
)) {
166 dm_warn("Failed to unbind dev '%s' on error path\n",
171 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE
)) {
172 list_del(&dev
->sibling_node
);
173 if (dev
->flags
& DM_FLAG_ALLOC_PARENT_PDATA
) {
174 free(dev
->parent_platdata
);
175 dev
->parent_platdata
= NULL
;
179 if (dev
->flags
& DM_FLAG_ALLOC_UCLASS_PDATA
) {
180 free(dev
->uclass_platdata
);
181 dev
->uclass_platdata
= NULL
;
184 if (dev
->flags
& DM_FLAG_ALLOC_PDATA
) {
186 dev
->platdata
= NULL
;
189 devres_release_all(dev
);
196 int device_bind_by_name(struct udevice
*parent
, bool pre_reloc_only
,
197 const struct driver_info
*info
, struct udevice
**devp
)
201 drv
= lists_driver_lookup_name(info
->name
);
204 if (pre_reloc_only
&& !(drv
->flags
& DM_FLAG_PRE_RELOC
))
207 return device_bind(parent
, drv
, info
->name
, (void *)info
->platdata
,
211 static void *alloc_priv(int size
, uint flags
)
215 if (flags
& DM_FLAG_ALLOC_PRIV_DMA
) {
216 priv
= memalign(ARCH_DMA_MINALIGN
, size
);
218 memset(priv
, '\0', size
);
220 priv
= calloc(1, size
);
226 int device_probe(struct udevice
*dev
)
228 const struct driver
*drv
;
236 if (dev
->flags
& DM_FLAG_ACTIVATED
)
242 /* Allocate private data if requested and not reentered */
243 if (drv
->priv_auto_alloc_size
&& !dev
->priv
) {
244 dev
->priv
= alloc_priv(drv
->priv_auto_alloc_size
, drv
->flags
);
250 /* Allocate private data if requested and not reentered */
251 size
= dev
->uclass
->uc_drv
->per_device_auto_alloc_size
;
252 if (size
&& !dev
->uclass_priv
) {
253 dev
->uclass_priv
= calloc(1, size
);
254 if (!dev
->uclass_priv
) {
260 /* Ensure all parents are probed */
262 size
= dev
->parent
->driver
->per_child_auto_alloc_size
;
264 size
= dev
->parent
->uclass
->uc_drv
->
265 per_child_auto_alloc_size
;
267 if (size
&& !dev
->parent_priv
) {
268 dev
->parent_priv
= alloc_priv(size
, drv
->flags
);
269 if (!dev
->parent_priv
) {
275 ret
= device_probe(dev
->parent
);
280 * The device might have already been probed during
281 * the call to device_probe() on its parent device
282 * (e.g. PCI bridge devices). Test the flags again
283 * so that we don't mess up the device.
285 if (dev
->flags
& DM_FLAG_ACTIVATED
)
289 seq
= uclass_resolve_seq(dev
);
296 dev
->flags
|= DM_FLAG_ACTIVATED
;
299 * Process pinctrl for everything except the root device, and
300 * continue regardless of the result of pinctrl. Don't process pinctrl
301 * settings for pinctrl devices since the device may not yet be
304 if (dev
->parent
&& device_get_uclass_id(dev
) != UCLASS_PINCTRL
)
305 pinctrl_select_state(dev
, "default");
307 ret
= uclass_pre_probe_device(dev
);
311 if (dev
->parent
&& dev
->parent
->driver
->child_pre_probe
) {
312 ret
= dev
->parent
->driver
->child_pre_probe(dev
);
317 if (drv
->ofdata_to_platdata
&& dev
->of_offset
>= 0) {
318 ret
= drv
->ofdata_to_platdata(dev
);
324 ret
= drv
->probe(dev
);
326 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
331 ret
= uclass_post_probe_device(dev
);
337 if (device_remove(dev
)) {
338 dm_warn("%s: Device '%s' failed to remove on error path\n",
339 __func__
, dev
->name
);
342 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
350 void *dev_get_platdata(struct udevice
*dev
)
353 dm_warn("%s: null device\n", __func__
);
357 return dev
->platdata
;
360 void *dev_get_parent_platdata(struct udevice
*dev
)
363 dm_warn("%s: null device\n", __func__
);
367 return dev
->parent_platdata
;
370 void *dev_get_uclass_platdata(struct udevice
*dev
)
373 dm_warn("%s: null device\n", __func__
);
377 return dev
->uclass_platdata
;
380 void *dev_get_priv(struct udevice
*dev
)
383 dm_warn("%s: null device\n", __func__
);
390 void *dev_get_uclass_priv(struct udevice
*dev
)
393 dm_warn("%s: null device\n", __func__
);
397 return dev
->uclass_priv
;
400 void *dev_get_parent_priv(struct udevice
*dev
)
403 dm_warn("%s: null device\n", __func__
);
407 return dev
->parent_priv
;
410 static int device_get_device_tail(struct udevice
*dev
, int ret
,
411 struct udevice
**devp
)
416 ret
= device_probe(dev
);
425 int device_get_child(struct udevice
*parent
, int index
, struct udevice
**devp
)
429 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
431 return device_get_device_tail(dev
, 0, devp
);
437 int device_find_child_by_seq(struct udevice
*parent
, int seq_or_req_seq
,
438 bool find_req_seq
, struct udevice
**devp
)
443 if (seq_or_req_seq
== -1)
446 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
447 if ((find_req_seq
? dev
->req_seq
: dev
->seq
) ==
457 int device_get_child_by_seq(struct udevice
*parent
, int seq
,
458 struct udevice
**devp
)
464 ret
= device_find_child_by_seq(parent
, seq
, false, &dev
);
465 if (ret
== -ENODEV
) {
467 * We didn't find it in probed devices. See if there is one
468 * that will request this seq if probed.
470 ret
= device_find_child_by_seq(parent
, seq
, true, &dev
);
472 return device_get_device_tail(dev
, ret
, devp
);
475 int device_find_child_by_of_offset(struct udevice
*parent
, int of_offset
,
476 struct udevice
**devp
)
482 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
483 if (dev
->of_offset
== of_offset
) {
492 int device_get_child_by_of_offset(struct udevice
*parent
, int node
,
493 struct udevice
**devp
)
499 ret
= device_find_child_by_of_offset(parent
, node
, &dev
);
500 return device_get_device_tail(dev
, ret
, devp
);
503 static struct udevice
*_device_find_global_by_of_offset(struct udevice
*parent
,
506 struct udevice
*dev
, *found
;
508 if (parent
->of_offset
== of_offset
)
511 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
512 found
= _device_find_global_by_of_offset(dev
, of_offset
);
520 int device_get_global_by_of_offset(int of_offset
, struct udevice
**devp
)
524 dev
= _device_find_global_by_of_offset(gd
->dm_root
, of_offset
);
525 return device_get_device_tail(dev
, dev
? 0 : -ENOENT
, devp
);
528 int device_find_first_child(struct udevice
*parent
, struct udevice
**devp
)
530 if (list_empty(&parent
->child_head
)) {
533 *devp
= list_first_entry(&parent
->child_head
, struct udevice
,
540 int device_find_next_child(struct udevice
**devp
)
542 struct udevice
*dev
= *devp
;
543 struct udevice
*parent
= dev
->parent
;
545 if (list_is_last(&dev
->sibling_node
, &parent
->child_head
)) {
548 *devp
= list_entry(dev
->sibling_node
.next
, struct udevice
,
555 struct udevice
*dev_get_parent(struct udevice
*child
)
557 return child
->parent
;
560 ulong
dev_get_driver_data(struct udevice
*dev
)
562 return dev
->driver_data
;
565 const void *dev_get_driver_ops(struct udevice
*dev
)
567 if (!dev
|| !dev
->driver
->ops
)
570 return dev
->driver
->ops
;
573 enum uclass_id
device_get_uclass_id(struct udevice
*dev
)
575 return dev
->uclass
->uc_drv
->id
;
578 const char *dev_get_uclass_name(struct udevice
*dev
)
583 return dev
->uclass
->uc_drv
->name
;
586 fdt_addr_t
dev_get_addr_index(struct udevice
*dev
, int index
)
588 #if CONFIG_IS_ENABLED(OF_CONTROL)
591 if (CONFIG_IS_ENABLED(OF_TRANSLATE
)) {
596 na
= fdt_address_cells(gd
->fdt_blob
, dev
->parent
->of_offset
);
598 debug("bad #address-cells\n");
599 return FDT_ADDR_T_NONE
;
602 ns
= fdt_size_cells(gd
->fdt_blob
, dev
->parent
->of_offset
);
604 debug("bad #size-cells\n");
605 return FDT_ADDR_T_NONE
;
608 reg
= fdt_getprop(gd
->fdt_blob
, dev
->of_offset
, "reg", &len
);
609 if (!reg
|| (len
<= (index
* sizeof(fdt32_t
) * (na
+ ns
)))) {
610 debug("Req index out of range\n");
611 return FDT_ADDR_T_NONE
;
614 reg
+= index
* (na
+ ns
);
617 * Use the full-fledged translate function for complex
620 addr
= fdt_translate_address((void *)gd
->fdt_blob
,
621 dev
->of_offset
, reg
);
624 * Use the "simple" translate function for less complex
627 addr
= fdtdec_get_addr_size_auto_parent(gd
->fdt_blob
,
628 dev
->parent
->of_offset
,
629 dev
->of_offset
, "reg",
631 if (CONFIG_IS_ENABLED(SIMPLE_BUS
) && addr
!= FDT_ADDR_T_NONE
) {
632 if (device_get_uclass_id(dev
->parent
) ==
634 addr
= simple_bus_translate(dev
->parent
, addr
);
639 * Some platforms need a special address translation. Those
640 * platforms (e.g. mvebu in SPL) can configure a translation
641 * offset in the DM by calling dm_set_translation_offset() that
642 * will get added to all addresses returned by dev_get_addr().
644 addr
+= dm_get_translation_offset();
648 return FDT_ADDR_T_NONE
;
652 fdt_addr_t
dev_get_addr(struct udevice
*dev
)
654 return dev_get_addr_index(dev
, 0);
657 bool device_has_children(struct udevice
*dev
)
659 return !list_empty(&dev
->child_head
);
662 bool device_has_active_children(struct udevice
*dev
)
664 struct udevice
*child
;
666 for (device_find_first_child(dev
, &child
);
668 device_find_next_child(&child
)) {
669 if (device_active(child
))
676 bool device_is_last_sibling(struct udevice
*dev
)
678 struct udevice
*parent
= dev
->parent
;
682 return list_is_last(&dev
->sibling_node
, &parent
->child_head
);
685 int device_set_name(struct udevice
*dev
, const char *name
)