4 * Copyright (c) 2013 Google, Inc
7 * Pavel Herrmann <morpheus.ibis@gmail.com>
9 * SPDX-License-Identifier: GPL-2.0+
15 #include <dm/device.h>
16 #include <dm/device-internal.h>
18 #include <dm/platdata.h>
19 #include <dm/uclass.h>
20 #include <dm/uclass-internal.h>
22 #include <linux/err.h>
23 #include <linux/list.h>
25 DECLARE_GLOBAL_DATA_PTR
;
27 int device_bind(struct udevice
*parent
, const struct driver
*drv
,
28 const char *name
, void *platdata
, int of_offset
,
29 struct udevice
**devp
)
39 ret
= uclass_get(drv
->id
, &uc
);
43 dev
= calloc(1, sizeof(struct udevice
));
47 INIT_LIST_HEAD(&dev
->sibling_node
);
48 INIT_LIST_HEAD(&dev
->child_head
);
49 INIT_LIST_HEAD(&dev
->uclass_node
);
51 INIT_LIST_HEAD(&dev
->devres_head
);
53 dev
->platdata
= platdata
;
55 dev
->of_offset
= of_offset
;
62 if (IS_ENABLED(CONFIG_OF_CONTROL
) && IS_ENABLED(CONFIG_DM_SEQ_ALIAS
)) {
64 * Some devices, such as a SPI bus, I2C bus and serial ports
65 * are numbered using aliases.
67 * This is just a 'requested' sequence, and will be
68 * resolved (and ->seq updated) when the device is probed.
70 if (uc
->uc_drv
->flags
& DM_UC_FLAG_SEQ_ALIAS
) {
71 if (uc
->uc_drv
->name
&& of_offset
!= -1) {
72 fdtdec_get_alias_seq(gd
->fdt_blob
,
73 uc
->uc_drv
->name
, of_offset
,
79 if (!dev
->platdata
&& drv
->platdata_auto_alloc_size
) {
80 dev
->flags
|= DM_FLAG_ALLOC_PDATA
;
81 dev
->platdata
= calloc(1, drv
->platdata_auto_alloc_size
);
88 size
= uc
->uc_drv
->per_device_platdata_auto_alloc_size
;
90 dev
->flags
|= DM_FLAG_ALLOC_UCLASS_PDATA
;
91 dev
->uclass_platdata
= calloc(1, size
);
92 if (!dev
->uclass_platdata
) {
99 size
= parent
->driver
->per_child_platdata_auto_alloc_size
;
101 size
= parent
->uclass
->uc_drv
->
102 per_child_platdata_auto_alloc_size
;
105 dev
->flags
|= DM_FLAG_ALLOC_PARENT_PDATA
;
106 dev
->parent_platdata
= calloc(1, size
);
107 if (!dev
->parent_platdata
) {
114 /* put dev into parent's successor list */
116 list_add_tail(&dev
->sibling_node
, &parent
->child_head
);
118 ret
= uclass_bind_device(dev
);
120 goto fail_uclass_bind
;
122 /* if we fail to bind we remove device from successors and free it */
124 ret
= drv
->bind(dev
);
128 if (parent
&& parent
->driver
->child_post_bind
) {
129 ret
= parent
->driver
->child_post_bind(dev
);
131 goto fail_child_post_bind
;
135 dm_dbg("Bound device %s to %s\n", dev
->name
, parent
->name
);
138 dev
->flags
|= DM_FLAG_BOUND
;
142 fail_child_post_bind
:
143 if (IS_ENABLED(CONFIG_DM_DEVICE_REMOVE
)) {
144 if (drv
->unbind
&& drv
->unbind(dev
)) {
145 dm_warn("unbind() method failed on dev '%s' on error path\n",
151 if (IS_ENABLED(CONFIG_DM_DEVICE_REMOVE
)) {
152 if (uclass_unbind_device(dev
)) {
153 dm_warn("Failed to unbind dev '%s' on error path\n",
158 if (IS_ENABLED(CONFIG_DM_DEVICE_REMOVE
)) {
159 list_del(&dev
->sibling_node
);
160 if (dev
->flags
& DM_FLAG_ALLOC_PARENT_PDATA
) {
161 free(dev
->parent_platdata
);
162 dev
->parent_platdata
= NULL
;
166 if (dev
->flags
& DM_FLAG_ALLOC_UCLASS_PDATA
) {
167 free(dev
->uclass_platdata
);
168 dev
->uclass_platdata
= NULL
;
171 if (dev
->flags
& DM_FLAG_ALLOC_PDATA
) {
173 dev
->platdata
= NULL
;
176 devres_release_all(dev
);
183 int device_bind_by_name(struct udevice
*parent
, bool pre_reloc_only
,
184 const struct driver_info
*info
, struct udevice
**devp
)
188 drv
= lists_driver_lookup_name(info
->name
);
191 if (pre_reloc_only
&& !(drv
->flags
& DM_FLAG_PRE_RELOC
))
194 return device_bind(parent
, drv
, info
->name
, (void *)info
->platdata
,
198 static void *alloc_priv(int size
, uint flags
)
202 if (flags
& DM_FLAG_ALLOC_PRIV_DMA
) {
203 priv
= memalign(ARCH_DMA_MINALIGN
, size
);
205 memset(priv
, '\0', size
);
207 priv
= calloc(1, size
);
213 int device_probe_child(struct udevice
*dev
, void *parent_priv
)
215 const struct driver
*drv
;
223 if (dev
->flags
& DM_FLAG_ACTIVATED
)
229 /* Allocate private data if requested */
230 if (drv
->priv_auto_alloc_size
) {
231 dev
->priv
= alloc_priv(drv
->priv_auto_alloc_size
, drv
->flags
);
237 /* Allocate private data if requested */
238 size
= dev
->uclass
->uc_drv
->per_device_auto_alloc_size
;
240 dev
->uclass_priv
= calloc(1, size
);
241 if (!dev
->uclass_priv
) {
247 /* Ensure all parents are probed */
249 size
= dev
->parent
->driver
->per_child_auto_alloc_size
;
251 size
= dev
->parent
->uclass
->uc_drv
->
252 per_child_auto_alloc_size
;
255 dev
->parent_priv
= alloc_priv(size
, drv
->flags
);
256 if (!dev
->parent_priv
) {
261 memcpy(dev
->parent_priv
, parent_priv
, size
);
264 ret
= device_probe(dev
->parent
);
269 seq
= uclass_resolve_seq(dev
);
276 dev
->flags
|= DM_FLAG_ACTIVATED
;
278 ret
= uclass_pre_probe_device(dev
);
282 if (dev
->parent
&& dev
->parent
->driver
->child_pre_probe
) {
283 ret
= dev
->parent
->driver
->child_pre_probe(dev
);
288 if (drv
->ofdata_to_platdata
&& dev
->of_offset
>= 0) {
289 ret
= drv
->ofdata_to_platdata(dev
);
295 ret
= drv
->probe(dev
);
297 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
302 ret
= uclass_post_probe_device(dev
);
308 if (device_remove(dev
)) {
309 dm_warn("%s: Device '%s' failed to remove on error path\n",
310 __func__
, dev
->name
);
313 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
321 int device_probe(struct udevice
*dev
)
323 return device_probe_child(dev
, NULL
);
326 void *dev_get_platdata(struct udevice
*dev
)
329 dm_warn("%s: null device\n", __func__
);
333 return dev
->platdata
;
336 void *dev_get_parent_platdata(struct udevice
*dev
)
339 dm_warn("%s: null device\n", __func__
);
343 return dev
->parent_platdata
;
346 void *dev_get_uclass_platdata(struct udevice
*dev
)
349 dm_warn("%s: null device\n", __func__
);
353 return dev
->uclass_platdata
;
356 void *dev_get_priv(struct udevice
*dev
)
359 dm_warn("%s: null device\n", __func__
);
366 void *dev_get_uclass_priv(struct udevice
*dev
)
369 dm_warn("%s: null device\n", __func__
);
373 return dev
->uclass_priv
;
376 void *dev_get_parentdata(struct udevice
*dev
)
379 dm_warn("%s: null device\n", __func__
);
383 return dev
->parent_priv
;
386 static int device_get_device_tail(struct udevice
*dev
, int ret
,
387 struct udevice
**devp
)
392 ret
= device_probe(dev
);
401 int device_get_child(struct udevice
*parent
, int index
, struct udevice
**devp
)
405 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
407 return device_get_device_tail(dev
, 0, devp
);
413 int device_find_child_by_seq(struct udevice
*parent
, int seq_or_req_seq
,
414 bool find_req_seq
, struct udevice
**devp
)
419 if (seq_or_req_seq
== -1)
422 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
423 if ((find_req_seq
? dev
->req_seq
: dev
->seq
) ==
433 int device_get_child_by_seq(struct udevice
*parent
, int seq
,
434 struct udevice
**devp
)
440 ret
= device_find_child_by_seq(parent
, seq
, false, &dev
);
441 if (ret
== -ENODEV
) {
443 * We didn't find it in probed devices. See if there is one
444 * that will request this seq if probed.
446 ret
= device_find_child_by_seq(parent
, seq
, true, &dev
);
448 return device_get_device_tail(dev
, ret
, devp
);
451 int device_find_child_by_of_offset(struct udevice
*parent
, int of_offset
,
452 struct udevice
**devp
)
458 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
459 if (dev
->of_offset
== of_offset
) {
468 int device_get_child_by_of_offset(struct udevice
*parent
, int node
,
469 struct udevice
**devp
)
475 ret
= device_find_child_by_of_offset(parent
, node
, &dev
);
476 return device_get_device_tail(dev
, ret
, devp
);
479 static struct udevice
*_device_find_global_by_of_offset(struct udevice
*parent
,
482 struct udevice
*dev
, *found
;
484 if (parent
->of_offset
== of_offset
)
487 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
488 found
= _device_find_global_by_of_offset(dev
, of_offset
);
496 int device_get_global_by_of_offset(int of_offset
, struct udevice
**devp
)
500 dev
= _device_find_global_by_of_offset(gd
->dm_root
, of_offset
);
501 return device_get_device_tail(dev
, dev
? 0 : -ENOENT
, devp
);
504 int device_find_first_child(struct udevice
*parent
, struct udevice
**devp
)
506 if (list_empty(&parent
->child_head
)) {
509 *devp
= list_first_entry(&parent
->child_head
, struct udevice
,
516 int device_find_next_child(struct udevice
**devp
)
518 struct udevice
*dev
= *devp
;
519 struct udevice
*parent
= dev
->parent
;
521 if (list_is_last(&dev
->sibling_node
, &parent
->child_head
)) {
524 *devp
= list_entry(dev
->sibling_node
.next
, struct udevice
,
531 struct udevice
*dev_get_parent(struct udevice
*child
)
533 return child
->parent
;
536 ulong
dev_get_driver_data(struct udevice
*dev
)
538 return dev
->driver_data
;
541 const void *dev_get_driver_ops(struct udevice
*dev
)
543 if (!dev
|| !dev
->driver
->ops
)
546 return dev
->driver
->ops
;
549 enum uclass_id
device_get_uclass_id(struct udevice
*dev
)
551 return dev
->uclass
->uc_drv
->id
;
554 const char *dev_get_uclass_name(struct udevice
*dev
)
559 return dev
->uclass
->uc_drv
->name
;
562 fdt_addr_t
dev_get_addr(struct udevice
*dev
)
564 #ifdef CONFIG_OF_CONTROL
567 addr
= fdtdec_get_addr(gd
->fdt_blob
, dev
->of_offset
, "reg");
568 if (addr
!= FDT_ADDR_T_NONE
) {
569 if (device_get_uclass_id(dev
->parent
) == UCLASS_SIMPLE_BUS
)
570 addr
= simple_bus_translate(dev
->parent
, addr
);
575 return FDT_ADDR_T_NONE
;
579 bool device_has_children(struct udevice
*dev
)
581 return !list_empty(&dev
->child_head
);
584 bool device_has_active_children(struct udevice
*dev
)
586 struct udevice
*child
;
588 for (device_find_first_child(dev
, &child
);
590 device_find_next_child(&child
)) {
591 if (device_active(child
))
598 bool device_is_last_sibling(struct udevice
*dev
)
600 struct udevice
*parent
= dev
->parent
;
604 return list_is_last(&dev
->sibling_node
, &parent
->child_head
);