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;
28 * device_chld_unbind() - Unbind all device's children from the device
30 * On error, the function continues to unbind all children, and reports the
33 * @dev: The device that is to be stripped of its children
34 * @return 0 on success, -ve on error
36 static int device_chld_unbind(struct udevice *dev)
38 struct udevice *pos, *n;
39 int ret, saved_ret = 0;
43 list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
44 ret = device_unbind(pos);
45 if (ret && !saved_ret)
53 * device_chld_remove() - Stop all device's children
54 * @dev: The device whose children are to be removed
55 * @return 0 on success, -ve on error
57 static int device_chld_remove(struct udevice *dev)
59 struct udevice *pos, *n;
64 list_for_each_entry_safe(pos, n, &dev->child_head, sibling_node) {
65 ret = device_remove(pos);
73 int device_bind(struct udevice *parent, struct driver *drv, const char *name,
74 void *platdata, int of_offset, struct udevice **devp)
84 ret = uclass_get(drv->id, &uc);
88 dev = calloc(1, sizeof(struct udevice));
92 INIT_LIST_HEAD(&dev->sibling_node);
93 INIT_LIST_HEAD(&dev->child_head);
94 INIT_LIST_HEAD(&dev->uclass_node);
95 dev->platdata = platdata;
97 dev->of_offset = of_offset;
103 * For some devices, such as a SPI or I2C bus, the 'reg' property
104 * is a reasonable indicator of the sequence number. But if there is
105 * an alias, we use that in preference. In any case, this is just
106 * a 'requested' sequence, and will be resolved (and ->seq updated)
107 * when the device is probed.
110 #ifdef CONFIG_OF_CONTROL
111 dev->req_seq = fdtdec_get_int(gd->fdt_blob, of_offset, "reg", -1);
112 if (!IS_ERR_VALUE(dev->req_seq))
113 dev->req_seq &= INT_MAX;
114 if (uc->uc_drv->name && of_offset != -1) {
115 fdtdec_get_alias_seq(gd->fdt_blob, uc->uc_drv->name, of_offset,
121 if (!dev->platdata && drv->platdata_auto_alloc_size)
122 dev->flags |= DM_FLAG_ALLOC_PDATA;
124 /* put dev into parent's successor list */
126 list_add_tail(&dev->sibling_node, &parent->child_head);
128 ret = uclass_bind_device(dev);
132 /* if we fail to bind we remove device from successors and free it */
134 ret = drv->bind(dev);
136 if (uclass_unbind_device(dev)) {
137 dm_warn("Failed to unbind dev '%s' on error path\n",
144 dm_dbg("Bound device %s to %s\n", dev->name, parent->name);
150 list_del(&dev->sibling_node);
155 int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
156 const struct driver_info *info, struct udevice **devp)
160 drv = lists_driver_lookup_name(info->name);
163 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
166 return device_bind(parent, drv, info->name, (void *)info->platdata,
170 int device_unbind(struct udevice *dev)
178 if (dev->flags & DM_FLAG_ACTIVATED)
185 ret = drv->unbind(dev);
190 ret = device_chld_unbind(dev);
194 ret = uclass_unbind_device(dev);
199 list_del(&dev->sibling_node);
206 * device_free() - Free memory buffers allocated by a device
207 * @dev: Device that is to be started
209 static void device_free(struct udevice *dev)
213 if (dev->driver->priv_auto_alloc_size) {
217 if (dev->flags & DM_FLAG_ALLOC_PDATA) {
219 dev->platdata = NULL;
221 size = dev->uclass->uc_drv->per_device_auto_alloc_size;
223 free(dev->uclass_priv);
224 dev->uclass_priv = NULL;
227 size = dev->parent->driver->per_child_auto_alloc_size;
229 free(dev->parent_priv);
230 dev->parent_priv = NULL;
235 int device_probe_child(struct udevice *dev, void *parent_priv)
245 if (dev->flags & DM_FLAG_ACTIVATED)
251 /* Allocate private data and platdata if requested */
252 if (drv->priv_auto_alloc_size) {
253 dev->priv = calloc(1, drv->priv_auto_alloc_size);
259 /* Allocate private data if requested */
260 if (dev->flags & DM_FLAG_ALLOC_PDATA) {
261 dev->platdata = calloc(1, drv->platdata_auto_alloc_size);
262 if (!dev->platdata) {
267 size = dev->uclass->uc_drv->per_device_auto_alloc_size;
269 dev->uclass_priv = calloc(1, size);
270 if (!dev->uclass_priv) {
276 /* Ensure all parents are probed */
278 size = dev->parent->driver->per_child_auto_alloc_size;
280 dev->parent_priv = calloc(1, size);
281 if (!dev->parent_priv) {
286 memcpy(dev->parent_priv, parent_priv, size);
289 ret = device_probe(dev->parent);
294 seq = uclass_resolve_seq(dev);
301 if (dev->parent && dev->parent->driver->child_pre_probe) {
302 ret = dev->parent->driver->child_pre_probe(dev);
307 if (drv->ofdata_to_platdata && dev->of_offset >= 0) {
308 ret = drv->ofdata_to_platdata(dev);
314 ret = drv->probe(dev);
319 dev->flags |= DM_FLAG_ACTIVATED;
321 ret = uclass_post_probe_device(dev);
323 dev->flags &= ~DM_FLAG_ACTIVATED;
329 if (device_remove(dev)) {
330 dm_warn("%s: Device '%s' failed to remove on error path\n",
331 __func__, dev->name);
340 int device_probe(struct udevice *dev)
342 return device_probe_child(dev, NULL);
345 int device_remove(struct udevice *dev)
353 if (!(dev->flags & DM_FLAG_ACTIVATED))
359 ret = uclass_pre_remove_device(dev);
363 ret = device_chld_remove(dev);
368 ret = drv->remove(dev);
373 if (dev->parent && dev->parent->driver->child_post_remove) {
374 ret = dev->parent->driver->child_post_remove(dev);
376 dm_warn("%s: Device '%s' failed child_post_remove()",
377 __func__, dev->name);
384 dev->flags &= ~DM_FLAG_ACTIVATED;
389 /* We can't put the children back */
390 dm_warn("%s: Device '%s' failed to remove, but children are gone\n",
391 __func__, dev->name);
393 ret = uclass_post_probe_device(dev);
395 dm_warn("%s: Device '%s' failed to post_probe on error path\n",
396 __func__, dev->name);
402 void *dev_get_platdata(struct udevice *dev)
405 dm_warn("%s: null device", __func__);
409 return dev->platdata;
412 void *dev_get_priv(struct udevice *dev)
415 dm_warn("%s: null device", __func__);
422 void *dev_get_parentdata(struct udevice *dev)
425 dm_warn("%s: null device", __func__);
429 return dev->parent_priv;
432 static int device_get_device_tail(struct udevice *dev, int ret,
433 struct udevice **devp)
438 ret = device_probe(dev);
447 int device_get_child(struct udevice *parent, int index, struct udevice **devp)
451 list_for_each_entry(dev, &parent->child_head, sibling_node) {
453 return device_get_device_tail(dev, 0, devp);
459 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
460 bool find_req_seq, struct udevice **devp)
465 if (seq_or_req_seq == -1)
468 list_for_each_entry(dev, &parent->child_head, sibling_node) {
469 if ((find_req_seq ? dev->req_seq : dev->seq) ==
479 int device_get_child_by_seq(struct udevice *parent, int seq,
480 struct udevice **devp)
486 ret = device_find_child_by_seq(parent, seq, false, &dev);
487 if (ret == -ENODEV) {
489 * We didn't find it in probed devices. See if there is one
490 * that will request this seq if probed.
492 ret = device_find_child_by_seq(parent, seq, true, &dev);
494 return device_get_device_tail(dev, ret, devp);
497 int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
498 struct udevice **devp)
504 list_for_each_entry(dev, &parent->child_head, sibling_node) {
505 if (dev->of_offset == of_offset) {
514 int device_get_child_by_of_offset(struct udevice *parent, int seq,
515 struct udevice **devp)
521 ret = device_find_child_by_of_offset(parent, seq, &dev);
522 return device_get_device_tail(dev, ret, devp);
525 int device_find_first_child(struct udevice *parent, struct udevice **devp)
527 if (list_empty(&parent->child_head)) {
530 *devp = list_first_entry(&parent->child_head, struct udevice,
537 int device_find_next_child(struct udevice **devp)
539 struct udevice *dev = *devp;
540 struct udevice *parent = dev->parent;
542 if (list_is_last(&dev->sibling_node, &parent->child_head)) {
545 *devp = list_entry(dev->sibling_node.next, struct udevice,