tools: dumpimage: Clarify help
[oweals/u-boot.git] / test / dm / bus.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2014 Google, Inc
4  */
5
6 #include <common.h>
7 #ifdef CONFIG_SANDBOX
8 #include <os.h>
9 #endif
10 #include <dm.h>
11 #include <dm/device-internal.h>
12 #include <dm/test.h>
13 #include <dm/uclass-internal.h>
14 #include <dm/util.h>
15 #include <test/ut.h>
16
17 DECLARE_GLOBAL_DATA_PTR;
18
19 struct dm_test_parent_platdata {
20         int count;
21         int bind_flag;
22         int uclass_bind_flag;
23 };
24
25 enum {
26         FLAG_CHILD_PROBED       = 10,
27         FLAG_CHILD_REMOVED      = -7,
28 };
29
30 static struct dm_test_state *test_state;
31
32 static int testbus_drv_probe(struct udevice *dev)
33 {
34         return dm_scan_fdt_dev(dev);
35 }
36
37 static int testbus_child_post_bind(struct udevice *dev)
38 {
39         struct dm_test_parent_platdata *plat;
40
41         plat = dev_get_parent_platdata(dev);
42         plat->bind_flag = 1;
43         plat->uclass_bind_flag = 2;
44
45         return 0;
46 }
47
48 static int testbus_child_pre_probe(struct udevice *dev)
49 {
50         struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
51
52         parent_data->flag += FLAG_CHILD_PROBED;
53
54         return 0;
55 }
56
57 static int testbus_child_pre_probe_uclass(struct udevice *dev)
58 {
59         struct dm_test_priv *priv = dev_get_priv(dev);
60
61         priv->uclass_flag++;
62
63         return 0;
64 }
65
66 static int testbus_child_post_probe_uclass(struct udevice *dev)
67 {
68         struct dm_test_priv *priv = dev_get_priv(dev);
69
70         priv->uclass_postp++;
71
72         return 0;
73 }
74
75 static int testbus_child_post_remove(struct udevice *dev)
76 {
77         struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
78         struct dm_test_state *dms = test_state;
79
80         parent_data->flag += FLAG_CHILD_REMOVED;
81         if (dms)
82                 dms->removed = dev;
83
84         return 0;
85 }
86
87 static const struct udevice_id testbus_ids[] = {
88         {
89                 .compatible = "denx,u-boot-test-bus",
90                 .data = DM_TEST_TYPE_FIRST },
91         { }
92 };
93
94 U_BOOT_DRIVER(testbus_drv) = {
95         .name   = "testbus_drv",
96         .of_match       = testbus_ids,
97         .id     = UCLASS_TEST_BUS,
98         .probe  = testbus_drv_probe,
99         .child_post_bind = testbus_child_post_bind,
100         .priv_auto_alloc_size = sizeof(struct dm_test_priv),
101         .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
102         .per_child_auto_alloc_size = sizeof(struct dm_test_parent_data),
103         .per_child_platdata_auto_alloc_size =
104                         sizeof(struct dm_test_parent_platdata),
105         .child_pre_probe = testbus_child_pre_probe,
106         .child_post_remove = testbus_child_post_remove,
107 };
108
109 UCLASS_DRIVER(testbus) = {
110         .name           = "testbus",
111         .id             = UCLASS_TEST_BUS,
112         .flags          = DM_UC_FLAG_SEQ_ALIAS,
113         .child_pre_probe = testbus_child_pre_probe_uclass,
114         .child_post_probe = testbus_child_post_probe_uclass,
115 };
116
117 /* Test that we can probe for children */
118 static int dm_test_bus_children(struct unit_test_state *uts)
119 {
120         int num_devices = 8;
121         struct udevice *bus;
122         struct uclass *uc;
123
124         ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
125         ut_asserteq(num_devices, list_count_items(&uc->dev_head));
126
127         /* Probe the bus, which should yield 3 more devices */
128         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
129         num_devices += 3;
130
131         ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
132         ut_asserteq(num_devices, list_count_items(&uc->dev_head));
133
134         ut_assert(!dm_check_devices(uts, num_devices));
135
136         return 0;
137 }
138 DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
139
140 /* Test our functions for accessing children */
141 static int dm_test_bus_children_funcs(struct unit_test_state *uts)
142 {
143         const void *blob = gd->fdt_blob;
144         struct udevice *bus, *dev;
145         int node;
146
147         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
148
149         /* device_get_child() */
150         ut_assertok(device_get_child(bus, 0, &dev));
151         ut_asserteq(-ENODEV, device_get_child(bus, 4, &dev));
152         ut_assertok(device_get_child_by_seq(bus, 5, &dev));
153         ut_assert(dev->flags & DM_FLAG_ACTIVATED);
154         ut_asserteq_str("c-test@5", dev->name);
155
156         /* Device with sequence number 0 should be accessible */
157         ut_asserteq(-ENODEV, device_find_child_by_seq(bus, -1, true, &dev));
158         ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
159         ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
160         ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 0, false, &dev));
161         ut_assertok(device_get_child_by_seq(bus, 0, &dev));
162         ut_assert(dev->flags & DM_FLAG_ACTIVATED);
163
164         /* There is no device with sequence number 2 */
165         ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, false, &dev));
166         ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, true, &dev));
167         ut_asserteq(-ENODEV, device_get_child_by_seq(bus, 2, &dev));
168
169         /* Looking for something that is not a child */
170         node = fdt_path_offset(blob, "/junk");
171         ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));
172         node = fdt_path_offset(blob, "/d-test");
173         ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));
174
175         return 0;
176 }
177 DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
178
179 static int dm_test_bus_children_of_offset(struct unit_test_state *uts)
180 {
181         const void *blob = gd->fdt_blob;
182         struct udevice *bus, *dev;
183         int node;
184
185         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
186         ut_assertnonnull(bus);
187
188         /* Find a valid child */
189         node = fdt_path_offset(blob, "/some-bus/c-test@1");
190         ut_assert(node > 0);
191         ut_assertok(device_find_child_by_of_offset(bus, node, &dev));
192         ut_assertnonnull(dev);
193         ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
194         ut_assertok(device_get_child_by_of_offset(bus, node, &dev));
195         ut_assertnonnull(dev);
196         ut_assert(dev->flags & DM_FLAG_ACTIVATED);
197
198         return 0;
199 }
200 DM_TEST(dm_test_bus_children_of_offset,
201         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
202
203 /* Test that we can iterate through children */
204 static int dm_test_bus_children_iterators(struct unit_test_state *uts)
205 {
206         struct udevice *bus, *dev, *child;
207
208         /* Walk through the children one by one */
209         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
210         ut_assertok(device_find_first_child(bus, &dev));
211         ut_asserteq_str("c-test@5", dev->name);
212         ut_assertok(device_find_next_child(&dev));
213         ut_asserteq_str("c-test@0", dev->name);
214         ut_assertok(device_find_next_child(&dev));
215         ut_asserteq_str("c-test@1", dev->name);
216         ut_assertok(device_find_next_child(&dev));
217         ut_asserteq_ptr(dev, NULL);
218
219         /* Move to the next child without using device_find_first_child() */
220         ut_assertok(device_find_child_by_seq(bus, 5, true, &dev));
221         ut_asserteq_str("c-test@5", dev->name);
222         ut_assertok(device_find_next_child(&dev));
223         ut_asserteq_str("c-test@0", dev->name);
224
225         /* Try a device with no children */
226         ut_assertok(device_find_first_child(dev, &child));
227         ut_asserteq_ptr(child, NULL);
228
229         return 0;
230 }
231 DM_TEST(dm_test_bus_children_iterators,
232         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
233
234 /* Test that the bus can store data about each child */
235 static int test_bus_parent_data(struct unit_test_state *uts)
236 {
237         struct dm_test_parent_data *parent_data;
238         struct udevice *bus, *dev;
239         struct uclass *uc;
240         int value;
241
242         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
243
244         /* Check that parent data is allocated */
245         ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
246         ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
247         ut_assertok(device_get_child_by_seq(bus, 0, &dev));
248         parent_data = dev_get_parent_priv(dev);
249         ut_assert(NULL != parent_data);
250
251         /* Check that it starts at 0 and goes away when device is removed */
252         parent_data->sum += 5;
253         ut_asserteq(5, parent_data->sum);
254         device_remove(dev, DM_REMOVE_NORMAL);
255         ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
256
257         /* Check that we can do this twice */
258         ut_assertok(device_get_child_by_seq(bus, 0, &dev));
259         parent_data = dev_get_parent_priv(dev);
260         ut_assert(NULL != parent_data);
261         parent_data->sum += 5;
262         ut_asserteq(5, parent_data->sum);
263
264         /* Add parent data to all children */
265         ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
266         value = 5;
267         uclass_foreach_dev(dev, uc) {
268                 /* Ignore these if they are not on this bus */
269                 if (dev->parent != bus) {
270                         ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
271                         continue;
272                 }
273                 ut_assertok(device_probe(dev));
274                 parent_data = dev_get_parent_priv(dev);
275
276                 parent_data->sum = value;
277                 value += 5;
278         }
279
280         /* Check it is still there */
281         value = 5;
282         uclass_foreach_dev(dev, uc) {
283                 /* Ignore these if they are not on this bus */
284                 if (dev->parent != bus)
285                         continue;
286                 parent_data = dev_get_parent_priv(dev);
287
288                 ut_asserteq(value, parent_data->sum);
289                 value += 5;
290         }
291
292         return 0;
293 }
294 /* Test that the bus can store data about each child */
295 static int dm_test_bus_parent_data(struct unit_test_state *uts)
296 {
297         return test_bus_parent_data(uts);
298 }
299 DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
300
301 /* As above but the size is controlled by the uclass */
302 static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
303 {
304         struct driver *drv;
305         struct udevice *bus;
306         int size;
307         int ret;
308
309         /* Set the driver size to 0 so that the uclass size is used */
310         ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
311         drv = (struct driver *)bus->driver;
312         size = drv->per_child_auto_alloc_size;
313
314 #ifdef CONFIG_SANDBOX
315         os_mprotect_allow(bus->uclass->uc_drv, sizeof(*bus->uclass->uc_drv));
316         os_mprotect_allow(drv, sizeof(*drv));
317 #endif
318         bus->uclass->uc_drv->per_child_auto_alloc_size = size;
319         drv->per_child_auto_alloc_size = 0;
320         ret = test_bus_parent_data(uts);
321         if (ret)
322                 return ret;
323         bus->uclass->uc_drv->per_child_auto_alloc_size = 0;
324         drv->per_child_auto_alloc_size = size;
325
326         return 0;
327 }
328 DM_TEST(dm_test_bus_parent_data_uclass,
329         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
330
331 /* Test that the bus ops are called when a child is probed/removed */
332 static int dm_test_bus_parent_ops(struct unit_test_state *uts)
333 {
334         struct dm_test_parent_data *parent_data;
335         struct dm_test_state *dms = uts->priv;
336         struct udevice *bus, *dev;
337         struct uclass *uc;
338
339         test_state = dms;
340         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
341         ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
342
343         uclass_foreach_dev(dev, uc) {
344                 /* Ignore these if they are not on this bus */
345                 if (dev->parent != bus)
346                         continue;
347                 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
348
349                 ut_assertok(device_probe(dev));
350                 parent_data = dev_get_parent_priv(dev);
351                 ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
352         }
353
354         uclass_foreach_dev(dev, uc) {
355                 /* Ignore these if they are not on this bus */
356                 if (dev->parent != bus)
357                         continue;
358                 parent_data = dev_get_parent_priv(dev);
359                 ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
360                 ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
361                 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
362                 ut_asserteq_ptr(dms->removed, dev);
363         }
364         test_state = NULL;
365
366         return 0;
367 }
368 DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
369
370 static int test_bus_parent_platdata(struct unit_test_state *uts)
371 {
372         struct dm_test_parent_platdata *plat;
373         struct udevice *bus, *dev;
374         int child_count;
375
376         /* Check that the bus has no children */
377         ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
378         device_find_first_child(bus, &dev);
379         ut_asserteq_ptr(NULL, dev);
380
381         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
382
383         for (device_find_first_child(bus, &dev), child_count = 0;
384              dev;
385              device_find_next_child(&dev)) {
386                 /* Check that platform data is allocated */
387                 plat = dev_get_parent_platdata(dev);
388                 ut_assert(plat != NULL);
389
390                 /*
391                  * Check that it is not affected by the device being
392                  * probed/removed
393                  */
394                 plat->count++;
395                 ut_asserteq(1, plat->count);
396                 device_probe(dev);
397                 device_remove(dev, DM_REMOVE_NORMAL);
398
399                 ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
400                 ut_asserteq(1, plat->count);
401                 ut_assertok(device_probe(dev));
402                 child_count++;
403         }
404         ut_asserteq(3, child_count);
405
406         /* Removing the bus should also have no effect (it is still bound) */
407         device_remove(bus, DM_REMOVE_NORMAL);
408         for (device_find_first_child(bus, &dev), child_count = 0;
409              dev;
410              device_find_next_child(&dev)) {
411                 /* Check that platform data is allocated */
412                 plat = dev_get_parent_platdata(dev);
413                 ut_assert(plat != NULL);
414                 ut_asserteq(1, plat->count);
415                 child_count++;
416         }
417         ut_asserteq(3, child_count);
418
419         /* Unbind all the children */
420         do {
421                 device_find_first_child(bus, &dev);
422                 if (dev)
423                         device_unbind(dev);
424         } while (dev);
425
426         /* Now the child platdata should be removed and re-added */
427         device_probe(bus);
428         for (device_find_first_child(bus, &dev), child_count = 0;
429              dev;
430              device_find_next_child(&dev)) {
431                 /* Check that platform data is allocated */
432                 plat = dev_get_parent_platdata(dev);
433                 ut_assert(plat != NULL);
434                 ut_asserteq(0, plat->count);
435                 child_count++;
436         }
437         ut_asserteq(3, child_count);
438
439         return 0;
440 }
441
442 /* Test that the bus can store platform data about each child */
443 static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
444 {
445         return test_bus_parent_platdata(uts);
446 }
447 DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
448
449 /* As above but the size is controlled by the uclass */
450 static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
451 {
452         struct udevice *bus;
453         struct driver *drv;
454         int size;
455         int ret;
456
457         /* Set the driver size to 0 so that the uclass size is used */
458         ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
459         drv = (struct driver *)bus->driver;
460         size = drv->per_child_platdata_auto_alloc_size;
461 #ifdef CONFIG_SANDBOX
462         os_mprotect_allow(bus->uclass->uc_drv, sizeof(*bus->uclass->uc_drv));
463         os_mprotect_allow(drv, sizeof(*drv));
464 #endif
465         bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
466         drv->per_child_platdata_auto_alloc_size = 0;
467         ret = test_bus_parent_platdata(uts);
468         if (ret)
469                 return ret;
470         bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
471         drv->per_child_platdata_auto_alloc_size = size;
472
473         return 0;
474 }
475 DM_TEST(dm_test_bus_parent_platdata_uclass,
476         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
477
478 /* Test that the child post_bind method is called */
479 static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
480 {
481         struct dm_test_parent_platdata *plat;
482         struct udevice *bus, *dev;
483         int child_count;
484
485         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
486         for (device_find_first_child(bus, &dev), child_count = 0;
487              dev;
488              device_find_next_child(&dev)) {
489                 /* Check that platform data is allocated */
490                 plat = dev_get_parent_platdata(dev);
491                 ut_assert(plat != NULL);
492                 ut_asserteq(1, plat->bind_flag);
493                 child_count++;
494         }
495         ut_asserteq(3, child_count);
496
497         return 0;
498 }
499 DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
500
501 /* Test that the child post_bind method is called */
502 static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
503 {
504         struct dm_test_parent_platdata *plat;
505         struct udevice *bus, *dev;
506         int child_count;
507
508         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
509         for (device_find_first_child(bus, &dev), child_count = 0;
510              dev;
511              device_find_next_child(&dev)) {
512                 /* Check that platform data is allocated */
513                 plat = dev_get_parent_platdata(dev);
514                 ut_assert(plat != NULL);
515                 ut_asserteq(2, plat->uclass_bind_flag);
516                 child_count++;
517         }
518         ut_asserteq(3, child_count);
519
520         return 0;
521 }
522 DM_TEST(dm_test_bus_child_post_bind_uclass,
523         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
524
525 /*
526  * Test that the bus' uclass' child_pre_probe() is called before the
527  * device's probe() method
528  */
529 static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
530 {
531         struct udevice *bus, *dev;
532         int child_count;
533
534         /*
535          * See testfdt_drv_probe() which effectively checks that the uclass
536          * flag is set before that method is called
537          */
538         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
539         for (device_find_first_child(bus, &dev), child_count = 0;
540              dev;
541              device_find_next_child(&dev)) {
542                 struct dm_test_priv *priv = dev_get_priv(dev);
543
544                 /* Check that things happened in the right order */
545                 ut_asserteq_ptr(NULL, priv);
546                 ut_assertok(device_probe(dev));
547
548                 priv = dev_get_priv(dev);
549                 ut_assert(priv != NULL);
550                 ut_asserteq(1, priv->uclass_flag);
551                 ut_asserteq(1, priv->uclass_total);
552                 child_count++;
553         }
554         ut_asserteq(3, child_count);
555
556         return 0;
557 }
558 DM_TEST(dm_test_bus_child_pre_probe_uclass,
559         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
560
561 /*
562  * Test that the bus' uclass' child_post_probe() is called after the
563  * device's probe() method
564  */
565 static int dm_test_bus_child_post_probe_uclass(struct unit_test_state *uts)
566 {
567         struct udevice *bus, *dev;
568         int child_count;
569
570         /*
571          * See testfdt_drv_probe() which effectively initializes that
572          * the uclass postp flag is set to a value
573          */
574         ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
575         for (device_find_first_child(bus, &dev), child_count = 0;
576              dev;
577              device_find_next_child(&dev)) {
578                 struct dm_test_priv *priv = dev_get_priv(dev);
579
580                 /* Check that things happened in the right order */
581                 ut_asserteq_ptr(NULL, priv);
582                 ut_assertok(device_probe(dev));
583
584                 priv = dev_get_priv(dev);
585                 ut_assert(priv != NULL);
586                 ut_asserteq(0, priv->uclass_postp);
587                 child_count++;
588         }
589         ut_asserteq(3, child_count);
590
591         return 0;
592 }
593 DM_TEST(dm_test_bus_child_post_probe_uclass,
594         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);