← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/test/dm/core.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/test/dm/core.c
 
1
/*
 
2
 * Tests for the core driver model code
 
3
 *
 
4
 * Copyright (c) 2013 Google, Inc
 
5
 *
 
6
 * SPDX-License-Identifier:     GPL-2.0+
 
7
 */
 
8
 
 
9
#include <common.h>
 
10
#include <errno.h>
 
11
#include <dm.h>
 
12
#include <fdtdec.h>
 
13
#include <malloc.h>
 
14
#include <dm/device-internal.h>
 
15
#include <dm/root.h>
 
16
#include <dm/ut.h>
 
17
#include <dm/util.h>
 
18
#include <dm/test.h>
 
19
#include <dm/uclass-internal.h>
 
20
 
 
21
DECLARE_GLOBAL_DATA_PTR;
 
22
 
 
23
enum {
 
24
        TEST_INTVAL1            = 0,
 
25
        TEST_INTVAL2            = 3,
 
26
        TEST_INTVAL3            = 6,
 
27
        TEST_INTVAL_MANUAL      = 101112,
 
28
};
 
29
 
 
30
static const struct dm_test_pdata test_pdata[] = {
 
31
        { .ping_add             = TEST_INTVAL1, },
 
32
        { .ping_add             = TEST_INTVAL2, },
 
33
        { .ping_add             = TEST_INTVAL3, },
 
34
};
 
35
 
 
36
static const struct dm_test_pdata test_pdata_manual = {
 
37
        .ping_add               = TEST_INTVAL_MANUAL,
 
38
};
 
39
 
 
40
U_BOOT_DEVICE(dm_test_info1) = {
 
41
        .name = "test_drv",
 
42
        .platdata = &test_pdata[0],
 
43
};
 
44
 
 
45
U_BOOT_DEVICE(dm_test_info2) = {
 
46
        .name = "test_drv",
 
47
        .platdata = &test_pdata[1],
 
48
};
 
49
 
 
50
U_BOOT_DEVICE(dm_test_info3) = {
 
51
        .name = "test_drv",
 
52
        .platdata = &test_pdata[2],
 
53
};
 
54
 
 
55
static struct driver_info driver_info_manual = {
 
56
        .name = "test_manual_drv",
 
57
        .platdata = &test_pdata_manual,
 
58
};
 
59
 
 
60
/* Test that binding with platdata occurs correctly */
 
61
static int dm_test_autobind(struct dm_test_state *dms)
 
62
{
 
63
        struct device *dev;
 
64
 
 
65
        /*
 
66
         * We should have a single class (UCLASS_ROOT) and a single root
 
67
         * device with no children.
 
68
         */
 
69
        ut_assert(dms->root);
 
70
        ut_asserteq(1, list_count_items(&gd->uclass_root));
 
71
        ut_asserteq(0, list_count_items(&gd->dm_root->child_head));
 
72
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
 
73
 
 
74
        ut_assertok(dm_scan_platdata());
 
75
 
 
76
        /* We should have our test class now at least, plus more children */
 
77
        ut_assert(1 < list_count_items(&gd->uclass_root));
 
78
        ut_assert(0 < list_count_items(&gd->dm_root->child_head));
 
79
 
 
80
        /* Our 3 dm_test_infox children should be bound to the test uclass */
 
81
        ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
 
82
 
 
83
        /* No devices should be probed */
 
84
        list_for_each_entry(dev, &gd->dm_root->child_head, sibling_node)
 
85
                ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
 
86
 
 
87
        /* Our test driver should have been bound 3 times */
 
88
        ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] == 3);
 
89
 
 
90
        return 0;
 
91
}
 
92
DM_TEST(dm_test_autobind, 0);
 
93
 
 
94
/* Test that autoprobe finds all the expected devices */
 
95
static int dm_test_autoprobe(struct dm_test_state *dms)
 
