1 // SPDX-License-Identifier: GPL-2.0+
3 * (C) Copyright 2018 Simon Goldschmidt
13 static int check_lmb(struct unit_test_state *uts, struct lmb *lmb,
14 phys_addr_t ram_base, phys_size_t ram_size,
15 unsigned long num_reserved,
16 phys_addr_t base1, phys_size_t size1,
17 phys_addr_t base2, phys_size_t size2,
18 phys_addr_t base3, phys_size_t size3)
21 ut_asserteq(lmb->memory.cnt, 1);
22 ut_asserteq(lmb->memory.region[0].base, ram_base);
23 ut_asserteq(lmb->memory.region[0].size, ram_size);
26 ut_asserteq(lmb->reserved.cnt, num_reserved);
27 if (num_reserved > 0) {
28 ut_asserteq(lmb->reserved.region[0].base, base1);
29 ut_asserteq(lmb->reserved.region[0].size, size1);
31 if (num_reserved > 1) {
32 ut_asserteq(lmb->reserved.region[1].base, base2);
33 ut_asserteq(lmb->reserved.region[1].size, size2);
35 if (num_reserved > 2) {
36 ut_asserteq(lmb->reserved.region[2].base, base3);
37 ut_asserteq(lmb->reserved.region[2].size, size3);
42 #define ASSERT_LMB(lmb, ram_base, ram_size, num_reserved, base1, size1, \
43 base2, size2, base3, size3) \
44 ut_assert(!check_lmb(uts, lmb, ram_base, ram_size, \
45 num_reserved, base1, size1, base2, size2, base3, \
49 * Test helper function that reserves 64 KiB somewhere in the simulated RAM and
50 * then does some alloc + free tests.
52 static int test_multi_alloc(struct unit_test_state *uts, const phys_addr_t ram,
53 const phys_size_t ram_size, const phys_addr_t ram0,
54 const phys_size_t ram0_size,
55 const phys_addr_t alloc_64k_addr)
57 const phys_addr_t ram_end = ram + ram_size;
58 const phys_addr_t alloc_64k_end = alloc_64k_addr + 0x10000;
62 phys_addr_t a, a2, b, b2, c, d;
64 /* check for overflow */
65 ut_assert(ram_end == 0 || ram_end > ram);
66 ut_assert(alloc_64k_end > alloc_64k_addr);
67 /* check input addresses + size */
68 ut_assert(alloc_64k_addr >= ram + 8);
69 ut_assert(alloc_64k_end <= ram_end - 8);
74 ret = lmb_add(&lmb, ram0, ram0_size);
78 ret = lmb_add(&lmb, ram, ram_size);
82 ut_asserteq(lmb.memory.cnt, 2);
83 ut_asserteq(lmb.memory.region[0].base, ram0);
84 ut_asserteq(lmb.memory.region[0].size, ram0_size);
85 ut_asserteq(lmb.memory.region[1].base, ram);
86 ut_asserteq(lmb.memory.region[1].size, ram_size);
88 ut_asserteq(lmb.memory.cnt, 1);
89 ut_asserteq(lmb.memory.region[0].base, ram);
90 ut_asserteq(lmb.memory.region[0].size, ram_size);
93 /* reserve 64KiB somewhere */
94 ret = lmb_reserve(&lmb, alloc_64k_addr, 0x10000);
96 ASSERT_LMB(&lmb, 0, 0, 1, alloc_64k_addr, 0x10000,
99 /* allocate somewhere, should be at the end of RAM */
100 a = lmb_alloc(&lmb, 4, 1);
101 ut_asserteq(a, ram_end - 4);
102 ASSERT_LMB(&lmb, 0, 0, 2, alloc_64k_addr, 0x10000,
103 ram_end - 4, 4, 0, 0);
104 /* alloc below end of reserved region -> below reserved region */
105 b = lmb_alloc_base(&lmb, 4, 1, alloc_64k_end);
106 ut_asserteq(b, alloc_64k_addr - 4);
107 ASSERT_LMB(&lmb, 0, 0, 2,
108 alloc_64k_addr - 4, 0x10000 + 4, ram_end - 4, 4, 0, 0);
111 c = lmb_alloc(&lmb, 4, 1);
112 ut_asserteq(c, ram_end - 8);
113 ASSERT_LMB(&lmb, 0, 0, 2,
114 alloc_64k_addr - 4, 0x10000 + 4, ram_end - 8, 8, 0, 0);
115 d = lmb_alloc_base(&lmb, 4, 1, alloc_64k_end);
116 ut_asserteq(d, alloc_64k_addr - 8);
117 ASSERT_LMB(&lmb, 0, 0, 2,
118 alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 8, 0, 0);
120 ret = lmb_free(&lmb, a, 4);
122 ASSERT_LMB(&lmb, 0, 0, 2,
123 alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
124 /* allocate again to ensure we get the same address */
125 a2 = lmb_alloc(&lmb, 4, 1);
127 ASSERT_LMB(&lmb, 0, 0, 2,
128 alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 8, 0, 0);
129 ret = lmb_free(&lmb, a2, 4);
131 ASSERT_LMB(&lmb, 0, 0, 2,
132 alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
134 ret = lmb_free(&lmb, b, 4);
136 ASSERT_LMB(&lmb, 0, 0, 3,
137 alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000,
139 /* allocate again to ensure we get the same address */
140 b2 = lmb_alloc_base(&lmb, 4, 1, alloc_64k_end);
142 ASSERT_LMB(&lmb, 0, 0, 2,
143 alloc_64k_addr - 8, 0x10000 + 8, ram_end - 8, 4, 0, 0);
144 ret = lmb_free(&lmb, b2, 4);
146 ASSERT_LMB(&lmb, 0, 0, 3,
147 alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000,
150 ret = lmb_free(&lmb, c, 4);
152 ASSERT_LMB(&lmb, 0, 0, 2,
153 alloc_64k_addr - 8, 4, alloc_64k_addr, 0x10000, 0, 0);
154 ret = lmb_free(&lmb, d, 4);
156 ASSERT_LMB(&lmb, 0, 0, 1, alloc_64k_addr, 0x10000,
160 ut_asserteq(lmb.memory.cnt, 2);
161 ut_asserteq(lmb.memory.region[0].base, ram0);
162 ut_asserteq(lmb.memory.region[0].size, ram0_size);
163 ut_asserteq(lmb.memory.region[1].base, ram);
164 ut_asserteq(lmb.memory.region[1].size, ram_size);
166 ut_asserteq(lmb.memory.cnt, 1);
167 ut_asserteq(lmb.memory.region[0].base, ram);
168 ut_asserteq(lmb.memory.region[0].size, ram_size);
174 static int test_multi_alloc_512mb(struct unit_test_state *uts,
175 const phys_addr_t ram)
177 return test_multi_alloc(uts, ram, 0x20000000, 0, 0, ram + 0x10000000);
180 static int test_multi_alloc_512mb_x2(struct unit_test_state *uts,
181 const phys_addr_t ram,
182 const phys_addr_t ram0)
184 return test_multi_alloc(uts, ram, 0x20000000, ram0, 0x20000000,
188 /* Create a memory region with one reserved region and allocate */
189 static int lib_test_lmb_simple(struct unit_test_state *uts)
193 /* simulate 512 MiB RAM beginning at 1GiB */
194 ret = test_multi_alloc_512mb(uts, 0x40000000);
198 /* simulate 512 MiB RAM beginning at 1.5GiB */
199 return test_multi_alloc_512mb(uts, 0xE0000000);
202 DM_TEST(lib_test_lmb_simple, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
204 /* Create two memory regions with one reserved region and allocate */
205 static int lib_test_lmb_simple_x2(struct unit_test_state *uts)
209 /* simulate 512 MiB RAM beginning at 2GiB and 1 GiB */
210 ret = test_multi_alloc_512mb_x2(uts, 0x80000000, 0x40000000);
214 /* simulate 512 MiB RAM beginning at 3.5GiB and 1 GiB */
215 return test_multi_alloc_512mb_x2(uts, 0xE0000000, 0x40000000);
218 DM_TEST(lib_test_lmb_simple_x2, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
220 /* Simulate 512 MiB RAM, allocate some blocks that fit/don't fit */
221 static int test_bigblock(struct unit_test_state *uts, const phys_addr_t ram)
223 const phys_size_t ram_size = 0x20000000;
224 const phys_size_t big_block_size = 0x10000000;
225 const phys_addr_t ram_end = ram + ram_size;
226 const phys_addr_t alloc_64k_addr = ram + 0x10000000;
231 /* check for overflow */
232 ut_assert(ram_end == 0 || ram_end > ram);
236 ret = lmb_add(&lmb, ram, ram_size);
239 /* reserve 64KiB in the middle of RAM */
240 ret = lmb_reserve(&lmb, alloc_64k_addr, 0x10000);
242 ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
245 /* allocate a big block, should be below reserved */
246 a = lmb_alloc(&lmb, big_block_size, 1);
248 ASSERT_LMB(&lmb, ram, ram_size, 1, a,
249 big_block_size + 0x10000, 0, 0, 0, 0);
250 /* allocate 2nd big block */
251 /* This should fail, printing an error */
252 b = lmb_alloc(&lmb, big_block_size, 1);
254 ASSERT_LMB(&lmb, ram, ram_size, 1, a,
255 big_block_size + 0x10000, 0, 0, 0, 0);
257 ret = lmb_free(&lmb, a, big_block_size);
259 ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
262 /* allocate too big block */
263 /* This should fail, printing an error */
264 a = lmb_alloc(&lmb, ram_size, 1);
266 ASSERT_LMB(&lmb, ram, ram_size, 1, alloc_64k_addr, 0x10000,
272 static int lib_test_lmb_big(struct unit_test_state *uts)
276 /* simulate 512 MiB RAM beginning at 1GiB */
277 ret = test_bigblock(uts, 0x40000000);
281 /* simulate 512 MiB RAM beginning at 1.5GiB */
282 return test_bigblock(uts, 0xE0000000);
285 DM_TEST(lib_test_lmb_big, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
287 /* Simulate 512 MiB RAM, allocate a block without previous reservation */
288 static int test_noreserved(struct unit_test_state *uts, const phys_addr_t ram,
289 const phys_addr_t alloc_size, const ulong align)
291 const phys_size_t ram_size = 0x20000000;
292 const phys_addr_t ram_end = ram + ram_size;
296 const phys_addr_t alloc_size_aligned = (alloc_size + align - 1) &
299 /* check for overflow */
300 ut_assert(ram_end == 0 || ram_end > ram);
304 ret = lmb_add(&lmb, ram, ram_size);
306 ASSERT_LMB(&lmb, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
308 /* allocate a block */
309 a = lmb_alloc(&lmb, alloc_size, align);
311 ASSERT_LMB(&lmb, ram, ram_size, 1, ram + ram_size - alloc_size_aligned,
312 alloc_size, 0, 0, 0, 0);
313 /* allocate another block */
314 b = lmb_alloc(&lmb, alloc_size, align);
316 if (alloc_size == alloc_size_aligned) {
317 ASSERT_LMB(&lmb, ram, ram_size, 1, ram + ram_size -
318 (alloc_size_aligned * 2), alloc_size * 2, 0, 0, 0,
321 ASSERT_LMB(&lmb, ram, ram_size, 2, ram + ram_size -
322 (alloc_size_aligned * 2), alloc_size, ram + ram_size
323 - alloc_size_aligned, alloc_size, 0, 0);
326 ret = lmb_free(&lmb, b, alloc_size);
328 ASSERT_LMB(&lmb, ram, ram_size, 1, ram + ram_size - alloc_size_aligned,
329 alloc_size, 0, 0, 0, 0);
330 ret = lmb_free(&lmb, a, alloc_size);
332 ASSERT_LMB(&lmb, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
334 /* allocate a block with base*/
335 b = lmb_alloc_base(&lmb, alloc_size, align, ram_end);
337 ASSERT_LMB(&lmb, ram, ram_size, 1, ram + ram_size - alloc_size_aligned,
338 alloc_size, 0, 0, 0, 0);
340 ret = lmb_free(&lmb, b, alloc_size);
342 ASSERT_LMB(&lmb, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
347 static int lib_test_lmb_noreserved(struct unit_test_state *uts)
351 /* simulate 512 MiB RAM beginning at 1GiB */
352 ret = test_noreserved(uts, 0x40000000, 4, 1);
356 /* simulate 512 MiB RAM beginning at 1.5GiB */
357 return test_noreserved(uts, 0xE0000000, 4, 1);
360 DM_TEST(lib_test_lmb_noreserved, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
362 static int lib_test_lmb_unaligned_size(struct unit_test_state *uts)
366 /* simulate 512 MiB RAM beginning at 1GiB */
367 ret = test_noreserved(uts, 0x40000000, 5, 8);
371 /* simulate 512 MiB RAM beginning at 1.5GiB */
372 return test_noreserved(uts, 0xE0000000, 5, 8);
375 DM_TEST(lib_test_lmb_unaligned_size, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
377 * Simulate a RAM that starts at 0 and allocate down to address 0, which must
378 * fail as '0' means failure for the lmb_alloc functions.
380 static int lib_test_lmb_at_0(struct unit_test_state *uts)
382 const phys_addr_t ram = 0;
383 const phys_size_t ram_size = 0x20000000;
390 ret = lmb_add(&lmb, ram, ram_size);
393 /* allocate nearly everything */
394 a = lmb_alloc(&lmb, ram_size - 4, 1);
395 ut_asserteq(a, ram + 4);
396 ASSERT_LMB(&lmb, ram, ram_size, 1, a, ram_size - 4,
398 /* allocate the rest */
399 /* This should fail as the allocated address would be 0 */
400 b = lmb_alloc(&lmb, 4, 1);
402 /* check that this was an error by checking lmb */
403 ASSERT_LMB(&lmb, ram, ram_size, 1, a, ram_size - 4,
405 /* check that this was an error by freeing b */
406 ret = lmb_free(&lmb, b, 4);
407 ut_asserteq(ret, -1);
408 ASSERT_LMB(&lmb, ram, ram_size, 1, a, ram_size - 4,
411 ret = lmb_free(&lmb, a, ram_size - 4);
413 ASSERT_LMB(&lmb, ram, ram_size, 0, 0, 0, 0, 0, 0, 0);
418 DM_TEST(lib_test_lmb_at_0, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
420 /* Check that calling lmb_reserve with overlapping regions fails. */
421 static int lib_test_lmb_overlapping_reserve(struct unit_test_state *uts)
423 const phys_addr_t ram = 0x40000000;
424 const phys_size_t ram_size = 0x20000000;
430 ret = lmb_add(&lmb, ram, ram_size);
433 ret = lmb_reserve(&lmb, 0x40010000, 0x10000);
435 ASSERT_LMB(&lmb, ram, ram_size, 1, 0x40010000, 0x10000,
437 /* allocate overlapping region should fail */
438 ret = lmb_reserve(&lmb, 0x40011000, 0x10000);
439 ut_asserteq(ret, -1);
440 ASSERT_LMB(&lmb, ram, ram_size, 1, 0x40010000, 0x10000,
442 /* allocate 3nd region */
443 ret = lmb_reserve(&lmb, 0x40030000, 0x10000);
445 ASSERT_LMB(&lmb, ram, ram_size, 2, 0x40010000, 0x10000,
446 0x40030000, 0x10000, 0, 0);
447 /* allocate 2nd region */
448 ret = lmb_reserve(&lmb, 0x40020000, 0x10000);
450 ASSERT_LMB(&lmb, ram, ram_size, 1, 0x40010000, 0x30000,
456 DM_TEST(lib_test_lmb_overlapping_reserve,
457 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
460 * Simulate 512 MiB RAM, reserve 3 blocks, allocate addresses in between.
461 * Expect addresses outside the memory range to fail.
463 static int test_alloc_addr(struct unit_test_state *uts, const phys_addr_t ram)
465 const phys_size_t ram_size = 0x20000000;
466 const phys_addr_t ram_end = ram + ram_size;
467 const phys_size_t alloc_addr_a = ram + 0x8000000;
468 const phys_size_t alloc_addr_b = ram + 0x8000000 * 2;
469 const phys_size_t alloc_addr_c = ram + 0x8000000 * 3;
472 phys_addr_t a, b, c, d, e;
474 /* check for overflow */
475 ut_assert(ram_end == 0 || ram_end > ram);
479 ret = lmb_add(&lmb, ram, ram_size);
482 /* reserve 3 blocks */
483 ret = lmb_reserve(&lmb, alloc_addr_a, 0x10000);
485 ret = lmb_reserve(&lmb, alloc_addr_b, 0x10000);
487 ret = lmb_reserve(&lmb, alloc_addr_c, 0x10000);
489 ASSERT_LMB(&lmb, ram, ram_size, 3, alloc_addr_a, 0x10000,
490 alloc_addr_b, 0x10000, alloc_addr_c, 0x10000);
492 /* allocate blocks */
493 a = lmb_alloc_addr(&lmb, ram, alloc_addr_a - ram);
495 ASSERT_LMB(&lmb, ram, ram_size, 3, ram, 0x8010000,
496 alloc_addr_b, 0x10000, alloc_addr_c, 0x10000);
497 b = lmb_alloc_addr(&lmb, alloc_addr_a + 0x10000,
498 alloc_addr_b - alloc_addr_a - 0x10000);
499 ut_asserteq(b, alloc_addr_a + 0x10000);
500 ASSERT_LMB(&lmb, ram, ram_size, 2, ram, 0x10010000,
501 alloc_addr_c, 0x10000, 0, 0);
502 c = lmb_alloc_addr(&lmb, alloc_addr_b + 0x10000,
503 alloc_addr_c - alloc_addr_b - 0x10000);
504 ut_asserteq(c, alloc_addr_b + 0x10000);
505 ASSERT_LMB(&lmb, ram, ram_size, 1, ram, 0x18010000,
507 d = lmb_alloc_addr(&lmb, alloc_addr_c + 0x10000,
508 ram_end - alloc_addr_c - 0x10000);
509 ut_asserteq(d, alloc_addr_c + 0x10000);
510 ASSERT_LMB(&lmb, ram, ram_size, 1, ram, ram_size,
513 /* allocating anything else should fail */
514 e = lmb_alloc(&lmb, 1, 1);
516 ASSERT_LMB(&lmb, ram, ram_size, 1, ram, ram_size,
519 ret = lmb_free(&lmb, d, ram_end - alloc_addr_c - 0x10000);
522 /* allocate at 3 points in free range */
524 d = lmb_alloc_addr(&lmb, ram_end - 4, 4);
525 ut_asserteq(d, ram_end - 4);
526 ASSERT_LMB(&lmb, ram, ram_size, 2, ram, 0x18010000,
528 ret = lmb_free(&lmb, d, 4);
530 ASSERT_LMB(&lmb, ram, ram_size, 1, ram, 0x18010000,
533 d = lmb_alloc_addr(&lmb, ram_end - 128, 4);
534 ut_asserteq(d, ram_end - 128);
535 ASSERT_LMB(&lmb, ram, ram_size, 2, ram, 0x18010000,
537 ret = lmb_free(&lmb, d, 4);
539 ASSERT_LMB(&lmb, ram, ram_size, 1, ram, 0x18010000,
542 d = lmb_alloc_addr(&lmb, alloc_addr_c + 0x10000, 4);
543 ut_asserteq(d, alloc_addr_c + 0x10000);
544 ASSERT_LMB(&lmb, ram, ram_size, 1, ram, 0x18010004,
546 ret = lmb_free(&lmb, d, 4);
548 ASSERT_LMB(&lmb, ram, ram_size, 1, ram, 0x18010000,
551 /* allocate at the bottom */
552 ret = lmb_free(&lmb, a, alloc_addr_a - ram);
554 ASSERT_LMB(&lmb, ram, ram_size, 1, ram + 0x8000000, 0x10010000,
556 d = lmb_alloc_addr(&lmb, ram, 4);
558 ASSERT_LMB(&lmb, ram, ram_size, 2, d, 4,
559 ram + 0x8000000, 0x10010000, 0, 0);
561 /* check that allocating outside memory fails */
563 ret = lmb_alloc_addr(&lmb, ram_end, 1);
567 ret = lmb_alloc_addr(&lmb, ram - 1, 1);
574 static int lib_test_lmb_alloc_addr(struct unit_test_state *uts)
578 /* simulate 512 MiB RAM beginning at 1GiB */
579 ret = test_alloc_addr(uts, 0x40000000);
583 /* simulate 512 MiB RAM beginning at 1.5GiB */
584 return test_alloc_addr(uts, 0xE0000000);
587 DM_TEST(lib_test_lmb_alloc_addr, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
589 /* Simulate 512 MiB RAM, reserve 3 blocks, check addresses in between */
590 static int test_get_unreserved_size(struct unit_test_state *uts,
591 const phys_addr_t ram)
593 const phys_size_t ram_size = 0x20000000;
594 const phys_addr_t ram_end = ram + ram_size;
595 const phys_size_t alloc_addr_a = ram + 0x8000000;
596 const phys_size_t alloc_addr_b = ram + 0x8000000 * 2;
597 const phys_size_t alloc_addr_c = ram + 0x8000000 * 3;
602 /* check for overflow */
603 ut_assert(ram_end == 0 || ram_end > ram);
607 ret = lmb_add(&lmb, ram, ram_size);
610 /* reserve 3 blocks */
611 ret = lmb_reserve(&lmb, alloc_addr_a, 0x10000);
613 ret = lmb_reserve(&lmb, alloc_addr_b, 0x10000);
615 ret = lmb_reserve(&lmb, alloc_addr_c, 0x10000);
617 ASSERT_LMB(&lmb, ram, ram_size, 3, alloc_addr_a, 0x10000,
618 alloc_addr_b, 0x10000, alloc_addr_c, 0x10000);
620 /* check addresses in between blocks */
621 s = lmb_get_free_size(&lmb, ram);
622 ut_asserteq(s, alloc_addr_a - ram);
623 s = lmb_get_free_size(&lmb, ram + 0x10000);
624 ut_asserteq(s, alloc_addr_a - ram - 0x10000);
625 s = lmb_get_free_size(&lmb, alloc_addr_a - 4);
628 s = lmb_get_free_size(&lmb, alloc_addr_a + 0x10000);
629 ut_asserteq(s, alloc_addr_b - alloc_addr_a - 0x10000);
630 s = lmb_get_free_size(&lmb, alloc_addr_a + 0x20000);
631 ut_asserteq(s, alloc_addr_b - alloc_addr_a - 0x20000);
632 s = lmb_get_free_size(&lmb, alloc_addr_b - 4);
635 s = lmb_get_free_size(&lmb, alloc_addr_c + 0x10000);
636 ut_asserteq(s, ram_end - alloc_addr_c - 0x10000);
637 s = lmb_get_free_size(&lmb, alloc_addr_c + 0x20000);
638 ut_asserteq(s, ram_end - alloc_addr_c - 0x20000);
639 s = lmb_get_free_size(&lmb, ram_end - 4);
645 static int lib_test_lmb_get_free_size(struct unit_test_state *uts)
649 /* simulate 512 MiB RAM beginning at 1GiB */
650 ret = test_get_unreserved_size(uts, 0x40000000);
654 /* simulate 512 MiB RAM beginning at 1.5GiB */
655 return test_get_unreserved_size(uts, 0xE0000000);
658 DM_TEST(lib_test_lmb_get_free_size,
659 DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);