test-fdt.c 30 KB

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