test-fdt.c 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200
  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/global_data.h>
  12. #include <asm/io.h>
  13. #include <dm/test.h>
  14. #include <dm/root.h>
  15. #include <dm/device-internal.h>
  16. #include <dm/devres.h>
  17. #include <dm/uclass-internal.h>
  18. #include <dm/util.h>
  19. #include <dm/lists.h>
  20. #include <dm/of_access.h>
  21. #include <linux/ioport.h>
  22. #include <test/test.h>
  23. #include <test/ut.h>
  24. DECLARE_GLOBAL_DATA_PTR;
  25. struct dm_testprobe_pdata {
  26. int probe_err;
  27. };
  28. static int testprobe_drv_probe(struct udevice *dev)
  29. {
  30. struct dm_testprobe_pdata *pdata = dev_get_plat(dev);
  31. return pdata->probe_err;
  32. }
  33. static const struct udevice_id testprobe_ids[] = {
  34. { .compatible = "denx,u-boot-probe-test" },
  35. { }
  36. };
  37. U_BOOT_DRIVER(testprobe_drv) = {
  38. .name = "testprobe_drv",
  39. .of_match = testprobe_ids,
  40. .id = UCLASS_TEST_PROBE,
  41. .probe = testprobe_drv_probe,
  42. .plat_auto = sizeof(struct dm_testprobe_pdata),
  43. };
  44. UCLASS_DRIVER(testprobe) = {
  45. .name = "testprobe",
  46. .id = UCLASS_TEST_PROBE,
  47. .flags = DM_UC_FLAG_SEQ_ALIAS,
  48. };
  49. struct dm_testdevres_pdata {
  50. void *ptr;
  51. };
  52. struct dm_testdevres_priv {
  53. void *ptr;
  54. void *ptr_ofdata;
  55. };
  56. static int testdevres_drv_bind(struct udevice *dev)
  57. {
  58. struct dm_testdevres_pdata *pdata = dev_get_plat(dev);
  59. pdata->ptr = devm_kmalloc(dev, TEST_DEVRES_SIZE, 0);
  60. return 0;
  61. }
  62. static int testdevres_drv_of_to_plat(struct udevice *dev)
  63. {
  64. struct dm_testdevres_priv *priv = dev_get_priv(dev);
  65. priv->ptr_ofdata = devm_kmalloc(dev, TEST_DEVRES_SIZE3, 0);
  66. return 0;
  67. }
  68. static int testdevres_drv_probe(struct udevice *dev)
  69. {
  70. struct dm_testdevres_priv *priv = dev_get_priv(dev);
  71. priv->ptr = devm_kmalloc(dev, TEST_DEVRES_SIZE2, 0);
  72. return 0;
  73. }
  74. static const struct udevice_id testdevres_ids[] = {
  75. { .compatible = "denx,u-boot-devres-test" },
  76. { }
  77. };
  78. U_BOOT_DRIVER(testdevres_drv) = {
  79. .name = "testdevres_drv",
  80. .of_match = testdevres_ids,
  81. .id = UCLASS_TEST_DEVRES,
  82. .bind = testdevres_drv_bind,
  83. .of_to_plat = testdevres_drv_of_to_plat,
  84. .probe = testdevres_drv_probe,
  85. .plat_auto = sizeof(struct dm_testdevres_pdata),
  86. .priv_auto = sizeof(struct dm_testdevres_priv),
  87. };
  88. UCLASS_DRIVER(testdevres) = {
  89. .name = "testdevres",
  90. .id = UCLASS_TEST_DEVRES,
  91. .flags = DM_UC_FLAG_SEQ_ALIAS,
  92. };
  93. int dm_check_devices(struct unit_test_state *uts, int num_devices)
  94. {
  95. struct udevice *dev;
  96. int ret;
  97. int i;
  98. /*
  99. * Now check that the ping adds are what we expect. This is using the
  100. * ping-add property in each node.
  101. */
  102. for (i = 0; i < num_devices; i++) {
  103. uint32_t base;
  104. ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev);
  105. ut_assert(!ret);
  106. /*
  107. * Get the 'ping-expect' property, which tells us what the
  108. * ping add should be. We don't use the plat because we
  109. * want to test the code that sets that up
  110. * (testfdt_drv_probe()).
  111. */
  112. base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),
  113. "ping-expect");
  114. debug("dev=%d, base=%d: %s\n", i, base,
  115. fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL));
  116. ut_assert(!dm_check_operations(uts, dev, base,
  117. dev_get_priv(dev)));
  118. }
  119. return 0;
  120. }
  121. /* Test that FDT-based binding works correctly */
  122. static int dm_test_fdt(struct unit_test_state *uts)
  123. {
  124. const int num_devices = 9;
  125. struct udevice *dev;
  126. struct uclass *uc;
  127. int ret;
  128. int i;
  129. ret = dm_extended_scan(false);
  130. ut_assert(!ret);
  131. ret = uclass_get(UCLASS_TEST_FDT, &uc);
  132. ut_assert(!ret);
  133. /* These are num_devices compatible root-level device tree nodes */
  134. ut_asserteq(num_devices, list_count_items(&uc->dev_head));
  135. /* Each should have platform data but no private data */
  136. for (i = 0; i < num_devices; i++) {
  137. ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev);
  138. ut_assert(!ret);
  139. ut_assert(!dev_get_priv(dev));
  140. ut_assert(dev_get_plat(dev));
  141. }
  142. ut_assertok(dm_check_devices(uts, num_devices));
  143. return 0;
  144. }
  145. DM_TEST(dm_test_fdt, 0);
  146. static int dm_test_alias_highest_id(struct unit_test_state *uts)
  147. {
  148. int ret;
  149. ret = dev_read_alias_highest_id("ethernet");
  150. ut_asserteq(5, ret);
  151. ret = dev_read_alias_highest_id("gpio");
  152. ut_asserteq(3, ret);
  153. ret = dev_read_alias_highest_id("pci");
  154. ut_asserteq(2, ret);
  155. ret = dev_read_alias_highest_id("i2c");
  156. ut_asserteq(0, ret);
  157. ret = dev_read_alias_highest_id("deadbeef");
  158. ut_asserteq(-1, ret);
  159. return 0;
  160. }
  161. DM_TEST(dm_test_alias_highest_id, 0);
  162. static int dm_test_fdt_pre_reloc(struct unit_test_state *uts)
  163. {
  164. struct uclass *uc;
  165. int ret;
  166. ret = dm_scan_fdt(true);
  167. ut_assert(!ret);
  168. ret = uclass_get(UCLASS_TEST_FDT, &uc);
  169. ut_assert(!ret);
  170. /*
  171. * These are 2 pre-reloc devices:
  172. * one with "u-boot,dm-pre-reloc" property (a-test node), and the other
  173. * one whose driver marked with DM_FLAG_PRE_RELOC flag (h-test node).
  174. */
  175. ut_asserteq(2, list_count_items(&uc->dev_head));
  176. return 0;
  177. }
  178. DM_TEST(dm_test_fdt_pre_reloc, 0);
  179. /* Test that sequence numbers are allocated properly */
  180. static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
  181. {
  182. struct udevice *dev;
  183. /* A few basic santiy tests */
  184. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
  185. ut_asserteq_str("b-test", dev->name);
  186. ut_asserteq(3, dev_seq(dev));
  187. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, &dev));
  188. ut_asserteq_str("a-test", dev->name);
  189. ut_asserteq(8, dev_seq(dev));
  190. /*
  191. * This device has no alias so gets the next value after all available
  192. * aliases. The last alias is testfdt12
  193. */
  194. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 13, &dev));
  195. ut_asserteq_str("d-test", dev->name);
  196. ut_asserteq(13, dev_seq(dev));
  197. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 9,
  198. &dev));
  199. ut_asserteq_ptr(NULL, dev);
  200. /* Test aliases */
  201. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev));
  202. ut_asserteq_str("e-test", dev->name);
  203. ut_asserteq(6, dev_seq(dev));
  204. /*
  205. * Note that c-test nodes are not probed since it is not a top-level
  206. * node
  207. */
  208. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
  209. ut_asserteq_str("b-test", dev->name);
  210. ut_asserteq(3, dev_seq(dev));
  211. /*
  212. * d-test wants sequence number 3 also, but it can't have it because
  213. * b-test gets it first.
  214. */
  215. ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev));
  216. ut_asserteq_str("d-test", dev->name);
  217. ut_asserteq(13, dev_seq(dev));
  218. /* g-test gets the next value after f-test */
  219. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 15, &dev));
  220. ut_asserteq_str("g-test", dev->name);
  221. ut_asserteq(15, dev_seq(dev));
  222. /* And we should still have holes in our sequence numbers */
  223. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 0,
  224. &dev));
  225. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 1,
  226. &dev));
  227. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 2,
  228. &dev));
  229. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 4,
  230. &dev));
  231. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,
  232. &dev));
  233. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 9,
  234. &dev));
  235. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 10,
  236. &dev));
  237. ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 11,
  238. &dev));
  239. return 0;
  240. }
  241. DM_TEST(dm_test_fdt_uclass_seq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  242. /* More tests for sequence numbers */
  243. static int dm_test_fdt_uclass_seq_manual(struct unit_test_state *uts)
  244. {
  245. struct udevice *dev;
  246. /*
  247. * Since DM_UC_FLAG_NO_AUTO_SEQ is set for this uclass, only testfdtm1
  248. * should get a sequence number assigned
  249. */
  250. ut_assertok(uclass_get_device(UCLASS_TEST_FDT_MANUAL, 0, &dev));
  251. ut_asserteq_str("testfdtm0", dev->name);
  252. ut_asserteq(-1, dev_seq(dev));
  253. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT_MANUAL, 1, &dev));
  254. ut_asserteq_str("testfdtm1", dev->name);
  255. ut_asserteq(1, dev_seq(dev));
  256. ut_assertok(uclass_get_device(UCLASS_TEST_FDT_MANUAL, 2, &dev));
  257. ut_asserteq_str("testfdtm2", dev->name);
  258. ut_asserteq(-1, dev_seq(dev));
  259. return 0;
  260. }
  261. DM_TEST(dm_test_fdt_uclass_seq_manual, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  262. static int dm_test_fdt_uclass_seq_more(struct unit_test_state *uts)
  263. {
  264. struct udevice *dev;
  265. ofnode node;
  266. /* Check creating a device with an alias */
  267. node = ofnode_path("/some-bus/c-test@1");
  268. ut_assertok(device_bind(dm_root(), DM_DRIVER_GET(denx_u_boot_fdt_test),
  269. "c-test@1", NULL, node, &dev));
  270. ut_asserteq(12, dev_seq(dev));
  271. ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 12, &dev));
  272. ut_asserteq_str("c-test@1", dev->name);
  273. /*
  274. * Now bind a device without an alias. It should not get the next
  275. * sequence number after all aliases, and existing bound devices. The
  276. * last alias is 12, so we have:
  277. *
  278. * 13 d-test
  279. * 14 f-test
  280. * 15 g-test
  281. * 16 h-test
  282. * 17 another-test
  283. * 18 chosen-test
  284. *
  285. * So next available is 19
  286. */
  287. ut_assertok(device_bind(dm_root(), DM_DRIVER_GET(denx_u_boot_fdt_test),
  288. "fred", NULL, ofnode_null(), &dev));
  289. ut_asserteq(19, dev_seq(dev));
  290. ut_assertok(device_bind(dm_root(), DM_DRIVER_GET(denx_u_boot_fdt_test),
  291. "fred2", NULL, ofnode_null(), &dev));
  292. ut_asserteq(20, dev_seq(dev));
  293. return 0;
  294. }
  295. DM_TEST(dm_test_fdt_uclass_seq_more, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  296. /* Test that we can find a device by device tree offset */
  297. static int dm_test_fdt_offset(struct unit_test_state *uts)
  298. {
  299. const void *blob = gd->fdt_blob;
  300. struct udevice *dev;
  301. int node;
  302. node = fdt_path_offset(blob, "/e-test");
  303. ut_assert(node > 0);
  304. ut_assertok(uclass_get_device_by_of_offset(UCLASS_TEST_FDT, node,
  305. &dev));
  306. ut_asserteq_str("e-test", dev->name);
  307. /* This node should not be bound */
  308. node = fdt_path_offset(blob, "/junk");
  309. ut_assert(node > 0);
  310. ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
  311. node, &dev));
  312. /* This is not a top level node so should not be probed */
  313. node = fdt_path_offset(blob, "/some-bus/c-test@5");
  314. ut_assert(node > 0);
  315. ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
  316. node, &dev));
  317. return 0;
  318. }
  319. DM_TEST(dm_test_fdt_offset,
  320. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  321. /**
  322. * Test various error conditions with uclass_first_device() and
  323. * uclass_next_device()
  324. */
  325. static int dm_test_first_next_device(struct unit_test_state *uts)
  326. {
  327. struct dm_testprobe_pdata *pdata;
  328. struct udevice *dev, *parent = NULL;
  329. int count;
  330. int ret;
  331. /* There should be 4 devices */
  332. for (ret = uclass_first_device(UCLASS_TEST_PROBE, &dev), count = 0;
  333. dev;
  334. ret = uclass_next_device(&dev)) {
  335. count++;
  336. parent = dev_get_parent(dev);
  337. }
  338. ut_assertok(ret);
  339. ut_asserteq(4, count);
  340. /* Remove them and try again, with an error on the second one */
  341. ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 1, &dev));
  342. pdata = dev_get_plat(dev);
  343. pdata->probe_err = -ENOMEM;
  344. device_remove(parent, DM_REMOVE_NORMAL);
  345. ut_assertok(uclass_first_device(UCLASS_TEST_PROBE, &dev));
  346. ut_asserteq(-ENOMEM, uclass_next_device(&dev));
  347. ut_asserteq_ptr(dev, NULL);
  348. /* Now an error on the first one */
  349. ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 0, &dev));
  350. pdata = dev_get_plat(dev);
  351. pdata->probe_err = -ENOENT;
  352. device_remove(parent, DM_REMOVE_NORMAL);
  353. ut_asserteq(-ENOENT, uclass_first_device(UCLASS_TEST_PROBE, &dev));
  354. return 0;
  355. }
  356. DM_TEST(dm_test_first_next_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  357. /* Test iteration through devices in a uclass */
  358. static int dm_test_uclass_foreach(struct unit_test_state *uts)
  359. {
  360. struct udevice *dev;
  361. struct uclass *uc;
  362. int count;
  363. count = 0;
  364. uclass_id_foreach_dev(UCLASS_TEST_FDT, dev, uc)
  365. count++;
  366. ut_asserteq(9, count);
  367. count = 0;
  368. uclass_foreach_dev(dev, uc)
  369. count++;
  370. ut_asserteq(9, count);
  371. return 0;
  372. }
  373. DM_TEST(dm_test_uclass_foreach, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  374. /**
  375. * check_devices() - Check return values and pointers
  376. *
  377. * This runs through a full sequence of uclass_first_device_check()...
  378. * uclass_next_device_check() checking that the return values and devices
  379. * are correct.
  380. *
  381. * @uts: Test state
  382. * @devlist: List of expected devices
  383. * @mask: Indicates which devices should return an error. Device n should
  384. * return error (-NOENT - n) if bit n is set, or no error (i.e. 0) if
  385. * bit n is clear.
  386. */
  387. static int check_devices(struct unit_test_state *uts,
  388. struct udevice *devlist[], int mask)
  389. {
  390. int expected_ret;
  391. struct udevice *dev;
  392. int i;
  393. expected_ret = (mask & 1) ? -ENOENT : 0;
  394. mask >>= 1;
  395. ut_asserteq(expected_ret,
  396. uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
  397. for (i = 0; i < 4; i++) {
  398. ut_asserteq_ptr(devlist[i], dev);
  399. expected_ret = (mask & 1) ? -ENOENT - (i + 1) : 0;
  400. mask >>= 1;
  401. ut_asserteq(expected_ret, uclass_next_device_check(&dev));
  402. }
  403. ut_asserteq_ptr(NULL, dev);
  404. return 0;
  405. }
  406. /* Test uclass_first_device_check() and uclass_next_device_check() */
  407. static int dm_test_first_next_ok_device(struct unit_test_state *uts)
  408. {
  409. struct dm_testprobe_pdata *pdata;
  410. struct udevice *dev, *parent = NULL, *devlist[4];
  411. int count;
  412. int ret;
  413. /* There should be 4 devices */
  414. count = 0;
  415. for (ret = uclass_first_device_check(UCLASS_TEST_PROBE, &dev);
  416. dev;
  417. ret = uclass_next_device_check(&dev)) {
  418. ut_assertok(ret);
  419. devlist[count++] = dev;
  420. parent = dev_get_parent(dev);
  421. }
  422. ut_asserteq(4, count);
  423. ut_assertok(uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
  424. ut_assertok(check_devices(uts, devlist, 0));
  425. /* Remove them and try again, with an error on the second one */
  426. pdata = dev_get_plat(devlist[1]);
  427. pdata->probe_err = -ENOENT - 1;
  428. device_remove(parent, DM_REMOVE_NORMAL);
  429. ut_assertok(check_devices(uts, devlist, 1 << 1));
  430. /* Now an error on the first one */
  431. pdata = dev_get_plat(devlist[0]);
  432. pdata->probe_err = -ENOENT - 0;
  433. device_remove(parent, DM_REMOVE_NORMAL);
  434. ut_assertok(check_devices(uts, devlist, 3 << 0));
  435. /* Now errors on all */
  436. pdata = dev_get_plat(devlist[2]);
  437. pdata->probe_err = -ENOENT - 2;
  438. pdata = dev_get_plat(devlist[3]);
  439. pdata->probe_err = -ENOENT - 3;
  440. device_remove(parent, DM_REMOVE_NORMAL);
  441. ut_assertok(check_devices(uts, devlist, 0xf << 0));
  442. return 0;
  443. }
  444. DM_TEST(dm_test_first_next_ok_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  445. static const struct udevice_id fdt_dummy_ids[] = {
  446. { .compatible = "denx,u-boot-fdt-dummy", },
  447. { }
  448. };
  449. UCLASS_DRIVER(fdt_dummy) = {
  450. .name = "fdt-dummy",
  451. .id = UCLASS_TEST_DUMMY,
  452. .flags = DM_UC_FLAG_SEQ_ALIAS,
  453. };
  454. U_BOOT_DRIVER(fdt_dummy_drv) = {
  455. .name = "fdt_dummy_drv",
  456. .of_match = fdt_dummy_ids,
  457. .id = UCLASS_TEST_DUMMY,
  458. };
  459. static int dm_test_fdt_translation(struct unit_test_state *uts)
  460. {
  461. struct udevice *dev;
  462. fdt32_t dma_addr[2];
  463. /* Some simple translations */
  464. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  465. ut_asserteq_str("dev@0,0", dev->name);
  466. ut_asserteq(0x8000, dev_read_addr(dev));
  467. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, &dev));
  468. ut_asserteq_str("dev@1,100", dev->name);
  469. ut_asserteq(0x9000, dev_read_addr(dev));
  470. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, &dev));
  471. ut_asserteq_str("dev@2,200", dev->name);
  472. ut_asserteq(0xA000, dev_read_addr(dev));
  473. /* No translation for busses with #size-cells == 0 */
  474. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, &dev));
  475. ut_asserteq_str("dev@42", dev->name);
  476. ut_asserteq(0x42, dev_read_addr(dev));
  477. /* dma address translation */
  478. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  479. dma_addr[0] = cpu_to_be32(0);
  480. dma_addr[1] = cpu_to_be32(0);
  481. ut_asserteq(0x10000000, dev_translate_dma_address(dev, dma_addr));
  482. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, &dev));
  483. dma_addr[0] = cpu_to_be32(1);
  484. dma_addr[1] = cpu_to_be32(0x100);
  485. ut_asserteq(0x20000000, dev_translate_dma_address(dev, dma_addr));
  486. return 0;
  487. }
  488. DM_TEST(dm_test_fdt_translation, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  489. static int dm_test_fdt_get_addr_ptr_flat(struct unit_test_state *uts)
  490. {
  491. struct udevice *gpio, *dev;
  492. void *ptr;
  493. /* Test for missing reg property */
  494. ut_assertok(uclass_first_device_err(UCLASS_GPIO, &gpio));
  495. ut_assertnull(devfdt_get_addr_ptr(gpio));
  496. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  497. ptr = devfdt_get_addr_ptr(dev);
  498. ut_asserteq_ptr((void *)0x8000, ptr);
  499. return 0;
  500. }
  501. DM_TEST(dm_test_fdt_get_addr_ptr_flat,
  502. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  503. static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
  504. {
  505. struct udevice *dev;
  506. fdt_addr_t addr;
  507. void *paddr;
  508. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  509. addr = devfdt_get_addr(dev);
  510. ut_asserteq(0x8000, addr);
  511. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  512. ut_assertnonnull(paddr);
  513. ut_asserteq_ptr(paddr, devfdt_remap_addr(dev));
  514. return 0;
  515. }
  516. DM_TEST(dm_test_fdt_remap_addr_flat,
  517. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  518. static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
  519. {
  520. struct udevice *dev;
  521. fdt_addr_t addr;
  522. fdt_size_t size;
  523. void *paddr;
  524. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  525. addr = devfdt_get_addr_size_index(dev, 0, &size);
  526. ut_asserteq(0x8000, addr);
  527. ut_asserteq(0x1000, size);
  528. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  529. ut_assertnonnull(paddr);
  530. ut_asserteq_ptr(paddr, devfdt_remap_addr_index(dev, 0));
  531. return 0;
  532. }
  533. DM_TEST(dm_test_fdt_remap_addr_index_flat,
  534. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  535. static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
  536. {
  537. struct udevice *dev;
  538. fdt_addr_t addr;
  539. fdt_size_t size;
  540. void *paddr;
  541. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  542. addr = devfdt_get_addr_size_name(dev, "sandbox-dummy-0", &size);
  543. ut_asserteq(0x8000, addr);
  544. ut_asserteq(0x1000, size);
  545. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  546. ut_assertnonnull(paddr);
  547. ut_asserteq_ptr(paddr, devfdt_remap_addr_name(dev, "sandbox-dummy-0"));
  548. return 0;
  549. }
  550. DM_TEST(dm_test_fdt_remap_addr_name_flat,
  551. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  552. static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
  553. {
  554. struct udevice *dev;
  555. fdt_addr_t addr;
  556. void *paddr;
  557. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  558. addr = dev_read_addr(dev);
  559. ut_asserteq(0x8000, addr);
  560. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  561. ut_assertnonnull(paddr);
  562. ut_asserteq_ptr(paddr, dev_remap_addr(dev));
  563. return 0;
  564. }
  565. DM_TEST(dm_test_fdt_remap_addr_live,
  566. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  567. static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
  568. {
  569. struct udevice *dev;
  570. fdt_addr_t addr;
  571. fdt_size_t size;
  572. void *paddr;
  573. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  574. addr = dev_read_addr_size_index(dev, 0, &size);
  575. ut_asserteq(0x8000, addr);
  576. ut_asserteq(0x1000, size);
  577. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  578. ut_assertnonnull(paddr);
  579. ut_asserteq_ptr(paddr, dev_remap_addr_index(dev, 0));
  580. return 0;
  581. }
  582. DM_TEST(dm_test_fdt_remap_addr_index_live,
  583. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  584. static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
  585. {
  586. struct udevice *dev;
  587. fdt_addr_t addr;
  588. fdt_size_t size;
  589. void *paddr;
  590. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, &dev));
  591. addr = dev_read_addr_size_name(dev, "sandbox-dummy-0", &size);
  592. ut_asserteq(0x8000, addr);
  593. ut_asserteq(0x1000, size);
  594. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  595. ut_assertnonnull(paddr);
  596. ut_asserteq_ptr(paddr, dev_remap_addr_name(dev, "sandbox-dummy-0"));
  597. return 0;
  598. }
  599. DM_TEST(dm_test_fdt_remap_addr_name_live,
  600. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  601. static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
  602. {
  603. struct udevice *dev;
  604. ofnode node;
  605. if (!of_live_active()) {
  606. printf("Live tree not active; ignore test\n");
  607. return 0;
  608. }
  609. /* Test enabling devices */
  610. node = ofnode_path("/usb@2");
  611. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  612. ofnode_set_enabled(node, true);
  613. ut_assert(of_device_is_available(ofnode_to_np(node)));
  614. device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
  615. &dev);
  616. ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, &dev));
  617. /* Test string property setting */
  618. ut_assert(device_is_compatible(dev, "sandbox,usb"));
  619. ofnode_write_string(node, "compatible", "gdsys,super-usb");
  620. ut_assert(device_is_compatible(dev, "gdsys,super-usb"));
  621. ofnode_write_string(node, "compatible", "sandbox,usb");
  622. ut_assert(device_is_compatible(dev, "sandbox,usb"));
  623. /* Test setting generic properties */
  624. /* Non-existent in DTB */
  625. ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr(dev));
  626. /* reg = 0x42, size = 0x100 */
  627. ut_assertok(ofnode_write_prop(node, "reg", 8,
  628. "\x00\x00\x00\x42\x00\x00\x01\x00"));
  629. ut_asserteq(0x42, dev_read_addr(dev));
  630. /* Test disabling devices */
  631. device_remove(dev, DM_REMOVE_NORMAL);
  632. device_unbind(dev);
  633. ut_assert(of_device_is_available(ofnode_to_np(node)));
  634. ofnode_set_enabled(node, false);
  635. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  636. return 0;
  637. }
  638. DM_TEST(dm_test_fdt_livetree_writing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  639. static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
  640. {
  641. ofnode node;
  642. if (!of_live_active()) {
  643. printf("Live tree not active; ignore test\n");
  644. return 0;
  645. }
  646. node = ofnode_path("/usb@2");
  647. /* Test enabling devices */
  648. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  649. dev_enable_by_path("/usb@2");
  650. ut_assert(of_device_is_available(ofnode_to_np(node)));
  651. /* Test disabling devices */
  652. ut_assert(of_device_is_available(ofnode_to_np(node)));
  653. dev_disable_by_path("/usb@2");
  654. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  655. return 0;
  656. }
  657. DM_TEST(dm_test_fdt_disable_enable_by_path, UT_TESTF_SCAN_PDATA |
  658. UT_TESTF_SCAN_FDT);
  659. /* Test a few uclass phandle functions */
  660. static int dm_test_fdt_phandle(struct unit_test_state *uts)
  661. {
  662. struct udevice *back, *dev, *dev2;
  663. ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back));
  664. ut_assertnonnull(back);
  665. ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR,
  666. back, "missing", &dev));
  667. ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back,
  668. "power-supply", &dev));
  669. ut_assertnonnull(dev);
  670. ut_asserteq(0, device_active(dev));
  671. ut_asserteq_str("ldo1", dev->name);
  672. ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back,
  673. "power-supply", &dev2));
  674. ut_asserteq_ptr(dev, dev2);
  675. return 0;
  676. }
  677. DM_TEST(dm_test_fdt_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  678. /* Test device_find_first_child_by_uclass() */
  679. static int dm_test_first_child(struct unit_test_state *uts)
  680. {
  681. struct udevice *i2c, *dev, *dev2;
  682. ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
  683. ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev));
  684. ut_asserteq_str("rtc@43", dev->name);
  685. ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2));
  686. ut_asserteq_ptr(dev, dev2);
  687. ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2));
  688. ut_asserteq_str("rtc@61", dev2->name);
  689. ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM,
  690. &dev));
  691. ut_asserteq_str("eeprom@2c", dev->name);
  692. ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2));
  693. ut_asserteq_ptr(dev, dev2);
  694. ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c,
  695. UCLASS_VIDEO, &dev));
  696. ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev));
  697. return 0;
  698. }
  699. DM_TEST(dm_test_first_child, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  700. /* Test integer functions in dm_read_...() */
  701. static int dm_test_read_int(struct unit_test_state *uts)
  702. {
  703. struct udevice *dev;
  704. u32 val32;
  705. s32 sval;
  706. uint val;
  707. u64 val64;
  708. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  709. ut_asserteq_str("a-test", dev->name);
  710. ut_assertok(dev_read_u32(dev, "int-value", &val32));
  711. ut_asserteq(1234, val32);
  712. ut_asserteq(-EINVAL, dev_read_u32(dev, "missing", &val32));
  713. ut_asserteq(6, dev_read_u32_default(dev, "missing", 6));
  714. ut_asserteq(1234, dev_read_u32_default(dev, "int-value", 6));
  715. ut_asserteq(1234, val32);
  716. ut_asserteq(-EINVAL, dev_read_s32(dev, "missing", &sval));
  717. ut_asserteq(6, dev_read_s32_default(dev, "missing", 6));
  718. ut_asserteq(-1234, dev_read_s32_default(dev, "uint-value", 6));
  719. ut_assertok(dev_read_s32(dev, "uint-value", &sval));
  720. ut_asserteq(-1234, sval);
  721. val = 0;
  722. ut_asserteq(-EINVAL, dev_read_u32u(dev, "missing", &val));
  723. ut_assertok(dev_read_u32u(dev, "uint-value", &val));
  724. ut_asserteq(-1234, val);
  725. ut_assertok(dev_read_u64(dev, "int64-value", &val64));
  726. ut_asserteq_64(0x1111222233334444, val64);
  727. ut_asserteq_64(-EINVAL, dev_read_u64(dev, "missing", &val64));
  728. ut_asserteq_64(6, dev_read_u64_default(dev, "missing", 6));
  729. ut_asserteq_64(0x1111222233334444,
  730. dev_read_u64_default(dev, "int64-value", 6));
  731. return 0;
  732. }
  733. DM_TEST(dm_test_read_int, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  734. static int dm_test_read_int_index(struct unit_test_state *uts)
  735. {
  736. struct udevice *dev;
  737. u32 val32;
  738. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  739. ut_asserteq_str("a-test", dev->name);
  740. ut_asserteq(-EINVAL, dev_read_u32_index(dev, "missing", 0, &val32));
  741. ut_asserteq(19, dev_read_u32_index_default(dev, "missing", 0, 19));
  742. ut_assertok(dev_read_u32_index(dev, "int-array", 0, &val32));
  743. ut_asserteq(5678, val32);
  744. ut_assertok(dev_read_u32_index(dev, "int-array", 1, &val32));
  745. ut_asserteq(9123, val32);
  746. ut_assertok(dev_read_u32_index(dev, "int-array", 2, &val32));
  747. ut_asserteq(4567, val32);
  748. ut_asserteq(-EOVERFLOW, dev_read_u32_index(dev, "int-array", 3,
  749. &val32));
  750. ut_asserteq(5678, dev_read_u32_index_default(dev, "int-array", 0, 2));
  751. ut_asserteq(9123, dev_read_u32_index_default(dev, "int-array", 1, 2));
  752. ut_asserteq(4567, dev_read_u32_index_default(dev, "int-array", 2, 2));
  753. ut_asserteq(2, dev_read_u32_index_default(dev, "int-array", 3, 2));
  754. return 0;
  755. }
  756. DM_TEST(dm_test_read_int_index, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  757. static int dm_test_read_phandle(struct unit_test_state *uts)
  758. {
  759. struct udevice *dev;
  760. struct ofnode_phandle_args args;
  761. int ret;
  762. const char prop[] = "test-gpios";
  763. const char cell[] = "#gpio-cells";
  764. const char prop2[] = "phandle-value";
  765. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  766. ut_asserteq_str("a-test", dev->name);
  767. /* Test dev_count_phandle_with_args with cell name */
  768. ret = dev_count_phandle_with_args(dev, "missing", cell, 0);
  769. ut_asserteq(-ENOENT, ret);
  770. ret = dev_count_phandle_with_args(dev, prop, "#invalid", 0);
  771. ut_asserteq(-EINVAL, ret);
  772. ut_asserteq(5, dev_count_phandle_with_args(dev, prop, cell, 0));
  773. /* Test dev_read_phandle_with_args with cell name */
  774. ret = dev_read_phandle_with_args(dev, "missing", cell, 0, 0, &args);
  775. ut_asserteq(-ENOENT, ret);
  776. ret = dev_read_phandle_with_args(dev, prop, "#invalid", 0, 0, &args);
  777. ut_asserteq(-EINVAL, ret);
  778. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 0, &args));
  779. ut_asserteq(1, args.args_count);
  780. ut_asserteq(1, args.args[0]);
  781. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 1, &args));
  782. ut_asserteq(1, args.args_count);
  783. ut_asserteq(4, args.args[0]);
  784. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 2, &args));
  785. ut_asserteq(5, args.args_count);
  786. ut_asserteq(5, args.args[0]);
  787. ut_asserteq(1, args.args[4]);
  788. ret = dev_read_phandle_with_args(dev, prop, cell, 0, 3, &args);
  789. ut_asserteq(-ENOENT, ret);
  790. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 4, &args));
  791. ut_asserteq(1, args.args_count);
  792. ut_asserteq(12, args.args[0]);
  793. ret = dev_read_phandle_with_args(dev, prop, cell, 0, 5, &args);
  794. ut_asserteq(-ENOENT, ret);
  795. /* Test dev_count_phandle_with_args with cell count */
  796. ret = dev_count_phandle_with_args(dev, "missing", NULL, 2);
  797. ut_asserteq(-ENOENT, ret);
  798. ut_asserteq(3, dev_count_phandle_with_args(dev, prop2, NULL, 1));
  799. /* Test dev_read_phandle_with_args with cell count */
  800. ut_assertok(dev_read_phandle_with_args(dev, prop2, NULL, 1, 0, &args));
  801. ut_asserteq(1, ofnode_valid(args.node));
  802. ut_asserteq(1, args.args_count);
  803. ut_asserteq(10, args.args[0]);
  804. ret = dev_read_phandle_with_args(dev, prop2, NULL, 1, 1, &args);
  805. ut_asserteq(-EINVAL, ret);
  806. ut_assertok(dev_read_phandle_with_args(dev, prop2, NULL, 1, 2, &args));
  807. ut_asserteq(1, ofnode_valid(args.node));
  808. ut_asserteq(1, args.args_count);
  809. ut_asserteq(30, args.args[0]);
  810. ret = dev_read_phandle_with_args(dev, prop2, NULL, 1, 3, &args);
  811. ut_asserteq(-ENOENT, ret);
  812. return 0;
  813. }
  814. DM_TEST(dm_test_read_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  815. /* Test iteration through devices by drvdata */
  816. static int dm_test_uclass_drvdata(struct unit_test_state *uts)
  817. {
  818. struct udevice *dev;
  819. ut_assertok(uclass_first_device_drvdata(UCLASS_TEST_FDT,
  820. DM_TEST_TYPE_FIRST, &dev));
  821. ut_asserteq_str("a-test", dev->name);
  822. ut_assertok(uclass_first_device_drvdata(UCLASS_TEST_FDT,
  823. DM_TEST_TYPE_SECOND, &dev));
  824. ut_asserteq_str("d-test", dev->name);
  825. ut_asserteq(-ENODEV, uclass_first_device_drvdata(UCLASS_TEST_FDT,
  826. DM_TEST_TYPE_COUNT,
  827. &dev));
  828. return 0;
  829. }
  830. DM_TEST(dm_test_uclass_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  831. /* Test device_first_child_ofdata_err(), etc. */
  832. static int dm_test_child_ofdata(struct unit_test_state *uts)
  833. {
  834. struct udevice *bus, *dev;
  835. int count;
  836. ut_assertok(uclass_first_device_err(UCLASS_TEST_BUS, &bus));
  837. count = 0;
  838. device_foreach_child_of_to_plat(dev, bus) {
  839. ut_assert(dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID);
  840. ut_assert(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED));
  841. count++;
  842. }
  843. ut_asserteq(3, count);
  844. return 0;
  845. }
  846. DM_TEST(dm_test_child_ofdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  847. /* Test device_first_child_err(), etc. */
  848. static int dm_test_first_child_probe(struct unit_test_state *uts)
  849. {
  850. struct udevice *bus, *dev;
  851. int count;
  852. ut_assertok(uclass_first_device_err(UCLASS_TEST_BUS, &bus));
  853. count = 0;
  854. device_foreach_child_probe(dev, bus) {
  855. ut_assert(dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID);
  856. ut_assert(dev_get_flags(dev) & DM_FLAG_ACTIVATED);
  857. count++;
  858. }
  859. ut_asserteq(3, count);
  860. return 0;
  861. }
  862. DM_TEST(dm_test_first_child_probe, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  863. /* Test that ofdata is read for parents before children */
  864. static int dm_test_ofdata_order(struct unit_test_state *uts)
  865. {
  866. struct udevice *bus, *dev;
  867. ut_assertok(uclass_find_first_device(UCLASS_I2C, &bus));
  868. ut_assertnonnull(bus);
  869. ut_assert(!(dev_get_flags(bus) & DM_FLAG_PLATDATA_VALID));
  870. ut_assertok(device_find_first_child(bus, &dev));
  871. ut_assertnonnull(dev);
  872. ut_assert(!(dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID));
  873. /* read the child's ofdata which should cause the parent's to be read */
  874. ut_assertok(device_of_to_plat(dev));
  875. ut_assert(dev_get_flags(dev) & DM_FLAG_PLATDATA_VALID);
  876. ut_assert(dev_get_flags(bus) & DM_FLAG_PLATDATA_VALID);
  877. ut_assert(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED));
  878. ut_assert(!(dev_get_flags(bus) & DM_FLAG_ACTIVATED));
  879. return 0;
  880. }
  881. DM_TEST(dm_test_ofdata_order, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  882. /* Test dev_decode_display_timing() */
  883. static int dm_test_decode_display_timing(struct unit_test_state *uts)
  884. {
  885. struct udevice *dev;
  886. struct display_timing timing;
  887. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  888. ut_asserteq_str("a-test", dev->name);
  889. ut_assertok(dev_decode_display_timing(dev, 0, &timing));
  890. ut_assert(timing.hactive.typ == 240);
  891. ut_assert(timing.hback_porch.typ == 7);
  892. ut_assert(timing.hfront_porch.typ == 6);
  893. ut_assert(timing.hsync_len.typ == 1);
  894. ut_assert(timing.vactive.typ == 320);
  895. ut_assert(timing.vback_porch.typ == 5);
  896. ut_assert(timing.vfront_porch.typ == 8);
  897. ut_assert(timing.vsync_len.typ == 2);
  898. ut_assert(timing.pixelclock.typ == 6500000);
  899. ut_assert(timing.flags & DISPLAY_FLAGS_HSYNC_HIGH);
  900. ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_LOW));
  901. ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_HIGH));
  902. ut_assert(timing.flags & DISPLAY_FLAGS_VSYNC_LOW);
  903. ut_assert(timing.flags & DISPLAY_FLAGS_DE_HIGH);
  904. ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_LOW));
  905. ut_assert(timing.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE);
  906. ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE));
  907. ut_assert(timing.flags & DISPLAY_FLAGS_INTERLACED);
  908. ut_assert(timing.flags & DISPLAY_FLAGS_DOUBLESCAN);
  909. ut_assert(timing.flags & DISPLAY_FLAGS_DOUBLECLK);
  910. ut_assertok(dev_decode_display_timing(dev, 1, &timing));
  911. ut_assert(timing.hactive.typ == 480);
  912. ut_assert(timing.hback_porch.typ == 59);
  913. ut_assert(timing.hfront_porch.typ == 10);
  914. ut_assert(timing.hsync_len.typ == 12);
  915. ut_assert(timing.vactive.typ == 800);
  916. ut_assert(timing.vback_porch.typ == 15);
  917. ut_assert(timing.vfront_porch.typ == 17);
  918. ut_assert(timing.vsync_len.typ == 16);
  919. ut_assert(timing.pixelclock.typ == 9000000);
  920. ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_HIGH));
  921. ut_assert(timing.flags & DISPLAY_FLAGS_HSYNC_LOW);
  922. ut_assert(timing.flags & DISPLAY_FLAGS_VSYNC_HIGH);
  923. ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_LOW));
  924. ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_HIGH));
  925. ut_assert(timing.flags & DISPLAY_FLAGS_DE_LOW);
  926. ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE));
  927. ut_assert(timing.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE);
  928. ut_assert(!(timing.flags & DISPLAY_FLAGS_INTERLACED));
  929. ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLESCAN));
  930. ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLECLK));
  931. ut_assertok(dev_decode_display_timing(dev, 2, &timing));
  932. ut_assert(timing.hactive.typ == 800);
  933. ut_assert(timing.hback_porch.typ == 89);
  934. ut_assert(timing.hfront_porch.typ == 164);
  935. ut_assert(timing.hsync_len.typ == 11);
  936. ut_assert(timing.vactive.typ == 480);
  937. ut_assert(timing.vback_porch.typ == 23);
  938. ut_assert(timing.vfront_porch.typ == 10);
  939. ut_assert(timing.vsync_len.typ == 13);
  940. ut_assert(timing.pixelclock.typ == 33500000);
  941. ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_HIGH));
  942. ut_assert(!(timing.flags & DISPLAY_FLAGS_HSYNC_LOW));
  943. ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_HIGH));
  944. ut_assert(!(timing.flags & DISPLAY_FLAGS_VSYNC_LOW));
  945. ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_HIGH));
  946. ut_assert(!(timing.flags & DISPLAY_FLAGS_DE_LOW));
  947. ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE));
  948. ut_assert(!(timing.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE));
  949. ut_assert(!(timing.flags & DISPLAY_FLAGS_INTERLACED));
  950. ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLESCAN));
  951. ut_assert(!(timing.flags & DISPLAY_FLAGS_DOUBLECLK));
  952. ut_assert(dev_decode_display_timing(dev, 3, &timing));
  953. return 0;
  954. }
  955. DM_TEST(dm_test_decode_display_timing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  956. /* Test read_resourcee() */
  957. static int dm_test_read_resource(struct unit_test_state *uts)
  958. {
  959. struct udevice *dev;
  960. struct resource res;
  961. /* test resource without translation */
  962. ut_assertok(uclass_find_device_by_name(UCLASS_SIMPLE_BUS, "syscon@2", &dev));
  963. ut_assertok(dev_read_resource(dev, 0, &res));
  964. ut_asserteq(0x40, res.start);
  965. ut_asserteq(0x44, res.end);
  966. ut_assertok(dev_read_resource(dev, 1, &res));
  967. ut_asserteq(0x48, res.start);
  968. ut_asserteq(0x4d, res.end);
  969. /* test resource with translation */
  970. ut_assertok(uclass_find_device_by_name(UCLASS_TEST_DUMMY, "dev@1,100", &dev));
  971. ut_assertok(dev_read_resource(dev, 0, &res));
  972. ut_asserteq(0x9000, res.start);
  973. ut_asserteq(0x9fff, res.end);
  974. /* test named resource */
  975. ut_assertok(uclass_find_device_by_name(UCLASS_TEST_DUMMY, "dev@0,0", &dev));
  976. ut_assertok(dev_read_resource_byname(dev, "sandbox-dummy-0", &res));
  977. ut_asserteq(0x8000, res.start);
  978. ut_asserteq(0x8fff, res.end);
  979. return 0;
  980. }
  981. DM_TEST(dm_test_read_resource, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);