test-fdt.c 31 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118
  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 = 9;
  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(9, count);
  386. count = 0;
  387. uclass_foreach_dev(dev, uc)
  388. count++;
  389. ut_asserteq(9, 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_get_addr_ptr_flat(struct unit_test_state *uts)
  509. {
  510. struct udevice *gpio, *dev;
  511. void *ptr;
  512. /* Test for missing reg property */
  513. ut_assertok(uclass_first_device_err(UCLASS_GPIO, &gpio));
  514. ut_assertnull(devfdt_get_addr_ptr(gpio));
  515. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  516. ptr = devfdt_get_addr_ptr(dev);
  517. ut_asserteq_ptr((void *)0x8000, ptr);
  518. return 0;
  519. }
  520. DM_TEST(dm_test_fdt_get_addr_ptr_flat,
  521. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  522. static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
  523. {
  524. struct udevice *dev;
  525. fdt_addr_t addr;
  526. void *paddr;
  527. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  528. addr = devfdt_get_addr(dev);
  529. ut_asserteq(0x8000, addr);
  530. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  531. ut_assertnonnull(paddr);
  532. ut_asserteq_ptr(paddr, devfdt_remap_addr(dev));
  533. return 0;
  534. }
  535. DM_TEST(dm_test_fdt_remap_addr_flat,
  536. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  537. static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
  538. {
  539. struct udevice *dev;
  540. fdt_addr_t addr;
  541. fdt_size_t size;
  542. void *paddr;
  543. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  544. addr = devfdt_get_addr_size_index(dev, 0, &size);
  545. ut_asserteq(0x8000, addr);
  546. ut_asserteq(0x1000, size);
  547. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  548. ut_assertnonnull(paddr);
  549. ut_asserteq_ptr(paddr, devfdt_remap_addr_index(dev, 0));
  550. return 0;
  551. }
  552. DM_TEST(dm_test_fdt_remap_addr_index_flat,
  553. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  554. static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
  555. {
  556. struct udevice *dev;
  557. fdt_addr_t addr;
  558. fdt_size_t size;
  559. void *paddr;
  560. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  561. addr = devfdt_get_addr_size_name(dev, "sandbox-dummy-0", &size);
  562. ut_asserteq(0x8000, addr);
  563. ut_asserteq(0x1000, size);
  564. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  565. ut_assertnonnull(paddr);
  566. ut_asserteq_ptr(paddr, devfdt_remap_addr_name(dev, "sandbox-dummy-0"));
  567. return 0;
  568. }
  569. DM_TEST(dm_test_fdt_remap_addr_name_flat,
  570. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
  571. static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
  572. {
  573. struct udevice *dev;
  574. fdt_addr_t addr;
  575. void *paddr;
  576. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  577. addr = dev_read_addr(dev);
  578. ut_asserteq(0x8000, addr);
  579. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  580. ut_assertnonnull(paddr);
  581. ut_asserteq_ptr(paddr, dev_remap_addr(dev));
  582. return 0;
  583. }
  584. DM_TEST(dm_test_fdt_remap_addr_live,
  585. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  586. static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
  587. {
  588. struct udevice *dev;
  589. fdt_addr_t addr;
  590. fdt_size_t size;
  591. void *paddr;
  592. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  593. addr = dev_read_addr_size_index(dev, 0, &size);
  594. ut_asserteq(0x8000, addr);
  595. ut_asserteq(0x1000, size);
  596. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  597. ut_assertnonnull(paddr);
  598. ut_asserteq_ptr(paddr, dev_remap_addr_index(dev, 0));
  599. return 0;
  600. }
  601. DM_TEST(dm_test_fdt_remap_addr_index_live,
  602. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  603. static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
  604. {
  605. struct udevice *dev;
  606. fdt_addr_t addr;
  607. fdt_size_t size;
  608. void *paddr;
  609. ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
  610. addr = dev_read_addr_size_name(dev, "sandbox-dummy-0", &size);
  611. ut_asserteq(0x8000, addr);
  612. ut_asserteq(0x1000, size);
  613. paddr = map_physmem(addr, 0, MAP_NOCACHE);
  614. ut_assertnonnull(paddr);
  615. ut_asserteq_ptr(paddr, dev_remap_addr_name(dev, "sandbox-dummy-0"));
  616. return 0;
  617. }
  618. DM_TEST(dm_test_fdt_remap_addr_name_live,
  619. UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  620. static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
  621. {
  622. struct udevice *dev;
  623. ofnode node;
  624. if (!of_live_active()) {
  625. printf("Live tree not active; ignore test\n");
  626. return 0;
  627. }
  628. /* Test enabling devices */
  629. node = ofnode_path("/usb@2");
  630. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  631. ofnode_set_enabled(node, true);
  632. ut_assert(of_device_is_available(ofnode_to_np(node)));
  633. device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
  634. &dev);
  635. ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, true, &dev));
  636. /* Test string property setting */
  637. ut_assert(device_is_compatible(dev, "sandbox,usb"));
  638. ofnode_write_string(node, "compatible", "gdsys,super-usb");
  639. ut_assert(device_is_compatible(dev, "gdsys,super-usb"));
  640. ofnode_write_string(node, "compatible", "sandbox,usb");
  641. ut_assert(device_is_compatible(dev, "sandbox,usb"));
  642. /* Test setting generic properties */
  643. /* Non-existent in DTB */
  644. ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr(dev));
  645. /* reg = 0x42, size = 0x100 */
  646. ut_assertok(ofnode_write_prop(node, "reg", 8,
  647. "\x00\x00\x00\x42\x00\x00\x01\x00"));
  648. ut_asserteq(0x42, dev_read_addr(dev));
  649. /* Test disabling devices */
  650. device_remove(dev, DM_REMOVE_NORMAL);
  651. device_unbind(dev);
  652. ut_assert(of_device_is_available(ofnode_to_np(node)));
  653. ofnode_set_enabled(node, false);
  654. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  655. return 0;
  656. }
  657. DM_TEST(dm_test_fdt_livetree_writing, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  658. static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
  659. {
  660. ofnode node;
  661. if (!of_live_active()) {
  662. printf("Live tree not active; ignore test\n");
  663. return 0;
  664. }
  665. node = ofnode_path("/usb@2");
  666. /* Test enabling devices */
  667. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  668. dev_enable_by_path("/usb@2");
  669. ut_assert(of_device_is_available(ofnode_to_np(node)));
  670. /* Test disabling devices */
  671. ut_assert(of_device_is_available(ofnode_to_np(node)));
  672. dev_disable_by_path("/usb@2");
  673. ut_assert(!of_device_is_available(ofnode_to_np(node)));
  674. return 0;
  675. }
  676. DM_TEST(dm_test_fdt_disable_enable_by_path, UT_TESTF_SCAN_PDATA |
  677. UT_TESTF_SCAN_FDT);
  678. /* Test a few uclass phandle functions */
  679. static int dm_test_fdt_phandle(struct unit_test_state *uts)
  680. {
  681. struct udevice *back, *dev, *dev2;
  682. ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back));
  683. ut_assertnonnull(back);
  684. ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR,
  685. back, "missing", &dev));
  686. ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back,
  687. "power-supply", &dev));
  688. ut_assertnonnull(dev);
  689. ut_asserteq(0, device_active(dev));
  690. ut_asserteq_str("ldo1", dev->name);
  691. ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back,
  692. "power-supply", &dev2));
  693. ut_asserteq_ptr(dev, dev2);
  694. return 0;
  695. }
  696. DM_TEST(dm_test_fdt_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  697. /* Test device_find_first_child_by_uclass() */
  698. static int dm_test_first_child(struct unit_test_state *uts)
  699. {
  700. struct udevice *i2c, *dev, *dev2;
  701. ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
  702. ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev));
  703. ut_asserteq_str("rtc@43", dev->name);
  704. ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2));
  705. ut_asserteq_ptr(dev, dev2);
  706. ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2));
  707. ut_asserteq_str("rtc@61", dev2->name);
  708. ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM,
  709. &dev));
  710. ut_asserteq_str("eeprom@2c", dev->name);
  711. ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2));
  712. ut_asserteq_ptr(dev, dev2);
  713. ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c,
  714. UCLASS_VIDEO, &dev));
  715. ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev));
  716. return 0;
  717. }
  718. DM_TEST(dm_test_first_child, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  719. /* Test integer functions in dm_read_...() */
  720. static int dm_test_read_int(struct unit_test_state *uts)
  721. {
  722. struct udevice *dev;
  723. u32 val32;
  724. s32 sval;
  725. uint val;
  726. u64 val64;
  727. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  728. ut_asserteq_str("a-test", dev->name);
  729. ut_assertok(dev_read_u32(dev, "int-value", &val32));
  730. ut_asserteq(1234, val32);
  731. ut_asserteq(-EINVAL, dev_read_u32(dev, "missing", &val32));
  732. ut_asserteq(6, dev_read_u32_default(dev, "missing", 6));
  733. ut_asserteq(1234, dev_read_u32_default(dev, "int-value", 6));
  734. ut_asserteq(1234, val32);
  735. ut_asserteq(-EINVAL, dev_read_s32(dev, "missing", &sval));
  736. ut_asserteq(6, dev_read_s32_default(dev, "missing", 6));
  737. ut_asserteq(-1234, dev_read_s32_default(dev, "uint-value", 6));
  738. ut_assertok(dev_read_s32(dev, "uint-value", &sval));
  739. ut_asserteq(-1234, sval);
  740. val = 0;
  741. ut_asserteq(-EINVAL, dev_read_u32u(dev, "missing", &val));
  742. ut_assertok(dev_read_u32u(dev, "uint-value", &val));
  743. ut_asserteq(-1234, val);
  744. ut_assertok(dev_read_u64(dev, "int64-value", &val64));
  745. ut_asserteq_64(0x1111222233334444, val64);
  746. ut_asserteq_64(-EINVAL, dev_read_u64(dev, "missing", &val64));
  747. ut_asserteq_64(6, dev_read_u64_default(dev, "missing", 6));
  748. ut_asserteq_64(0x1111222233334444,
  749. dev_read_u64_default(dev, "int64-value", 6));
  750. return 0;
  751. }
  752. DM_TEST(dm_test_read_int, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  753. static int dm_test_read_int_index(struct unit_test_state *uts)
  754. {
  755. struct udevice *dev;
  756. u32 val32;
  757. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  758. ut_asserteq_str("a-test", dev->name);
  759. ut_asserteq(-EINVAL, dev_read_u32_index(dev, "missing", 0, &val32));
  760. ut_asserteq(19, dev_read_u32_index_default(dev, "missing", 0, 19));
  761. ut_assertok(dev_read_u32_index(dev, "int-array", 0, &val32));
  762. ut_asserteq(5678, val32);
  763. ut_assertok(dev_read_u32_index(dev, "int-array", 1, &val32));
  764. ut_asserteq(9123, val32);
  765. ut_assertok(dev_read_u32_index(dev, "int-array", 2, &val32));
  766. ut_asserteq(4567, val32);
  767. ut_asserteq(-EOVERFLOW, dev_read_u32_index(dev, "int-array", 3,
  768. &val32));
  769. ut_asserteq(5678, dev_read_u32_index_default(dev, "int-array", 0, 2));
  770. ut_asserteq(9123, dev_read_u32_index_default(dev, "int-array", 1, 2));
  771. ut_asserteq(4567, dev_read_u32_index_default(dev, "int-array", 2, 2));
  772. ut_asserteq(2, dev_read_u32_index_default(dev, "int-array", 3, 2));
  773. return 0;
  774. }
  775. DM_TEST(dm_test_read_int_index, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  776. static int dm_test_read_phandle(struct unit_test_state *uts)
  777. {
  778. struct udevice *dev;
  779. struct ofnode_phandle_args args;
  780. int ret;
  781. const char prop[] = "test-gpios";
  782. const char cell[] = "#gpio-cells";
  783. const char prop2[] = "phandle-value";
  784. ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
  785. ut_asserteq_str("a-test", dev->name);
  786. /* Test dev_count_phandle_with_args with cell name */
  787. ret = dev_count_phandle_with_args(dev, "missing", cell, 0);
  788. ut_asserteq(-ENOENT, ret);
  789. ret = dev_count_phandle_with_args(dev, prop, "#invalid", 0);
  790. ut_asserteq(-EINVAL, ret);
  791. ut_asserteq(5, dev_count_phandle_with_args(dev, prop, cell, 0));
  792. /* Test dev_read_phandle_with_args with cell name */
  793. ret = dev_read_phandle_with_args(dev, "missing", cell, 0, 0, &args);
  794. ut_asserteq(-ENOENT, ret);
  795. ret = dev_read_phandle_with_args(dev, prop, "#invalid", 0, 0, &args);
  796. ut_asserteq(-EINVAL, ret);
  797. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 0, &args));
  798. ut_asserteq(1, args.args_count);
  799. ut_asserteq(1, args.args[0]);
  800. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 1, &args));
  801. ut_asserteq(1, args.args_count);
  802. ut_asserteq(4, args.args[0]);
  803. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 2, &args));
  804. ut_asserteq(5, args.args_count);
  805. ut_asserteq(5, args.args[0]);
  806. ut_asserteq(1, args.args[4]);
  807. ret = dev_read_phandle_with_args(dev, prop, cell, 0, 3, &args);
  808. ut_asserteq(-ENOENT, ret);
  809. ut_assertok(dev_read_phandle_with_args(dev, prop, cell, 0, 4, &args));
  810. ut_asserteq(1, args.args_count);
  811. ut_asserteq(12, args.args[0]);
  812. ret = dev_read_phandle_with_args(dev, prop, cell, 0, 5, &args);
  813. ut_asserteq(-ENOENT, ret);
  814. /* Test dev_count_phandle_with_args with cell count */
  815. ret = dev_count_phandle_with_args(dev, "missing", NULL, 2);
  816. ut_asserteq(-ENOENT, ret);
  817. ut_asserteq(3, dev_count_phandle_with_args(dev, prop2, NULL, 1));
  818. /* Test dev_read_phandle_with_args with cell count */
  819. ut_assertok(dev_read_phandle_with_args(dev, prop2, NULL, 1, 0, &args));
  820. ut_asserteq(1, ofnode_valid(args.node));
  821. ut_asserteq(1, args.args_count);
  822. ut_asserteq(10, args.args[0]);
  823. ret = dev_read_phandle_with_args(dev, prop2, NULL, 1, 1, &args);
  824. ut_asserteq(-EINVAL, ret);
  825. ut_assertok(dev_read_phandle_with_args(dev, prop2, NULL, 1, 2, &args));
  826. ut_asserteq(1, ofnode_valid(args.node));
  827. ut_asserteq(1, args.args_count);
  828. ut_asserteq(30, args.args[0]);
  829. ret = dev_read_phandle_with_args(dev, prop2, NULL, 1, 3, &args);
  830. ut_asserteq(-ENOENT, ret);
  831. return 0;
  832. }
  833. DM_TEST(dm_test_read_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  834. /* Test iteration through devices by drvdata */
  835. static int dm_test_uclass_drvdata(struct unit_test_state *uts)
  836. {
  837. struct udevice *dev;
  838. ut_assertok(uclass_first_device_drvdata(UCLASS_TEST_FDT,
  839. DM_TEST_TYPE_FIRST, &dev));
  840. ut_asserteq_str("a-test", dev->name);
  841. ut_assertok(uclass_first_device_drvdata(UCLASS_TEST_FDT,
  842. DM_TEST_TYPE_SECOND, &dev));
  843. ut_asserteq_str("d-test", dev->name);
  844. ut_asserteq(-ENODEV, uclass_first_device_drvdata(UCLASS_TEST_FDT,
  845. DM_TEST_TYPE_COUNT,
  846. &dev));
  847. return 0;
  848. }
  849. DM_TEST(dm_test_uclass_drvdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  850. /* Test device_first_child_ofdata_err(), etc. */
  851. static int dm_test_child_ofdata(struct unit_test_state *uts)
  852. {
  853. struct udevice *bus, *dev;
  854. int count;
  855. ut_assertok(uclass_first_device_err(UCLASS_TEST_BUS, &bus));
  856. count = 0;
  857. device_foreach_child_ofdata_to_platdata(dev, bus) {
  858. ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
  859. ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
  860. count++;
  861. }
  862. ut_asserteq(3, count);
  863. return 0;
  864. }
  865. DM_TEST(dm_test_child_ofdata, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  866. /* Test device_first_child_err(), etc. */
  867. static int dm_test_first_child_probe(struct unit_test_state *uts)
  868. {
  869. struct udevice *bus, *dev;
  870. int count;
  871. ut_assertok(uclass_first_device_err(UCLASS_TEST_BUS, &bus));
  872. count = 0;
  873. device_foreach_child_probe(dev, bus) {
  874. ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
  875. ut_assert(dev->flags & DM_FLAG_ACTIVATED);
  876. count++;
  877. }
  878. ut_asserteq(3, count);
  879. return 0;
  880. }
  881. DM_TEST(dm_test_first_child_probe, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
  882. /* Test that ofdata is read for parents before children */
  883. static int dm_test_ofdata_order(struct unit_test_state *uts)
  884. {
  885. struct udevice *bus, *dev;
  886. ut_assertok(uclass_find_first_device(UCLASS_I2C, &bus));
  887. ut_assertnonnull(bus);
  888. ut_assert(!(bus->flags & DM_FLAG_PLATDATA_VALID));
  889. ut_assertok(device_find_first_child(bus, &dev));
  890. ut_assertnonnull(dev);
  891. ut_assert(!(dev->flags & DM_FLAG_PLATDATA_VALID));
  892. /* read the child's ofdata which should cause the parent's to be read */
  893. ut_assertok(device_ofdata_to_platdata(dev));
  894. ut_assert(dev->flags & DM_FLAG_PLATDATA_VALID);
  895. ut_assert(bus->flags & DM_FLAG_PLATDATA_VALID);
  896. ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
  897. ut_assert(!(bus->flags & DM_FLAG_ACTIVATED));
  898. return 0;
  899. }
  900. DM_TEST(dm_test_ofdata_order, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);