blob: 7006d4163db832632662c9214333d2cc939b46af [file] [log] [blame]
Simon Glass1ca7e202014-07-23 06:55:18 -06001/*
2 * Copyright (c) 2014 Google, Inc
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 */
6
7#include <common.h>
8#include <dm.h>
Simon Glasse59f4582014-07-23 06:55:20 -06009#include <dm/device-internal.h>
Simon Glass1ca7e202014-07-23 06:55:18 -060010#include <dm/test.h>
Simon Glasscdc133b2015-01-25 08:27:01 -070011#include <dm/uclass-internal.h>
Simon Glass1ca7e202014-07-23 06:55:18 -060012#include <dm/util.h>
Joe Hershbergere721b882015-05-20 14:27:27 -050013#include <test/ut.h>
Simon Glass1ca7e202014-07-23 06:55:18 -060014
15DECLARE_GLOBAL_DATA_PTR;
16
Simon Glasscdc133b2015-01-25 08:27:01 -070017struct dm_test_parent_platdata {
18 int count;
Simon Glass0118ce72015-01-25 08:27:03 -070019 int bind_flag;
Simon Glass081f2fc2015-01-25 08:27:08 -070020 int uclass_bind_flag;
Simon Glasscdc133b2015-01-25 08:27:01 -070021};
22
Simon Glassa327dee2014-07-23 06:55:21 -060023enum {
24 FLAG_CHILD_PROBED = 10,
25 FLAG_CHILD_REMOVED = -7,
26};
27
28static struct dm_test_state *test_state;
29
Simon Glass1ca7e202014-07-23 06:55:18 -060030static int testbus_drv_probe(struct udevice *dev)
31{
Simon Glass2e3f1ff2016-07-05 17:10:09 -060032 return dm_scan_fdt_dev(dev);
Simon Glass1ca7e202014-07-23 06:55:18 -060033}
34
Simon Glass0118ce72015-01-25 08:27:03 -070035static 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;
Simon Glass081f2fc2015-01-25 08:27:08 -070041 plat->uclass_bind_flag = 2;
Simon Glass0118ce72015-01-25 08:27:03 -070042
43 return 0;
44}
45
Simon Glassa327dee2014-07-23 06:55:21 -060046static int testbus_child_pre_probe(struct udevice *dev)
47{
Simon Glassbcbe3d12015-09-28 23:32:01 -060048 struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
Simon Glassa327dee2014-07-23 06:55:21 -060049
50 parent_data->flag += FLAG_CHILD_PROBED;
51
52 return 0;
53}
54
Simon Glass83c7e432015-01-25 08:27:10 -070055static 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
Simon Glassa327dee2014-07-23 06:55:21 -060064static int testbus_child_post_remove(struct udevice *dev)
65{
Simon Glassbcbe3d12015-09-28 23:32:01 -060066 struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
Simon Glassa327dee2014-07-23 06:55:21 -060067 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
Simon Glass1ca7e202014-07-23 06:55:18 -060076static const struct udevice_id testbus_ids[] = {
77 {
78 .compatible = "denx,u-boot-test-bus",
79 .data = DM_TEST_TYPE_FIRST },
80 { }
81};
82
83U_BOOT_DRIVER(testbus_drv) = {
84 .name = "testbus_drv",
85 .of_match = testbus_ids,
86 .id = UCLASS_TEST_BUS,
87 .probe = testbus_drv_probe,
Simon Glass0118ce72015-01-25 08:27:03 -070088 .child_post_bind = testbus_child_post_bind,
Simon Glass1ca7e202014-07-23 06:55:18 -060089 .priv_auto_alloc_size = sizeof(struct dm_test_priv),
90 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
Simon Glasse59f4582014-07-23 06:55:20 -060091 .per_child_auto_alloc_size = sizeof(struct dm_test_parent_data),
Simon Glasscdc133b2015-01-25 08:27:01 -070092 .per_child_platdata_auto_alloc_size =
93 sizeof(struct dm_test_parent_platdata),
Simon Glassa327dee2014-07-23 06:55:21 -060094 .child_pre_probe = testbus_child_pre_probe,
95 .child_post_remove = testbus_child_post_remove,
Simon Glass1ca7e202014-07-23 06:55:18 -060096};
97
98UCLASS_DRIVER(testbus) = {
99 .name = "testbus",
100 .id = UCLASS_TEST_BUS,
Simon Glass9cc36a22015-01-25 08:27:05 -0700101 .flags = DM_UC_FLAG_SEQ_ALIAS,
Simon Glass83c7e432015-01-25 08:27:10 -0700102 .child_pre_probe = testbus_child_pre_probe_uclass,
Simon Glass1ca7e202014-07-23 06:55:18 -0600103};
104
105/* Test that we can probe for children */
Joe Hershbergere721b882015-05-20 14:27:27 -0500106static int dm_test_bus_children(struct unit_test_state *uts)
Simon Glass1ca7e202014-07-23 06:55:18 -0600107{
Simon Glass9cc36a22015-01-25 08:27:05 -0700108 int num_devices = 6;
Simon Glass1ca7e202014-07-23 06:55:18 -0600109 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
Joe Hershbergere721b882015-05-20 14:27:27 -0500122 ut_assert(!dm_check_devices(uts, num_devices));
Simon Glass1ca7e202014-07-23 06:55:18 -0600123
124 return 0;
125}
126DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glass997c87b2014-07-23 06:55:19 -0600127
128/* Test our functions for accessing children */
Joe Hershbergere721b882015-05-20 14:27:27 -0500129static int dm_test_bus_children_funcs(struct unit_test_state *uts)
Simon Glass997c87b2014-07-23 06:55:19 -0600130{
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
Simon Glass298afb52017-05-18 20:09:43 -0600163 return 0;
164}
165DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
166
167static 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));
Simon Glass4f414d32017-06-07 10:28:44 -0600174 ut_assertnonnull(bus);
Simon Glass298afb52017-05-18 20:09:43 -0600175
Simon Glass997c87b2014-07-23 06:55:19 -0600176 /* Find a valid child */
177 node = fdt_path_offset(blob, "/some-bus/c-test@1");
Simon Glass298afb52017-05-18 20:09:43 -0600178 ut_assert(node > 0);
Simon Glass997c87b2014-07-23 06:55:19 -0600179 ut_assertok(device_find_child_by_of_offset(bus, node, &dev));
Simon Glass4f414d32017-06-07 10:28:44 -0600180 ut_assertnonnull(dev);
Simon Glass997c87b2014-07-23 06:55:19 -0600181 ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
182 ut_assertok(device_get_child_by_of_offset(bus, node, &dev));
Simon Glass4f414d32017-06-07 10:28:44 -0600183 ut_assertnonnull(dev);
Simon Glass997c87b2014-07-23 06:55:19 -0600184 ut_assert(dev->flags & DM_FLAG_ACTIVATED);
185
186 return 0;
187}
Simon Glass298afb52017-05-18 20:09:43 -0600188DM_TEST(dm_test_bus_children_of_offset,
189 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
Simon Glasse59f4582014-07-23 06:55:20 -0600190
Simon Glassa8981d42014-10-13 23:41:49 -0600191/* Test that we can iterate through children */
Joe Hershbergere721b882015-05-20 14:27:27 -0500192static int dm_test_bus_children_iterators(struct unit_test_state *uts)
Simon Glassa8981d42014-10-13 23:41:49 -0600193{
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}
219DM_TEST(dm_test_bus_children_iterators,
220 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
221
Simon Glasse59f4582014-07-23 06:55:20 -0600222/* Test that the bus can store data about each child */
Joe Hershbergere721b882015-05-20 14:27:27 -0500223static int test_bus_parent_data(struct unit_test_state *uts)
Simon Glasse59f4582014-07-23 06:55:20 -0600224{
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));
Simon Glassbcbe3d12015-09-28 23:32:01 -0600234 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
Simon Glasse59f4582014-07-23 06:55:20 -0600235 ut_assertok(device_get_child_by_seq(bus, 0, &dev));
Simon Glassbcbe3d12015-09-28 23:32:01 -0600236 parent_data = dev_get_parent_priv(dev);
Simon Glasse59f4582014-07-23 06:55:20 -0600237 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);
Stefan Roese706865a2017-03-20 12:51:48 +0100242 device_remove(dev, DM_REMOVE_NORMAL);
Simon Glassbcbe3d12015-09-28 23:32:01 -0600243 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
Simon Glasse59f4582014-07-23 06:55:20 -0600244
245 /* Check that we can do this twice */
246 ut_assertok(device_get_child_by_seq(bus, 0, &dev));
Simon Glassbcbe3d12015-09-28 23:32:01 -0600247 parent_data = dev_get_parent_priv(dev);
Simon Glasse59f4582014-07-23 06:55:20 -0600248 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) {
Simon Glassbcbe3d12015-09-28 23:32:01 -0600258 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
Simon Glasse59f4582014-07-23 06:55:20 -0600259 continue;
260 }
261 ut_assertok(device_probe(dev));
Simon Glassbcbe3d12015-09-28 23:32:01 -0600262 parent_data = dev_get_parent_priv(dev);
Simon Glasse59f4582014-07-23 06:55:20 -0600263
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;
Simon Glassbcbe3d12015-09-28 23:32:01 -0600274 parent_data = dev_get_parent_priv(dev);
Simon Glasse59f4582014-07-23 06:55:20 -0600275
276 ut_asserteq(value, parent_data->sum);
277 value += 5;
278 }
279
280 return 0;
281}
Simon Glassdac8db22015-01-25 08:27:06 -0700282/* Test that the bus can store data about each child */
Joe Hershbergere721b882015-05-20 14:27:27 -0500283static int dm_test_bus_parent_data(struct unit_test_state *uts)
Simon Glassdac8db22015-01-25 08:27:06 -0700284{
Joe Hershbergere721b882015-05-20 14:27:27 -0500285 return test_bus_parent_data(uts);
Simon Glassdac8db22015-01-25 08:27:06 -0700286}
Simon Glasse59f4582014-07-23 06:55:20 -0600287DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glassa327dee2014-07-23 06:55:21 -0600288
Simon Glassdac8db22015-01-25 08:27:06 -0700289/* As above but the size is controlled by the uclass */
Joe Hershbergere721b882015-05-20 14:27:27 -0500290static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
Simon Glassdac8db22015-01-25 08:27:06 -0700291{
Simon Glasse23eb612015-03-25 12:21:51 -0600292 struct driver *drv;
Simon Glassdac8db22015-01-25 08:27:06 -0700293 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));
Simon Glasse23eb612015-03-25 12:21:51 -0600299 drv = (struct driver *)bus->driver;
300 size = drv->per_child_auto_alloc_size;
Simon Glassdac8db22015-01-25 08:27:06 -0700301 bus->uclass->uc_drv->per_child_auto_alloc_size = size;
Simon Glasse23eb612015-03-25 12:21:51 -0600302 drv->per_child_auto_alloc_size = 0;
Joe Hershbergere721b882015-05-20 14:27:27 -0500303 ret = test_bus_parent_data(uts);
Simon Glassdac8db22015-01-25 08:27:06 -0700304 if (ret)
305 return ret;
306 bus->uclass->uc_drv->per_child_auto_alloc_size = 0;
Simon Glasse23eb612015-03-25 12:21:51 -0600307 drv->per_child_auto_alloc_size = size;
Simon Glassdac8db22015-01-25 08:27:06 -0700308
309 return 0;
310}
311DM_TEST(dm_test_bus_parent_data_uclass,
312 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
313
Simon Glassa327dee2014-07-23 06:55:21 -0600314/* Test that the bus ops are called when a child is probed/removed */
Joe Hershbergere721b882015-05-20 14:27:27 -0500315static int dm_test_bus_parent_ops(struct unit_test_state *uts)
Simon Glassa327dee2014-07-23 06:55:21 -0600316{
317 struct dm_test_parent_data *parent_data;
Joe Hershbergere721b882015-05-20 14:27:27 -0500318 struct dm_test_state *dms = uts->priv;
Simon Glassa327dee2014-07-23 06:55:21 -0600319 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;
Simon Glassbcbe3d12015-09-28 23:32:01 -0600330 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
Simon Glassa327dee2014-07-23 06:55:21 -0600331
332 ut_assertok(device_probe(dev));
Simon Glassbcbe3d12015-09-28 23:32:01 -0600333 parent_data = dev_get_parent_priv(dev);
Simon Glassa327dee2014-07-23 06:55:21 -0600334 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;
Simon Glassbcbe3d12015-09-28 23:32:01 -0600341 parent_data = dev_get_parent_priv(dev);
Simon Glassa327dee2014-07-23 06:55:21 -0600342 ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
Stefan Roese706865a2017-03-20 12:51:48 +0100343 ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
Simon Glassbcbe3d12015-09-28 23:32:01 -0600344 ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
Simon Glassa327dee2014-07-23 06:55:21 -0600345 ut_asserteq_ptr(dms->removed, dev);
346 }
347 test_state = NULL;
348
349 return 0;
350}
351DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glasscdc133b2015-01-25 08:27:01 -0700352
Joe Hershbergere721b882015-05-20 14:27:27 -0500353static int test_bus_parent_platdata(struct unit_test_state *uts)
Simon Glasscdc133b2015-01-25 08:27:01 -0700354{
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);
Stefan Roese706865a2017-03-20 12:51:48 +0100380 device_remove(dev, DM_REMOVE_NORMAL);
Simon Glasscdc133b2015-01-25 08:27:01 -0700381
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) */
Stefan Roese706865a2017-03-20 12:51:48 +0100390 device_remove(bus, DM_REMOVE_NORMAL);
Simon Glasscdc133b2015-01-25 08:27:01 -0700391 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}
Simon Glassba8da9d2015-01-25 08:27:02 -0700424
425/* Test that the bus can store platform data about each child */
Joe Hershbergere721b882015-05-20 14:27:27 -0500426static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
Simon Glassba8da9d2015-01-25 08:27:02 -0700427{
Joe Hershbergere721b882015-05-20 14:27:27 -0500428 return test_bus_parent_platdata(uts);
Simon Glassba8da9d2015-01-25 08:27:02 -0700429}
Simon Glasscdc133b2015-01-25 08:27:01 -0700430DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glassba8da9d2015-01-25 08:27:02 -0700431
432/* As above but the size is controlled by the uclass */
Joe Hershbergere721b882015-05-20 14:27:27 -0500433static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
Simon Glassba8da9d2015-01-25 08:27:02 -0700434{
435 struct udevice *bus;
Simon Glasse23eb612015-03-25 12:21:51 -0600436 struct driver *drv;
Simon Glassba8da9d2015-01-25 08:27:02 -0700437 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));
Simon Glasse23eb612015-03-25 12:21:51 -0600442 drv = (struct driver *)bus->driver;
443 size = drv->per_child_platdata_auto_alloc_size;
Simon Glassba8da9d2015-01-25 08:27:02 -0700444 bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
Simon Glasse23eb612015-03-25 12:21:51 -0600445 drv->per_child_platdata_auto_alloc_size = 0;
Joe Hershbergere721b882015-05-20 14:27:27 -0500446 ret = test_bus_parent_platdata(uts);
Simon Glassba8da9d2015-01-25 08:27:02 -0700447 if (ret)
448 return ret;
449 bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
Simon Glasse23eb612015-03-25 12:21:51 -0600450 drv->per_child_platdata_auto_alloc_size = size;
Simon Glassba8da9d2015-01-25 08:27:02 -0700451
452 return 0;
453}
454DM_TEST(dm_test_bus_parent_platdata_uclass,
455 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glass0118ce72015-01-25 08:27:03 -0700456
457/* Test that the child post_bind method is called */
Joe Hershbergere721b882015-05-20 14:27:27 -0500458static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
Simon Glass0118ce72015-01-25 08:27:03 -0700459{
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}
478DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glass081f2fc2015-01-25 08:27:08 -0700479
480/* Test that the child post_bind method is called */
Joe Hershbergere721b882015-05-20 14:27:27 -0500481static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
Simon Glass081f2fc2015-01-25 08:27:08 -0700482{
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}
501DM_TEST(dm_test_bus_child_post_bind_uclass,
502 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Simon Glass83c7e432015-01-25 08:27:10 -0700503
504/*
505 * Test that the bus' uclass' child_pre_probe() is called before the
506 * device's probe() method
507 */
Joe Hershbergere721b882015-05-20 14:27:27 -0500508static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
Simon Glass83c7e432015-01-25 08:27:10 -0700509{
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}
537DM_TEST(dm_test_bus_child_pre_probe_uclass,
538 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);