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