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