96
{
 
97
        int expected_base_add;
 
98
        struct device *dev;
 
99
        struct uclass *uc;
 
100
        int i;
 
101
 
 
102
        ut_assertok(uclass_get(UCLASS_TEST, &uc));
 
103
        ut_assert(uc);
 
104
 
 
105
        ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
 
106
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
 
107
 
 
108
        /* The root device should not be activated until needed */
 
109
        ut_assert(!(dms->root->flags & DM_FLAG_ACTIVATED));
 
110
 
 
111
        /*
 
112
         * We should be able to find the three test devices, and they should
 
113
         * all be activated as they are used (lazy activation, required by
 
114
         * U-Boot)
 
115
         */
 
116
        for (i = 0; i < 3; i++) {
 
117
                ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 
118
                ut_assert(dev);
 
119
                ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
 
120
                           "Driver %d/%s already activated", i, dev->name);
 
121
 
 
122
                /* This should activate it */
 
123
                ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
 
124
                ut_assert(dev);
 
125
                ut_assert(dev->flags & DM_FLAG_ACTIVATED);
 
126
 
 
127
                /* Activating a device should activate the root device */
 
128
                if (!i)
 
129
                        ut_assert(dms->root->flags & DM_FLAG_ACTIVATED);
 
130
        }
 
131
 
 
132
        /* Our 3 dm_test_infox children should be passed to post_probe */
 
133
        ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
 
134
 
 
135
        /* Also we can check the per-device data */
 
136
        expected_base_add = 0;
 
137
        for (i = 0; i < 3; i++) {
 
138
                struct dm_test_uclass_perdev_priv *priv;
 
139
                struct dm_test_pdata *pdata;
 
140
 
 
141
                ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 
142
                ut_assert(dev);
 
143
 
 
144
                priv = dev->uclass_priv;
 
145
                ut_assert(priv);
 
146
                ut_asserteq(expected_base_add, priv->base_add);
 
147
 
 
148
                pdata = dev->platdata;
 
149
                expected_base_add += pdata->ping_add;
 
150
        }
 
151
 
 
152
        return 0;
 
153
}
 
154
DM_TEST(dm_test_autoprobe, DM_TESTF_SCAN_PDATA);
 
155
 
 
156
/* Check that we see the correct platdata in each device */
 
157
static int dm_test_platdata(struct dm_test_state *dms)
 
158
{
 
159
        const struct dm_test_pdata *pdata;
 
160
        struct device *dev;
 
161
        int i;
 
162
 
 
163
        for (i = 0; i < 3; i++) {
 
164
                ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 
165
                ut_assert(dev);
 
166
                pdata = dev->platdata;
 
167
                ut_assert(pdata->ping_add == test_pdata[i].ping_add);
 
168
        }
 
169
 
 
170
        return 0;
 
171
}
 
172
DM_TEST(dm_test_platdata, DM_TESTF_SCAN_PDATA);
 
173
 
 
174
/* Test that we can bind, probe, remove, unbind a driver */
 
175
static int dm_test_lifecycle(struct dm_test_state *dms)
 
176
{
 
177
        int op_count[DM_TEST_OP_COUNT];
 
178
        struct device *dev, *test_dev;
 
179
        int pingret;
 
180
        int ret;
 
181
 
 
182
        memcpy(op_count, dm_testdrv_op_count, sizeof(op_count));
 
183
 
 
184
        ut_assertok(device_bind_by_name(dms->root, &driver_info_manual,
 
185
                                        &dev));
 
186
        ut_assert(dev);
 
187
        ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND]
 
188
                        == op_count[DM_TEST_OP_BIND] + 1);
 
189
        ut_assert(!dev->priv);
 
190
 
 
191
        /* Probe the device - it should fail allocating private data */
 
192
        dms->force_fail_alloc = 1;
 
193
        ret = device_probe(dev);
 
194
        ut_assert(ret == -ENOMEM);
 
195
        ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
 
196
                        == op_count[DM_TEST_OP_PROBE] + 1);
 
197
        ut_assert(!dev->priv);
 
198
 
 
199
        /* Try again without the alloc failure */
 
200
        dms->force_fail_alloc = 0;
 
201
        ut_assertok(device_probe(dev));
 
202
        ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
 
203
                        == op_count[DM_TEST_OP_PROBE] + 2);
 
204
        ut_assert(dev->priv);
 
205
 
 
206
        /* This should be device 3 in the uclass */
 
207
        ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
 
208
        ut_assert(dev == test_dev);
 
209
 
 
210
        /* Try ping */
 
211
        ut_assertok(test_ping(dev, 100, &pingret));
 
212
        ut_assert(pingret == 102);
 
213
 
 
214
        /* Now remove device 3 */
 
215
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
 
216
        ut_assertok(device_remove(dev));
 
217
        ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
 
218
 
 
219
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 
220
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
 
221
        ut_assertok(device_unbind(dev));
 
