blob: 3199d6a1b73ba47c964671b18a701e1c3059fd12 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glassdd6ab882014-02-26 15:59:18 -07002/*
3 * Device manager
4 *
5 * Copyright (c) 2013 Google, Inc
6 *
7 * (C) Copyright 2012
8 * Pavel Herrmann <morpheus.ibis@gmail.com>
Simon Glassdd6ab882014-02-26 15:59:18 -07009 */
10
11#include <common.h>
Simon Glass63334482019-11-14 12:57:39 -070012#include <cpu_func.h>
Simon Glass3ee337a2022-03-04 08:43:03 -070013#include <event.h>
Simon Glass0f2af882020-05-10 11:40:05 -060014#include <log.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060015#include <asm/global_data.h>
Vignesh R0dff3702016-07-06 09:58:55 +053016#include <asm/io.h>
Philipp Tomsich9cf03b02018-01-08 13:59:18 +010017#include <clk.h>
Simon Glassdb6f0202014-07-23 06:55:12 -060018#include <fdtdec.h>
Stefan Roeseadc09052015-09-02 07:41:12 +020019#include <fdt_support.h>
Simon Glassdd6ab882014-02-26 15:59:18 -070020#include <malloc.h>
Simon Glass274e0b02020-05-10 11:39:56 -060021#include <asm/cache.h>
Simon Glassdd6ab882014-02-26 15:59:18 -070022#include <dm/device.h>
23#include <dm/device-internal.h>
24#include <dm/lists.h>
Mario Six1f1c1ec2018-01-15 11:07:20 +010025#include <dm/of_access.h>
Masahiro Yamadaf8efa632015-08-27 12:44:29 +090026#include <dm/pinctrl.h>
Simon Glassdd6ab882014-02-26 15:59:18 -070027#include <dm/platdata.h>
Simon Glass322b2902017-05-18 20:09:05 -060028#include <dm/read.h>
Simon Glassdd6ab882014-02-26 15:59:18 -070029#include <dm/uclass.h>
30#include <dm/uclass-internal.h>
31#include <dm/util.h>
Mark Kettenise1311b62021-10-23 16:58:01 +020032#include <iommu.h>
Simon Glassdd6ab882014-02-26 15:59:18 -070033#include <linux/err.h>
34#include <linux/list.h>
Peng Fan6fba32d2018-07-27 10:20:38 +080035#include <power-domain.h>
Simon Glassdd6ab882014-02-26 15:59:18 -070036
Simon Glassdb6f0202014-07-23 06:55:12 -060037DECLARE_GLOBAL_DATA_PTR;
38
Stephen Warren8c93df12016-05-11 15:26:24 -060039static int device_bind_common(struct udevice *parent, const struct driver *drv,
Simon Glass71fa5b42020-12-03 16:55:18 -070040 const char *name, void *plat,
Simon Glassb0cf4b32017-05-17 17:18:11 -060041 ulong driver_data, ofnode node,
Simon Glass39edb952020-12-03 16:55:19 -070042 uint of_plat_size, struct udevice **devp)
Simon Glassdd6ab882014-02-26 15:59:18 -070043{
Heiko Schocherb74fcb42014-05-22 12:43:05 +020044 struct udevice *dev;
Simon Glassdd6ab882014-02-26 15:59:18 -070045 struct uclass *uc;
Przemyslaw Marczakd850e672015-04-15 13:07:18 +020046 int size, ret = 0;
Simon Glass7272e922020-12-16 21:20:09 -070047 bool auto_seq = true;
Simon Glass2543b162020-12-22 19:30:29 -070048 void *ptr;
Simon Glassdd6ab882014-02-26 15:59:18 -070049
Simon Glass47fd4a22021-03-15 17:25:15 +130050 if (CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND))
51 return -ENOSYS;
52
Masahiro Yamadae1cc1f02015-08-27 12:44:28 +090053 if (devp)
54 *devp = NULL;
Simon Glassdd6ab882014-02-26 15:59:18 -070055 if (!name)
56 return -EINVAL;
57
58 ret = uclass_get(drv->id, &uc);
Simon Glass43313de2015-08-30 16:55:16 -060059 if (ret) {
60 debug("Missing uclass for driver %s\n", drv->name);
Simon Glassdd6ab882014-02-26 15:59:18 -070061 return ret;
Simon Glass43313de2015-08-30 16:55:16 -060062 }
Simon Glassdd6ab882014-02-26 15:59:18 -070063
Heiko Schocherb74fcb42014-05-22 12:43:05 +020064 dev = calloc(1, sizeof(struct udevice));
Simon Glassdd6ab882014-02-26 15:59:18 -070065 if (!dev)
66 return -ENOMEM;
67
68 INIT_LIST_HEAD(&dev->sibling_node);
69 INIT_LIST_HEAD(&dev->child_head);
70 INIT_LIST_HEAD(&dev->uclass_node);
Simon Glass3996f062022-03-27 14:26:19 -060071#if CONFIG_IS_ENABLED(DEVRES)
Masahiro Yamada8b15b162015-07-25 21:52:35 +090072 INIT_LIST_HEAD(&dev->devres_head);
Masahiro Yamada029bfca2015-07-25 21:52:37 +090073#endif
Simon Glass2543b162020-12-22 19:30:29 -070074 dev_set_plat(dev, plat);
Stephen Warren8c93df12016-05-11 15:26:24 -060075 dev->driver_data = driver_data;
Simon Glassdd6ab882014-02-26 15:59:18 -070076 dev->name = name;
Simon Glassa7ece582020-12-19 10:40:14 -070077 dev_set_ofnode(dev, node);
Simon Glassdd6ab882014-02-26 15:59:18 -070078 dev->parent = parent;
79 dev->driver = drv;
80 dev->uclass = uc;
Simon Glassdb6f0202014-07-23 06:55:12 -060081
Simon Glass5e349922020-12-19 10:40:09 -070082 dev->seq_ = -1;
Jean-Jacques Hiblota5da3002018-12-07 14:50:39 +010083 if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
84 (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) {
Simon Glass1bd3deb2015-02-27 22:06:30 -070085 /*
Stefan Roese9d4ce6b2016-03-16 09:58:01 +010086 * Some devices, such as a SPI bus, I2C bus and serial ports
87 * are numbered using aliases.
Stefan Roese9d4ce6b2016-03-16 09:58:01 +010088 */
Simon Glasse422f8c2020-07-09 18:39:24 -060089 if (CONFIG_IS_ENABLED(OF_CONTROL) &&
90 !CONFIG_IS_ENABLED(OF_PLATDATA)) {
Simon Glass7272e922020-12-16 21:20:09 -070091 if (uc->uc_drv->name && ofnode_valid(node)) {
Simon Glass28823e32021-07-05 16:32:39 -060092 if (!dev_read_alias_seq(dev, &dev->seq_)) {
Simon Glass38040a92020-12-16 21:20:32 -070093 auto_seq = false;
Simon Glass28823e32021-07-05 16:32:39 -060094 log_debug(" - seq=%d\n", dev->seq_);
95 }
Simon Glass7272e922020-12-16 21:20:09 -070096 }
Simon Glass0ccb0972015-01-25 08:27:05 -070097 }
Simon Glassdb6f0202014-07-23 06:55:12 -060098 }
Simon Glass3a9d5f12020-12-16 21:20:17 -070099 if (auto_seq && !(uc->uc_drv->flags & DM_UC_FLAG_NO_AUTO_SEQ))
Simon Glass5e349922020-12-19 10:40:09 -0700100 dev->seq_ = uclass_find_next_free_seq(uc);
Simon Glass1bd3deb2015-02-27 22:06:30 -0700101
Simon Glasse07434b2021-02-03 21:29:43 -0700102 /* Check if we need to allocate plat */
Simon Glass71fa5b42020-12-03 16:55:18 -0700103 if (drv->plat_auto) {
104 bool alloc = !plat;
Simon Glassafbf9b82016-07-04 11:58:18 -0600105
Simon Glasse07434b2021-02-03 21:29:43 -0700106 /*
107 * For of-platdata, we try use the existing data, but if
108 * plat_auto is larger, we must allocate a new space
109 */
Simon Glassafbf9b82016-07-04 11:58:18 -0600110 if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
Simon Glasse07434b2021-02-03 21:29:43 -0700111 if (of_plat_size)
Simon Glass6211d762020-12-19 10:40:10 -0700112 dev_or_flags(dev, DM_FLAG_OF_PLATDATA);
Simon Glasse07434b2021-02-03 21:29:43 -0700113 if (of_plat_size < drv->plat_auto)
114 alloc = true;
Simon Glassafbf9b82016-07-04 11:58:18 -0600115 }
116 if (alloc) {
Simon Glass6211d762020-12-19 10:40:10 -0700117 dev_or_flags(dev, DM_FLAG_ALLOC_PDATA);
Simon Glass2543b162020-12-22 19:30:29 -0700118 ptr = calloc(1, drv->plat_auto);
119 if (!ptr) {
Simon Glassafbf9b82016-07-04 11:58:18 -0600120 ret = -ENOMEM;
121 goto fail_alloc1;
122 }
Simon Glasse07434b2021-02-03 21:29:43 -0700123
124 /*
125 * For of-platdata, copy the old plat into the new
126 * space
127 */
Simon Glass2543b162020-12-22 19:30:29 -0700128 if (CONFIG_IS_ENABLED(OF_PLATDATA) && plat)
129 memcpy(ptr, plat, of_plat_size);
130 dev_set_plat(dev, ptr);
Simon Glassba750492015-01-25 08:27:00 -0700131 }
132 }
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200133
Simon Glass71fa5b42020-12-03 16:55:18 -0700134 size = uc->uc_drv->per_device_plat_auto;
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200135 if (size) {
Simon Glass6211d762020-12-19 10:40:10 -0700136 dev_or_flags(dev, DM_FLAG_ALLOC_UCLASS_PDATA);
Simon Glass2543b162020-12-22 19:30:29 -0700137 ptr = calloc(1, size);
138 if (!ptr) {
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200139 ret = -ENOMEM;
140 goto fail_alloc2;
141 }
Simon Glass2543b162020-12-22 19:30:29 -0700142 dev_set_uclass_plat(dev, ptr);
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200143 }
Simon Glass11b61732015-01-25 08:27:01 -0700144
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200145 if (parent) {
Simon Glass71fa5b42020-12-03 16:55:18 -0700146 size = parent->driver->per_child_plat_auto;
Simon Glassd6206a52021-02-03 21:29:44 -0700147 if (!size)
Simon Glass71fa5b42020-12-03 16:55:18 -0700148 size = parent->uclass->uc_drv->per_child_plat_auto;
Simon Glass11b61732015-01-25 08:27:01 -0700149 if (size) {
Simon Glass6211d762020-12-19 10:40:10 -0700150 dev_or_flags(dev, DM_FLAG_ALLOC_PARENT_PDATA);
Simon Glass2543b162020-12-22 19:30:29 -0700151 ptr = calloc(1, size);
152 if (!ptr) {
Simon Glass11b61732015-01-25 08:27:01 -0700153 ret = -ENOMEM;
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200154 goto fail_alloc3;
Simon Glass11b61732015-01-25 08:27:01 -0700155 }
Simon Glass2543b162020-12-22 19:30:29 -0700156 dev_set_parent_plat(dev, ptr);
Simon Glass11b61732015-01-25 08:27:01 -0700157 }
Heinrich Schuchardt5246b372020-02-15 21:38:48 +0100158 /* put dev into parent's successor list */
Simon Glassdd6ab882014-02-26 15:59:18 -0700159 list_add_tail(&dev->sibling_node, &parent->child_head);
Heinrich Schuchardt5246b372020-02-15 21:38:48 +0100160 }
Simon Glassdd6ab882014-02-26 15:59:18 -0700161
162 ret = uclass_bind_device(dev);
163 if (ret)
Simon Glass4ebe01b2015-01-25 08:26:59 -0700164 goto fail_uclass_bind;
Simon Glassdd6ab882014-02-26 15:59:18 -0700165
166 /* if we fail to bind we remove device from successors and free it */
167 if (drv->bind) {
168 ret = drv->bind(dev);
Simon Glass4ebe01b2015-01-25 08:26:59 -0700169 if (ret)
Simon Glassdd6ab882014-02-26 15:59:18 -0700170 goto fail_bind;
Simon Glassdd6ab882014-02-26 15:59:18 -0700171 }
Simon Glassa4a51a02015-01-25 08:27:03 -0700172 if (parent && parent->driver->child_post_bind) {
173 ret = parent->driver->child_post_bind(dev);
174 if (ret)
175 goto fail_child_post_bind;
176 }
Simon Glass286863d2016-01-05 09:30:59 -0700177 if (uc->uc_drv->post_bind) {
178 ret = uc->uc_drv->post_bind(dev);
179 if (ret)
180 goto fail_uclass_post_bind;
181 }
Simon Glassa4a51a02015-01-25 08:27:03 -0700182
Simon Glassdd6ab882014-02-26 15:59:18 -0700183 if (parent)
Masahiro Yamadaf70f39f2017-09-29 12:31:20 +0900184 pr_debug("Bound device %s to %s\n", dev->name, parent->name);
Masahiro Yamadae1cc1f02015-08-27 12:44:28 +0900185 if (devp)
186 *devp = dev;
Simon Glassdd6ab882014-02-26 15:59:18 -0700187
Simon Glass6211d762020-12-19 10:40:10 -0700188 dev_or_flags(dev, DM_FLAG_BOUND);
Masahiro Yamadabdbb5dd2015-07-25 21:52:34 +0900189
Simon Glassdd6ab882014-02-26 15:59:18 -0700190 return 0;
191
Simon Glass286863d2016-01-05 09:30:59 -0700192fail_uclass_post_bind:
193 /* There is no child unbind() method, so no clean-up required */
Simon Glassa4a51a02015-01-25 08:27:03 -0700194fail_child_post_bind:
Masahiro Yamada04aa00d2015-08-12 07:31:52 +0900195 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
Simon Glasse70a4f42015-02-27 22:06:33 -0700196 if (drv->unbind && drv->unbind(dev)) {
197 dm_warn("unbind() method failed on dev '%s' on error path\n",
198 dev->name);
199 }
Simon Glassa4a51a02015-01-25 08:27:03 -0700200 }
201
Simon Glassdd6ab882014-02-26 15:59:18 -0700202fail_bind:
Masahiro Yamada04aa00d2015-08-12 07:31:52 +0900203 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
Simon Glasse70a4f42015-02-27 22:06:33 -0700204 if (uclass_unbind_device(dev)) {
205 dm_warn("Failed to unbind dev '%s' on error path\n",
206 dev->name);
207 }
Simon Glass4ebe01b2015-01-25 08:26:59 -0700208 }
209fail_uclass_bind:
Masahiro Yamada04aa00d2015-08-12 07:31:52 +0900210 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
Simon Glasse70a4f42015-02-27 22:06:33 -0700211 list_del(&dev->sibling_node);
Simon Glass6211d762020-12-19 10:40:10 -0700212 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PARENT_PDATA) {
Simon Glass2543b162020-12-22 19:30:29 -0700213 free(dev_get_parent_plat(dev));
214 dev_set_parent_plat(dev, NULL);
Simon Glasse70a4f42015-02-27 22:06:33 -0700215 }
Simon Glass11b61732015-01-25 08:27:01 -0700216 }
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200217fail_alloc3:
Simon Glassd6206a52021-02-03 21:29:44 -0700218 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
219 if (dev_get_flags(dev) & DM_FLAG_ALLOC_UCLASS_PDATA) {
220 free(dev_get_uclass_plat(dev));
221 dev_set_uclass_plat(dev, NULL);
222 }
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200223 }
Simon Glass11b61732015-01-25 08:27:01 -0700224fail_alloc2:
Simon Glassd6206a52021-02-03 21:29:44 -0700225 if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
226 if (dev_get_flags(dev) & DM_FLAG_ALLOC_PDATA) {
227 free(dev_get_plat(dev));
228 dev_set_plat(dev, NULL);
229 }
Simon Glassba750492015-01-25 08:27:00 -0700230 }
231fail_alloc1:
Masahiro Yamada8b15b162015-07-25 21:52:35 +0900232 devres_release_all(dev);
233
Simon Glassdd6ab882014-02-26 15:59:18 -0700234 free(dev);
Simon Glass4ebe01b2015-01-25 08:26:59 -0700235
Simon Glassdd6ab882014-02-26 15:59:18 -0700236 return ret;
237}
238
Stephen Warren8c93df12016-05-11 15:26:24 -0600239int device_bind_with_driver_data(struct udevice *parent,
240 const struct driver *drv, const char *name,
Simon Glass322b2902017-05-18 20:09:05 -0600241 ulong driver_data, ofnode node,
Stephen Warren8c93df12016-05-11 15:26:24 -0600242 struct udevice **devp)
243{
Simon Glass322b2902017-05-18 20:09:05 -0600244 return device_bind_common(parent, drv, name, NULL, driver_data, node,
245 0, devp);
Stephen Warren8c93df12016-05-11 15:26:24 -0600246}
247
Simon Glass884870f2020-11-28 17:50:01 -0700248int device_bind(struct udevice *parent, const struct driver *drv,
Simon Glass71fa5b42020-12-03 16:55:18 -0700249 const char *name, void *plat, ofnode node,
Simon Glass884870f2020-11-28 17:50:01 -0700250 struct udevice **devp)
Simon Glass9eb151e2018-06-11 13:07:15 -0600251{
Simon Glass71fa5b42020-12-03 16:55:18 -0700252 return device_bind_common(parent, drv, name, plat, 0, node, 0,
Simon Glass9eb151e2018-06-11 13:07:15 -0600253 devp);
254}
255
Simon Glassfef72b72014-07-23 06:55:03 -0600256int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
Simon Glasscfd6a002020-10-03 11:31:33 -0600257 const struct driver_info *info, struct udevice **devp)
Simon Glassdd6ab882014-02-26 15:59:18 -0700258{
259 struct driver *drv;
Simon Glass39edb952020-12-03 16:55:19 -0700260 uint plat_size = 0;
Walter Lozanoffc41b02020-06-25 01:10:11 -0300261 int ret;
Simon Glassdd6ab882014-02-26 15:59:18 -0700262
263 drv = lists_driver_lookup_name(info->name);
264 if (!drv)
265 return -ENOENT;
Simon Glassfef72b72014-07-23 06:55:03 -0600266 if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
267 return -EPERM;
Simon Glassdd6ab882014-02-26 15:59:18 -0700268
Simon Glassafbf9b82016-07-04 11:58:18 -0600269#if CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass39edb952020-12-03 16:55:19 -0700270 plat_size = info->plat_size;
Simon Glassafbf9b82016-07-04 11:58:18 -0600271#endif
Simon Glass71fa5b42020-12-03 16:55:18 -0700272 ret = device_bind_common(parent, drv, info->name, (void *)info->plat, 0,
Simon Glass39edb952020-12-03 16:55:19 -0700273 ofnode_null(), plat_size, devp);
Walter Lozanoffc41b02020-06-25 01:10:11 -0300274 if (ret)
275 return ret;
Walter Lozanoffc41b02020-06-25 01:10:11 -0300276
277 return ret;
Simon Glassdd6ab882014-02-26 15:59:18 -0700278}
279
Claudiu Bezneabf5b8232020-09-07 17:46:33 +0300280int device_reparent(struct udevice *dev, struct udevice *new_parent)
281{
282 struct udevice *pos, *n;
283
284 assert(dev);
285 assert(new_parent);
286
287 list_for_each_entry_safe(pos, n, &dev->parent->child_head,
288 sibling_node) {
289 if (pos->driver != dev->driver)
290 continue;
291
292 list_del(&dev->sibling_node);
293 list_add_tail(&dev->sibling_node, &new_parent->child_head);
294 dev->parent = new_parent;
295
296 break;
297 }
298
299 return 0;
300}
301
Simon Glass825d3f92015-03-25 12:21:53 -0600302static void *alloc_priv(int size, uint flags)
303{
304 void *priv;
305
306 if (flags & DM_FLAG_ALLOC_PRIV_DMA) {
Faiz Abbas03020a92017-09-19 16:53:50 +0530307 size = ROUND(size, ARCH_DMA_MINALIGN);
Simon Glass825d3f92015-03-25 12:21:53 -0600308 priv = memalign(ARCH_DMA_MINALIGN, size);
Simon Glass27bc9b12017-04-04 13:00:19 -0600309 if (priv) {
Simon Glass825d3f92015-03-25 12:21:53 -0600310 memset(priv, '\0', size);
Simon Glass27bc9b12017-04-04 13:00:19 -0600311
312 /*
313 * Ensure that the zero bytes are flushed to memory.
314 * This prevents problems if the driver uses this as
315 * both an input and an output buffer:
316 *
317 * 1. Zeroes written to buffer (here) and sit in the
318 * cache
319 * 2. Driver issues a read command to DMA
320 * 3. CPU runs out of cache space and evicts some cache
321 * data in the buffer, writing zeroes to RAM from
322 * the memset() above
323 * 4. DMA completes
324 * 5. Buffer now has some DMA data and some zeroes
325 * 6. Data being read is now incorrect
326 *
327 * To prevent this, ensure that the cache is clean
328 * within this range at the start. The driver can then
329 * use normal flush-after-write, invalidate-before-read
330 * procedures.
331 *
332 * TODO(sjg@chromium.org): Drop this microblaze
333 * exception.
334 */
335#ifndef CONFIG_MICROBLAZE
336 flush_dcache_range((ulong)priv, (ulong)priv + size);
337#endif
338 }
Simon Glass825d3f92015-03-25 12:21:53 -0600339 } else {
340 priv = calloc(1, size);
341 }
342
343 return priv;
344}
345
Simon Glassad337e62020-12-19 10:40:08 -0700346/**
347 * device_alloc_priv() - Allocate priv/plat data required by the device
348 *
349 * @dev: Device to process
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100350 * Return: 0 if OK, -ENOMEM if out of memory
Simon Glassad337e62020-12-19 10:40:08 -0700351 */
352static int device_alloc_priv(struct udevice *dev)
Simon Glassdd6ab882014-02-26 15:59:18 -0700353{
Simon Glassa626dff2015-03-25 12:21:54 -0600354 const struct driver *drv;
Simon Glass2543b162020-12-22 19:30:29 -0700355 void *ptr;
Simon Glassad337e62020-12-19 10:40:08 -0700356 int size;
Simon Glass44c47892020-04-05 15:38:19 -0600357
Simon Glassdd6ab882014-02-26 15:59:18 -0700358 drv = dev->driver;
359 assert(drv);
360
Bin Meng82cdd782015-08-24 01:14:02 -0700361 /* Allocate private data if requested and not reentered */
Simon Glass2543b162020-12-22 19:30:29 -0700362 if (drv->priv_auto && !dev_get_priv(dev)) {
363 ptr = alloc_priv(drv->priv_auto, drv->flags);
Simon Glassad337e62020-12-19 10:40:08 -0700364 if (!ptr)
365 return -ENOMEM;
Simon Glass2543b162020-12-22 19:30:29 -0700366 dev_set_priv(dev, ptr);
Simon Glassdd6ab882014-02-26 15:59:18 -0700367 }
Simon Glassad337e62020-12-19 10:40:08 -0700368
Bin Meng82cdd782015-08-24 01:14:02 -0700369 /* Allocate private data if requested and not reentered */
Simon Glass8a2b47f2020-12-03 16:55:17 -0700370 size = dev->uclass->uc_drv->per_device_auto;
Simon Glass2543b162020-12-22 19:30:29 -0700371 if (size && !dev_get_uclass_priv(dev)) {
372 ptr = alloc_priv(size, dev->uclass->uc_drv->flags);
Simon Glassad337e62020-12-19 10:40:08 -0700373 if (!ptr)
374 return -ENOMEM;
Simon Glass2543b162020-12-22 19:30:29 -0700375 dev_set_uclass_priv(dev, ptr);
Simon Glassdd6ab882014-02-26 15:59:18 -0700376 }
377
Simon Glassa8d8f162019-12-29 21:19:18 -0700378 /* Allocate parent data for this child */
Simon Glassdd6ab882014-02-26 15:59:18 -0700379 if (dev->parent) {
Simon Glass8a2b47f2020-12-03 16:55:17 -0700380 size = dev->parent->driver->per_child_auto;
Simon Glass2543b162020-12-22 19:30:29 -0700381 if (!size)
Simon Glass8a2b47f2020-12-03 16:55:17 -0700382 size = dev->parent->uclass->uc_drv->per_child_auto;
Simon Glass2543b162020-12-22 19:30:29 -0700383 if (size && !dev_get_parent_priv(dev)) {
384 ptr = alloc_priv(size, drv->flags);
Simon Glassad337e62020-12-19 10:40:08 -0700385 if (!ptr)
386 return -ENOMEM;
Simon Glass2543b162020-12-22 19:30:29 -0700387 dev_set_parent_priv(dev, ptr);
Simon Glass60d971b2014-07-23 06:55:20 -0600388 }
Simon Glassa8d8f162019-12-29 21:19:18 -0700389 }
390
Simon Glassad337e62020-12-19 10:40:08 -0700391 return 0;
392}
393
394int device_of_to_plat(struct udevice *dev)
395{
396 const struct driver *drv;
397 int ret;
398
399 if (!dev)
400 return -EINVAL;
401
Simon Glass6211d762020-12-19 10:40:10 -0700402 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
Simon Glassad337e62020-12-19 10:40:08 -0700403 return 0;
404
Simon Glass47fd4a22021-03-15 17:25:15 +1300405 /*
406 * This is not needed if binding is disabled, since data is allocated
407 * at build time.
408 */
409 if (!CONFIG_IS_ENABLED(OF_PLATDATA_NO_BIND)) {
410 /* Ensure all parents have ofdata */
411 if (dev->parent) {
412 ret = device_of_to_plat(dev->parent);
413 if (ret)
414 goto fail;
415
416 /*
417 * The device might have already been probed during
418 * the call to device_probe() on its parent device
419 * (e.g. PCI bridge devices). Test the flags again
420 * so that we don't mess up the device.
421 */
422 if (dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID)
423 return 0;
424 }
425
426 ret = device_alloc_priv(dev);
Simon Glassad337e62020-12-19 10:40:08 -0700427 if (ret)
428 goto fail;
Simon Glassad337e62020-12-19 10:40:08 -0700429 }
Simon Glassad337e62020-12-19 10:40:08 -0700430 drv = dev->driver;
431 assert(drv);
432
Simon Glassaad29ae2020-12-03 16:55:21 -0700433 if (drv->of_to_plat &&
Simon Glass07c17772020-12-19 10:40:12 -0700434 (CONFIG_IS_ENABLED(OF_PLATDATA) || dev_has_ofnode(dev))) {
Simon Glassaad29ae2020-12-03 16:55:21 -0700435 ret = drv->of_to_plat(dev);
Simon Glassa8d8f162019-12-29 21:19:18 -0700436 if (ret)
437 goto fail;
438 }
Simon Glass60d971b2014-07-23 06:55:20 -0600439
Simon Glass6211d762020-12-19 10:40:10 -0700440 dev_or_flags(dev, DM_FLAG_PLATDATA_VALID);
Simon Glassd3c9d302019-12-29 21:19:21 -0700441
Simon Glass4a263852019-12-29 21:19:20 -0700442 return 0;
443fail:
444 device_free(dev);
445
446 return ret;
447}
448
Nicolas Saenz Juliennea2c7ead2021-01-12 13:55:24 +0100449/**
450 * device_get_dma_constraints() - Populate device's DMA constraints
451 *
452 * Gets a device's DMA constraints from firmware. This information is later
453 * used by drivers to translate physcal addresses to the device's bus address
454 * space. For now only device-tree is supported.
455 *
456 * @dev: Pointer to target device
457 * Return: 0 if OK or if no DMA constraints were found, error otherwise
458 */
459static int device_get_dma_constraints(struct udevice *dev)
460{
461 struct udevice *parent = dev->parent;
462 phys_addr_t cpu = 0;
463 dma_addr_t bus = 0;
464 u64 size = 0;
465 int ret;
466
467 if (!CONFIG_IS_ENABLED(DM_DMA) || !parent || !dev_has_ofnode(parent))
468 return 0;
469
470 /*
471 * We start parsing for dma-ranges from the device's bus node. This is
472 * specially important on nested buses.
473 */
474 ret = dev_get_dma_range(parent, &cpu, &bus, &size);
475 /* Don't return an error if no 'dma-ranges' were found */
476 if (ret && ret != -ENOENT) {
477 dm_warn("%s: failed to get DMA range, %d\n", dev->name, ret);
478 return ret;
479 }
480
481 dev_set_dma_offset(dev, cpu - bus);
482
483 return 0;
484}
485
Simon Glass4a263852019-12-29 21:19:20 -0700486int device_probe(struct udevice *dev)
487{
488 const struct driver *drv;
489 int ret;
Simon Glass4a263852019-12-29 21:19:20 -0700490
491 if (!dev)
492 return -EINVAL;
493
Simon Glass6211d762020-12-19 10:40:10 -0700494 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
Simon Glass4a263852019-12-29 21:19:20 -0700495 return 0;
496
Simon Glass3ee337a2022-03-04 08:43:03 -0700497 ret = device_notify(dev, EVT_DM_PRE_PROBE);
498 if (ret)
499 return ret;
500
Simon Glass4a263852019-12-29 21:19:20 -0700501 drv = dev->driver;
502 assert(drv);
503
Simon Glassaad29ae2020-12-03 16:55:21 -0700504 ret = device_of_to_plat(dev);
Simon Glass4a263852019-12-29 21:19:20 -0700505 if (ret)
506 goto fail;
507
Simon Glassa8d8f162019-12-29 21:19:18 -0700508 /* Ensure all parents are probed */
509 if (dev->parent) {
Simon Glassdd6ab882014-02-26 15:59:18 -0700510 ret = device_probe(dev->parent);
511 if (ret)
512 goto fail;
Bin Meng82cdd782015-08-24 01:14:02 -0700513
514 /*
515 * The device might have already been probed during
516 * the call to device_probe() on its parent device
517 * (e.g. PCI bridge devices). Test the flags again
518 * so that we don't mess up the device.
519 */
Simon Glass6211d762020-12-19 10:40:10 -0700520 if (dev_get_flags(dev) & DM_FLAG_ACTIVATED)
Bin Meng82cdd782015-08-24 01:14:02 -0700521 return 0;
Simon Glassdd6ab882014-02-26 15:59:18 -0700522 }
Simon Glassdb6f0202014-07-23 06:55:12 -0600523
Simon Glass6211d762020-12-19 10:40:10 -0700524 dev_or_flags(dev, DM_FLAG_ACTIVATED);
Simon Glass8b04e732015-03-25 12:21:56 -0600525
Michal Simekc5190ed2022-01-07 16:38:09 +0100526 if (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent &&
527 (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) &&
528 !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) {
529 ret = dev_power_domain_on(dev);
530 if (ret)
531 goto fail;
532 }
533
Simon Glassbb53bda2015-09-12 08:45:19 -0600534 /*
535 * Process pinctrl for everything except the root device, and
Simon Glass27ce9622016-01-21 19:43:25 -0700536 * continue regardless of the result of pinctrl. Don't process pinctrl
537 * settings for pinctrl devices since the device may not yet be
538 * probed.
Simon Glass303c3c22021-01-21 13:57:13 -0700539 *
540 * This call can produce some non-intuitive results. For example, on an
541 * x86 device where dev is the main PCI bus, the pinctrl device may be
542 * child or grandchild of that bus, meaning that the child will be
543 * probed here. If the child happens to be the P2SB and the pinctrl
544 * device is a child of that, then both the pinctrl and P2SB will be
545 * probed by this call. This works because the DM_FLAG_ACTIVATED flag
546 * is set just above. However, the PCI bus' probe() method and
547 * associated uclass methods have not yet been called.
Simon Glassbb53bda2015-09-12 08:45:19 -0600548 */
Patrick Delaunay99f0cd22021-11-19 10:02:27 +0100549 if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL) {
550 ret = pinctrl_select_state(dev, "default");
551 if (ret && ret != -ENOSYS)
552 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n",
553 dev->name, ret, errno_str(ret));
554 }
Masahiro Yamadaf8efa632015-08-27 12:44:29 +0900555
Mark Kettenise1311b62021-10-23 16:58:01 +0200556 if (CONFIG_IS_ENABLED(IOMMU) && dev->parent &&
557 (device_get_uclass_id(dev) != UCLASS_IOMMU)) {
558 ret = dev_iommu_enable(dev);
559 if (ret)
560 goto fail;
561 }
562
Nicolas Saenz Juliennea2c7ead2021-01-12 13:55:24 +0100563 ret = device_get_dma_constraints(dev);
564 if (ret)
565 goto fail;
566
Simon Glass9c1f3822015-03-05 12:25:22 -0700567 ret = uclass_pre_probe_device(dev);
Simon Glass5104b982015-01-25 08:27:10 -0700568 if (ret)
569 goto fail;
570
Simon Glassd45560d2014-07-23 06:55:21 -0600571 if (dev->parent && dev->parent->driver->child_pre_probe) {
572 ret = dev->parent->driver->child_pre_probe(dev);
573 if (ret)
574 goto fail;
575 }
576
Bin Meng513cf402019-07-05 09:23:16 -0700577 /* Only handle devices that have a valid ofnode */
Simon Glassf1d50f72020-12-19 10:40:13 -0700578 if (dev_has_ofnode(dev)) {
Bin Meng513cf402019-07-05 09:23:16 -0700579 /*
580 * Process 'assigned-{clocks/clock-parents/clock-rates}'
581 * properties
582 */
Sean Anderson08d531c2021-06-11 00:16:07 -0400583 ret = clk_set_defaults(dev, CLK_DEFAULTS_PRE);
Bin Meng513cf402019-07-05 09:23:16 -0700584 if (ret)
585 goto fail;
586 }
Philipp Tomsich9cf03b02018-01-08 13:59:18 +0100587
Simon Glassdd6ab882014-02-26 15:59:18 -0700588 if (drv->probe) {
589 ret = drv->probe(dev);
Simon Glass9046dec2019-12-29 21:19:16 -0700590 if (ret)
Simon Glassdd6ab882014-02-26 15:59:18 -0700591 goto fail;
592 }
593
Simon Glassdd6ab882014-02-26 15:59:18 -0700594 ret = uclass_post_probe_device(dev);
Simon Glass8b04e732015-03-25 12:21:56 -0600595 if (ret)
Simon Glassdd6ab882014-02-26 15:59:18 -0700596 goto fail_uclass;
Simon Glassdd6ab882014-02-26 15:59:18 -0700597
Patrick Delaunay99f0cd22021-11-19 10:02:27 +0100598 if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL) {
599 ret = pinctrl_select_state(dev, "default");
600 if (ret && ret != -ENOSYS)
601 log_debug("Device '%s' failed to configure default pinctrl: %d (%s)\n",
602 dev->name, ret, errno_str(ret));
603 }
Peng Fan7cf58dd2016-03-12 13:17:38 +0800604
Simon Glass3ee337a2022-03-04 08:43:03 -0700605 ret = device_notify(dev, EVT_DM_POST_PROBE);
606 if (ret)
607 return ret;
608
Simon Glassdd6ab882014-02-26 15:59:18 -0700609 return 0;
610fail_uclass:
Stefan Roese80b5bc92017-03-20 12:51:48 +0100611 if (device_remove(dev, DM_REMOVE_NORMAL)) {
Simon Glassdd6ab882014-02-26 15:59:18 -0700612 dm_warn("%s: Device '%s' failed to remove on error path\n",
613 __func__, dev->name);
614 }
615fail:
Simon Glass6211d762020-12-19 10:40:10 -0700616 dev_bic_flags(dev, DM_FLAG_ACTIVATED);
Simon Glass8b04e732015-03-25 12:21:56 -0600617
Simon Glassdd6ab882014-02-26 15:59:18 -0700618 device_free(dev);
619
620 return ret;
621}
622
Simon Glassfa20e932020-12-03 16:55:20 -0700623void *dev_get_plat(const struct udevice *dev)
Simon Glassdd6ab882014-02-26 15:59:18 -0700624{
625 if (!dev) {
Simon Glassdf1e0722014-12-10 08:55:56 -0700626 dm_warn("%s: null device\n", __func__);
Simon Glassdd6ab882014-02-26 15:59:18 -0700627 return NULL;
628 }
629
Simon Glass781aa3e2021-03-15 17:25:40 +1300630 return dm_priv_to_rw(dev->plat_);
Simon Glassdd6ab882014-02-26 15:59:18 -0700631}
632
Simon Glass71fa5b42020-12-03 16:55:18 -0700633void *dev_get_parent_plat(const struct udevice *dev)
Simon Glass11b61732015-01-25 08:27:01 -0700634{
635 if (!dev) {
Simon Glasscdfc5052015-07-06 16:47:40 -0600636 dm_warn("%s: null device\n", __func__);
Simon Glass11b61732015-01-25 08:27:01 -0700637 return NULL;
638 }
639
Simon Glass781aa3e2021-03-15 17:25:40 +1300640 return dm_priv_to_rw(dev->parent_plat_);
Simon Glass11b61732015-01-25 08:27:01 -0700641}
642
Simon Glass71fa5b42020-12-03 16:55:18 -0700643void *dev_get_uclass_plat(const struct udevice *dev)
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200644{
645 if (!dev) {
Simon Glasscdfc5052015-07-06 16:47:40 -0600646 dm_warn("%s: null device\n", __func__);
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200647 return NULL;
648 }
649
Simon Glass781aa3e2021-03-15 17:25:40 +1300650 return dm_priv_to_rw(dev->uclass_plat_);
Przemyslaw Marczakd850e672015-04-15 13:07:18 +0200651}
652
Simon Glass2e5e5ec2018-10-01 12:22:06 -0600653void *dev_get_priv(const struct udevice *dev)
Simon Glassdd6ab882014-02-26 15:59:18 -0700654{
655 if (!dev) {
Simon Glassdf1e0722014-12-10 08:55:56 -0700656 dm_warn("%s: null device\n", __func__);
Simon Glassdd6ab882014-02-26 15:59:18 -0700657 return NULL;
658 }
659
Simon Glass781aa3e2021-03-15 17:25:40 +1300660 return dm_priv_to_rw(dev->priv_);
Simon Glassdd6ab882014-02-26 15:59:18 -0700661}
Simon Glass48d4e292014-07-23 06:55:19 -0600662
Simon Glass2e5e5ec2018-10-01 12:22:06 -0600663void *dev_get_uclass_priv(const struct udevice *dev)
Simon Glassde0977b2015-03-05 12:25:20 -0700664{
665 if (!dev) {
666 dm_warn("%s: null device\n", __func__);
667 return NULL;
668 }
669
Simon Glass781aa3e2021-03-15 17:25:40 +1300670 return dm_priv_to_rw(dev->uclass_priv_);
Simon Glassde0977b2015-03-05 12:25:20 -0700671}
672
Simon Glass2e5e5ec2018-10-01 12:22:06 -0600673void *dev_get_parent_priv(const struct udevice *dev)
Simon Glass60d971b2014-07-23 06:55:20 -0600674{
675 if (!dev) {
Simon Glassdf1e0722014-12-10 08:55:56 -0700676 dm_warn("%s: null device\n", __func__);
Simon Glass60d971b2014-07-23 06:55:20 -0600677 return NULL;
678 }
679
Simon Glass781aa3e2021-03-15 17:25:40 +1300680 return dm_priv_to_rw(dev->parent_priv_);
Simon Glass60d971b2014-07-23 06:55:20 -0600681}
682
Simon Glass48d4e292014-07-23 06:55:19 -0600683static int device_get_device_tail(struct udevice *dev, int ret,
684 struct udevice **devp)
685{
686 if (ret)
687 return ret;
688
689 ret = device_probe(dev);
690 if (ret)
691 return ret;
692
693 *devp = dev;
694
695 return 0;
696}
697
Simon Glass3580f6d2021-08-07 07:24:03 -0600698#if CONFIG_IS_ENABLED(OF_REAL)
Mario Six3bedfbe2018-06-26 08:46:50 +0200699/**
700 * device_find_by_ofnode() - Return device associated with given ofnode
701 *
702 * The returned device is *not* activated.
703 *
704 * @node: The ofnode for which a associated device should be looked up
705 * @devp: Pointer to structure to hold the found device
706 * Return: 0 if OK, -ve on error
707 */
708static int device_find_by_ofnode(ofnode node, struct udevice **devp)
709{
710 struct uclass *uc;
711 struct udevice *dev;
712 int ret;
713
Simon Glass784cd9e2020-12-19 10:40:17 -0700714 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
Mario Six3bedfbe2018-06-26 08:46:50 +0200715 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node,
716 &dev);
717 if (!ret || dev) {
718 *devp = dev;
719 return 0;
720 }
721 }
722
723 return -ENODEV;
724}
Marek Vasut7f18c342019-08-31 18:03:28 +0200725#endif
Mario Six3bedfbe2018-06-26 08:46:50 +0200726
Simon Glass2a580882020-01-27 08:49:36 -0700727int device_get_child(const struct udevice *parent, int index,
728 struct udevice **devp)
Simon Glass48d4e292014-07-23 06:55:19 -0600729{
730 struct udevice *dev;
731
732 list_for_each_entry(dev, &parent->child_head, sibling_node) {
733 if (!index--)
734 return device_get_device_tail(dev, 0, devp);
735 }
736
737 return -ENODEV;
738}
739
Simon Glass2a580882020-01-27 08:49:36 -0700740int device_get_child_count(const struct udevice *parent)
Lokesh Vutlafa45a082019-09-04 16:01:26 +0530741{
742 struct udevice *dev;
743 int count = 0;
744
745 list_for_each_entry(dev, &parent->child_head, sibling_node)
746 count++;
747
748 return count;
749}
750
Simon Glass51608c92021-12-16 20:59:32 -0700751int device_get_decendent_count(const struct udevice *parent)
752{
753 const struct udevice *dev;
754 int count = 1;
755
756 list_for_each_entry(dev, &parent->child_head, sibling_node)
757 count += device_get_decendent_count(dev);
758
759 return count;
760}
761
Simon Glass07e13382020-12-16 21:20:29 -0700762int device_find_child_by_seq(const struct udevice *parent, int seq,
763 struct udevice **devp)
Simon Glass48d4e292014-07-23 06:55:19 -0600764{
765 struct udevice *dev;
766
767 *devp = NULL;
Simon Glass48d4e292014-07-23 06:55:19 -0600768
769 list_for_each_entry(dev, &parent->child_head, sibling_node) {
Simon Glass5e349922020-12-19 10:40:09 -0700770 if (dev->seq_ == seq) {
Simon Glass48d4e292014-07-23 06:55:19 -0600771 *devp = dev;
772 return 0;
773 }
774 }
775
776 return -ENODEV;
777}
778
Simon Glass2a580882020-01-27 08:49:36 -0700779int device_get_child_by_seq(const struct udevice *parent, int seq,
Simon Glass48d4e292014-07-23 06:55:19 -0600780 struct udevice **devp)
781{
782 struct udevice *dev;
783 int ret;
784
785 *devp = NULL;
Simon Glass07e13382020-12-16 21:20:29 -0700786 ret = device_find_child_by_seq(parent, seq, &dev);
787
Simon Glass48d4e292014-07-23 06:55:19 -0600788 return device_get_device_tail(dev, ret, devp);
789}
790
Simon Glass2a580882020-01-27 08:49:36 -0700791int device_find_child_by_of_offset(const struct udevice *parent, int of_offset,
Simon Glass48d4e292014-07-23 06:55:19 -0600792 struct udevice **devp)
793{
794 struct udevice *dev;
795
796 *devp = NULL;
797
798 list_for_each_entry(dev, &parent->child_head, sibling_node) {
Simon Glassdd79d6e2017-01-17 16:52:55 -0700799 if (dev_of_offset(dev) == of_offset) {
Simon Glass48d4e292014-07-23 06:55:19 -0600800 *devp = dev;
801 return 0;
802 }
803 }
804
805 return -ENODEV;
806}
807
Simon Glass2a580882020-01-27 08:49:36 -0700808int device_get_child_by_of_offset(const struct udevice *parent, int node,
Simon Glass48d4e292014-07-23 06:55:19 -0600809 struct udevice **devp)
810{
811 struct udevice *dev;
812 int ret;
813
814 *devp = NULL;
Simon Glass861bc9f2015-06-23 15:38:38 -0600815 ret = device_find_child_by_of_offset(parent, node, &dev);
Simon Glass48d4e292014-07-23 06:55:19 -0600816 return device_get_device_tail(dev, ret, devp);
817}
Simon Glass44da7352014-10-13 23:41:49 -0600818
Jean-Jacques Hiblota7b0d6a2018-08-09 16:17:44 +0200819static struct udevice *_device_find_global_by_ofnode(struct udevice *parent,
820 ofnode ofnode)
Simon Glassae2efac2015-06-23 15:38:37 -0600821{
822 struct udevice *dev, *found;
823
Jean-Jacques Hiblota7b0d6a2018-08-09 16:17:44 +0200824 if (ofnode_equal(dev_ofnode(parent), ofnode))
Simon Glassae2efac2015-06-23 15:38:37 -0600825 return parent;
826
827 list_for_each_entry(dev, &parent->child_head, sibling_node) {
Jean-Jacques Hiblota7b0d6a2018-08-09 16:17:44 +0200828 found = _device_find_global_by_ofnode(dev, ofnode);
Simon Glassae2efac2015-06-23 15:38:37 -0600829 if (found)
830 return found;
831 }
832
833 return NULL;
834}
835
Jean-Jacques Hiblota7b0d6a2018-08-09 16:17:44 +0200836int device_find_global_by_ofnode(ofnode ofnode, struct udevice **devp)
837{
838 *devp = _device_find_global_by_ofnode(gd->dm_root, ofnode);
839
840 return *devp ? 0 : -ENOENT;
841}
842
843int device_get_global_by_ofnode(ofnode ofnode, struct udevice **devp)
Simon Glassae2efac2015-06-23 15:38:37 -0600844{
845 struct udevice *dev;
846
Jean-Jacques Hiblota7b0d6a2018-08-09 16:17:44 +0200847 dev = _device_find_global_by_ofnode(gd->dm_root, ofnode);
Simon Glassae2efac2015-06-23 15:38:37 -0600848 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
849}
Walter Lozanoffc41b02020-06-25 01:10:11 -0300850
851#if CONFIG_IS_ENABLED(OF_PLATDATA)
Simon Glass0000e0d2021-03-15 17:25:28 +1300852int device_get_by_ofplat_idx(uint idx, struct udevice **devp)
Simon Glass5792f4b2020-10-03 11:31:40 -0600853{
Simon Glass5792f4b2020-10-03 11:31:40 -0600854 struct udevice *dev;
855
Simon Glass0000e0d2021-03-15 17:25:28 +1300856 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST)) {
857 struct udevice *base = ll_entry_start(struct udevice, udevice);
858
859 dev = base + idx;
860 } else {
861 struct driver_rt *drt = gd_dm_driver_rt() + idx;
862
863 dev = drt->dev;
864 }
Simon Glass5792f4b2020-10-03 11:31:40 -0600865 *devp = NULL;
866
867 return device_get_device_tail(dev, dev ? 0 : -ENOENT, devp);
868}
Walter Lozanoffc41b02020-06-25 01:10:11 -0300869#endif
Simon Glassae2efac2015-06-23 15:38:37 -0600870
Simon Glass2a580882020-01-27 08:49:36 -0700871int device_find_first_child(const struct udevice *parent, struct udevice **devp)
Simon Glass44da7352014-10-13 23:41:49 -0600872{
873 if (list_empty(&parent->child_head)) {
874 *devp = NULL;
875 } else {
876 *devp = list_first_entry(&parent->child_head, struct udevice,
877 sibling_node);
878 }
879
880 return 0;
881}
882
883int device_find_next_child(struct udevice **devp)
884{
885 struct udevice *dev = *devp;
886 struct udevice *parent = dev->parent;
887
888 if (list_is_last(&dev->sibling_node, &parent->child_head)) {
889 *devp = NULL;
890 } else {
891 *devp = list_entry(dev->sibling_node.next, struct udevice,
892 sibling_node);
893 }
894
895 return 0;
896}
Simon Glass70c3a0e2014-11-11 10:46:18 -0700897
Simon Glass2a580882020-01-27 08:49:36 -0700898int device_find_first_inactive_child(const struct udevice *parent,
Simon Glassb775e872018-10-01 12:22:07 -0600899 enum uclass_id uclass_id,
900 struct udevice **devp)
901{
902 struct udevice *dev;
903
904 *devp = NULL;
905 list_for_each_entry(dev, &parent->child_head, sibling_node) {
906 if (!device_active(dev) &&
907 device_get_uclass_id(dev) == uclass_id) {
908 *devp = dev;
909 return 0;
910 }
911 }
912
913 return -ENODEV;
914}
915
Simon Glass2a580882020-01-27 08:49:36 -0700916int device_find_first_child_by_uclass(const struct udevice *parent,
Simon Glassa11341a2018-11-18 08:14:31 -0700917 enum uclass_id uclass_id,
918 struct udevice **devp)
919{
920 struct udevice *dev;
921
922 *devp = NULL;
923 list_for_each_entry(dev, &parent->child_head, sibling_node) {
924 if (device_get_uclass_id(dev) == uclass_id) {
925 *devp = dev;
926 return 0;
927 }
928 }
929
930 return -ENODEV;
931}
932
Simon Glass4b23e452021-10-23 17:26:08 -0600933int device_find_child_by_namelen(const struct udevice *parent, const char *name,
934 int len, struct udevice **devp)
Simon Glassa11341a2018-11-18 08:14:31 -0700935{
936 struct udevice *dev;
937
938 *devp = NULL;
939
940 list_for_each_entry(dev, &parent->child_head, sibling_node) {
Simon Glass4b23e452021-10-23 17:26:08 -0600941 if (!strncmp(dev->name, name, len) &&
942 strlen(dev->name) == len) {
Simon Glassa11341a2018-11-18 08:14:31 -0700943 *devp = dev;
944 return 0;
945 }
946 }
947
948 return -ENODEV;
949}
950
Simon Glass4b23e452021-10-23 17:26:08 -0600951int device_find_child_by_name(const struct udevice *parent, const char *name,
952 struct udevice **devp)
953{
954 return device_find_child_by_namelen(parent, name, strlen(name), devp);
955}
956
Simon Glass76db9b72020-01-27 08:49:48 -0700957int device_first_child_err(struct udevice *parent, struct udevice **devp)
958{
959 struct udevice *dev;
960
961 device_find_first_child(parent, &dev);
962 if (!dev)
963 return -ENODEV;
964
965 return device_get_device_tail(dev, 0, devp);
966}
967
968int device_next_child_err(struct udevice **devp)
969{
970 struct udevice *dev = *devp;
971
972 device_find_next_child(&dev);
973 if (!dev)
974 return -ENODEV;
975
976 return device_get_device_tail(dev, 0, devp);
977}
978
Simon Glass000676b2020-01-27 08:49:47 -0700979int device_first_child_ofdata_err(struct udevice *parent, struct udevice **devp)
980{
981 struct udevice *dev;
982 int ret;
983
984 device_find_first_child(parent, &dev);
985 if (!dev)
986 return -ENODEV;
987
Simon Glassaad29ae2020-12-03 16:55:21 -0700988 ret = device_of_to_plat(dev);
Simon Glass000676b2020-01-27 08:49:47 -0700989 if (ret)
990 return ret;
991
992 *devp = dev;
993
994 return 0;
995}
996
997int device_next_child_ofdata_err(struct udevice **devp)
998{
999 struct udevice *dev = *devp;
1000 int ret;
1001
1002 device_find_next_child(&dev);
1003 if (!dev)
1004 return -ENODEV;
1005
Simon Glassaad29ae2020-12-03 16:55:21 -07001006 ret = device_of_to_plat(dev);
Simon Glass000676b2020-01-27 08:49:47 -07001007 if (ret)
1008 return ret;
1009
1010 *devp = dev;
1011
1012 return 0;
1013}
1014
Simon Glass2e5e5ec2018-10-01 12:22:06 -06001015struct udevice *dev_get_parent(const struct udevice *child)
Simon Glass43f488a2014-11-11 10:46:19 -07001016{
1017 return child->parent;
1018}
1019
Simon Glass2e5e5ec2018-10-01 12:22:06 -06001020ulong dev_get_driver_data(const struct udevice *dev)
Simon Glass70c3a0e2014-11-11 10:46:18 -07001021{
Simon Glass46227bd2015-03-25 12:21:55 -06001022 return dev->driver_data;
Simon Glass70c3a0e2014-11-11 10:46:18 -07001023}
Simon Glass98fd5d12015-01-25 08:27:04 -07001024
Simon Glass2e5e5ec2018-10-01 12:22:06 -06001025const void *dev_get_driver_ops(const struct udevice *dev)
Przemyslaw Marczakd3ef0d72015-04-15 13:07:24 +02001026{
1027 if (!dev || !dev->driver->ops)
1028 return NULL;
1029
1030 return dev->driver->ops;
1031}
1032
Simon Glass2e5e5ec2018-10-01 12:22:06 -06001033enum uclass_id device_get_uclass_id(const struct udevice *dev)
Simon Glass98fd5d12015-01-25 08:27:04 -07001034{
1035 return dev->uclass->uc_drv->id;
1036}
Peng Fan99b72352015-02-10 14:46:32 +08001037
Simon Glass2e5e5ec2018-10-01 12:22:06 -06001038const char *dev_get_uclass_name(const struct udevice *dev)
Przemyslaw Marczak5ed2e422015-04-15 13:07:25 +02001039{
1040 if (!dev)
1041 return NULL;
1042
1043 return dev->uclass->uc_drv->name;
1044}
1045
Simon Glass2e5e5ec2018-10-01 12:22:06 -06001046bool device_has_children(const struct udevice *dev)
Simon Glass40f829a2015-03-25 12:21:57 -06001047{
1048 return !list_empty(&dev->child_head);
1049}
1050
Simon Glass2a580882020-01-27 08:49:36 -07001051bool device_has_active_children(const struct udevice *dev)
Simon Glass40f829a2015-03-25 12:21:57 -06001052{
1053 struct udevice *child;
1054
1055 for (device_find_first_child(dev, &child);
1056 child;
1057 device_find_next_child(&child)) {
1058 if (device_active(child))
1059 return true;
1060 }
1061
1062 return false;
1063}
1064
Simon Glass2a580882020-01-27 08:49:36 -07001065bool device_is_last_sibling(const struct udevice *dev)
Simon Glass40f829a2015-03-25 12:21:57 -06001066{
1067 struct udevice *parent = dev->parent;
1068
1069 if (!parent)
1070 return false;
1071 return list_is_last(&dev->sibling_node, &parent->child_head);
1072}
Simon Glasse3b23e22015-07-30 13:40:39 -06001073
Simon Glass7760ba22016-05-01 13:52:23 -06001074void device_set_name_alloced(struct udevice *dev)
1075{
Simon Glass6211d762020-12-19 10:40:10 -07001076 dev_or_flags(dev, DM_FLAG_NAME_ALLOCED);
Simon Glass7760ba22016-05-01 13:52:23 -06001077}
1078
Simon Glasse3b23e22015-07-30 13:40:39 -06001079int device_set_name(struct udevice *dev, const char *name)
1080{
1081 name = strdup(name);
1082 if (!name)
1083 return -ENOMEM;
1084 dev->name = name;
Simon Glass7760ba22016-05-01 13:52:23 -06001085 device_set_name_alloced(dev);
Simon Glasse3b23e22015-07-30 13:40:39 -06001086
1087 return 0;
1088}
Mugunthan V N4666bd92016-04-28 15:36:02 +05301089
Simon Glassd4f0c942020-12-22 19:30:27 -07001090void dev_set_priv(struct udevice *dev, void *priv)
1091{
Simon Glass541f62c2020-12-22 19:30:30 -07001092 dev->priv_ = priv;
Simon Glassd4f0c942020-12-22 19:30:27 -07001093}
1094
1095void dev_set_parent_priv(struct udevice *dev, void *parent_priv)
1096{
Simon Glass541f62c2020-12-22 19:30:30 -07001097 dev->parent_priv_ = parent_priv;
Simon Glassd4f0c942020-12-22 19:30:27 -07001098}
1099
1100void dev_set_uclass_priv(struct udevice *dev, void *uclass_priv)
1101{
Simon Glass541f62c2020-12-22 19:30:30 -07001102 dev->uclass_priv_ = uclass_priv;
Simon Glassd4f0c942020-12-22 19:30:27 -07001103}
1104
1105void dev_set_plat(struct udevice *dev, void *plat)
1106{
Simon Glass541f62c2020-12-22 19:30:30 -07001107 dev->plat_ = plat;
Simon Glassd4f0c942020-12-22 19:30:27 -07001108}
1109
1110void dev_set_parent_plat(struct udevice *dev, void *parent_plat)
1111{
Simon Glass541f62c2020-12-22 19:30:30 -07001112 dev->parent_plat_ = parent_plat;
Simon Glassd4f0c942020-12-22 19:30:27 -07001113}
1114
1115void dev_set_uclass_plat(struct udevice *dev, void *uclass_plat)
1116{
Simon Glass541f62c2020-12-22 19:30:30 -07001117 dev->uclass_plat_ = uclass_plat;
Simon Glassd4f0c942020-12-22 19:30:27 -07001118}
1119
Simon Glass3580f6d2021-08-07 07:24:03 -06001120#if CONFIG_IS_ENABLED(OF_REAL)
Simon Glass2a580882020-01-27 08:49:36 -07001121bool device_is_compatible(const struct udevice *dev, const char *compat)
Mugunthan V N4666bd92016-04-28 15:36:02 +05301122{
Masahiro Yamada9349bcc2018-04-19 12:14:02 +09001123 return ofnode_device_is_compatible(dev_ofnode(dev), compat);
Mugunthan V N4666bd92016-04-28 15:36:02 +05301124}
1125
1126bool of_machine_is_compatible(const char *compat)
1127{
Patrick Delaunayc5574ea2022-05-17 14:37:05 +02001128 return ofnode_device_is_compatible(ofnode_root(), compat);
Mugunthan V N4666bd92016-04-28 15:36:02 +05301129}
Mario Six3bedfbe2018-06-26 08:46:50 +02001130
1131int dev_disable_by_path(const char *path)
1132{
1133 struct uclass *uc;
1134 ofnode node = ofnode_path(path);
1135 struct udevice *dev;
1136 int ret = 1;
1137
1138 if (!of_live_active())
1139 return -ENOSYS;
1140
Simon Glass784cd9e2020-12-19 10:40:17 -07001141 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
Mario Six3bedfbe2018-06-26 08:46:50 +02001142 ret = uclass_find_device_by_ofnode(uc->uc_drv->id, node, &dev);
1143 if (!ret)
1144 break;
1145 }
1146
1147 if (ret)
1148 return ret;
1149
1150 ret = device_remove(dev, DM_REMOVE_NORMAL);
1151 if (ret)
1152 return ret;
1153
1154 ret = device_unbind(dev);
1155 if (ret)
1156 return ret;
1157
1158 return ofnode_set_enabled(node, false);
1159}
1160
1161int dev_enable_by_path(const char *path)
1162{
1163 ofnode node = ofnode_path(path);
1164 ofnode pnode = ofnode_get_parent(node);
1165 struct udevice *parent;
1166 int ret = 1;
1167
1168 if (!of_live_active())
1169 return -ENOSYS;
1170
1171 ret = device_find_by_ofnode(pnode, &parent);
1172 if (ret)
1173 return ret;
1174
1175 ret = ofnode_set_enabled(node, true);
1176 if (ret)
1177 return ret;
1178
Patrice Chotardcc523cf2021-09-10 16:16:20 +02001179 return lists_bind_fdt(parent, node, NULL, NULL, false);
Mario Six3bedfbe2018-06-26 08:46:50 +02001180}
Marek Vasut7f18c342019-08-31 18:03:28 +02001181#endif
Simon Glassb5660c42021-03-15 17:25:37 +13001182
1183#if CONFIG_IS_ENABLED(OF_PLATDATA_RT)
1184static struct udevice_rt *dev_get_rt(const struct udevice *dev)
1185{
1186 struct udevice *base = ll_entry_start(struct udevice, udevice);
Simon Glass308d91b2022-03-27 14:26:20 -06001187 uint each_size = dm_udevice_size();
1188 int idx = ((void *)dev - (void *)base) / each_size;
Simon Glassb5660c42021-03-15 17:25:37 +13001189
1190 struct udevice_rt *urt = gd_dm_udevice_rt() + idx;
1191
1192 return urt;
1193}
1194
1195u32 dev_get_flags(const struct udevice *dev)
1196{
1197 const struct udevice_rt *urt = dev_get_rt(dev);
1198
1199 return urt->flags_;
1200}
1201
1202void dev_or_flags(const struct udevice *dev, u32 or)
1203{
1204 struct udevice_rt *urt = dev_get_rt(dev);
1205
1206 urt->flags_ |= or;
1207}
1208
1209void dev_bic_flags(const struct udevice *dev, u32 bic)
1210{
1211 struct udevice_rt *urt = dev_get_rt(dev);
1212
1213 urt->flags_ &= ~bic;
1214}
1215#endif /* OF_PLATDATA_RT */