test/dm/test-fdt.c

   1 /*
   2  * Copyright (c) 2013 Google, Inc
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <errno.h>
  10 #include <fdtdec.h>
  11 #include <malloc.h>
  12 #include <asm/io.h>
  13 #include <dm/test.h>
  14 #include <dm/root.h>
  15 #include <dm/ut.h>
  16 #include <dm/uclass-internal.h>
  17 #include <dm/util.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 static int testfdt_drv_ping(struct udevice *dev, int pingval, int *pingret)
  22 {
  23         const struct dm_test_pdata *pdata = dev->platdata;
  24         struct dm_test_priv *priv = dev_get_priv(dev);
  25
  26         *pingret = pingval + pdata->ping_add;
  27         priv->ping_total += *pingret;
  28
  29         return 0;
  30 }
  31
  32 static const struct test_ops test_ops = {
  33         .ping = testfdt_drv_ping,
  34 };
  35
  36 static int testfdt_ofdata_to_platdata(struct udevice *dev)
  37 {
  38         struct dm_test_pdata *pdata = dev_get_platdata(dev);
  39
  40         pdata->ping_add = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
  41                                         "ping-add", -1);
  42         pdata->base = fdtdec_get_addr(gd->fdt_blob, dev->of_offset,
  43                                       "ping-expect");
  44
  45         return 0;
  46 }
  47
  48 static int testfdt_drv_probe(struct udevice *dev)
  49 {
  50         struct dm_test_priv *priv = dev_get_priv(dev);
  51
  52         priv->ping_total += DM_TEST_START_TOTAL;
  53
  54         return 0;
  55 }
  56
  57 static const struct udevice_id testfdt_ids[] = {
  58         {
  59                 .compatible = "denx,u-boot-fdt-test",
  60                 .data = DM_TEST_TYPE_FIRST },
  61         {
  62                 .compatible = "google,another-fdt-test",
  63                 .data = DM_TEST_TYPE_SECOND },
  64         { }
  65 };
  66
  67 U_BOOT_DRIVER(testfdt_drv) = {
  68         .name   = "testfdt_drv",
  69         .of_match       = testfdt_ids,
  70         .id     = UCLASS_TEST_FDT,
  71         .ofdata_to_platdata = testfdt_ofdata_to_platdata,
  72         .probe  = testfdt_drv_probe,
  73         .ops    = &test_ops,
  74         .priv_auto_alloc_size = sizeof(struct dm_test_priv),
  75         .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
  76 };
  77
  78 /* From here is the testfdt uclass code */
  79 int testfdt_ping(struct udevice *dev, int pingval, int *pingret)
  80 {
  81         const struct test_ops *ops = device_get_ops(dev);
  82
  83         if (!ops->ping)
  84                 return -ENOSYS;
  85
  86         return ops->ping(dev, pingval, pingret);
  87 }
  88
  89 UCLASS_DRIVER(testfdt) = {
  90         .name           = "testfdt",
  91         .id             = UCLASS_TEST_FDT,
  92         .flags          = DM_UC_FLAG_SEQ_ALIAS,
  93 };
  94
  95 int dm_check_devices(struct dm_test_state *dms, int num_devices)
  96 {
  97         struct udevice *dev;
  98         int ret;
  99         int i;
 100
 101         /*
 102          * Now check that the ping adds are what we expect. This is using the
 103          * ping-add property in each node.
 104          */
 105         for (i = 0; i < num_devices; i++) {
 106                 uint32_t base;
 107
 108                 ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev);
 109                 ut_assert(!ret);
 110
 111                 /*
 112                  * Get the 'ping-expect' property, which tells us what the
 113                  * ping add should be. We don't use the platdata because we
 114                  * want to test the code that sets that up
 115                  * (testfdt_drv_probe()).
 116                  */
 117                 base = fdtdec_get_addr(gd->fdt_blob, dev->of_offset,
 118                                        "ping-expect");
 119                 debug("dev=%d, base=%d: %s\n", i, base,
 120                       fdt_get_name(gd->fdt_blob, dev->of_offset, NULL));
 121
 122                 ut_assert(!dm_check_operations(dms, dev, base,
 123                                                dev_get_priv(dev)));
 124         }
 125
 126         return 0;
 127 }
 128
 129 /* Test that FDT-based binding works correctly */
 130 static int dm_test_fdt(struct dm_test_state *dms)
 131 {
 132         const int num_devices = 6;
 133         struct udevice *dev;
 134         struct uclass *uc;
 135         int ret;
 136         int i;
 137
 138         ret = dm_scan_fdt(gd->fdt_blob, false);
 139         ut_assert(!ret);
 140
 141         ret = uclass_get(UCLASS_TEST_FDT, &uc);
 142         ut_assert(!ret);
 143
 144         /* These are num_devices compatible root-level device tree nodes */
 145         ut_asserteq(num_devices, list_count_items(&uc->dev_head));
 146
 147         /* Each should have platform data but no private data */
 148         for (i = 0; i < num_devices; i++) {
 149                 ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev);
 150                 ut_assert(!ret);
 151                 ut_assert(!dev_get_priv(dev));
 152                 ut_assert(dev->platdata);
 153         }
 154
 155         ut_assertok(dm_check_devices(dms, num_devices));
 156
 157         return 0;
 158 }
 159 DM_TEST(dm_test_fdt, 0);
 160
 161 static int dm_test_fdt_pre_reloc(struct dm_test_state *dms)
 162 {
 163         struct uclass *uc;
 164         int ret;
 165
 166         ret = dm_scan_fdt(gd->fdt_blob, true);
 167         ut_assert(!ret);
 168
 169         ret = uclass_get(UCLASS_TEST_FDT, &uc);
 170         ut_assert(!ret);
 171
 172         /* These is only one pre-reloc device */
 173         ut_asserteq(1, list_count_items(&uc->dev_head));
 174
 175         return 0;
 176 }
 177 DM_TEST(dm_test_fdt_pre_reloc, 0);
 178
 179 /* Test that sequence numbers are allocated properly */
 180 static int dm_test_fdt_uclass_seq(struct dm_test_state *dms)
 181 {
 182         struct udevice *dev;
 183
 184         /* A few basic santiy tests */
 185         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev));
 186         ut_asserteq_str("b-test", dev->name);
 187
 188         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, true, &dev));
 189         ut_asserteq_str("a-test", dev->name);
 190
 191         ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 5,
 192                                                        true, &dev));
 193         ut_asserteq_ptr(NULL, dev);
 194
 195         /* Test aliases */
 196         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev));
 197         ut_asserteq_str("e-test", dev->name);
 198
 199         ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,
 200                                                        true, &dev));
 201
 202         /*
 203          * Note that c-test nodes are not probed since it is not a top-level
 204          * node
 205          */
 206         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
 207         ut_asserteq_str("b-test", dev->name);
 208
 209         /*
 210          * d-test wants sequence number 3 also, but it can't have it because
 211          * b-test gets it first.
 212          */
 213         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev));
 214         ut_asserteq_str("d-test", dev->name);
 215
 216         /* d-test actually gets 0 */
 217         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 0, &dev));
 218         ut_asserteq_str("d-test", dev->name);
 219
 220         /* initially no one wants seq 1 */
 221         ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_TEST_FDT, 1,
 222                                                       &dev));
 223         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
 224         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 4, &dev));
 225
 226         /* But now that it is probed, we can find it */
 227         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 1, &dev));
 228         ut_asserteq_str("f-test", dev->name);
 229
 230         return 0;
 231 }
 232 DM_TEST(dm_test_fdt_uclass_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 233
 234 /* Test that we can find a device by device tree offset */
 235 static int dm_test_fdt_offset(struct dm_test_state *dms)
 236 {
 237         const void *blob = gd->fdt_blob;
 238         struct udevice *dev;
 239         int node;
 240
 241         node = fdt_path_offset(blob, "/e-test");
 242         ut_assert(node > 0);
 243         ut_assertok(uclass_get_device_by_of_offset(UCLASS_TEST_FDT, node,
 244                                                    &dev));
 245         ut_asserteq_str("e-test", dev->name);
 246
 247         /* This node should not be bound */
 248         node = fdt_path_offset(blob, "/junk");
 249         ut_assert(node > 0);
 250         ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
 251                                                             node, &dev));
 252
 253         /* This is not a top level node so should not be probed */
 254         node = fdt_path_offset(blob, "/some-bus/c-test@5");
 255         ut_assert(node > 0);
 256         ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
 257                                                             node, &dev));
 258
 259         return 0;
 260 }
 261 DM_TEST(dm_test_fdt_offset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);