1
2
3
4
5
6
7
8
9
10#include <common.h>
11#include <errno.h>
12#include <malloc.h>
13#include <dm/device.h>
14#include <dm/device-internal.h>
15#include <dm/lists.h>
16#include <dm/uclass.h>
17#include <dm/uclass-internal.h>
18#include <dm/util.h>
19
20DECLARE_GLOBAL_DATA_PTR;
21
22struct uclass *uclass_find(enum uclass_id key)
23{
24 struct uclass *uc;
25
26 if (!gd->dm_root)
27 return NULL;
28
29
30
31
32
33 list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
34 if (uc->uc_drv->id == key)
35 return uc;
36 }
37
38 return NULL;
39}
40
41
42
43
44
45
46
47
48
49
50static int uclass_add(enum uclass_id id, struct uclass **ucp)
51{
52 struct uclass_driver *uc_drv;
53 struct uclass *uc;
54 int ret;
55
56 *ucp = NULL;
57 uc_drv = lists_uclass_lookup(id);
58 if (!uc_drv) {
59 debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
60 id);
61
62
63
64
65
66 return -EPFNOSUPPORT;
67 }
68 uc = calloc(1, sizeof(*uc));
69 if (!uc)
70 return -ENOMEM;
71 if (uc_drv->priv_auto_alloc_size) {
72 uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
73 if (!uc->priv) {
74 ret = -ENOMEM;
75 goto fail_mem;
76 }
77 }
78 uc->uc_drv = uc_drv;
79 INIT_LIST_HEAD(&uc->sibling_node);
80 INIT_LIST_HEAD(&uc->dev_head);
81 list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
82
83 if (uc_drv->init) {
84 ret = uc_drv->init(uc);
85 if (ret)
86 goto fail;
87 }
88
89 *ucp = uc;
90
91 return 0;
92fail:
93 if (uc_drv->priv_auto_alloc_size) {
94 free(uc->priv);
95 uc->priv = NULL;
96 }
97 list_del(&uc->sibling_node);
98fail_mem:
99 free(uc);
100
101 return ret;
102}
103
104int uclass_destroy(struct uclass *uc)
105{
106 struct uclass_driver *uc_drv;
107 struct udevice *dev;
108 int ret;
109
110
111
112
113
114
115
116 while (!list_empty(&uc->dev_head)) {
117 dev = list_first_entry(&uc->dev_head, struct udevice,
118 uclass_node);
119 ret = device_remove(dev);
120 if (ret)
121 return ret;
122 ret = device_unbind(dev);
123 if (ret)
124 return ret;
125 }
126
127 uc_drv = uc->uc_drv;
128 if (uc_drv->destroy)
129 uc_drv->destroy(uc);
130 list_del(&uc->sibling_node);
131 if (uc_drv->priv_auto_alloc_size)
132 free(uc->priv);
133 free(uc);
134
135 return 0;
136}
137
138int uclass_get(enum uclass_id id, struct uclass **ucp)
139{
140 struct uclass *uc;
141
142 *ucp = NULL;
143 uc = uclass_find(id);
144 if (!uc)
145 return uclass_add(id, ucp);
146 *ucp = uc;
147
148 return 0;
149}
150
151int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
152{
153 struct uclass *uc;
154 struct udevice *dev;
155 int ret;
156
157 *devp = NULL;
158 ret = uclass_get(id, &uc);
159 if (ret)
160 return ret;
161 if (list_empty(&uc->dev_head))
162 return -ENODEV;
163
164 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
165 if (!index--) {
166 *devp = dev;
167 return 0;
168 }
169 }
170
171 return -ENODEV;
172}
173
174int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
175{
176 struct uclass *uc;
177 int ret;
178
179 *devp = NULL;
180 ret = uclass_get(id, &uc);
181 if (ret)
182 return ret;
183 if (list_empty(&uc->dev_head))
184 return 0;
185
186 *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
187
188 return 0;
189}
190
191int uclass_find_next_device(struct udevice **devp)
192{
193 struct udevice *dev = *devp;
194
195 *devp = NULL;
196 if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
197 return 0;
198
199 *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
200
201 return 0;
202}
203
204int uclass_find_device_by_name(enum uclass_id id, const char *name,
205 struct udevice **devp)
206{
207 struct uclass *uc;
208 struct udevice *dev;
209 int ret;
210
211 *devp = NULL;
212 if (!name)
213 return -EINVAL;
214 ret = uclass_get(id, &uc);
215 if (ret)
216 return ret;
217
218 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
219 if (!strncmp(dev->name, name, strlen(name))) {
220 *devp = dev;
221 return 0;
222 }
223 }
224
225 return -ENODEV;
226}
227
228int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
229 bool find_req_seq, struct udevice **devp)
230{
231 struct uclass *uc;
232 struct udevice *dev;
233 int ret;
234
235 *devp = NULL;
236 debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
237 if (seq_or_req_seq == -1)
238 return -ENODEV;
239 ret = uclass_get(id, &uc);
240 if (ret)
241 return ret;
242
243 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
244 debug(" - %d %d\n", dev->req_seq, dev->seq);
245 if ((find_req_seq ? dev->req_seq : dev->seq) ==
246 seq_or_req_seq) {
247 *devp = dev;
248 debug(" - found\n");
249 return 0;
250 }
251 }
252 debug(" - not found\n");
253
254 return -ENODEV;
255}
256
257int uclass_find_device_by_of_offset(enum uclass_id id, int node,
258 struct udevice **devp)
259{
260 struct uclass *uc;
261 struct udevice *dev;
262 int ret;
263
264 *devp = NULL;
265 if (node < 0)
266 return -ENODEV;
267 ret = uclass_get(id, &uc);
268 if (ret)
269 return ret;
270
271 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
272 if (dev->of_offset == node) {
273 *devp = dev;
274 return 0;
275 }
276 }
277
278 return -ENODEV;
279}
280
281#if CONFIG_IS_ENABLED(OF_CONTROL)
282static int uclass_find_device_by_phandle(enum uclass_id id,
283 struct udevice *parent,
284 const char *name,
285 struct udevice **devp)
286{
287 struct udevice *dev;
288 struct uclass *uc;
289 int find_phandle;
290 int ret;
291
292 *devp = NULL;
293 find_phandle = fdtdec_get_int(gd->fdt_blob, parent->of_offset, name,
294 -1);
295 if (find_phandle <= 0)
296 return -ENOENT;
297 ret = uclass_get(id, &uc);
298 if (ret)
299 return ret;
300
301 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
302 uint phandle = fdt_get_phandle(gd->fdt_blob, dev->of_offset);
303
304 if (phandle == find_phandle) {
305 *devp = dev;
306 return 0;
307 }
308 }
309
310 return -ENODEV;
311}
312#endif
313
314int uclass_get_device_tail(struct udevice *dev, int ret,
315 struct udevice **devp)
316{
317 if (ret)
318 return ret;
319
320 assert(dev);
321 ret = device_probe(dev);
322 if (ret)
323 return ret;
324
325 *devp = dev;
326
327 return 0;
328}
329
330int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
331{
332 struct udevice *dev;
333 int ret;
334
335 *devp = NULL;
336 ret = uclass_find_device(id, index, &dev);
337 return uclass_get_device_tail(dev, ret, devp);
338}
339
340int uclass_get_device_by_name(enum uclass_id id, const char *name,
341 struct udevice **devp)
342{
343 struct udevice *dev;
344 int ret;
345
346 *devp = NULL;
347 ret = uclass_find_device_by_name(id, name, &dev);
348 return uclass_get_device_tail(dev, ret, devp);
349}
350
351int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
352{
353 struct udevice *dev;
354 int ret;
355
356 *devp = NULL;
357 ret = uclass_find_device_by_seq(id, seq, false, &dev);
358 if (ret == -ENODEV) {
359
360
361
362
363 ret = uclass_find_device_by_seq(id, seq, true, &dev);
364 }
365 return uclass_get_device_tail(dev, ret, devp);
366}
367
368int uclass_get_device_by_of_offset(enum uclass_id id, int node,
369 struct udevice **devp)
370{
371 struct udevice *dev;
372 int ret;
373
374 *devp = NULL;
375 ret = uclass_find_device_by_of_offset(id, node, &dev);
376 return uclass_get_device_tail(dev, ret, devp);
377}
378
379#if CONFIG_IS_ENABLED(OF_CONTROL)
380int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
381 const char *name, struct udevice **devp)
382{
383 struct udevice *dev;
384 int ret;
385
386 *devp = NULL;
387 ret = uclass_find_device_by_phandle(id, parent, name, &dev);
388 return uclass_get_device_tail(dev, ret, devp);
389}
390#endif
391
392int uclass_first_device(enum uclass_id id, struct udevice **devp)
393{
394 struct udevice *dev;
395 int ret;
396
397 *devp = NULL;
398 ret = uclass_find_first_device(id, &dev);
399 if (!dev)
400 return 0;
401 return uclass_get_device_tail(dev, ret, devp);
402}
403
404int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
405{
406 int ret;
407
408 ret = uclass_first_device(id, devp);
409 if (ret)
410 return ret;
411 else if (!*devp)
412 return -ENODEV;
413
414 return 0;
415}
416
417int uclass_next_device(struct udevice **devp)
418{
419 struct udevice *dev = *devp;
420 int ret;
421
422 *devp = NULL;
423 ret = uclass_find_next_device(&dev);
424 if (!dev)
425 return 0;
426 return uclass_get_device_tail(dev, ret, devp);
427}
428
429int uclass_bind_device(struct udevice *dev)
430{
431 struct uclass *uc;
432 int ret;
433
434 uc = dev->uclass;
435 list_add_tail(&dev->uclass_node, &uc->dev_head);
436
437 if (dev->parent) {
438 struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
439
440 if (uc_drv->child_post_bind) {
441 ret = uc_drv->child_post_bind(dev);
442 if (ret)
443 goto err;
444 }
445 }
446
447 return 0;
448err:
449
450 list_del(&dev->uclass_node);
451
452 return ret;
453}
454
455#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
456int uclass_unbind_device(struct udevice *dev)
457{
458 struct uclass *uc;
459 int ret;
460
461 uc = dev->uclass;
462 if (uc->uc_drv->pre_unbind) {
463 ret = uc->uc_drv->pre_unbind(dev);
464 if (ret)
465 return ret;
466 }
467
468 list_del(&dev->uclass_node);
469 return 0;
470}
471#endif
472
473int uclass_resolve_seq(struct udevice *dev)
474{
475 struct udevice *dup;
476 int seq;
477 int ret;
478
479 assert(dev->seq == -1);
480 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
481 false, &dup);
482 if (!ret) {
483 dm_warn("Device '%s': seq %d is in use by '%s'\n",
484 dev->name, dev->req_seq, dup->name);
485 } else if (ret == -ENODEV) {
486
487 if (dev->req_seq != -1)
488 return dev->req_seq;
489 } else {
490 return ret;
491 }
492
493 for (seq = 0; seq < DM_MAX_SEQ; seq++) {
494 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
495 false, &dup);
496 if (ret == -ENODEV)
497 break;
498 if (ret)
499 return ret;
500 }
501 return seq;
502}
503
504int uclass_pre_probe_device(struct udevice *dev)
505{
506 struct uclass_driver *uc_drv;
507 int ret;
508
509 uc_drv = dev->uclass->uc_drv;
510 if (uc_drv->pre_probe) {
511 ret = uc_drv->pre_probe(dev);
512 if (ret)
513 return ret;
514 }
515
516 if (!dev->parent)
517 return 0;
518 uc_drv = dev->parent->uclass->uc_drv;
519 if (uc_drv->child_pre_probe)
520 return uc_drv->child_pre_probe(dev);
521
522 return 0;
523}
524
525int uclass_post_probe_device(struct udevice *dev)
526{
527 struct uclass_driver *uc_drv = dev->uclass->uc_drv;
528
529 if (uc_drv->post_probe)
530 return uc_drv->post_probe(dev);
531
532 return 0;
533}
534
535#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
536int uclass_pre_remove_device(struct udevice *dev)
537{
538 struct uclass *uc;
539 int ret;
540
541 uc = dev->uclass;
542 if (uc->uc_drv->pre_remove) {
543 ret = uc->uc_drv->pre_remove(dev);
544 if (ret)
545 return ret;
546 }
547
548 return 0;
549}
550#endif
551