222
        ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 
223
        ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
 
224
 
 
225
        return 0;
 
226
}
 
227
DM_TEST(dm_test_lifecycle, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
 
228
 
 
229
/* Test that we can bind/unbind and the lists update correctly */
 
230
static int dm_test_ordering(struct dm_test_state *dms)
 
231
{
 
232
        struct device *dev, *dev_penultimate, *dev_last, *test_dev;
 
233
        int pingret;
 
234
 
 
235
        ut_assertok(device_bind_by_name(dms->root, &driver_info_manual,
 
236
                                        &dev));
 
237
        ut_assert(dev);
 
238
 
 
239
        /* Bind two new devices (numbers 4 and 5) */
 
240
        ut_assertok(device_bind_by_name(dms->root, &driver_info_manual,
 
241
                                        &dev_penultimate));
 
242
        ut_assert(dev_penultimate);
 
243
        ut_assertok(device_bind_by_name(dms->root, &driver_info_manual,
 
244
                                        &dev_last));
 
245
        ut_assert(dev_last);
 
246
 
 
247
        /* Now remove device 3 */
 
248
        ut_assertok(device_remove(dev));
 
249
        ut_assertok(device_unbind(dev));
 
250
 
 
251
        /* The device numbering should have shifted down one */
 
252
        ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
 
253
        ut_assert(dev_penultimate == test_dev);
 
254
        ut_assertok(uclass_find_device(UCLASS_TEST, 4, &test_dev));
 
255
        ut_assert(dev_last == test_dev);
 
256
 
 
257
        /* Add back the original device 3, now in position 5 */
 
258
        ut_assertok(device_bind_by_name(dms->root, &driver_info_manual, &dev));
 
259
        ut_assert(dev);
 
260
 
 
261
        /* Try ping */
 
262
        ut_assertok(test_ping(dev, 100, &pingret));
 
263
        ut_assert(pingret == 102);
 
264
 
 
265
        /* Remove 3 and 4 */
 
266
        ut_assertok(device_remove(dev_penultimate));
 
267
        ut_assertok(device_unbind(dev_penultimate));
 
268
        ut_assertok(device_remove(dev_last));
 
269
        ut_assertok(device_unbind(dev_last));
 
270
 
 
271
        /* Our device should now be in position 3 */
 
272
        ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
 
273
        ut_assert(dev == test_dev);
 
274
 
 
275
        /* Now remove device 3 */
 
276
        ut_assertok(device_remove(dev));
 
277
        ut_assertok(device_unbind(dev));
 
278
 
 
279
        return 0;
 
280
}
 
281
DM_TEST(dm_test_ordering, DM_TESTF_SCAN_PDATA);
 
282
 
 
283
/* Check that we can perform operations on a device (do a ping) */
 
284
int dm_check_operations(struct dm_test_state *dms, struct device *dev,
 
285
                        uint32_t base, struct dm_test_priv *priv)
 
286
{
 
287
        int expected;
 
288
        int pingret;
 
289
 
 
290
        /* Getting the child device should allocate platdata / priv */
 
291
        ut_assertok(testfdt_ping(dev, 10, &pingret));
 
292
        ut_assert(dev->priv);
 
293
        ut_assert(dev->platdata);
 
294
 
 
295
        expected = 10 + base;
 
296
        ut_asserteq(expected, pingret);
 
297
 
 
298
        /* Do another ping */
 
299
        ut_assertok(testfdt_ping(dev, 20, &pingret));
 
300
        expected = 20 + base;
 
301
        ut_asserteq(expected, pingret);
 
302
 
 
303
        /* Now check the ping_total */
 
304
        priv = dev->priv;
 
305
        ut_asserteq(DM_TEST_START_TOTAL + 10 + 20 + base * 2,
 
306
                    priv->ping_total);
 
307
 
 
308
        return 0;
 
309
}
 
310
 
 
311
/* Check that we can perform operations on devices */
 
312
static int dm_test_operations(struct dm_test_state *dms)
 
313
{
 
314
        struct device *dev;
 
315
        int i;
 
316
 
 
317
        /*
 
318
         * Now check that the ping adds are what we expect. This is using the
 
319
         * ping-add property in each node.
 
320
         */
 
321
        for (i = 0; i < ARRAY_SIZE(test_pdata); i++) {
 
322
                uint32_t base;
 
323
 
 
324
                ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
 
325
 
 
326
                /*
 
327
                 * Get the 'reg' property, which tells us what the ping add
 
328
                 * should be. We don't use the platdata because we want
 
329
                 * to test the code that sets that up (testfdt_drv_probe()).
 
330
                 */
 
331
                base = test_pdata[i].ping_add;
 
332
                debug("dev=%d, base=%d\n", i, base);
 
333
 
 
334
                ut_assert(!dm_check_operations(dms, dev, base, dev->priv));
 
335
        }
 
336
 
 
337
        return 0;
 
338
}
 
339
DM_TEST(dm_test_operations, DM_TESTF_SCAN_PDATA);
 
340
 
 
341
/* Remove all drivers and check that things work */
 
342
static int dm_test_remove(struct dm_test_state *dms)
 
343
{
 
344
        struct device *dev;
 
345
        int i;
 
346
 
 
347
        for (i = 0; i < 3; i++) {
 
348
                ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 
349
                ut_assert(dev);
 
350
                ut_assertf(dev->flags & DM_FLAG_ACTIVATED,
 
351
                           "Driver %d/%s not activated", i, dev->name);
 
352
                ut_assertok(device_remove(dev));
 
353
                ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
 
354
                           "Driver %d/%s should have deactivated", i,
 
355
                           dev->name);
 
356
                ut_assert(!dev->priv);
 
357
        }
 
358
 
 
359
        return 0;
 
360
}
 
