1 /*
2 * Copyright (c) 2013 Google, Inc
3 *
4 * (C) Copyright 2012
5 * Pavel Herrmann <morpheus.ibis@gmail.com>
6 *
7 * SPDX-License-Identifier: GPL-2.0+
8 */
9
10 #include <common.h>
11 #include <dm.h>
12 #include <errno.h>
13 #include <malloc.h>
14 #include <dm/device.h>
15 #include <dm/device-internal.h>
16 #include <dm/lists.h>
17 #include <dm/uclass.h>
18 #include <dm/uclass-internal.h>
19 #include <dm/util.h>
20
21 DECLARE_GLOBAL_DATA_PTR;
22
uclass_find(enum uclass_id key)23 struct uclass *uclass_find(enum uclass_id key)
24 {
25 struct uclass *uc;
26
27 if (!gd->dm_root)
28 return NULL;
29 /*
30 * TODO(sjg@chromium.org): Optimise this, perhaps moving the found
31 * node to the start of the list, or creating a linear array mapping
32 * id to node.
33 */
34 list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
35 if (uc->uc_drv->id == key)
36 return uc;
37
38 if (uc->uc_drv->id == UCLASS_ROOT)
39 break;
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
49 * @return 0 on success, -ve on error
50 *
51 * The new uclass is added to the list. There must be only one uclass for
52 * each id.
53 */
uclass_add(enum uclass_id id,struct uclass ** ucp)54 static 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) {
63 debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
64 id);
65 /*
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;
71 }
72 uc = calloc(1, sizeof(*uc));
73 if (!uc)
74 return -ENOMEM;
75 if (uc_drv->priv_auto_alloc_size) {
76 uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
77 if (!uc->priv) {
78 ret = -ENOMEM;
79 goto fail_mem;
80 }
81 }
82 uc->uc_drv = uc_drv;
83 #ifdef CONFIG_USING_KERNEL_DTB_V2
84 uc->u_boot_dev_head = NULL;
85 #endif
86 INIT_LIST_HEAD(&uc->sibling_node);
87 INIT_LIST_HEAD(&uc->dev_head);
88 list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
89
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;
99 fail:
100 if (uc_drv->priv_auto_alloc_size) {
101 free(uc->priv);
102 uc->priv = NULL;
103 }
104 list_del(&uc->sibling_node);
105 fail_mem:
106 free(uc);
107
108 return ret;
109 }
110
uclass_destroy(struct uclass * uc)111 int uclass_destroy(struct uclass *uc)
112 {
113 struct uclass_driver *uc_drv;
114 struct udevice *dev;
115 int ret;
116
117 /*
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);
126 ret = device_remove(dev, DM_REMOVE_NORMAL);
127 if (ret)
128 return ret;
129 ret = device_unbind(dev);
130 if (ret)
131 return ret;
132 }
133
134 uc_drv = uc->uc_drv;
135 if (uc_drv->destroy)
136 uc_drv->destroy(uc);
137 list_del(&uc->sibling_node);
138 if (uc_drv->priv_auto_alloc_size)
139 free(uc->priv);
140 free(uc);
141
142 return 0;
143 }
144
uclass_get(enum uclass_id id,struct uclass ** ucp)145 int uclass_get(enum uclass_id id, struct uclass **ucp)
146 {
147 struct uclass *uc;
148
149 *ucp = NULL;
150 uc = uclass_find(id);
151 if (!uc)
152 return uclass_add(id, ucp);
153 *ucp = uc;
154
155 return 0;
156 }
157
uclass_get_name(enum uclass_id id)158 const char *uclass_get_name(enum uclass_id id)
159 {
160 struct uclass *uc;
161
162 if (uclass_get(id, &uc))
163 return NULL;
164 return uc->uc_drv->name;
165 }
166
uclass_get_by_name(const char * name)167 enum uclass_id uclass_get_by_name(const char *name)
168 {
169 int i;
170
171 for (i = 0; i < UCLASS_COUNT; i++) {
172 struct uclass_driver *uc_drv = lists_uclass_lookup(i);
173
174 if (uc_drv && !strcmp(uc_drv->name, name))
175 return i;
176 }
177
178 return UCLASS_INVALID;
179 }
180
uclass_find_device(enum uclass_id id,int index,struct udevice ** devp)181 int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
182 {
183 struct uclass *uc;
184 struct udevice *dev;
185 int ret;
186
187 *devp = NULL;
188 ret = uclass_get(id, &uc);
189 if (ret)
190 return ret;
191 if (list_empty(&uc->dev_head))
192 return -ENODEV;
193
194 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
195 if (!index--) {
196 *devp = dev;
197 return 0;
198 }
199 }
200
201 return -ENODEV;
202 }
203
uclass_find_first_device(enum uclass_id id,struct udevice ** devp)204 int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
205 {
206 struct uclass *uc;
207 int ret;
208
209 *devp = NULL;
210 ret = uclass_get(id, &uc);
211 if (ret)
212 return ret;
213 if (list_empty(&uc->dev_head))
214 return 0;
215
216 *devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
217
218 return 0;
219 }
220
uclass_find_next_device(struct udevice ** devp)221 int uclass_find_next_device(struct udevice **devp)
222 {
223 struct udevice *dev = *devp;
224
225 *devp = NULL;
226 if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
227 return 0;
228
229 *devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
230
231 return 0;
232 }
233
uclass_find_device_by_name(enum uclass_id id,const char * name,struct udevice ** devp)234 int uclass_find_device_by_name(enum uclass_id id, const char *name,
235 struct udevice **devp)
236 {
237 struct uclass *uc;
238 struct udevice *dev;
239 int ret;
240
241 *devp = NULL;
242 if (!name)
243 return -EINVAL;
244 ret = uclass_get(id, &uc);
245 if (ret)
246 return ret;
247
248 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
249 if (!strncmp(dev->name, name, strlen(name))) {
250 *devp = dev;
251 return 0;
252 }
253 }
254
255 return -ENODEV;
256 }
257
uclass_find_device_by_seq(enum uclass_id id,int seq_or_req_seq,bool find_req_seq,struct udevice ** devp)258 int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
259 bool find_req_seq, struct udevice **devp)
260 {
261 struct uclass *uc;
262 struct udevice *dev;
263 int ret;
264
265 *devp = NULL;
266 pr_debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
267 if (seq_or_req_seq == -1)
268 return -ENODEV;
269 ret = uclass_get(id, &uc);
270 if (ret)
271 return ret;
272
273 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
274 pr_debug(" - %d %d '%s'\n", dev->req_seq, dev->seq, dev->name);
275 if ((find_req_seq ? dev->req_seq : dev->seq) ==
276 seq_or_req_seq) {
277 *devp = dev;
278 pr_debug(" - found\n");
279 return 0;
280 }
281 }
282 pr_debug(" - not found\n");
283
284 return -ENODEV;
285 }
286
uclass_find_device_by_of_offset(enum uclass_id id,int node,struct udevice ** devp)287 int uclass_find_device_by_of_offset(enum uclass_id id, int node,
288 struct udevice **devp)
289 {
290 struct uclass *uc;
291 struct udevice *dev;
292 int ret;
293
294 *devp = NULL;
295 if (node < 0)
296 return -ENODEV;
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 if (dev_of_offset(dev) == node) {
303 *devp = dev;
304 return 0;
305 }
306 }
307
308 return -ENODEV;
309 }
310
uclass_find_device_by_ofnode(enum uclass_id id,ofnode node,struct udevice ** devp)311 int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
312 struct udevice **devp)
313 {
314 struct uclass *uc;
315 struct udevice *dev;
316 int ret;
317
318 *devp = NULL;
319 if (!ofnode_valid(node))
320 return -ENODEV;
321 ret = uclass_get(id, &uc);
322 if (ret)
323 return ret;
324
325 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
326 if (ofnode_equal(dev_ofnode(dev), node)) {
327 *devp = dev;
328 return 0;
329 }
330 }
331
332 return -ENODEV;
333 }
334
335 #if CONFIG_IS_ENABLED(OF_CONTROL)
uclass_find_device_by_phandle(enum uclass_id id,struct udevice * parent,const char * name,struct udevice ** devp)336 static int uclass_find_device_by_phandle(enum uclass_id id,
337 struct udevice *parent,
338 const char *name,
339 struct udevice **devp)
340 {
341 struct udevice *dev;
342 struct uclass *uc;
343 int find_phandle;
344 int ret;
345
346 *devp = NULL;
347 find_phandle = dev_read_u32_default(parent, name, -1);
348 if (find_phandle <= 0)
349 return -ENOENT;
350 ret = uclass_get(id, &uc);
351 if (ret)
352 return ret;
353
354 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
355 uint phandle;
356
357 phandle = dev_read_phandle(dev);
358
359 if (phandle == find_phandle) {
360 *devp = dev;
361 return 0;
362 }
363 }
364
365 return -ENODEV;
366 }
367 #endif
368
uclass_get_device_by_driver(enum uclass_id id,const struct driver * find_drv,struct udevice ** devp)369 int uclass_get_device_by_driver(enum uclass_id id,
370 const struct driver *find_drv,
371 struct udevice **devp)
372 {
373 struct udevice *dev;
374 struct uclass *uc;
375 int ret;
376
377 ret = uclass_get(id, &uc);
378 if (ret)
379 return ret;
380
381 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
382 if (dev->driver == find_drv)
383 return uclass_get_device_tail(dev, 0, devp);
384 }
385
386 return -ENODEV;
387 }
388
uclass_get_device_tail(struct udevice * dev,int ret,struct udevice ** devp)389 int uclass_get_device_tail(struct udevice *dev, int ret, struct udevice **devp)
390 {
391 if (ret)
392 return ret;
393
394 assert(dev);
395 ret = device_probe(dev);
396 if (ret)
397 return ret;
398
399 *devp = dev;
400
401 return 0;
402 }
403
uclass_get_device(enum uclass_id id,int index,struct udevice ** devp)404 int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
405 {
406 struct udevice *dev;
407 int ret;
408
409 *devp = NULL;
410 ret = uclass_find_device(id, index, &dev);
411 return uclass_get_device_tail(dev, ret, devp);
412 }
413
uclass_get_device_by_name(enum uclass_id id,const char * name,struct udevice ** devp)414 int uclass_get_device_by_name(enum uclass_id id, const char *name,
415 struct udevice **devp)
416 {
417 struct udevice *dev;
418 int ret;
419
420 *devp = NULL;
421 ret = uclass_find_device_by_name(id, name, &dev);
422 return uclass_get_device_tail(dev, ret, devp);
423 }
424
uclass_get_device_by_seq(enum uclass_id id,int seq,struct udevice ** devp)425 int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
426 {
427 struct udevice *dev;
428 int ret;
429
430 *devp = NULL;
431 ret = uclass_find_device_by_seq(id, seq, false, &dev);
432 if (ret == -ENODEV) {
433 /*
434 * We didn't find it in probed devices. See if there is one
435 * that will request this seq if probed.
436 */
437 ret = uclass_find_device_by_seq(id, seq, true, &dev);
438 }
439 return uclass_get_device_tail(dev, ret, devp);
440 }
441
uclass_get_device_by_of_offset(enum uclass_id id,int node,struct udevice ** devp)442 int uclass_get_device_by_of_offset(enum uclass_id id, int node,
443 struct udevice **devp)
444 {
445 struct udevice *dev;
446 int ret;
447
448 *devp = NULL;
449 ret = uclass_find_device_by_of_offset(id, node, &dev);
450 return uclass_get_device_tail(dev, ret, devp);
451 }
452
uclass_get_device_by_ofnode(enum uclass_id id,ofnode node,struct udevice ** devp)453 int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
454 struct udevice **devp)
455 {
456 struct udevice *dev;
457 int ret;
458
459 *devp = NULL;
460 ret = uclass_find_device_by_ofnode(id, node, &dev);
461
462 return uclass_get_device_tail(dev, ret, devp);
463 }
464
465 #if CONFIG_IS_ENABLED(OF_CONTROL)
uclass_get_device_by_phandle_id(enum uclass_id id,uint phandle_id,struct udevice ** devp)466 int uclass_get_device_by_phandle_id(enum uclass_id id, uint phandle_id,
467 struct udevice **devp)
468 {
469 struct udevice *dev;
470 struct uclass *uc;
471 int ret;
472
473 *devp = NULL;
474 ret = uclass_get(id, &uc);
475 if (ret)
476 return ret;
477
478 ret = -ENODEV;
479 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
480 uint phandle;
481
482 phandle = dev_read_phandle(dev);
483
484 if (phandle == phandle_id) {
485 *devp = dev;
486 ret = 0;
487 break;
488 }
489 }
490
491 return uclass_get_device_tail(dev, ret, devp);
492 }
493
uclass_get_device_by_phandle(enum uclass_id id,struct udevice * parent,const char * name,struct udevice ** devp)494 int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
495 const char *name, struct udevice **devp)
496 {
497 struct udevice *dev;
498 int ret;
499
500 *devp = NULL;
501 ret = uclass_find_device_by_phandle(id, parent, name, &dev);
502 return uclass_get_device_tail(dev, ret, devp);
503 }
504 #endif
505
uclass_first_device(enum uclass_id id,struct udevice ** devp)506 int uclass_first_device(enum uclass_id id, struct udevice **devp)
507 {
508 struct udevice *dev;
509 int ret;
510
511 *devp = NULL;
512 ret = uclass_find_first_device(id, &dev);
513 if (!dev)
514 return 0;
515 return uclass_get_device_tail(dev, ret, devp);
516 }
517
uclass_first_device_err(enum uclass_id id,struct udevice ** devp)518 int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
519 {
520 int ret;
521
522 ret = uclass_first_device(id, devp);
523 if (ret)
524 return ret;
525 else if (!*devp)
526 return -ENODEV;
527
528 return 0;
529 }
530
uclass_next_device(struct udevice ** devp)531 int uclass_next_device(struct udevice **devp)
532 {
533 struct udevice *dev = *devp;
534 int ret;
535
536 *devp = NULL;
537 ret = uclass_find_next_device(&dev);
538 if (!dev)
539 return 0;
540 return uclass_get_device_tail(dev, ret, devp);
541 }
542
uclass_first_device_check(enum uclass_id id,struct udevice ** devp)543 int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
544 {
545 int ret;
546
547 *devp = NULL;
548 ret = uclass_find_first_device(id, devp);
549 if (ret)
550 return ret;
551 if (!*devp)
552 return 0;
553
554 return device_probe(*devp);
555 }
556
uclass_next_device_check(struct udevice ** devp)557 int uclass_next_device_check(struct udevice **devp)
558 {
559 int ret;
560
561 ret = uclass_find_next_device(devp);
562 if (ret)
563 return ret;
564 if (!*devp)
565 return 0;
566
567 return device_probe(*devp);
568 }
569
uclass_bind_device(struct udevice * dev,bool after_u_boot_dev)570 int uclass_bind_device(struct udevice *dev, bool after_u_boot_dev)
571 {
572 struct uclass *uc;
573 int ret;
574
575 uc = dev->uclass;
576 #ifdef CONFIG_USING_KERNEL_DTB_V2
577 if (after_u_boot_dev)
578 list_add_tail(&dev->uclass_node, &uc->dev_head);
579 else
580 list_add_tail(&dev->uclass_node, uc->u_boot_dev_head);
581 #else
582 list_add_tail(&dev->uclass_node, &uc->dev_head);
583 #endif
584 if (dev->parent) {
585 struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
586
587 if (uc_drv->child_post_bind) {
588 ret = uc_drv->child_post_bind(dev);
589 if (ret)
590 goto err;
591 }
592 }
593
594 return 0;
595 err:
596 /* There is no need to undo the parent's post_bind call */
597 list_del(&dev->uclass_node);
598
599 return ret;
600 }
601
602 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
uclass_unbind_device(struct udevice * dev)603 int uclass_unbind_device(struct udevice *dev)
604 {
605 struct uclass *uc;
606 int ret;
607
608 uc = dev->uclass;
609 if (uc->uc_drv->pre_unbind) {
610 ret = uc->uc_drv->pre_unbind(dev);
611 if (ret)
612 return ret;
613 }
614
615 list_del(&dev->uclass_node);
616 return 0;
617 }
618 #endif
619
uclass_resolve_seq(struct udevice * dev)620 int uclass_resolve_seq(struct udevice *dev)
621 {
622 struct udevice *dup;
623 int seq;
624 int ret;
625
626 assert(dev->seq == -1);
627 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
628 false, &dup);
629 if (!ret) {
630 dm_warn("Device '%s': seq %d is in use by '%s'\n",
631 dev->name, dev->req_seq, dup->name);
632 } else if (ret == -ENODEV) {
633 /* Our requested sequence number is available */
634 if (dev->req_seq != -1)
635 return dev->req_seq;
636 } else {
637 return ret;
638 }
639
640 for (seq = 0; seq < DM_MAX_SEQ; seq++) {
641 ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
642 false, &dup);
643 if (ret == -ENODEV)
644 break;
645 if (ret)
646 return ret;
647 }
648 return seq;
649 }
650
uclass_pre_probe_device(struct udevice * dev)651 int uclass_pre_probe_device(struct udevice *dev)
652 {
653 struct uclass_driver *uc_drv;
654 int ret;
655
656 uc_drv = dev->uclass->uc_drv;
657 if (uc_drv->pre_probe) {
658 ret = uc_drv->pre_probe(dev);
659 if (ret)
660 return ret;
661 }
662
663 if (!dev->parent)
664 return 0;
665 uc_drv = dev->parent->uclass->uc_drv;
666 if (uc_drv->child_pre_probe)
667 return uc_drv->child_pre_probe(dev);
668
669 return 0;
670 }
671
uclass_post_probe_device(struct udevice * dev)672 int uclass_post_probe_device(struct udevice *dev)
673 {
674 struct uclass_driver *uc_drv = dev->uclass->uc_drv;
675
676 if (uc_drv->post_probe)
677 return uc_drv->post_probe(dev);
678
679 return 0;
680 }
681
682 #if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
uclass_pre_remove_device(struct udevice * dev)683 int uclass_pre_remove_device(struct udevice *dev)
684 {
685 struct uclass *uc;
686 int ret;
687
688 uc = dev->uclass;
689 if (uc->uc_drv->pre_remove) {
690 ret = uc->uc_drv->pre_remove(dev);
691 if (ret)
692 return ret;
693 }
694
695 return 0;
696 }
697 #endif
698
699 UCLASS_DRIVER(nop) = {
700 .id = UCLASS_NOP,
701 .name = "nop",
702 };
703