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 };
  93
  94 int dm_check_devices(struct dm_test_state *dms, int num_devices)
  95 {
  96         struct udevice *dev;
  97         int ret;
  98         int i;
  99
 100         /*
 101          * Now check that the ping adds are what we expect. This is using the
 102          * ping-add property in each node.
 103          */
 104         for (i = 0; i < num_devices; i++) {
 105                 uint32_t base;
 106
 107                 ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev);
 108                 ut_assert(!ret);
 109
 110                 /*
 111                  * Get the 'ping-expect' property, which tells us what the
 112                  * ping add should be. We don't use the platdata because we
 113                  * want to test the code that sets that up
 114                  * (testfdt_drv_probe()).
 115                  */
 116                 base = fdtdec_get_addr(gd->fdt_blob, dev->of_offset,
 117                                        "ping-expect");
 118                 debug("dev=%d, base=%d: %s\n", i, base,
 119                       fdt_get_name(gd->fdt_blob, dev->of_offset, NULL));
 120
 121                 ut_assert(!dm_check_operations(dms, dev, base,
 122                                                dev_get_priv(dev)));
 123         }
 124
 125         return 0;
 126 }
 127
 128 /* Test that FDT-based binding works correctly */
 129 static int dm_test_fdt(struct dm_test_state *dms)
 130 {
 131         const int num_devices = 4;
 132         struct udevice *dev;
 133         struct uclass *uc;
 134         int ret;
 135         int i;
 136
 137         ret = dm_scan_fdt(gd->fdt_blob, false);
 138         ut_assert(!ret);
 139
 140         ret = uclass_get(UCLASS_TEST_FDT, &uc);
 141         ut_assert(!ret);
 142
 143         /* These are num_devices compatible root-level device tree nodes */
 144         ut_asserteq(num_devices, list_count_items(&uc->dev_head));
 145
 146         /* Each should have no platdata / priv */
 147         for (i = 0; i < num_devices; i++) {
 148                 ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev);
 149                 ut_assert(!ret);
 150                 ut_assert(!dev_get_priv(dev));
 151                 ut_assert(!dev->platdata);
 152         }
 153
 154         ut_assertok(dm_check_devices(dms, num_devices));
 155
 156         return 0;
 157 }
 158 DM_TEST(dm_test_fdt, 0);
 159
 160 static int dm_test_fdt_pre_reloc(struct dm_test_state *dms)
 161 {
 162         struct uclass *uc;
 163         int ret;
 164
 165         ret = dm_scan_fdt(gd->fdt_blob, true);
 166         ut_assert(!ret);
 167
 168         ret = uclass_get(UCLASS_TEST_FDT, &uc);
 169         ut_assert(!ret);
 170
 171         /* These is only one pre-reloc device */
 172         ut_asserteq(1, list_count_items(&uc->dev_head));
 173
 174         return 0;
 175 }
 176 DM_TEST(dm_test_fdt_pre_reloc, 0);
 177
 178 /* Test that sequence numbers are allocated properly */
 179 static int dm_test_fdt_uclass_seq(struct dm_test_state *dms)
 180 {
 181         struct udevice *dev;
 182
 183         /* A few basic santiy tests */
 184         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev));
 185         ut_asserteq_str("b-test", dev->name);
 186
 187         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 0, true, &dev));
 188         ut_asserteq_str("a-test", dev->name);
 189
 190         ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 5,
 191                                                        true, &dev));
 192         ut_asserteq_ptr(NULL, dev);
 193
 194         /* Test aliases */
 195         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev));
 196         ut_asserteq_str("e-test", dev->name);
 197
 198         ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,
 199                                                        true, &dev));
 200
 201         /*
 202          * Note that c-test nodes are not probed since it is not a top-level
 203          * node
 204          */
 205         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
 206         ut_asserteq_str("b-test", dev->name);
 207
 208         /*
 209          * d-test wants sequence number 3 also, but it can't have it because
 210          * b-test gets it first.
 211          */
 212         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev));
 213         ut_asserteq_str("d-test", dev->name);
 214
 215         /* d-test actually gets 0 */
 216         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 0, &dev));
 217         ut_asserteq_str("d-test", dev->name);
 218
 219         /* initially no one wants seq 1 */
 220         ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_TEST_FDT, 1,
 221                                                       &dev));
 222         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
 223         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 1, &dev));
 224
 225         /* But now that it is probed, we can find it */
 226         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 1, &dev));
 227         ut_asserteq_str("a-test", dev->name);
 228
 229         return 0;
 230 }
 231 DM_TEST(dm_test_fdt_uclass_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 232
 233 /* Test that we can find a device by device tree offset */
 234 static int dm_test_fdt_offset(struct dm_test_state *dms)
 235 {
 236         const void *blob = gd->fdt_blob;
 237         struct udevice *dev;
 238         int node;
 239
 240         node = fdt_path_offset(blob, "/e-test");
 241         ut_assert(node > 0);
 242         ut_assertok(uclass_get_device_by_of_offset(UCLASS_TEST_FDT, node,
 243                                                    &dev));
 244         ut_asserteq_str("e-test", dev->name);
 245
 246         /* This node should not be bound */
 247         node = fdt_path_offset(blob, "/junk");
 248         ut_assert(node > 0);
 249         ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
 250                                                             node, &dev));
 251
 252         /* This is not a top level node so should not be probed */
 253         node = fdt_path_offset(blob, "/some-bus/c-test@5");
 254         ut_assert(node > 0);
 255         ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
 256                                                             node, &dev));
 257
 258         return 0;
 259 }
 260 DM_TEST(dm_test_fdt_offset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);