test/dm/of_platdata.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 #include <common.h>
   4 #include <clk.h>
   5 #include <dm.h>
   6 #include <dt-structs.h>
   7 #include <irq.h>
   8 #include <dm/test.h>
   9 #include <test/test.h>
  10 #include <test/ut.h>
  11 #include <asm-generic/gpio.h>
  12 #include <asm/global_data.h>
  13
  14 /* Test that we can find a device using of-platdata */
  15 static int dm_test_of_plat_base(struct unit_test_state *uts)
  16 {
  17         struct udevice *dev;
  18
  19         ut_assertok(uclass_first_device_err(UCLASS_SERIAL, &dev));
  20         ut_asserteq_str("sandbox_serial", dev->name);
  21
  22         return 0;
  23 }
  24 DM_TEST(dm_test_of_plat_base, UT_TESTF_SCAN_PDATA);
  25
  26 /* Test that we can read properties from a device */
  27 static int dm_test_of_plat_props(struct unit_test_state *uts)
  28 {
  29         struct dtd_sandbox_spl_test *plat;
  30         struct udevice *dev;
  31         int i;
  32
  33         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_spl_test",
  34                                               &dev));
  35
  36         plat = dev_get_plat(dev);
  37         ut_assert(plat->boolval);
  38         ut_asserteq(1, plat->intval);
  39         ut_asserteq(3, ARRAY_SIZE(plat->intarray));
  40         ut_asserteq(2, plat->intarray[0]);
  41         ut_asserteq(3, plat->intarray[1]);
  42         ut_asserteq(4, plat->intarray[2]);
  43         ut_asserteq(5, plat->byteval);
  44         ut_asserteq(1, ARRAY_SIZE(plat->maybe_empty_int));
  45         ut_asserteq(0, plat->maybe_empty_int[0]);
  46         ut_asserteq(3, ARRAY_SIZE(plat->bytearray));
  47         ut_asserteq(6, plat->bytearray[0]);
  48         ut_asserteq(0, plat->bytearray[1]);
  49         ut_asserteq(0, plat->bytearray[2]);
  50         ut_asserteq(9, ARRAY_SIZE(plat->longbytearray));
  51         for (i = 0; i < ARRAY_SIZE(plat->longbytearray); i++)
  52                 ut_asserteq(9 + i, plat->longbytearray[i]);
  53         ut_asserteq_str("message", plat->stringval);
  54         ut_asserteq(3, ARRAY_SIZE(plat->stringarray));
  55         ut_asserteq_str("multi-word", plat->stringarray[0]);
  56         ut_asserteq_str("message", plat->stringarray[1]);
  57         ut_asserteq_str("", plat->stringarray[2]);
  58
  59         ut_assertok(uclass_next_device_err(&dev));
  60         plat = dev_get_plat(dev);
  61         ut_assert(!plat->boolval);
  62         ut_asserteq(3, plat->intval);
  63         ut_asserteq(5, plat->intarray[0]);
  64         ut_asserteq(0, plat->intarray[1]);
  65         ut_asserteq(0, plat->intarray[2]);
  66         ut_asserteq(8, plat->byteval);
  67         ut_asserteq(3, ARRAY_SIZE(plat->bytearray));
  68         ut_asserteq(1, plat->bytearray[0]);
  69         ut_asserteq(0x23, plat->bytearray[1]);
  70         ut_asserteq(0x34, plat->bytearray[2]);
  71         for (i = 0; i < ARRAY_SIZE(plat->longbytearray); i++)
  72                 ut_asserteq(i < 4 ? 9 + i : 0, plat->longbytearray[i]);
  73         ut_asserteq_str("message2", plat->stringval);
  74         ut_asserteq_str("another", plat->stringarray[0]);
  75         ut_asserteq_str("multi-word", plat->stringarray[1]);
  76         ut_asserteq_str("message", plat->stringarray[2]);
  77
  78         ut_assertok(uclass_next_device_err(&dev));
  79         plat = dev_get_plat(dev);
  80         ut_assert(!plat->boolval);
  81         ut_asserteq_str("one", plat->stringarray[0]);
  82         ut_asserteq_str("", plat->stringarray[1]);
  83         ut_asserteq_str("", plat->stringarray[2]);
  84         ut_asserteq(1, plat->maybe_empty_int[0]);
  85
  86         ut_assertok(uclass_next_device_err(&dev));
  87         plat = dev_get_plat(dev);
  88         ut_assert(!plat->boolval);
  89         ut_asserteq_str("spl", plat->stringarray[0]);
  90
  91         ut_asserteq(-ENODEV, uclass_next_device_err(&dev));
  92
  93         return 0;
  94 }
  95 DM_TEST(dm_test_of_plat_props, UT_TESTF_SCAN_PDATA);
  96
  97 /*
  98  * find_driver_info - recursively find the driver_info for a device
  99  *
 100  * This sets found[idx] to true when it finds the driver_info record for a
 101  * device, where idx is the index in the driver_info linker list.
 102  *
 103  * @uts: Test state
 104  * @parent: Parent to search
 105  * @found: bool array to update
 106  * Return: 0 if OK, non-zero on error
 107  */
 108 static int find_driver_info(struct unit_test_state *uts, struct udevice *parent,
 109                             bool found[])
 110 {
 111         struct udevice *dev;
 112
 113         /* If not the root device, find the entry that caused it to be bound */
 114         if (parent->parent) {
 115                 const int n_ents =
 116                         ll_entry_count(struct driver_info, driver_info);
 117                 int idx = -1;
 118                 int i;
 119
 120                 for (i = 0; i < n_ents; i++) {
 121                         const struct driver_rt *drt = gd_dm_driver_rt() + i;
 122
 123                         if (drt->dev == parent) {
 124                                 idx = i;
 125                                 found[idx] = true;
 126                                 break;
 127                         }
 128                 }
 129
 130                 ut_assert(idx != -1);
 131         }
 132
 133         device_foreach_child(dev, parent) {
 134                 int ret;
 135
 136                 ret = find_driver_info(uts, dev, found);
 137                 if (ret < 0)
 138                         return ret;
 139         }
 140
 141         return 0;
 142 }
 143
 144 /* Check that every device is recorded in its driver_info struct */
 145 static int dm_test_of_plat_dev(struct unit_test_state *uts)
 146 {
 147         const int n_ents = ll_entry_count(struct driver_info, driver_info);
 148         bool found[n_ents];
 149         uint i;
 150
 151         /* Skip this test if there is no platform data */
 152         if (!CONFIG_IS_ENABLED(OF_PLATDATA_DRIVER_RT))
 153                 return 0;
 154
 155         /* Record the indexes that are found */
 156         memset(found, '\0', sizeof(found));
 157         ut_assertok(find_driver_info(uts, gd->dm_root, found));
 158
 159         /* Make sure that the driver entries without devices have no ->dev */
 160         for (i = 0; i < n_ents; i++) {
 161                 const struct driver_rt *drt = gd_dm_driver_rt() + i;
 162                 struct udevice *dev;
 163
 164                 if (found[i]) {
 165                         /* Make sure we can find it */
 166                         ut_assertnonnull(drt->dev);
 167                         ut_assertok(device_get_by_ofplat_idx(i, &dev));
 168                         ut_asserteq_ptr(dev, drt->dev);
 169                 } else {
 170                         ut_assertnull(drt->dev);
 171                         ut_asserteq(-ENOENT, device_get_by_ofplat_idx(i, &dev));
 172                 }
 173         }
 174
 175         return 0;
 176 }
 177 DM_TEST(dm_test_of_plat_dev, UT_TESTF_SCAN_PDATA);
 178
 179 /* Test handling of phandles that point to other devices */
 180 static int dm_test_of_plat_phandle(struct unit_test_state *uts)
 181 {
 182         struct dtd_sandbox_clk_test *plat;
 183         struct udevice *dev, *clk;
 184
 185         ut_assertok(uclass_first_device_err(UCLASS_MISC, &dev));
 186         ut_asserteq_str("sandbox_clk_test", dev->name);
 187         plat = dev_get_plat(dev);
 188
 189         ut_assertok(device_get_by_ofplat_idx(plat->clocks[0].idx, &clk));
 190         ut_asserteq_str("sandbox_fixed_clock", clk->name);
 191
 192         ut_assertok(device_get_by_ofplat_idx(plat->clocks[1].idx, &clk));
 193         ut_asserteq_str("sandbox_clk", clk->name);
 194         ut_asserteq(1, plat->clocks[1].arg[0]);
 195
 196         ut_assertok(device_get_by_ofplat_idx(plat->clocks[2].idx, &clk));
 197         ut_asserteq_str("sandbox_clk", clk->name);
 198         ut_asserteq(0, plat->clocks[2].arg[0]);
 199
 200         ut_assertok(device_get_by_ofplat_idx(plat->clocks[3].idx, &clk));
 201         ut_asserteq_str("sandbox_clk", clk->name);
 202         ut_asserteq(3, plat->clocks[3].arg[0]);
 203
 204         ut_assertok(device_get_by_ofplat_idx(plat->clocks[4].idx, &clk));
 205         ut_asserteq_str("sandbox_clk", clk->name);
 206         ut_asserteq(2, plat->clocks[4].arg[0]);
 207
 208         return 0;
 209 }
 210 DM_TEST(dm_test_of_plat_phandle, UT_TESTF_SCAN_PDATA);
 211
 212 #if CONFIG_IS_ENABLED(OF_PLATDATA_PARENT)
 213 /* Test that device parents are correctly set up */
 214 static int dm_test_of_plat_parent(struct unit_test_state *uts)
 215 {
 216         struct udevice *rtc, *i2c;
 217
 218         ut_assertok(uclass_first_device_err(UCLASS_RTC, &rtc));
 219         ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
 220         ut_asserteq_ptr(i2c, dev_get_parent(rtc));
 221
 222         return 0;
 223 }
 224 DM_TEST(dm_test_of_plat_parent, UT_TESTF_SCAN_PDATA);
 225 #endif
 226
 227 /* Test clocks with of-platdata */
 228 static int dm_test_of_plat_clk(struct unit_test_state *uts)
 229 {
 230         struct dtd_sandbox_clk_test *plat;
 231         struct udevice *dev;
 232         struct clk clk;
 233
 234         ut_assertok(uclass_first_device_err(UCLASS_MISC, &dev));
 235         ut_asserteq_str("sandbox_clk_test", dev->name);
 236         plat = dev_get_plat(dev);
 237
 238         ut_assertok(clk_get_by_phandle(dev, &plat->clocks[0], &clk));
 239         ut_asserteq_str("sandbox_fixed_clock", clk.dev->name);
 240
 241         return 0;
 242 }
 243 DM_TEST(dm_test_of_plat_clk, UT_TESTF_SCAN_PDATA);
 244
 245 /* Test irqs with of-platdata */
 246 static int dm_test_of_plat_irq(struct unit_test_state *uts)
 247 {
 248         struct dtd_sandbox_irq_test *plat;
 249         struct udevice *dev;
 250         struct irq irq;
 251
 252         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_irq_test",
 253                                               &dev));
 254         plat = dev_get_plat(dev);
 255
 256         ut_assertok(irq_get_by_phandle(dev, &plat->interrupts_extended[0],
 257                                        &irq));
 258         ut_asserteq_str("sandbox_irq", irq.dev->name);
 259
 260         return 0;
 261 }
 262 DM_TEST(dm_test_of_plat_irq, UT_TESTF_SCAN_PDATA);
 263
 264 /* Test GPIOs with of-platdata */
 265 static int dm_test_of_plat_gpio(struct unit_test_state *uts)
 266 {
 267         struct dtd_sandbox_gpio_test *plat;
 268         struct udevice *dev;
 269         struct gpio_desc desc;
 270
 271         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "sandbox_gpio_test",
 272                                               &dev));
 273         plat = dev_get_plat(dev);
 274
 275         ut_assertok(gpio_request_by_phandle(dev, &plat->test_gpios[0], &desc,
 276                                             GPIOD_IS_OUT));
 277         ut_asserteq_str("sandbox_gpio", desc.dev->name);
 278
 279         return 0;
 280 }
 281 DM_TEST(dm_test_of_plat_gpio, UT_TESTF_SCAN_PDATA);