blob: e46d5717aa62206d18734573ffe31cc8ede399bf [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass6494d702014-02-26 15:59:18 -07002/*
3 * Copyright (c) 2013 Google, Inc
4 *
5 * (C) Copyright 2012
6 * Pavel Herrmann <morpheus.ibis@gmail.com>
Simon Glass6494d702014-02-26 15:59:18 -07007 */
8
Kever Yang97b5f9d2019-10-22 15:39:47 +08009#define LOG_CATEGORY LOGC_DM
10
Simon Glass6494d702014-02-26 15:59:18 -070011#include <common.h>
Simon Glass40bb6372017-05-18 20:09:09 -060012#include <dm.h>
Simon Glass6494d702014-02-26 15:59:18 -070013#include <errno.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060014#include <log.h>
Simon Glass6494d702014-02-26 15:59:18 -070015#include <malloc.h>
Simon Glass401d1c42020-10-30 21:38:53 -060016#include <asm/global_data.h>
Simon Glass6494d702014-02-26 15:59:18 -070017#include <dm/device.h>
18#include <dm/device-internal.h>
19#include <dm/lists.h>
20#include <dm/uclass.h>
21#include <dm/uclass-internal.h>
22#include <dm/util.h>
23
24DECLARE_GLOBAL_DATA_PTR;
25
26struct uclass *uclass_find(enum uclass_id key)
27{
28 struct uclass *uc;
29
Simon Glassc910e2e2014-07-23 06:55:15 -060030 if (!gd->dm_root)
31 return NULL;
Simon Glass6494d702014-02-26 15:59:18 -070032 /*
33 * TODO(sjg@chromium.org): Optimise this, perhaps moving the found
34 * node to the start of the list, or creating a linear array mapping
35 * id to node.
36 */
Simon Glass8a715532020-12-19 10:40:17 -070037 list_for_each_entry(uc, gd->uclass_root, sibling_node) {
Simon Glass6494d702014-02-26 15:59:18 -070038 if (uc->uc_drv->id == key)
39 return uc;
40 }
41
42 return NULL;
43}
44
45/**
46 * uclass_add() - Create new uclass in list
47 * @id: Id number to create
48 * @ucp: Returns pointer to uclass, or NULL on error
Heinrich Schuchardt185f8122022-01-19 18:05:50 +010049 * Return: 0 on success, -ve on error
Simon Glass6494d702014-02-26 15:59:18 -070050 *
51 * The new uclass is added to the list. There must be only one uclass for
52 * each id.
53 */
54static int uclass_add(enum uclass_id id, struct uclass **ucp)
55{
56 struct uclass_driver *uc_drv;
57 struct uclass *uc;
58 int ret;
59
60 *ucp = NULL;
61 uc_drv = lists_uclass_lookup(id);
62 if (!uc_drv) {
Masahiro Yamada643e6902015-07-07 18:51:32 +090063 debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
64 id);
Simon Glass3346c872015-08-30 16:55:16 -060065 /*
66 * Use a strange error to make this case easier to find. When
67 * a uclass is not available it can prevent driver model from
68 * starting up and this failure is otherwise hard to debug.
69 */
70 return -EPFNOSUPPORT;
Simon Glass6494d702014-02-26 15:59:18 -070071 }
Simon Glass6494d702014-02-26 15:59:18 -070072 uc = calloc(1, sizeof(*uc));
73 if (!uc)
74 return -ENOMEM;
Simon Glass41575d82020-12-03 16:55:17 -070075 if (uc_drv->priv_auto) {
Simon Glass89ba6d52020-12-22 19:30:29 -070076 void *ptr;
77
78 ptr = calloc(1, uc_drv->priv_auto);
79 if (!ptr) {
Simon Glass6494d702014-02-26 15:59:18 -070080 ret = -ENOMEM;
81 goto fail_mem;
82 }
Simon Glass89ba6d52020-12-22 19:30:29 -070083 uclass_set_priv(uc, ptr);
Simon Glass6494d702014-02-26 15:59:18 -070084 }
85 uc->uc_drv = uc_drv;
86 INIT_LIST_HEAD(&uc->sibling_node);
87 INIT_LIST_HEAD(&uc->dev_head);
Simon Glass8a715532020-12-19 10:40:17 -070088 list_add(&uc->sibling_node, DM_UCLASS_ROOT_NON_CONST);
Simon Glass6494d702014-02-26 15:59:18 -070089
90 if (uc_drv->init) {
91 ret = uc_drv->init(uc);
92 if (ret)
93 goto fail;
94 }
95
96 *ucp = uc;
97
98 return 0;
99fail:
Simon Glass41575d82020-12-03 16:55:17 -0700100 if (uc_drv->priv_auto) {
Simon Glass89ba6d52020-12-22 19:30:29 -0700101 free(uclass_get_priv(uc));
102 uclass_set_priv(uc, NULL);
Simon Glass6494d702014-02-26 15:59:18 -0700103 }
104 list_del(&uc->sibling_node);
105fail_mem:
106 free(uc);
107
108 return ret;
109}
110
111int uclass_destroy(struct uclass *uc)
112{
113 struct uclass_driver *uc_drv;
Simon Glass07d260e2015-04-19 07:20:58 -0600114 struct udevice *dev;
Simon Glass6494d702014-02-26 15:59:18 -0700115 int ret;
116
Simon Glass07d260e2015-04-19 07:20:58 -0600117 /*
118 * We cannot use list_for_each_entry_safe() here. If a device in this
119 * uclass has a child device also in this uclass, it will be also be
120 * unbound (by the recursion in the call to device_unbind() below).
121 * We can loop until the list is empty.
122 */
123 while (!list_empty(&uc->dev_head)) {
124 dev = list_first_entry(&uc->dev_head, struct udevice,
125 uclass_node);
Simon Glassced10802020-03-28 14:03:48 -0600126 ret = device_remove(dev, DM_REMOVE_NORMAL | DM_REMOVE_NO_PD);
Simon Glass6494d702014-02-26 15:59:18 -0700127 if (ret)
Simon Glass8474da92020-03-28 14:03:47 -0600128 return log_msg_ret("remove", ret);
Simon Glass6494d702014-02-26 15:59:18 -0700129 ret = device_unbind(dev);
130 if (ret)
Simon Glass8474da92020-03-28 14:03:47 -0600131 return log_msg_ret("unbind", ret);
Simon Glass6494d702014-02-26 15:59:18 -0700132 }
133
134 uc_drv = uc->uc_drv;
135 if (uc_drv->destroy)
136 uc_drv->destroy(uc);
137 list_del(&uc->sibling_node);
Simon Glass41575d82020-12-03 16:55:17 -0700138 if (uc_drv->priv_auto)
Simon Glass89ba6d52020-12-22 19:30:29 -0700139 free(uclass_get_priv(uc));
Simon Glass6494d702014-02-26 15:59:18 -0700140 free(uc);
141
142 return 0;
143}
144
145int uclass_get(enum uclass_id id, struct uclass **ucp)
146{
147 struct uclass *uc;
148
Simon Glass1e9ced22021-08-01 12:05:23 -0600149 /* Immediately fail if driver model is not set up */
150 if (!gd->uclass_root)
151 return -EDEADLK;
Simon Glass6494d702014-02-26 15:59:18 -0700152 *ucp = NULL;
153 uc = uclass_find(id);
Simon Glass91bcfdf2021-03-15 17:25:18 +1300154 if (!uc) {
155 if (CONFIG_IS_ENABLED(OF_PLATDATA_INST))
156 return -ENOENT;
Simon Glass6494d702014-02-26 15:59:18 -0700157 return uclass_add(id, ucp);
Simon Glass91bcfdf2021-03-15 17:25:18 +1300158 }
Simon Glass6494d702014-02-26 15:59:18 -0700159 *ucp = uc;
160
161 return 0;
162}
163
Simon Glass0a5f6f82016-10-05 20:42:13 -0600164const char *uclass_get_name(enum uclass_id id)
165{
166 struct uclass *uc;
167
168 if (uclass_get(id, &uc))
169 return NULL;
170 return uc->uc_drv->name;
171}
172
Simon Glass80647392020-12-22 19:30:26 -0700173void *uclass_get_priv(const struct uclass *uc)
174{
Simon Glassfb8c9fb2020-12-22 19:30:30 -0700175 return uc->priv_;
Simon Glass80647392020-12-22 19:30:26 -0700176}
177
178void uclass_set_priv(struct uclass *uc, void *priv)
179{
Simon Glassfb8c9fb2020-12-22 19:30:30 -0700180 uc->priv_ = priv;
Simon Glass80647392020-12-22 19:30:26 -0700181}
182
Simon Glass6aa4fe32022-04-24 23:30:59 -0600183enum uclass_id uclass_get_by_namelen(const char *name, int len)
Simon Glass6e43d1b2017-12-28 13:14:15 -0700184{
185 int i;
186
187 for (i = 0; i < UCLASS_COUNT; i++) {
188 struct uclass_driver *uc_drv = lists_uclass_lookup(i);
189
Simon Glass6aa4fe32022-04-24 23:30:59 -0600190 if (uc_drv && !strncmp(uc_drv->name, name, len) &&
191 strlen(uc_drv->name) == len)
Simon Glass6e43d1b2017-12-28 13:14:15 -0700192 return i;
193 }
194
195 return UCLASS_INVALID;
196}
197
Simon Glass4b030172021-10-23 17:26:08 -0600198enum uclass_id uclass_get_by_name(const char *name)
199{
Simon Glass6aa4fe32022-04-24 23:30:59 -0600200 return uclass_get_by_namelen(name, strlen(name));
Simon Glass4b030172021-10-23 17:26:08 -0600201}
202
Jean-Jacques Hiblote7c86562018-08-09 16:17:42 +0200203int dev_get_uclass_index(struct udevice *dev, struct uclass **ucp)
204{
205 struct udevice *iter;
206 struct uclass *uc = dev->uclass;
207 int i = 0;
208
209 if (list_empty(&uc->dev_head))
210 return -ENODEV;
211
Liviu Dudau81f351d2018-09-28 14:12:55 +0100212 uclass_foreach_dev(iter, uc) {
Jean-Jacques Hiblote7c86562018-08-09 16:17:42 +0200213 if (iter == dev) {
214 if (ucp)
215 *ucp = uc;
216 return i;
217 }
218 i++;
219 }
220
221 return -ENODEV;
222}
223
Heiko Schocher54c5d082014-05-22 12:43:05 +0200224int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
Simon Glass6494d702014-02-26 15:59:18 -0700225{
226 struct uclass *uc;
Heiko Schocher54c5d082014-05-22 12:43:05 +0200227 struct udevice *dev;
Simon Glass6494d702014-02-26 15:59:18 -0700228 int ret;
229
230 *devp = NULL;
231 ret = uclass_get(id, &uc);
232 if (ret)
233 return ret;
Simon Glass2fda14a2015-07-31 09:31:19 -0600234 if (list_empty(&uc->dev_head))
235 return -ENODEV;
Simon Glass6494d702014-02-26 15:59:18 -0700236
Liviu Dudau81f351d2018-09-28 14:12:55 +0100237 uclass_foreach_dev(dev, uc) {
Simon Glass6494d702014-02-26 15:59:18 -0700238 if (!index--) {
239 *devp = dev;
240 return 0;
241 }
242 }
243
244 return -ENODEV;
245}
246
Przemyslaw Marczakc1d6f912015-04-15 13:07:17 +0200247int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
248{
249 struct uclass *uc;
250 int ret;
251
252 *devp = NULL;
253 ret = uclass_get(id, &uc);
254 if (ret)
255 return ret;
256 if (list_empty(&uc->dev_head))
Simon Glass4805a7a2019-09-25 08:55:55 -0600257 return 0;
Przemyslaw Marczakc1d6f912015-04-15 13:07:17 +0200258
259 *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
260
261 return 0;
262}
263
264int uclass_find_next_device(struct udevice **devp)
265{
266 struct udevice *dev = *devp;
267
268 *devp = NULL;
269 if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
270 return 0;
271
272 *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
273
274 return 0;
275}
276
Simon Glass4e0710a2022-04-24 23:31:00 -0600277int uclass_find_device_by_namelen(enum uclass_id id, const char *name, int len,
278 struct udevice **devp)
Przemyslaw Marczake0735a42015-04-15 13:07:22 +0200279{
280 struct uclass *uc;
281 struct udevice *dev;
282 int ret;
283
284 *devp = NULL;
285 if (!name)
286 return -EINVAL;
287 ret = uclass_get(id, &uc);
288 if (ret)
289 return ret;
290
Liviu Dudau81f351d2018-09-28 14:12:55 +0100291 uclass_foreach_dev(dev, uc) {
Simon Glass4e0710a2022-04-24 23:31:00 -0600292 if (!strncmp(dev->name, name, len) &&
293 strlen(dev->name) == len) {
Przemyslaw Marczake0735a42015-04-15 13:07:22 +0200294 *devp = dev;
295 return 0;
296 }
297 }
298
299 return -ENODEV;
300}
301
Simon Glass4e0710a2022-04-24 23:31:00 -0600302int uclass_find_device_by_name(enum uclass_id id, const char *name,
303 struct udevice **devp)
304{
305 return uclass_find_device_by_namelen(id, name, strlen(name), devp);
306}
307
Simon Glassa133e212020-12-16 21:20:30 -0700308int uclass_find_next_free_seq(struct uclass *uc)
Jean-Jacques Hiblot3542ff22018-12-07 14:50:39 +0100309{
Jean-Jacques Hiblot3542ff22018-12-07 14:50:39 +0100310 struct udevice *dev;
Jean-Jacques Hiblot3542ff22018-12-07 14:50:39 +0100311 int max = -1;
312
Simon Glassa133e212020-12-16 21:20:30 -0700313 /* If using aliases, start with the highest alias value */
314 if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
315 (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS))
316 max = dev_read_alias_highest_id(uc->uc_drv->name);
Jean-Jacques Hiblot3542ff22018-12-07 14:50:39 +0100317
Simon Glassa133e212020-12-16 21:20:30 -0700318 /* Avoid conflict with existing devices */
319 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
Simon Glass24621392020-12-19 10:40:09 -0700320 if (dev->seq_ > max)
321 max = dev->seq_;
Simon Glassa133e212020-12-16 21:20:30 -0700322 }
323 /*
324 * At this point, max will be -1 if there are no existing aliases or
325 * devices
326 */
Jean-Jacques Hiblot3542ff22018-12-07 14:50:39 +0100327
328 return max + 1;
329}
Jean-Jacques Hiblot3542ff22018-12-07 14:50:39 +0100330
Simon Glass99175912020-12-16 21:20:29 -0700331int uclass_find_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
Simon Glass5a66a8f2014-07-23 06:55:12 -0600332{
333 struct uclass *uc;
334 struct udevice *dev;
335 int ret;
336
337 *devp = NULL;
Simon Glass99175912020-12-16 21:20:29 -0700338 log_debug("%d\n", seq);
339 if (seq == -1)
Simon Glass5a66a8f2014-07-23 06:55:12 -0600340 return -ENODEV;
341 ret = uclass_get(id, &uc);
342 if (ret)
343 return ret;
344
Liviu Dudau81f351d2018-09-28 14:12:55 +0100345 uclass_foreach_dev(dev, uc) {
Simon Glass24621392020-12-19 10:40:09 -0700346 log_debug(" - %d '%s'\n", dev->seq_, dev->name);
347 if (dev->seq_ == seq) {
Simon Glass5a66a8f2014-07-23 06:55:12 -0600348 *devp = dev;
Kever Yang97b5f9d2019-10-22 15:39:47 +0800349 log_debug(" - found\n");
Simon Glass5a66a8f2014-07-23 06:55:12 -0600350 return 0;
351 }
352 }
Kever Yang97b5f9d2019-10-22 15:39:47 +0800353 log_debug(" - not found\n");
Simon Glass5a66a8f2014-07-23 06:55:12 -0600354
355 return -ENODEV;
356}
357
Simon Glass1b30d612016-01-21 19:43:57 -0700358int uclass_find_device_by_of_offset(enum uclass_id id, int node,
359 struct udevice **devp)
Simon Glassf4cdead2014-07-23 06:55:14 -0600360{
361 struct uclass *uc;
362 struct udevice *dev;
363 int ret;
364
365 *devp = NULL;
366 if (node < 0)
367 return -ENODEV;
368 ret = uclass_get(id, &uc);
369 if (ret)
370 return ret;
371
Liviu Dudau81f351d2018-09-28 14:12:55 +0100372 uclass_foreach_dev(dev, uc) {
Simon Glasse160f7d2017-01-17 16:52:55 -0700373 if (dev_of_offset(dev) == node) {
Simon Glassf4cdead2014-07-23 06:55:14 -0600374 *devp = dev;
375 return 0;
376 }
377 }
378
379 return -ENODEV;
380}
381
Simon Glass40bb6372017-05-18 20:09:09 -0600382int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
383 struct udevice **devp)
384{
385 struct uclass *uc;
386 struct udevice *dev;
387 int ret;
388
Simon Glass31e60ff2018-06-11 13:07:19 -0600389 log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
Simon Glass40bb6372017-05-18 20:09:09 -0600390 *devp = NULL;
391 if (!ofnode_valid(node))
392 return -ENODEV;
393 ret = uclass_get(id, &uc);
394 if (ret)
395 return ret;
396
Liviu Dudau81f351d2018-09-28 14:12:55 +0100397 uclass_foreach_dev(dev, uc) {
Simon Glass31e60ff2018-06-11 13:07:19 -0600398 log(LOGC_DM, LOGL_DEBUG_CONTENT, " - checking %s\n",
399 dev->name);
Simon Glass40bb6372017-05-18 20:09:09 -0600400 if (ofnode_equal(dev_ofnode(dev), node)) {
401 *devp = dev;
Simon Glass31e60ff2018-06-11 13:07:19 -0600402 goto done;
Simon Glass40bb6372017-05-18 20:09:09 -0600403 }
404 }
Simon Glass31e60ff2018-06-11 13:07:19 -0600405 ret = -ENODEV;
Simon Glass40bb6372017-05-18 20:09:09 -0600406
Simon Glass31e60ff2018-06-11 13:07:19 -0600407done:
408 log(LOGC_DM, LOGL_DEBUG, " - result for %s: %s (ret=%d)\n",
409 ofnode_get_name(node), *devp ? (*devp)->name : "(none)", ret);
410 return ret;
Simon Glass40bb6372017-05-18 20:09:09 -0600411}
412
Simon Glass414cc152021-08-07 07:24:03 -0600413#if CONFIG_IS_ENABLED(OF_REAL)
Rasmus Villemoes6ebb3572023-04-13 17:16:11 +0200414static int uclass_find_device_by_phandle_id(enum uclass_id id,
415 uint find_phandle,
416 struct udevice **devp)
Simon Glassd82ba4c2015-07-02 18:15:38 -0600417{
418 struct udevice *dev;
419 struct uclass *uc;
Simon Glassd82ba4c2015-07-02 18:15:38 -0600420 int ret;
421
Simon Glassd82ba4c2015-07-02 18:15:38 -0600422 ret = uclass_get(id, &uc);
423 if (ret)
424 return ret;
425
Liviu Dudau81f351d2018-09-28 14:12:55 +0100426 uclass_foreach_dev(dev, uc) {
Simon Glasse160f7d2017-01-17 16:52:55 -0700427 uint phandle;
428
Simon Glassa40cc8e2017-05-18 20:09:12 -0600429 phandle = dev_read_phandle(dev);
Simon Glassd82ba4c2015-07-02 18:15:38 -0600430
431 if (phandle == find_phandle) {
432 *devp = dev;
433 return 0;
434 }
435 }
436
437 return -ENODEV;
438}
Rasmus Villemoes6ebb3572023-04-13 17:16:11 +0200439
440int uclass_find_device_by_phandle(enum uclass_id id, struct udevice *parent,
441 const char *name, struct udevice **devp)
442{
443 int find_phandle;
444
445 *devp = NULL;
446 find_phandle = dev_read_u32_default(parent, name, -1);
447 if (find_phandle <= 0)
448 return -ENOENT;
449
450 return uclass_find_device_by_phandle_id(id, find_phandle, devp);
451}
Simon Glassc275dfe2015-12-19 19:38:55 -0700452#endif
Simon Glassd82ba4c2015-07-02 18:15:38 -0600453
Simon Glassc57f8062016-07-17 15:23:15 -0600454int uclass_get_device_by_driver(enum uclass_id id,
455 const struct driver *find_drv,
456 struct udevice **devp)
457{
458 struct udevice *dev;
459 struct uclass *uc;
460 int ret;
461
462 ret = uclass_get(id, &uc);
463 if (ret)
464 return ret;
465
Liviu Dudau81f351d2018-09-28 14:12:55 +0100466 uclass_foreach_dev(dev, uc) {
Simon Glassc57f8062016-07-17 15:23:15 -0600467 if (dev->driver == find_drv)
468 return uclass_get_device_tail(dev, 0, devp);
469 }
470
471 return -ENODEV;
472}
473
Simon Glass30a570a2017-04-23 20:10:43 -0600474int uclass_get_device_tail(struct udevice *dev, int ret, struct udevice **devp)
Simon Glass6494d702014-02-26 15:59:18 -0700475{
Simon Glass6494d702014-02-26 15:59:18 -0700476 if (ret)
477 return ret;
478
Simon Glassf66529f2015-04-24 22:33:07 -0600479 assert(dev);
Simon Glass6494d702014-02-26 15:59:18 -0700480 ret = device_probe(dev);
481 if (ret)
482 return ret;
483
484 *devp = dev;
485
486 return 0;
487}
488
Simon Glass9ca296a2014-07-23 06:55:08 -0600489int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
490{
491 struct udevice *dev;
492 int ret;
493
494 *devp = NULL;
495 ret = uclass_find_device(id, index, &dev);
496 return uclass_get_device_tail(dev, ret, devp);
497}
498
Przemyslaw Marczakb7af1a22015-04-15 13:07:23 +0200499int uclass_get_device_by_name(enum uclass_id id, const char *name,
500 struct udevice **devp)
501{
502 struct udevice *dev;
503 int ret;
504
505 *devp = NULL;
506 ret = uclass_find_device_by_name(id, name, &dev);
507 return uclass_get_device_tail(dev, ret, devp);
508}
509
Simon Glass5a66a8f2014-07-23 06:55:12 -0600510int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
511{
512 struct udevice *dev;
513 int ret;
514
515 *devp = NULL;
Simon Glass99175912020-12-16 21:20:29 -0700516 ret = uclass_find_device_by_seq(id, seq, &dev);
517
Simon Glass5a66a8f2014-07-23 06:55:12 -0600518 return uclass_get_device_tail(dev, ret, devp);
519}
520
Simon Glassf4cdead2014-07-23 06:55:14 -0600521int uclass_get_device_by_of_offset(enum uclass_id id, int node,
522 struct udevice **devp)
523{
524 struct udevice *dev;
525 int ret;
526
527 *devp = NULL;
528 ret = uclass_find_device_by_of_offset(id, node, &dev);
529 return uclass_get_device_tail(dev, ret, devp);
530}
531
Simon Glass40bb6372017-05-18 20:09:09 -0600532int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
533 struct udevice **devp)
534{
535 struct udevice *dev;
536 int ret;
537
Simon Glass31e60ff2018-06-11 13:07:19 -0600538 log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
Simon Glass40bb6372017-05-18 20:09:09 -0600539 *devp = NULL;
540 ret = uclass_find_device_by_ofnode(id, node, &dev);
Simon Glass31e60ff2018-06-11 13:07:19 -0600541 log(LOGC_DM, LOGL_DEBUG, " - result for %s: %s (ret=%d)\n",
542 ofnode_get_name(node), dev ? dev->name : "(none)", ret);
Simon Glass40bb6372017-05-18 20:09:09 -0600543
544 return uclass_get_device_tail(dev, ret, devp);
545}
546
Rasmus Villemoes6ebb3572023-04-13 17:16:11 +0200547#if CONFIG_IS_ENABLED(OF_REAL)
Rasmus Villemoesca031c02023-04-13 17:17:03 +0200548int uclass_get_device_by_of_path(enum uclass_id id, const char *path,
549 struct udevice **devp)
550{
551 return uclass_get_device_by_ofnode(id, ofnode_path(path), devp);
552}
553
Kever Yangd255fad2018-02-09 10:56:23 +0800554int uclass_get_device_by_phandle_id(enum uclass_id id, uint phandle_id,
555 struct udevice **devp)
556{
557 struct udevice *dev;
Kever Yangd255fad2018-02-09 10:56:23 +0800558 int ret;
559
560 *devp = NULL;
Rasmus Villemoes6ebb3572023-04-13 17:16:11 +0200561 ret = uclass_find_device_by_phandle_id(id, phandle_id, &dev);
562 return uclass_get_device_tail(dev, ret, devp);
Kever Yangd255fad2018-02-09 10:56:23 +0800563}
564
Simon Glassd82ba4c2015-07-02 18:15:38 -0600565int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
566 const char *name, struct udevice **devp)
567{
568 struct udevice *dev;
569 int ret;
570
571 *devp = NULL;
572 ret = uclass_find_device_by_phandle(id, parent, name, &dev);
573 return uclass_get_device_tail(dev, ret, devp);
574}
Simon Glassc275dfe2015-12-19 19:38:55 -0700575#endif
Simon Glassd82ba4c2015-07-02 18:15:38 -0600576
Michal Suchanekf2195472022-10-12 21:58:09 +0200577/*
578 * Starting from the given device @dev, return pointer to the first device in
579 * the uclass that probes successfully in @devp.
580 */
581static void _uclass_next_device(struct udevice *dev, struct udevice **devp)
582{
583 for (; dev; uclass_find_next_device(&dev)) {
584 if (!device_probe(dev))
585 break;
586 }
587 *devp = dev;
588}
589
590void uclass_first_device(enum uclass_id id, struct udevice **devp)
Simon Glass6494d702014-02-26 15:59:18 -0700591{
Heiko Schocher54c5d082014-05-22 12:43:05 +0200592 struct udevice *dev;
Simon Glass6494d702014-02-26 15:59:18 -0700593 int ret;
594
Przemyslaw Marczakc1d6f912015-04-15 13:07:17 +0200595 ret = uclass_find_first_device(id, &dev);
Michal Suchanekf2195472022-10-12 21:58:09 +0200596 _uclass_next_device(dev, devp);
Simon Glass6494d702014-02-26 15:59:18 -0700597}
598
Michal Suchanekf2195472022-10-12 21:58:09 +0200599void uclass_next_device(struct udevice **devp)
Simon Glass6494d702014-02-26 15:59:18 -0700600{
Heiko Schocher54c5d082014-05-22 12:43:05 +0200601 struct udevice *dev = *devp;
Simon Glass6494d702014-02-26 15:59:18 -0700602
Michal Suchanekf2195472022-10-12 21:58:09 +0200603 uclass_find_next_device(&dev);
604 _uclass_next_device(dev, devp);
Simon Glass6494d702014-02-26 15:59:18 -0700605}
606
Michal Suchaneke44d7e72022-10-12 21:58:06 +0200607int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
608{
609 int ret;
610
611 ret = uclass_first_device_check(id, devp);
612 if (ret)
613 return ret;
614 else if (!*devp)
615 return -ENODEV;
616
617 return 0;
618}
619
Patrice Chotardf6abd532018-10-24 14:10:15 +0200620int uclass_next_device_err(struct udevice **devp)
621{
622 int ret;
623
Michal Suchaneke44d7e72022-10-12 21:58:06 +0200624 ret = uclass_next_device_check(devp);
Patrice Chotardf6abd532018-10-24 14:10:15 +0200625 if (ret)
626 return ret;
627 else if (!*devp)
628 return -ENODEV;
629
630 return 0;
631}
632
Simon Glass95ce3852017-04-23 20:10:45 -0600633int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
634{
635 int ret;
636
637 *devp = NULL;
638 ret = uclass_find_first_device(id, devp);
639 if (ret)
640 return ret;
641 if (!*devp)
642 return 0;
643
644 return device_probe(*devp);
645}
646
647int uclass_next_device_check(struct udevice **devp)
648{
649 int ret;
650
651 ret = uclass_find_next_device(devp);
652 if (ret)
653 return ret;
654 if (!*devp)
655 return 0;
656
657 return device_probe(*devp);
658}
659
Simon Glass6476c4d2021-12-16 20:59:32 -0700660int uclass_get_count(void)
661{
662 const struct uclass *uc;
663 int count = 0;
664
665 if (gd->dm_root) {
666 list_for_each_entry(uc, gd->uclass_root, sibling_node)
667 count++;
668 }
669
670 return count;
671}
672
Simon Glass50162342020-02-06 09:54:50 -0700673int uclass_first_device_drvdata(enum uclass_id id, ulong driver_data,
674 struct udevice **devp)
675{
676 struct udevice *dev;
677 struct uclass *uc;
678
679 uclass_id_foreach_dev(id, dev, uc) {
680 if (dev_get_driver_data(dev) == driver_data) {
681 *devp = dev;
682
683 return device_probe(dev);
684 }
685 }
686
687 return -ENODEV;
688}
689
Heiko Schocher54c5d082014-05-22 12:43:05 +0200690int uclass_bind_device(struct udevice *dev)
Simon Glass6494d702014-02-26 15:59:18 -0700691{
692 struct uclass *uc;
693 int ret;
694
695 uc = dev->uclass;
Simon Glass6494d702014-02-26 15:59:18 -0700696 list_add_tail(&dev->uclass_node, &uc->dev_head);
697
Simon Glass081f2fc2015-01-25 08:27:08 -0700698 if (dev->parent) {
699 struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
700
701 if (uc_drv->child_post_bind) {
702 ret = uc_drv->child_post_bind(dev);
703 if (ret)
704 goto err;
705 }
706 }
Simon Glass6494d702014-02-26 15:59:18 -0700707
708 return 0;
Simon Glass081f2fc2015-01-25 08:27:08 -0700709err:
710 /* There is no need to undo the parent's post_bind call */
711 list_del(&dev->uclass_node);
712
713 return ret;
Simon Glass6494d702014-02-26 15:59:18 -0700714}
715
Masahiro Yamada0a5804b2015-08-12 07:31:52 +0900716#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
Simon Glass80443182021-10-23 17:26:05 -0600717int uclass_pre_unbind_device(struct udevice *dev)
Simon Glass6494d702014-02-26 15:59:18 -0700718{
719 struct uclass *uc;
720 int ret;
721
722 uc = dev->uclass;
723 if (uc->uc_drv->pre_unbind) {
724 ret = uc->uc_drv->pre_unbind(dev);
725 if (ret)
726 return ret;
727 }
728
Simon Glass80443182021-10-23 17:26:05 -0600729 return 0;
730}
731
732int uclass_unbind_device(struct udevice *dev)
733{
Simon Glass6494d702014-02-26 15:59:18 -0700734 list_del(&dev->uclass_node);
Simon Glass80443182021-10-23 17:26:05 -0600735
Simon Glass6494d702014-02-26 15:59:18 -0700736 return 0;
737}
Simon Glass7f9875e2015-02-27 22:06:31 -0700738#endif
Simon Glass6494d702014-02-26 15:59:18 -0700739
Simon Glass02c07b32015-03-05 12:25:22 -0700740int uclass_pre_probe_device(struct udevice *dev)
Simon Glass83c7e432015-01-25 08:27:10 -0700741{
742 struct uclass_driver *uc_drv;
Simon Glass02c07b32015-03-05 12:25:22 -0700743 int ret;
744
745 uc_drv = dev->uclass->uc_drv;
746 if (uc_drv->pre_probe) {
747 ret = uc_drv->pre_probe(dev);
748 if (ret)
749 return ret;
750 }
Simon Glass83c7e432015-01-25 08:27:10 -0700751
752 if (!dev->parent)
753 return 0;
754 uc_drv = dev->parent->uclass->uc_drv;
Simon Glassc8b31cc2019-09-25 08:55:47 -0600755 if (uc_drv->child_pre_probe) {
756 ret = uc_drv->child_pre_probe(dev);
757 if (ret)
758 return ret;
759 }
Simon Glass83c7e432015-01-25 08:27:10 -0700760
761 return 0;
762}
763
Heiko Schocher54c5d082014-05-22 12:43:05 +0200764int uclass_post_probe_device(struct udevice *dev)
Simon Glass6494d702014-02-26 15:59:18 -0700765{
Bin Meng651d0c02018-10-15 02:20:57 -0700766 struct uclass_driver *uc_drv;
767 int ret;
Simon Glass6494d702014-02-26 15:59:18 -0700768
Bin Meng651d0c02018-10-15 02:20:57 -0700769 if (dev->parent) {
770 uc_drv = dev->parent->uclass->uc_drv;
771 if (uc_drv->child_post_probe) {
772 ret = uc_drv->child_post_probe(dev);
773 if (ret)
774 return ret;
775 }
776 }
777
778 uc_drv = dev->uclass->uc_drv;
Simon Glassc8b31cc2019-09-25 08:55:47 -0600779 if (uc_drv->post_probe) {
780 ret = uc_drv->post_probe(dev);
781 if (ret)
782 return ret;
783 }
Simon Glass6494d702014-02-26 15:59:18 -0700784
785 return 0;
786}
787
Masahiro Yamada0a5804b2015-08-12 07:31:52 +0900788#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
Heiko Schocher54c5d082014-05-22 12:43:05 +0200789int uclass_pre_remove_device(struct udevice *dev)
Simon Glass6494d702014-02-26 15:59:18 -0700790{
Simon Glass6494d702014-02-26 15:59:18 -0700791 struct uclass *uc;
792 int ret;
793
794 uc = dev->uclass;
Simon Glass6494d702014-02-26 15:59:18 -0700795 if (uc->uc_drv->pre_remove) {
796 ret = uc->uc_drv->pre_remove(dev);
797 if (ret)
798 return ret;
799 }
Simon Glass6494d702014-02-26 15:59:18 -0700800
801 return 0;
802}
Simon Glass7f9875e2015-02-27 22:06:31 -0700803#endif
Jean-Jacques Hiblot07e33712019-07-05 09:33:57 +0200804
Vabhav Sharmaa59153d2020-12-09 10:42:03 +0530805int uclass_probe_all(enum uclass_id id)
806{
807 struct udevice *dev;
Michal Suchanekdfecd632022-10-12 21:57:50 +0200808 int ret, err;
Vabhav Sharmaa59153d2020-12-09 10:42:03 +0530809
Michal Suchanekdfecd632022-10-12 21:57:50 +0200810 err = uclass_first_device_check(id, &dev);
Vabhav Sharmaa59153d2020-12-09 10:42:03 +0530811
812 /* Scanning uclass to probe all devices */
813 while (dev) {
Michal Suchanekdfecd632022-10-12 21:57:50 +0200814 ret = uclass_next_device_check(&dev);
Vabhav Sharmaa59153d2020-12-09 10:42:03 +0530815 if (ret)
Michal Suchanekdfecd632022-10-12 21:57:50 +0200816 err = ret;
Vabhav Sharmaa59153d2020-12-09 10:42:03 +0530817 }
818
Michal Suchanekdfecd632022-10-12 21:57:50 +0200819 return err;
Vabhav Sharmaa59153d2020-12-09 10:42:03 +0530820}
821
Simon Glass29fe5552021-10-23 17:26:09 -0600822int uclass_id_count(enum uclass_id id)
823{
824 struct udevice *dev;
825 struct uclass *uc;
826 int count = 0;
827
828 uclass_id_foreach_dev(id, dev, uc)
829 count++;
830
831 return count;
832}
833
Jean-Jacques Hiblot07e33712019-07-05 09:33:57 +0200834UCLASS_DRIVER(nop) = {
835 .id = UCLASS_NOP,
836 .name = "nop",
837};