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>
23 #include <dm/uclass.h>
24 #include <dm/uclass-internal.h>
26 #include <linux/err.h>
27 #include <linux/list.h>
29 DECLARE_GLOBAL_DATA_PTR
;
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
)
45 ret
= uclass_get(drv
->id
, &uc
);
47 debug("Missing uclass for driver %s\n", drv
->name
);
51 dev
= calloc(1, sizeof(struct udevice
));
55 INIT_LIST_HEAD(&dev
->sibling_node
);
56 INIT_LIST_HEAD(&dev
->child_head
);
57 INIT_LIST_HEAD(&dev
->uclass_node
);
59 INIT_LIST_HEAD(&dev
->devres_head
);
61 dev
->platdata
= platdata
;
62 dev
->driver_data
= driver_data
;
71 if (CONFIG_IS_ENABLED(OF_CONTROL
) && CONFIG_IS_ENABLED(DM_SEQ_ALIAS
)) {
73 * Some devices, such as a SPI bus, I2C bus and serial ports
74 * are numbered using aliases.
76 * This is just a 'requested' sequence, and will be
77 * resolved (and ->seq updated) when the device is probed.
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
);
86 if (drv
->platdata_auto_alloc_size
) {
87 bool alloc
= !platdata
;
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
)
98 dev
->flags
|= DM_FLAG_ALLOC_PDATA
;
99 dev
->platdata
= calloc(1,
100 drv
->platdata_auto_alloc_size
);
101 if (!dev
->platdata
) {
105 if (CONFIG_IS_ENABLED(OF_PLATDATA
) && platdata
) {
106 memcpy(dev
->platdata
, platdata
,
112 size
= uc
->uc_drv
->per_device_platdata_auto_alloc_size
;
114 dev
->flags
|= DM_FLAG_ALLOC_UCLASS_PDATA
;
115 dev
->uclass_platdata
= calloc(1, size
);
116 if (!dev
->uclass_platdata
) {
123 size
= parent
->driver
->per_child_platdata_auto_alloc_size
;
125 size
= parent
->uclass
->uc_drv
->
126 per_child_platdata_auto_alloc_size
;
129 dev
->flags
|= DM_FLAG_ALLOC_PARENT_PDATA
;
130 dev
->parent_platdata
= calloc(1, size
);
131 if (!dev
->parent_platdata
) {
138 /* put dev into parent's successor list */
140 list_add_tail(&dev
->sibling_node
, &parent
->child_head
);
142 ret
= uclass_bind_device(dev
);
144 goto fail_uclass_bind
;
146 /* if we fail to bind we remove device from successors and free it */
148 ret
= drv
->bind(dev
);
152 if (parent
&& parent
->driver
->child_post_bind
) {
153 ret
= parent
->driver
->child_post_bind(dev
);
155 goto fail_child_post_bind
;
157 if (uc
->uc_drv
->post_bind
) {
158 ret
= uc
->uc_drv
->post_bind(dev
);
160 goto fail_uclass_post_bind
;
164 dm_dbg("Bound device %s to %s\n", dev
->name
, parent
->name
);
168 dev
->flags
|= DM_FLAG_BOUND
;
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",
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",
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
;
198 if (dev
->flags
& DM_FLAG_ALLOC_UCLASS_PDATA
) {
199 free(dev
->uclass_platdata
);
200 dev
->uclass_platdata
= NULL
;
203 if (dev
->flags
& DM_FLAG_ALLOC_PDATA
) {
205 dev
->platdata
= NULL
;
208 devres_release_all(dev
);
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
)
220 return device_bind_common(parent
, drv
, name
, NULL
, driver_data
, node
,
224 int device_bind(struct udevice
*parent
, const struct driver
*drv
,
225 const char *name
, void *platdata
, int of_offset
,
226 struct udevice
**devp
)
228 return device_bind_common(parent
, drv
, name
, platdata
, 0,
229 offset_to_ofnode(of_offset
), 0, devp
);
232 int device_bind_by_name(struct udevice
*parent
, bool pre_reloc_only
,
233 const struct driver_info
*info
, struct udevice
**devp
)
236 uint platdata_size
= 0;
238 drv
= lists_driver_lookup_name(info
->name
);
241 if (pre_reloc_only
&& !(drv
->flags
& DM_FLAG_PRE_RELOC
))
244 #if CONFIG_IS_ENABLED(OF_PLATDATA)
245 platdata_size
= info
->platdata_size
;
247 return device_bind_common(parent
, drv
, info
->name
,
248 (void *)info
->platdata
, 0, ofnode_null(), platdata_size
,
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
);
262 * Ensure that the zero bytes are flushed to memory.
263 * This prevents problems if the driver uses this as
264 * both an input and an output buffer:
266 * 1. Zeroes written to buffer (here) and sit in the
268 * 2. Driver issues a read command to DMA
269 * 3. CPU runs out of cache space and evicts some cache
270 * data in the buffer, writing zeroes to RAM from
273 * 5. Buffer now has some DMA data and some zeroes
274 * 6. Data being read is now incorrect
276 * To prevent this, ensure that the cache is clean
277 * within this range at the start. The driver can then
278 * use normal flush-after-write, invalidate-before-read
281 * TODO(sjg@chromium.org): Drop this microblaze
284 #ifndef CONFIG_MICROBLAZE
285 flush_dcache_range((ulong
)priv
, (ulong
)priv
+ size
);
289 priv
= calloc(1, size
);
295 int device_probe(struct udevice
*dev
)
297 const struct driver
*drv
;
305 if (dev
->flags
& DM_FLAG_ACTIVATED
)
311 /* Allocate private data if requested and not reentered */
312 if (drv
->priv_auto_alloc_size
&& !dev
->priv
) {
313 dev
->priv
= alloc_priv(drv
->priv_auto_alloc_size
, drv
->flags
);
319 /* Allocate private data if requested and not reentered */
320 size
= dev
->uclass
->uc_drv
->per_device_auto_alloc_size
;
321 if (size
&& !dev
->uclass_priv
) {
322 dev
->uclass_priv
= calloc(1, size
);
323 if (!dev
->uclass_priv
) {
329 /* Ensure all parents are probed */
331 size
= dev
->parent
->driver
->per_child_auto_alloc_size
;
333 size
= dev
->parent
->uclass
->uc_drv
->
334 per_child_auto_alloc_size
;
336 if (size
&& !dev
->parent_priv
) {
337 dev
->parent_priv
= alloc_priv(size
, drv
->flags
);
338 if (!dev
->parent_priv
) {
344 ret
= device_probe(dev
->parent
);
349 * The device might have already been probed during
350 * the call to device_probe() on its parent device
351 * (e.g. PCI bridge devices). Test the flags again
352 * so that we don't mess up the device.
354 if (dev
->flags
& DM_FLAG_ACTIVATED
)
358 seq
= uclass_resolve_seq(dev
);
365 dev
->flags
|= DM_FLAG_ACTIVATED
;
368 * Process pinctrl for everything except the root device, and
369 * continue regardless of the result of pinctrl. Don't process pinctrl
370 * settings for pinctrl devices since the device may not yet be
373 if (dev
->parent
&& device_get_uclass_id(dev
) != UCLASS_PINCTRL
)
374 pinctrl_select_state(dev
, "default");
376 ret
= uclass_pre_probe_device(dev
);
380 if (dev
->parent
&& dev
->parent
->driver
->child_pre_probe
) {
381 ret
= dev
->parent
->driver
->child_pre_probe(dev
);
386 if (drv
->ofdata_to_platdata
&& dev_has_of_node(dev
)) {
387 ret
= drv
->ofdata_to_platdata(dev
);
393 ret
= drv
->probe(dev
);
395 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
400 ret
= uclass_post_probe_device(dev
);
404 if (dev
->parent
&& device_get_uclass_id(dev
) == UCLASS_PINCTRL
)
405 pinctrl_select_state(dev
, "default");
409 if (device_remove(dev
, DM_REMOVE_NORMAL
)) {
410 dm_warn("%s: Device '%s' failed to remove on error path\n",
411 __func__
, dev
->name
);
414 dev
->flags
&= ~DM_FLAG_ACTIVATED
;
422 void *dev_get_platdata(struct udevice
*dev
)
425 dm_warn("%s: null device\n", __func__
);
429 return dev
->platdata
;
432 void *dev_get_parent_platdata(struct udevice
*dev
)
435 dm_warn("%s: null device\n", __func__
);
439 return dev
->parent_platdata
;
442 void *dev_get_uclass_platdata(struct udevice
*dev
)
445 dm_warn("%s: null device\n", __func__
);
449 return dev
->uclass_platdata
;
452 void *dev_get_priv(struct udevice
*dev
)
455 dm_warn("%s: null device\n", __func__
);
462 void *dev_get_uclass_priv(struct udevice
*dev
)
465 dm_warn("%s: null device\n", __func__
);
469 return dev
->uclass_priv
;
472 void *dev_get_parent_priv(struct udevice
*dev
)
475 dm_warn("%s: null device\n", __func__
);
479 return dev
->parent_priv
;
482 static int device_get_device_tail(struct udevice
*dev
, int ret
,
483 struct udevice
**devp
)
488 ret
= device_probe(dev
);
497 int device_get_child(struct udevice
*parent
, int index
, struct udevice
**devp
)
501 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
503 return device_get_device_tail(dev
, 0, devp
);
509 int device_find_child_by_seq(struct udevice
*parent
, int seq_or_req_seq
,
510 bool find_req_seq
, struct udevice
**devp
)
515 if (seq_or_req_seq
== -1)
518 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
519 if ((find_req_seq
? dev
->req_seq
: dev
->seq
) ==
529 int device_get_child_by_seq(struct udevice
*parent
, int seq
,
530 struct udevice
**devp
)
536 ret
= device_find_child_by_seq(parent
, seq
, false, &dev
);
537 if (ret
== -ENODEV
) {
539 * We didn't find it in probed devices. See if there is one
540 * that will request this seq if probed.
542 ret
= device_find_child_by_seq(parent
, seq
, true, &dev
);
544 return device_get_device_tail(dev
, ret
, devp
);
547 int device_find_child_by_of_offset(struct udevice
*parent
, int of_offset
,
548 struct udevice
**devp
)
554 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
555 if (dev_of_offset(dev
) == of_offset
) {
564 int device_get_child_by_of_offset(struct udevice
*parent
, int node
,
565 struct udevice
**devp
)
571 ret
= device_find_child_by_of_offset(parent
, node
, &dev
);
572 return device_get_device_tail(dev
, ret
, devp
);
575 static struct udevice
*_device_find_global_by_of_offset(struct udevice
*parent
,
578 struct udevice
*dev
, *found
;
580 if (dev_of_offset(parent
) == of_offset
)
583 list_for_each_entry(dev
, &parent
->child_head
, sibling_node
) {
584 found
= _device_find_global_by_of_offset(dev
, of_offset
);
592 int device_get_global_by_of_offset(int of_offset
, struct udevice
**devp
)
596 dev
= _device_find_global_by_of_offset(gd
->dm_root
, of_offset
);
597 return device_get_device_tail(dev
, dev
? 0 : -ENOENT
, devp
);
600 int device_find_first_child(struct udevice
*parent
, struct udevice
**devp
)
602 if (list_empty(&parent
->child_head
)) {
605 *devp
= list_first_entry(&parent
->child_head
, struct udevice
,
612 int device_find_next_child(struct udevice
**devp
)
614 struct udevice
*dev
= *devp
;
615 struct udevice
*parent
= dev
->parent
;
617 if (list_is_last(&dev
->sibling_node
, &parent
->child_head
)) {
620 *devp
= list_entry(dev
->sibling_node
.next
, struct udevice
,
627 struct udevice
*dev_get_parent(struct udevice
*child
)
629 return child
->parent
;
632 ulong
dev_get_driver_data(struct udevice
*dev
)
634 return dev
->driver_data
;
637 const void *dev_get_driver_ops(struct udevice
*dev
)
639 if (!dev
|| !dev
->driver
->ops
)
642 return dev
->driver
->ops
;
645 enum uclass_id
device_get_uclass_id(struct udevice
*dev
)
647 return dev
->uclass
->uc_drv
->id
;
650 const char *dev_get_uclass_name(struct udevice
*dev
)
655 return dev
->uclass
->uc_drv
->name
;
658 bool device_has_children(struct udevice
*dev
)
660 return !list_empty(&dev
->child_head
);
663 bool device_has_active_children(struct udevice
*dev
)
665 struct udevice
*child
;
667 for (device_find_first_child(dev
, &child
);
669 device_find_next_child(&child
)) {
670 if (device_active(child
))
677 bool device_is_last_sibling(struct udevice
*dev
)
679 struct udevice
*parent
= dev
->parent
;
683 return list_is_last(&dev
->sibling_node
, &parent
->child_head
);
686 void device_set_name_alloced(struct udevice
*dev
)
688 dev
->flags
|= DM_FLAG_NAME_ALLOCED
;
691 int device_set_name(struct udevice
*dev
, const char *name
)
697 device_set_name_alloced(dev
);
702 bool device_is_compatible(struct udevice
*dev
, const char *compat
)
704 const void *fdt
= gd
->fdt_blob
;
706 return !fdt_node_check_compatible(fdt
, dev_of_offset(dev
), compat
);
709 bool of_machine_is_compatible(const char *compat
)
711 const void *fdt
= gd
->fdt_blob
;
713 return !fdt_node_check_compatible(fdt
, 0, compat
);