361
DM_TEST(dm_test_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
 
362
 
 
363
/* Remove and recreate everything, check for memory leaks */
 
364
static int dm_test_leak(struct dm_test_state *dms)
 
365
{
 
366
        int i;
 
367
 
 
368
        for (i = 0; i < 2; i++) {
 
369
                struct mallinfo start, end;
 
370
                struct device *dev;
 
371
                int ret;
 
372
                int id;
 
373
 
 
374
                start = mallinfo();
 
375
                if (!start.uordblks)
 
376
                        puts("Warning: Please add '#define DEBUG' to the top of common/dlmalloc.c\n");
 
377
 
 
378
                ut_assertok(dm_scan_platdata());
 
379
                ut_assertok(dm_scan_fdt(gd->fdt_blob));
 
380
 
 
381
                /* Scanning the uclass is enough to probe all the devices */
 
382
                for (id = UCLASS_ROOT; id < UCLASS_COUNT; id++) {
 
383
                        for (ret = uclass_first_device(UCLASS_TEST, &dev);
 
384
                             dev;
 
385
                             ret = uclass_next_device(&dev))
 
386
                                ;
 
387
                        ut_assertok(ret);
 
388
                }
 
389
 
 
390
                /* Don't delete the root class, since we started with that */
 
391
                for (id = UCLASS_ROOT + 1; id < UCLASS_COUNT; id++) {
 
392
                        struct uclass *uc;
 
393
 
 
394
                        uc = uclass_find(id);
 
395
                        if (!uc)
 
396
                                continue;
 
397
                        ut_assertok(uclass_destroy(uc));
 
398
                }
 
399
 
 
400
                end = mallinfo();
 
401
                ut_asserteq(start.uordblks, end.uordblks);
 
402
        }
 
403
 
 
404
        return 0;
 
405
}
 
406
DM_TEST(dm_test_leak, 0);
 
407
 
 
408
/* Test uclass init/destroy methods */
 
409
static int dm_test_uclass(struct dm_test_state *dms)
 
410
{
 
411
        struct uclass *uc;
 
412
 
 
413
        ut_assertok(uclass_get(UCLASS_TEST, &uc));
 
414
        ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
 
415
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
 
416
        ut_assert(uc->priv);
 
417
 
 
418
        ut_assertok(uclass_destroy(uc));
 
419
        ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
 
420
        ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
 
421
 
 
422
        return 0;
 
423
}
 
424
DM_TEST(dm_test_uclass, 0);
 
425
 
 
426
/**
 
427
 * create_children() - Create children of a parent node
 
428
 *
 
429
 * @dms:        Test system state
 
430
 * @parent:     Parent device
 
431
 * @count:      Number of children to create
 
432
 * @key:        Key value to put in first child. Subsequence children
 
433
 *              receive an incrementing value
 
434
 * @child:      If not NULL, then the child device pointers are written into
 
435
 *              this array.
 
436
 * @return 0 if OK, -ve on error
 
437
 */
 
438
static int create_children(struct dm_test_state *dms, struct device *parent,
 
439
                           int count, int key, struct device *child[])
 
440
{
 
441
        struct device *dev;
 
442
        int i;
 
443
 
 
444
        for (i = 0; i < count; i++) {
 
445
                struct dm_test_pdata *pdata;
 
446
 
 
447
                ut_assertok(device_bind_by_name(parent, &driver_info_manual,
 
448
                                                &dev));
 
449
                pdata = calloc(1, sizeof(*pdata));
 
450
                pdata->ping_add = key + i;
 
451
                dev->platdata = pdata;
 
452
                if (child)
 
453
                        child[i] = dev;
 
454
        }
 
455
 
 
456
        return 0;
 
457
}
 
458
 
 
459
#define NODE_COUNT      10
 
460
 
 
461
static int dm_test_children(struct dm_test_state *dms)
 
462
{
 
463
        struct device *top[NODE_COUNT];
 
464
        struct device *child[NODE_COUNT];
 
465
        struct device *grandchild[NODE_COUNT];
 
466
        struct device *dev;
 
467
        int total;
 
468
        int ret;
 
469
        int i;
 
470
 
 
471
        /* We don't care about the numbering for this test */
 
472
        dms->skip_post_probe = 1;
 
473
 
 
474
        ut_assert(NODE_COUNT > 5);
 
475
 
 
476
        /* First create 10 top-level children */
 
477
        ut_assertok(create_children(dms, dms->root, NODE_COUNT, 0, top));
 
478
 
 
479
        /* Now a few have their own children */
 
480
        ut_assertok(create_children(dms, top[2], NODE_COUNT, 2, NULL));
 
481
        ut_assertok(create_children(dms, top[5], NODE_COUNT, 5, child));
 
482
 
 
483
        /* And grandchildren */
 
484
        for (i = 0; i < NODE_COUNT; i++)
 
485
                ut_assertok(create_children(dms, child[i], NODE_COUNT, 50 * i,
 
486
                                            i == 2 ? grandchild : NULL));
 
487
 
 
488
        /* Check total number of devices */
 
489
        total = NODE_COUNT * (3 + NODE_COUNT);
 
490
        ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_BIND]);
 
