test-fdt.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2013 Google, Inc
  4. */
  5. #include <common.h>
  6. #include <dm.h>
  7. #include <errno.h>
  8. #include <fdtdec.h>
  9. #include <log.h>
  10. #include <malloc.h>
  11. #include <asm/io.h>
  12. #include <dm/test.h>
  13. #include <dm/root.h>
  14. #include <dm/device-internal.h>
  15. #include <dm/devres.h>
  16. #include <dm/uclass-internal.h>
  17. #include <dm/util.h>
  18. #include <dm/lists.h>
  19. #include <dm/of_access.h>
  20. #include <test/test.h>
  21. #include <test/ut.h>
  22. DECLARE_GLOBAL_DATA_PTR;
  23. static int testfdt_drv_ping(struct udevice *dev, int pingval, int *pingret)
  24. {
  25. const struct dm_test_pdata *pdata = dev->platdata;
  26. struct dm_test_priv *priv = dev_get_priv(dev);
  27. *pingret = pingval + pdata->ping_add;
  28. priv->ping_total += *pingret;
  29. return 0;
  30. }
  31. static const struct test_ops test_ops = {
  32. .ping = testfdt_drv_ping,
  33. };
  34. static int testfdt_ofdata_to_platdata(struct udevice *dev)
  35. {
  36. struct dm_test_pdata *pdata = dev_get_platdata(dev);
  37. pdata->ping_add = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
  38. "ping-add", -1);
  39. pdata->base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),
  40. "ping-expect");
  41. return 0;
  42. }
  43. static int testfdt_drv_probe(struct udevice *dev)
  44. {
  45. struct dm_test_priv *priv = dev_get_priv(dev);
  46. priv->ping_total += DM_TEST_START_TOTAL;
  47. /*
  48. * If this device is on a bus, the uclass_flag will be set before
  49. * calling this function. In the meantime the uclass_postp is
  50. * initlized to a value -1. These are used respectively by
  51. * dm_test_bus_child_pre_probe_uclass() and
  52. * dm_test_bus_child_post_probe_uclass().
  53. */
  54. priv->uclass_total += priv->uclass_flag;
  55. priv->uclass_postp = -1;
  56. return 0;
  57. }
  58. static const struct udevice_id testfdt_ids[] = {
  59. {
  60. .compatible = "denx,u-boot-fdt-test",
  61. .data = DM_TEST_TYPE_FIRST },
  62. {
  63. .compatible = "google,another-fdt-test",
  64. .data = DM_TEST_TYPE_SECOND },
  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. static const struct udevice_id testfdt1_ids[] = {
  78. {
  79. .compatible = "denx,u-boot-fdt-test1",
  80. .data = DM_TEST_TYPE_FIRST },
  81. { }
  82. };
  83. U_BOOT_DRIVER(testfdt1_drv) = {
  84. .name = "testfdt1_drv",
  85. .of_match = testfdt1_ids,
  86. .id = UCLASS_TEST_FDT,
  87. .ofdata_to_platdata = testfdt_ofdata_to_platdata,
  88. .probe = testfdt_drv_probe,
  89. .ops = &test_ops,
  90. .priv_auto_alloc_size = sizeof(struct dm_test_priv),
  91. .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
  92. .flags = DM_FLAG_PRE_RELOC,
  93. };
  94. /* From here is the testfdt uclass code */
  95. int testfdt_ping(struct udevice *dev, int pingval, int *pingret)
  96. {
  97. const struct test_ops *ops = device_get_ops(dev);
  98. if (!ops->ping)
  99. return -ENOSYS;
  100. return ops->ping(dev, pingval, pingret);
  101. }
  102. UCLASS_DRIVER(testfdt) = {
  103. .name = "testfdt",
  104. .id = UCLASS_TEST_FDT,
  105. .flags = DM_UC_FLAG_SEQ_ALIAS,
  106. };
  107. struct dm_testprobe_pdata {
  108. int probe_err;
  109. };
  110. static int testprobe_drv_probe(struct udevice *dev)
  111. {
  112. struct dm_testprobe_pdata *pdata = dev_get_platdata(dev);
  113. return pdata->probe_err;
  114. }
  115. static const struct udevice_id testprobe_ids[] = {
  116. { .compatible = "denx,u-boot-probe-test" },
  117. { }
  118. };
  119. U_BOOT_DRIVER(testprobe_drv) = {
  120. .name = "testprobe_drv",
  121. .of_match = testprobe_ids,
  122. .id = UCLASS_TEST_PROBE,
  123. .probe = testprobe_drv_probe,
  124. .platdata_auto_alloc_size = sizeof(struct dm_testprobe_pdata),
  125. };
  126. UCLASS_DRIVER(testprobe) = {
  127. .name = "testprobe",
  128. .id = UCLASS_TEST_PROBE,
  129. .flags = DM_UC_FLAG_SEQ_ALIAS,
  130. };
  131. struct dm_testdevres_pdata {
  132. void *ptr;
  133. };
  134. struct dm_testdevres_priv {
  135. void *ptr;
  136. void *ptr_ofdata;
  137. };
  138. static int testdevres_drv_bind(struct udevice *dev)
  139. {
  140. struct dm_testdevres_pdata *pdata = dev_get_platdata(dev);
  141. pdata->ptr = devm_kmalloc(dev, TEST_DEVRES_SIZE, 0);
  142. return 0;
  143. }
  144. static int testdevres_drv_ofdata_to_platdata(struct udevice *dev)
  145. {
  146. struct dm_testdevres_priv *priv = dev_get_priv(dev);
  147. priv->ptr_ofdata = devm_kmalloc(dev, TEST_DEVRES_SIZE3, 0);
  148. return 0;
  149. }
  150. static int testdevres_drv_probe(struct udevice *dev)
  151. {
  152. struct dm_testdevres_priv *priv = dev_get_priv(dev);
  153. priv->ptr = devm_kmalloc(dev, TEST_DEVRES_SIZE2, 0);
  154. return 0;
  155. }
  156. static const struct udevice_id testdevres_ids[] = {
  157. { .compatible = "denx,u-boot-devres-test" },
  158. { }
  159. };
  160. U_BOOT_DRIVER(testdevres_drv) = {
  161. .name = "testdevres_drv",
  162. .of_match = testdevres_ids,
  163. .id = UCLASS_TEST_DEVRES,
  164. .bind = testdevres_drv_bind,
  165. .ofdata_to_platdata = testdevres_drv_ofdata_to_platdata,
  166. .probe = testdevres_drv_probe,
  167. .platdata_auto_alloc_size = sizeof(struct dm_testdevres_pdata),
  168. .priv_auto_alloc_size = sizeof(struct dm_testdevres_priv),
  169. };
  170. UCLASS_DRIVER(testdevres) = {
  171. .name = "testdevres",
  172. .id = UCLASS_TEST_DEVRES,
  173. .flags = DM_UC_FLAG_SEQ_ALIAS,
  174. };
  175. int dm_check_devices(struct unit_test_state *uts, int num_devices)
  176. {
  177. struct udevice *dev;
  178. int ret;
  179. int i;
  180. /*
  181. * Now check that the ping adds are what we expect. This is using the
  182. * ping-add property in each node.
  183. */
  184. for (i = 0; i < num_devices; i++) {
  185. uint32_t base;
  186. ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev);
  187. ut_assert(!ret);
  188. /*
  189. * Get the 'ping-expect' property, which tells us what the
  190. * ping add should be. We don't use the platdata because we
  191. * want to test the code that sets that up
  192. * (testfdt_drv_probe()).
  193. */
  194. base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),
  195. "ping-expect");
  196. debug("dev=%d, base=%d: %s\n", i, base,
  197. fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL));
  198. ut_assert(!dm_check_operations(uts, dev, base,
  199. dev_get_priv(dev)));
  200. }
  201. return 0;
  202. }
  203. /* Test that FDT-based binding works correctly */
  204. static int dm_test_fdt(struct unit_test_state *uts)
  205. {
  206. const int num_devices = 8;
  207. struct udevice *dev;
  208. struct uclass *uc;
  209. int ret;
  210. int i;
  211. ret = dm_extended_scan_fdt(gd->fdt_blob, false);
  212. ut_assert(!ret);
  213. ret = uclass_get(UCLASS_TEST_FDT, &uc);
  214. ut_assert(!ret);
  215. /* These are num_devices compatible root-level device tree nodes */
  216. ut_asserteq(num_devices, list_count_items(&uc->dev_head));
  217. /* Each should have platform data but no private data */
  218. for (i = 0; i < num_devices; i++) {
  219. ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev);
  220. ut_assert(!ret);
  221. ut_assert(!dev_get_priv(dev));
  222. ut_assert(dev->platdata);
  223. }
  224. ut_assertok(dm_check_devices(uts, num_devices));
  225. return 0;
  226. }
  227. DM_TEST(dm_test_fdt, 0);
  228. static int dm_test_alias_highest_id(struct unit_test_state *uts)
  229. {
  230. int ret;
  231. ret = dev_read_alias_highest_id("eth");
  232. ut_asserteq(5, ret);
  233. ret = dev_read_alias_highest_id("gpio");
  234. ut_asserteq(3, ret);
  235. ret = dev_read_alias_highest_id("pci");
  236. ut_asserteq(2, ret);
  237. ret = dev_read_alias_highest_id("i2c");
  238. ut_asserteq(0, ret);
  239. ret = dev_read_alias_highest_id("deadbeef");
  240. ut_asserteq(-1, ret);
  241. return 0;
  242. }
  243. DM_TEST(dm_test_alias_highest_id, 0);
  244. static int dm_test_fdt_pre_reloc(struct unit_test_state *uts)
  245. {
  246. struct uclass *uc;
  247. int ret;
  248. ret = dm_scan_fdt(gd->fdt_blob, true);
  249. ut_assert(!ret);
  250. ret = uclass_get(UCLASS_TEST_FDT, &uc);
  251. ut_assert(!ret);
  252. /*
  253. * These are 2 pre-reloc devices:
  254. * one with "u-boot,dm-pre-reloc" property (a-test node), and the other
  255. * one whose driver marked with DM_FLAG_PRE_RELOC flag (h-test node).
  256. */
  257. ut_asserteq(2, list_count_items(&uc->dev_head));
  258. return 0;
  259. }
  260. DM_TEST(dm_test_fdt_pre_reloc, 0);
  261. /* Test that sequence numbers are allocated properly */
  262. static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
  263. {
  264. struct udevice *dev;
  265. /* A few basic santiy tests */
  266. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev));
  267. ut_asserteq_str("b-test", dev->name);
  268. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, true, &dev));
  269. ut_asserteq_str("a-test", dev->name);
  270. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 5,
  271. true, &dev));
  272. ut_asserteq_ptr(NULL, dev);
  273. /* Test aliases */
  274. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev));
  275. ut_asserteq_str("e-test", dev->name);
  276. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,
  277. true, &dev));
  278. /*
  279. * Note that c-test nodes are not probed since it is not a top-level
  280. * node
  281. */
  282. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
  283. ut_asserteq_str("b-test", dev->name);
  284. /*
  285. * d-test wants sequence number 3 also, but it can't have it because
  286. * b-test gets it first.
  287. */
  288. ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev));
  289. ut_asserteq_str("d-test", dev->name);
  290. /*
  291. * d-test actually gets 9, because thats the next free one after the
  292. * aliases.
  293. */
  294. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 9, &dev));
  295. ut_asserteq_str("d-test", dev->name);
  296. /* initially no one wants seq 10 */
  297. ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_TEST_FDT, 10,
  298. &dev));
  299. ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
  300. ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 4, &dev));
  301. /* But now that it is probed, we can find it */
  302. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 10, &dev));
  303. ut_asserteq_str("f-test", dev->name);
  304. /*
  305. * And we should still have holes in our sequence numbers, that is 2
  306. * and 4 should not be used.
  307. */
  308. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 2,
  309. true, &dev));
  310. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 4,
  311. true, &dev));
  312. return 0;
  313. }
  314. DM_TEST(dm_test_fdt_uclass_seq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  315. /* Test that we can find a device by device tree offset */
  316. static int dm_test_fdt_offset(struct unit_test_state *uts)
  317. {
  318. const void *blob = gd->fdt_blob;
  319. struct udevice *dev;
  320. int node;
  321. node = fdt_path_offset(blob, "/e-test");
  322. ut_assert(node > 0);
  323. ut_assertok(uclass_get_device_by_of_offset(UCLASS_TEST_FDT, node,
  324. &dev));
  325. ut_asserteq_str("e-test", dev->name);
  326. /* This node should not be bound */
  327. node = fdt_path_offset(blob, "/junk");
  328. ut_assert(node > 0);
  329. ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
  330. node, &dev));
  331. /* This is not a top level node so should not be probed */
  332. node = fdt_path_offset(blob, "/some-bus/c-test@5");
  333. ut_assert(node > 0);
  334. ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
  335. node, &dev));
  336. return 0;
  337. }
  338. DM_TEST(dm_test_fdt_offset,
  339. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  340. /**
  341. * Test various error conditions with uclass_first_device() and
  342. * uclass_next_device()
  343. */
  344. static int dm_test_first_next_device(struct unit_test_state *uts)
  345. {
  346. struct dm_testprobe_pdata *pdata;
  347. struct udevice *dev, *parent = NULL;
  348. int count;
  349. int ret;
  350. /* There should be 4 devices */
  351. for (ret = uclass_first_device(UCLASS_TEST_PROBE, &dev), count = 0;
  352. dev;
  353. ret = uclass_next_device(&dev)) {
  354. count++;
  355. parent = dev_get_parent(dev);
  356. }
  357. ut_assertok(ret);
  358. ut_asserteq(4, count);
  359. /* Remove them and try again, with an error on the second one */
  360. ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 1, &dev));
  361. pdata = dev_get_platdata(dev);
  362. pdata->probe_err = -ENOMEM;
  363. device_remove(parent, DM_REMOVE_NORMAL);
  364. ut_assertok(uclass_first_device(UCLASS_TEST_PROBE, &dev));
  365. ut_asserteq(-ENOMEM, uclass_next_device(&dev));
  366. ut_asserteq_ptr(dev, NULL);
  367. /* Now an error on the first one */
  368. ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 0, &dev));
  369. pdata = dev_get_platdata(dev);
  370. pdata->probe_err = -ENOENT;
  371. device_remove(parent, DM_REMOVE_NORMAL);
  372. ut_asserteq(-ENOENT, uclass_first_device(UCLASS_TEST_PROBE, &dev));
  373. return 0;
  374. }
  375. DM_TEST(dm_test_first_next_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  376. /* Test iteration through devices in a uclass */
  377. static int dm_test_uclass_foreach(struct unit_test_state *uts)
  378. {
  379. struct udevice *dev;
  380. struct uclass *uc;
  381. int count;
  382. count = 0;
  383. uclass_id_foreach_dev(UCLASS_TEST_FDT, dev, uc)
  384. count++;
  385. ut_asserteq(8, count);
  386. count = 0;
  387. uclass_foreach_dev(dev, uc)
  388. count++;
  389. ut_asserteq(8, count);
  390. return 0;
  391. }
  392. DM_TEST(dm_test_uclass_foreach, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  393. /**
  394. * check_devices() - Check return values and pointers
  395. *
  396. * This runs through a full sequence of uclass_first_device_check()...
  397. * uclass_next_device_check() checking that the return values and devices
  398. * are correct.
  399. *
  400. * @uts: Test state
  401. * @devlist: List of expected devices
  402. * @mask: Indicates which devices should return an error. Device n should
  403. * return error (-NOENT - n) if bit n is set, or no error (i.e. 0) if
  404. * bit n is clear.
  405. */
  406. static int check_devices(struct unit_test_state *uts,
  407. struct udevice *devlist[], int mask)
  408. {
  409. int expected_ret;
  410. struct udevice *dev;
  411. int i;
  412. expected_ret = (mask & 1) ? -ENOENT : 0;
  413. mask >>= 1;
  414. ut_asserteq(expected_ret,
  415. uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
  416. for (i = 0; i < 4; i++) {
  417. ut_asserteq_ptr(devlist[i], dev);
  418. expected_ret = (mask & 1) ? -ENOENT - (i + 1) : 0;
  419. mask >>= 1;
  420. ut_asserteq(expected_ret, uclass_next_device_check(&dev));
  421. }
  422. ut_asserteq_ptr(NULL, dev);
  423. return 0;
  424. }
  425. /* Test uclass_first_device_check() and uclass_next_device_check() */
  426. static int dm_test_first_next_ok_device(struct unit_test_state *uts)
  427. {
  428. struct dm_testprobe_pdata *pdata;
  429. struct udevice *dev, *parent = NULL, *devlist[4];
  430. int count;
  431. int ret;
  432. /* There should be 4 devices */
  433. count = 0;
  434. for (ret = uclass_first_device_check(UCLASS_TEST_PROBE, &dev);
  435. dev;
  436. ret = uclass_next_device_check(&dev)) {
  437. ut_assertok(ret);
  438. devlist[count++] = dev;
  439. parent = dev_get_parent(dev);
  440. }
  441. ut_asserteq(4, count);
  442. ut_assertok(uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
  443. ut_assertok(check_devices(uts, devlist, 0));
  444. /* Remove them and try again, with an error on the second one */
  445. pdata = dev_get_platdata(devlist[1]);
  446. pdata->probe_err = -ENOENT - 1;
  447. device_remove(parent, DM_REMOVE_NORMAL);
  448. ut_assertok(check_devices(uts, devlist, 1 << 1));
  449. /* Now an error on the first one */
  450. pdata = dev_get_platdata(devlist[0]);
  451. pdata->probe_err = -ENOENT - 0;
  452. device_remove(parent, DM_REMOVE_NORMAL);
  453. ut_assertok(check_devices(uts, devlist, 3 << 0));
  454. /* Now errors on all */
  455. pdata = dev_get_platdata(devlist[2]);
  456. pdata->probe_err = -ENOENT - 2;
  457. pdata = dev_get_platdata(devlist[3]);
  458. pdata->probe_err = -ENOENT - 3;
  459. device_remove(parent, DM_REMOVE_NORMAL);
  460. ut_assertok(check_devices(uts, devlist, 0xf << 0));
  461. return 0;
  462. }
  463. DM_TEST(dm_test_first_next_ok_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  464. static const struct udevice_id fdt_dummy_ids[] = {
  465. { .compatible = "denx,u-boot-fdt-dummy", },
  466. { }
  467. };
  468. UCLASS_DRIVER(fdt_dummy) = {
  469. .name = "fdt-dummy",
  470. .id = UCLASS_TEST_DUMMY,
  471. .flags = DM_UC_FLAG_SEQ_ALIAS,
  472. };
  473. U_BOOT_DRIVER(fdt_dummy_drv) = {
  474. .name = "fdt_dummy_drv",
  475. .of_match = fdt_dummy_ids,
  476. .id = UCLASS_TEST_DUMMY,
  477. };
  478. static int dm_test_fdt_translation(struct unit_test_state *uts)
  479. {
  480. struct udevice *dev;
  481. fdt32_t dma_addr[2];
  482. /* Some simple translations */
  483. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  484. ut_asserteq_str("dev@0,0", dev->name);
  485. ut_asserteq(0x8000, dev_read_addr(dev));
  486. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
  487. ut_asserteq_str("dev@1,100", dev->name);
  488. ut_asserteq(0x9000, dev_read_addr(dev));
  489. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, true, &dev));
  490. ut_asserteq_str("dev@2,200", dev->name);
  491. ut_asserteq(0xA000, dev_read_addr(dev));
  492. /* No translation for busses with #size-cells == 0 */
  493. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, true, &dev));
  494. ut_asserteq_str("dev@42", dev->name);
  495. ut_asserteq(0x42, dev_read_addr(dev));
  496. /* dma address translation */
  497. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  498. dma_addr[0] = cpu_to_be32(0);
  499. dma_addr[1] = cpu_to_be32(0);
  500. ut_asserteq(0x10000000, dev_translate_dma_address(dev, dma_addr));
  501. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
  502. dma_addr[0] = cpu_to_be32(1);
  503. dma_addr[1] = cpu_to_be32(0x100);
  504. ut_asserteq(0x20000000, dev_translate_dma_address(dev, dma_addr));
  505. return 0;
  506. }
  507. DM_TEST(dm_test_fdt_translation, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  508. static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
  509. {
  510. struct udevice *dev;
  511. fdt_addr_t addr;
  512. void *paddr;
  513. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  514. addr = devfdt_get_addr(dev);
  515. ut_asserteq(0x8000, addr);
  516. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  517. ut_assertnonnull(paddr);
  518. ut_asserteq_ptr(paddr, devfdt_remap_addr(dev));
  519. return 0;
  520. }
  521. DM_TEST(dm_test_fdt_remap_addr_flat,
  522. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  523. static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
  524. {
  525. struct udevice *dev;
  526. fdt_addr_t addr;
  527. fdt_size_t size;
  528. void *paddr;
  529. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  530. addr = devfdt_get_addr_size_index(dev, 0, &size);
  531. ut_asserteq(0x8000, addr);
  532. ut_asserteq(0x1000, size);
  533. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  534. ut_assertnonnull(paddr);
  535. ut_asserteq_ptr(paddr, devfdt_remap_addr_index(dev, 0));
  536. return 0;
  537. }
  538. DM_TEST(dm_test_fdt_remap_addr_index_flat,
  539. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  540. static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
  541. {
  542. struct udevice *dev;
  543. fdt_addr_t addr;
  544. fdt_size_t size;
  545. void *paddr;
  546. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  547. addr = devfdt_get_addr_size_name(dev, "sandbox-dummy-0", &size);
  548. ut_asserteq(0x8000, addr);
  549. ut_asserteq(0x1000, size);
  550. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  551. ut_assertnonnull(paddr);
  552. ut_asserteq_ptr(paddr, devfdt_remap_addr_name(dev, "sandbox-dummy-0"));
  553. return 0;
  554. }
  555. DM_TEST(dm_test_fdt_remap_addr_name_flat,
  556. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  557. static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
  558. {
  559. struct udevice *dev;
  560. fdt_addr_t addr;
  561. void *paddr;
  562. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  563. addr = dev_read_addr(dev);
  564. ut_asserteq(0x8000, addr);
  565. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  566. ut_assertnonnull(paddr);
  567. ut_asserteq_ptr(paddr, dev_remap_addr(dev));
  568. return 0;
  569. }
  570. DM_TEST(dm_test_fdt_remap_addr_live,
  571. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  572. static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
  573. {
  574. struct udevice *dev;
  575. fdt_addr_t addr;
  576. fdt_size_t size;
  577. void *paddr;
  578. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  579. addr = dev_read_addr_size_index(dev, 0, &size);
  580. ut_asserteq(0x8000, addr);
  581. ut_asserteq(0x1000, size);
  582. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  583. ut_assertnonnull(paddr);
  584. ut_asserteq_ptr(paddr, dev_remap_addr_index(dev, 0));
  585. return 0;
  586. }
  587. DM_TEST(dm_test_fdt_remap_addr_index_live,
  588. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  589. static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
  590. {
  591. struct udevice *dev;
  592. fdt_addr_t addr;
  593. fdt_size_t size;
  594. void *paddr;
  595. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  596. addr = dev_read_addr_size_name(dev, "sandbox-dummy-0", &size);
  597. ut_asserteq(0x8000, addr);
  598. ut_asserteq(0x1000, size);
  599. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  600. ut_assertnonnull(paddr);
  601. ut_asserteq_ptr(paddr, dev_remap_addr_name(dev, "sandbox-dummy-0"));
  602. return 0;
  603. }
  604. DM_TEST(dm_test_fdt_remap_addr_name_live,
  605. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  606. static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
  607. {
  608. struct udevice *dev;
  609. ofnode node;
  610. if (!of_live_active()) {
  611. printf("Live tree not active; ignore test\n");
  612. return 0;
  613. }
  614. /* Test enabling devices */
  615. node = ofnode_path("/usb@2");
  616. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  617. ofnode_set_enabled(node, true);
  618. ut_assert(of_device_is_available(ofnode_to_np(node)));
  619. device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
  620. &dev);
  621. ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, true, &dev));
  622. /* Test string property setting */
  623. ut_assert(device_is_compatible(dev, "sandbox,usb"));
  624. ofnode_write_string(node, "compatible", "gdsys,super-usb");
  625. ut_assert(device_is_compatible(dev, "gdsys,super-usb"));
  626. ofnode_write_string(node, "compatible", "sandbox,usb");
  627. ut_assert(device_is_compatible(dev, "sandbox,usb"));
  628. /* Test setting generic properties */
  629. /* Non-existent in DTB */
  630. ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr(dev));
  631. /* reg = 0x42, size = 0x100 */
  632. ut_assertok(ofnode_write_prop(node, "reg", 8,
  633. "\x00\x00\x00\x42\x00\x00\x01\x00"));
  634. ut_asserteq(0x42, dev_read_addr(dev));
  635. /* Test disabling devices */
  636. device_remove(dev, DM_REMOVE_NORMAL);
  637. device_unbind(dev);
  638. ut_assert(of_device_is_available(ofnode_to_np(node)));
  639. ofnode_set_enabled(node, false);
  640. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  641. return 0;
  642. }
  643. DM_TEST(dm_test_fdt_livetree_writing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  644. static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
  645. {
  646. ofnode node;
  647. if (!of_live_active()) {
  648. printf("Live tree not active; ignore test\n");
  649. return 0;
  650. }
  651. node = ofnode_path("/usb@2");
  652. /* Test enabling devices */
  653. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  654. dev_enable_by_path("/usb@2");
  655. ut_assert(of_device_is_available(ofnode_to_np(node)));
  656. /* Test disabling devices */
  657. ut_assert(of_device_is_available(ofnode_to_np(node)));
  658. dev_disable_by_path("/usb@2");
  659. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  660. return 0;
  661. }
  662. DM_TEST(dm_test_fdt_disable_enable_by_path, UT_TESTF_SCAN_PDATA |
  663. UT_TESTF_SCAN_FDT);
  664. /* Test a few uclass phandle functions */
  665. static int dm_test_fdt_phandle(struct unit_test_state *uts)
  666. {
  667. struct udevice *back, *dev, *dev2;
  668. ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back));
  669. ut_assertnonnull(back);
  670. ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR,
  671. back, "missing", &dev));
  672. ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back,
  673. "power-supply", &dev));
  674. ut_assertnonnull(dev);
  675. ut_asserteq(0, device_active(dev));
  676. ut_asserteq_str("ldo1", dev->name);
  677. ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back,
  678. "power-supply", &dev2));
  679. ut_asserteq_ptr(dev, dev2);
  680. return 0;
  681. }
  682. DM_TEST(dm_test_fdt_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  683. /* Test device_find_first_child_by_uclass() */
  684. static int dm_test_first_child(struct unit_test_state *uts)
  685. {
  686. struct udevice *i2c, *dev, *dev2;
  687. ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
  688. ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev));
  689. ut_asserteq_str("rtc@43", dev->name);
  690. ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2));
  691. ut_asserteq_ptr(dev, dev2);
  692. ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2));
  693. ut_asserteq_str("rtc@61", dev2->name);
  694. ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM,
  695. &dev));
  696. ut_asserteq_str("eeprom@2c", dev->name);
  697. ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2));
  698. ut_asserteq_ptr(dev, dev2);
  699. ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c,
  700. UCLASS_VIDEO, &dev));
  701. ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev));
  702. return 0;
  703. }
  704. DM_TEST(dm_test_first_child, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  705. /* Test integer functions in dm_read_...() */
  706. static int dm_test_read_int(struct unit_test_state *uts)
  707. {
  708. struct udevice *dev;
  709. u32 val32;
  710. s32 sval;
  711. uint val;
  712. u64 val64;
  713. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  714. ut_asserteq_str("a-test", dev->name);
  715. ut_assertok(dev_read_u32(dev, "int-value", &val32));
  716. ut_asserteq(1234, val32);
  717. ut_asserteq(-EINVAL, dev_read_u32(dev, "missing", &val32));
  718. ut_asserteq(6, dev_read_u32_default(dev, "missing", 6));
  719. ut_asserteq(1234, dev_read_u32_default(dev, "int-value", 6));
  720. ut_asserteq(1234, val32);
  721. ut_asserteq(-EINVAL, dev_read_s32(dev, "missing", &sval));
  722. ut_asserteq(6, dev_read_s32_default(dev, "missing", 6));
  723. ut_asserteq(-1234, dev_read_s32_default(dev, "uint-value", 6));
  724. ut_assertok(dev_read_s32(dev, "uint-value", &sval));
  725. ut_asserteq(-1234, sval);
  726. val = 0;
  727. ut_asserteq(-EINVAL, dev_read_u32u(dev, "missing", &val));
  728. ut_assertok(dev_read_u32u(dev, "uint-value", &val));
  729. ut_asserteq(-1234, val);
  730. ut_assertok(dev_read_u64(dev, "int64-value", &val64));
  731. ut_asserteq_64(0x1111222233334444, val64);
  732. ut_asserteq_64(-EINVAL, dev_read_u64(dev, "missing", &val64));
  733. ut_asserteq_64(6, dev_read_u64_default(dev, "missing", 6));
  734. ut_asserteq_64(0x1111222233334444,
  735. dev_read_u64_default(dev, "int64-value", 6));
  736. return 0;
  737. }
  738. DM_TEST(dm_test_read_int, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  739. static int dm_test_read_int_index(struct unit_test_state *uts)
  740. {
  741. struct udevice *dev;
  742. u32 val32;
  743. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  744. ut_asserteq_str("a-test", dev->name);
  745. ut_asserteq(-EINVAL, dev_read_u32_index(dev, "missing", 0, &val32));
  746. ut_asserteq(19, dev_read_u32_index_default(dev, "missing", 0, 19));
  747. ut_assertok(dev_read_u32_index(dev, "int-array", 0, &val32));
  748. ut_asserteq(5678, val32);
  749. ut_assertok(dev_read_u32_index(dev, "int-array", 1, &val32));
  750. ut_asserteq(9123, val32);
  751. ut_assertok(dev_read_u32_index(dev, "int-array", 2, &val32));
  752. ut_asserteq(4567, val32);
  753. ut_asserteq(-EOVERFLOW, dev_read_u32_index(dev, "int-array", 3,
  754. &val32));
  755. ut_asserteq(5678, dev_read_u32_index_default(dev, "int-array", 0, 2));
  756. ut_asserteq(9123, dev_read_u32_index_default(dev, "int-array", 1, 2));
  757. ut_asserteq(4567, dev_read_u32_index_default(dev, "int-array", 2, 2));
  758. ut_asserteq(2, dev_read_u32_index_default(dev, "int-array", 3, 2));
  759. return 0;
  760. }
  761. DM_TEST(dm_test_read_int_index, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  762. /* Test iteration through devices by drvdata */
  763. static int dm_test_uclass_drvdata(struct unit_test_state *uts)
  764. {
  765. struct udevice *dev;
  766. ut_assertok(uclass_first_device_drvdata(UCLASS_TEST_FDT,
  767. DM_TEST_TYPE_FIRST, &dev));
  768. ut_asserteq_str("a-test", dev->name);
  769. ut_assertok(uclass_first_device_drvdata(UCLASS_TEST_FDT,
  770. DM_TEST_TYPE_SECOND, &dev));
  771. ut_asserteq_str("d-test", dev->name);
  772. ut_asserteq(-ENODEV, uclass_first_device_drvdata(UCLASS_TEST_FDT,
  773. DM_TEST_TYPE_COUNT,
  774. &dev));
  775. return 0;
  776. }
  777. DM_TEST(dm_test_uclass_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  778. /* Test device_first_child_ofdata_err(), etc. */
  779. static int dm_test_child_ofdata(struct unit_test_state *uts)
  780. {
  781. struct udevice *bus, *dev;
  782. int count;
  783. ut_assertok(uclass_first_device_err(UCLASS_TEST_BUS, &bus));
  784. count = 0;
  785. device_foreach_child_ofdata_to_platdata(dev, bus) {
  786. ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
  787. ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
  788. count++;
  789. }
  790. ut_asserteq(3, count);
  791. return 0;
  792. }
  793. DM_TEST(dm_test_child_ofdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  794. /* Test device_first_child_err(), etc. */
  795. static int dm_test_first_child_probe(struct unit_test_state *uts)
  796. {
  797. struct udevice *bus, *dev;
  798. int count;
  799. ut_assertok(uclass_first_device_err(UCLASS_TEST_BUS, &bus));
  800. count = 0;
  801. device_foreach_child_probe(dev, bus) {
  802. ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
  803. ut_assert(dev->flags & DM_FLAG_ACTIVATED);
  804. count++;
  805. }
  806. ut_asserteq(3, count);
  807. return 0;
  808. }
  809. DM_TEST(dm_test_first_child_probe, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  810. /* Test that ofdata is read for parents before children */
  811. static int dm_test_ofdata_order(struct unit_test_state *uts)
  812. {
  813. struct udevice *bus, *dev;
  814. ut_assertok(uclass_find_first_device(UCLASS_I2C, &bus));
  815. ut_assertnonnull(bus);
  816. ut_assert(!(bus->flags & DM_FLAG_PLATDATA_VALID));
  817. ut_assertok(device_find_first_child(bus, &dev));
  818. ut_assertnonnull(dev);
  819. ut_assert(!(dev->flags & DM_FLAG_PLATDATA_VALID));
  820. /* read the child's ofdata which should cause the parent's to be read */
  821. ut_assertok(device_ofdata_to_platdata(dev));
  822. ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
  823. ut_assert(bus->flags & DM_FLAG_PLATDATA_VALID);
  824. ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
  825. ut_assert(!(bus->flags & DM_FLAG_ACTIVATED));
  826. return 0;
  827. }
  828. DM_TEST(dm_test_ofdata_order, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);