491
 
 
492
        /* Try probing one of the grandchildren */
 
493
        ut_assertok(uclass_get_device(UCLASS_TEST,
 
494
                                      NODE_COUNT * 3 + 2 * NODE_COUNT, &dev));
 
495
        ut_asserteq_ptr(grandchild[0], dev);
 
496
 
 
497
        /*
 
498
         * This should have probed the child and top node also, for a total
 
499
         * of 3 nodes.
 
500
         */
 
501
        ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
 
502
 
 
503
        /* Probe the other grandchildren */
 
504
        for (i = 1; i < NODE_COUNT; i++)
 
505
                ut_assertok(device_probe(grandchild[i]));
 
506
 
 
507
        ut_asserteq(2 + NODE_COUNT, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
 
508
 
 
509
        /* Probe everything */
 
510
        for (ret = uclass_first_device(UCLASS_TEST, &dev);
 
511
             dev;
 
512
             ret = uclass_next_device(&dev))
 
513
                ;
 
514
        ut_assertok(ret);
 
515
 
 
516
        ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
 
517
 
 
518
        /* Remove a top-level child and check that the children are removed */
 
519
        ut_assertok(device_remove(top[2]));
 
520
        ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
 
521
        dm_testdrv_op_count[DM_TEST_OP_REMOVE] = 0;
 
522
 
 
523
        /* Try one with grandchildren */
 
524
        ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
 
525
        ut_asserteq_ptr(dev, top[5]);
 
526
        ut_assertok(device_remove(dev));
 
527
        ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
 
528
                    dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
 
529
 
 
530
        /* Try the same with unbind */
 
531
        ut_assertok(device_unbind(top[2]));
 
532
        ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 
533
        dm_testdrv_op_count[DM_TEST_OP_UNBIND] = 0;
 
534
 
 
535
        /* Try one with grandchildren */
 
536
        ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
 
537
        ut_asserteq_ptr(dev, top[6]);
 
538
        ut_assertok(device_unbind(top[5]));
 
539
        ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
 
540
                    dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 
541
 
 
542
        return 0;
 
543
}
 
544
DM_TEST(dm_test_children, 0);