fdt.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107
  1. /*
  2. * Copyright (c) 2006-2022, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2022-08-25 GuEe-GUI first version
  9. */
  10. #include <rthw.h>
  11. #include <rtthread.h>
  12. #include <drivers/ofw_fdt.h>
  13. #include <drivers/ofw_raw.h>
  14. #include <drivers/core/dm.h>
  15. #define DBG_TAG "rtdm.ofw"
  16. #define DBG_LVL DBG_INFO
  17. #include <rtdbg.h>
  18. #include "ofw_internal.h"
  19. struct rt_fdt_earlycon fdt_earlycon rt_section(".bss.noclean.earlycon");
  20. RT_OFW_SYMBOL_TYPE_RANGE(earlycon, struct rt_fdt_earlycon_id, _earlycon_start = {}, _earlycon_end = {});
  21. #ifndef ARCH_INIT_MEMREGION_NR
  22. #define ARCH_INIT_MEMREGION_NR 128
  23. #endif
  24. static rt_region_t _memregion[ARCH_INIT_MEMREGION_NR] rt_section(".bss.noclean.memregion");
  25. static int _memregion_front_idx = 0, _memregion_last_idx = RT_ARRAY_SIZE(_memregion) - 1;
  26. static void *_fdt = RT_NULL;
  27. static rt_phandle _phandle_min;
  28. static rt_phandle _phandle_max;
  29. static rt_size_t _root_size_cells;
  30. static rt_size_t _root_addr_cells;
  31. const char *rt_fdt_node_name(const char *full_name)
  32. {
  33. const char *node_name = strrchr(full_name, '/');
  34. return node_name ? node_name + 1 : full_name;
  35. }
  36. rt_uint64_t rt_fdt_read_number(const fdt32_t *cell, int size)
  37. {
  38. rt_uint64_t val = 0;
  39. for (; size--; ++cell)
  40. {
  41. val = (val << 32) | fdt32_to_cpu(*cell);
  42. }
  43. return val;
  44. }
  45. rt_uint64_t rt_fdt_next_cell(const fdt32_t **cellptr, int size)
  46. {
  47. const fdt32_t *ptr = *cellptr;
  48. *cellptr = ptr + size;
  49. return rt_fdt_read_number(ptr, size);
  50. }
  51. rt_uint64_t rt_fdt_translate_address(void *fdt, int nodeoffset, rt_uint64_t address)
  52. {
  53. rt_uint64_t ret = address;
  54. if (fdt && nodeoffset >= 0)
  55. {
  56. struct
  57. {
  58. rt_uint64_t addr;
  59. rt_size_t size;
  60. int addr_cells;
  61. int size_cells;
  62. } local, cpu;
  63. int parent, length = 0, group_len;
  64. const fdt32_t *ranges = RT_NULL;
  65. parent = fdt_parent_offset(fdt, nodeoffset);
  66. if (parent >= 0)
  67. {
  68. ranges = fdt_getprop(fdt, nodeoffset, "ranges", &length);
  69. }
  70. if (ranges && length > 0)
  71. {
  72. local.addr_cells = fdt_address_cells(fdt, nodeoffset);
  73. local.size_cells = fdt_size_cells(fdt, nodeoffset);
  74. cpu.addr_cells = fdt_io_addr_cells(fdt, nodeoffset);
  75. cpu.size_cells = fdt_io_size_cells(fdt, nodeoffset);
  76. group_len = local.addr_cells + cpu.addr_cells + local.size_cells;
  77. while (length > 0)
  78. {
  79. local.addr = rt_fdt_next_cell(&ranges, local.addr_cells);
  80. cpu.addr = rt_fdt_next_cell(&ranges, cpu.addr_cells);
  81. local.size = rt_fdt_next_cell(&ranges, local.size_cells);
  82. if (local.addr <= address && local.addr + local.size > address)
  83. {
  84. ret += address - cpu.addr;
  85. break;
  86. }
  87. length -= group_len;
  88. }
  89. }
  90. }
  91. return ret;
  92. }
  93. rt_bool_t rt_fdt_device_is_available(void *fdt, int nodeoffset)
  94. {
  95. rt_bool_t ret;
  96. const char *status = fdt_getprop(fdt, nodeoffset, "status", RT_NULL);
  97. if (!status)
  98. {
  99. ret = RT_TRUE;
  100. }
  101. else if (!rt_strcmp(status, "ok") || !rt_strcmp(status, "okay"))
  102. {
  103. ret = RT_TRUE;
  104. }
  105. else
  106. {
  107. ret = RT_FALSE;
  108. }
  109. return ret;
  110. }
  111. rt_err_t rt_fdt_commit_memregion_early(rt_region_t *region, rt_bool_t is_reserved)
  112. {
  113. rt_err_t err = RT_EOK;
  114. if (region && region->name)
  115. {
  116. if (_memregion_front_idx < _memregion_last_idx)
  117. {
  118. int idx;
  119. if (!_memregion_front_idx && _memregion_last_idx == RT_ARRAY_SIZE(_memregion) - 1)
  120. {
  121. for (int i = 0; i < RT_ARRAY_SIZE(_memregion); ++i)
  122. {
  123. _memregion[i].name = RT_NULL;
  124. }
  125. }
  126. idx = is_reserved ? _memregion_last_idx-- : _memregion_front_idx++;
  127. rt_memcpy(&_memregion[idx], region, sizeof(*region));
  128. }
  129. else
  130. {
  131. err = -RT_EEMPTY;
  132. }
  133. }
  134. else
  135. {
  136. err = -RT_EINVAL;
  137. }
  138. return err;
  139. }
  140. rt_err_t rt_fdt_commit_memregion_request(rt_region_t **out_region, rt_size_t *out_nr, rt_bool_t is_reserved)
  141. {
  142. rt_err_t err = RT_EOK;
  143. if (out_region && out_nr)
  144. {
  145. if (is_reserved)
  146. {
  147. *out_region = &_memregion[_memregion_last_idx + 1];
  148. *out_nr = RT_ARRAY_SIZE(_memregion) - 1 - _memregion_last_idx;
  149. }
  150. else
  151. {
  152. *out_region = &_memregion[0];
  153. *out_nr = _memregion_front_idx;
  154. }
  155. if (*out_nr == 0)
  156. {
  157. err = -RT_EEMPTY;
  158. }
  159. }
  160. else
  161. {
  162. err = -RT_EINVAL;
  163. }
  164. return err;
  165. }
  166. rt_err_t rt_fdt_prefetch(void *fdt)
  167. {
  168. rt_err_t err = -RT_ERROR;
  169. if (fdt)
  170. {
  171. _fdt = fdt;
  172. if (!fdt_check_header(_fdt))
  173. {
  174. err = rt_fdt_scan_root();
  175. }
  176. else
  177. {
  178. err = -RT_EINVAL;
  179. }
  180. }
  181. return err;
  182. }
  183. rt_err_t rt_fdt_scan_root(void)
  184. {
  185. rt_err_t err = RT_EOK;
  186. int root = fdt_path_offset(_fdt, "/");
  187. if (root >= 0)
  188. {
  189. const fdt32_t *prop;
  190. _root_addr_cells = OFW_ROOT_NODE_ADDR_CELLS_DEFAULT;
  191. _root_size_cells = OFW_ROOT_NODE_SIZE_CELLS_DEFAULT;
  192. if ((prop = fdt_getprop(_fdt, root, "#address-cells", RT_NULL)))
  193. {
  194. _root_addr_cells = fdt32_to_cpu(*prop);
  195. }
  196. if ((prop = fdt_getprop(_fdt, root, "#size-cells", RT_NULL)))
  197. {
  198. _root_size_cells = fdt32_to_cpu(*prop);
  199. }
  200. }
  201. else
  202. {
  203. err = -RT_EEMPTY;
  204. }
  205. return err;
  206. }
  207. rt_inline rt_err_t commit_memregion(const char *name, rt_uint64_t base, rt_uint64_t size, rt_bool_t is_reserved)
  208. {
  209. return rt_fdt_commit_memregion_early(&(rt_region_t)
  210. {
  211. .name = name,
  212. .start = (rt_size_t)base,
  213. .end = (rt_size_t)(base + size),
  214. }, is_reserved);
  215. }
  216. static rt_err_t reserve_memregion(const char *name, rt_uint64_t base, rt_uint64_t size)
  217. {
  218. if (commit_memregion(name, base, size, RT_TRUE) == -RT_EEMPTY)
  219. {
  220. LOG_W("Reserved memory: %p - %p%s", base, base + size, " unable to record");
  221. }
  222. return RT_EOK;
  223. }
  224. static rt_err_t fdt_reserved_mem_check_root(int nodeoffset)
  225. {
  226. rt_err_t err = RT_EOK;
  227. const fdt32_t *prop = fdt_getprop(_fdt, nodeoffset, "#size-cells", RT_NULL);
  228. if (!prop || fdt32_to_cpu(*prop) != _root_size_cells)
  229. {
  230. err = -RT_EINVAL;
  231. }
  232. if (!err)
  233. {
  234. prop = fdt_getprop(_fdt, nodeoffset, "#address-cells", RT_NULL);
  235. if (!prop || fdt32_to_cpu(*prop) != _root_addr_cells)
  236. {
  237. err = -RT_EINVAL;
  238. }
  239. }
  240. if (!err && !(prop = fdt_getprop(_fdt, nodeoffset, "ranges", RT_NULL)))
  241. {
  242. err = -RT_EINVAL;
  243. }
  244. return err;
  245. }
  246. static rt_err_t fdt_reserved_memory_reg(int nodeoffset, const char *uname)
  247. {
  248. rt_err_t err = RT_EOK;
  249. rt_ubase_t base, size;
  250. const fdt32_t *prop;
  251. int len, t_len = (_root_addr_cells + _root_size_cells) * sizeof(fdt32_t);
  252. if ((prop = fdt_getprop(_fdt, nodeoffset, "reg", &len)))
  253. {
  254. if (len && len % t_len != 0)
  255. {
  256. LOG_E("Reserved memory: invalid reg property in '%s', skipping node", uname);
  257. err = -RT_EINVAL;
  258. }
  259. else
  260. {
  261. while (len >= t_len)
  262. {
  263. base = rt_fdt_next_cell(&prop, _root_addr_cells);
  264. size = rt_fdt_next_cell(&prop, _root_size_cells);
  265. if (!size)
  266. {
  267. continue;
  268. }
  269. base = rt_fdt_translate_address(_fdt, nodeoffset, base);
  270. reserve_memregion(fdt_get_name(_fdt, nodeoffset, RT_NULL), base, size);
  271. len -= t_len;
  272. }
  273. }
  274. }
  275. else
  276. {
  277. err = -RT_EEMPTY;
  278. }
  279. return err;
  280. }
  281. static void fdt_scan_reserved_memory(void)
  282. {
  283. int nodeoffset, child;
  284. nodeoffset = fdt_path_offset(_fdt, "/reserved-memory");
  285. if (nodeoffset >= 0)
  286. {
  287. if (!fdt_reserved_mem_check_root(nodeoffset))
  288. {
  289. fdt_for_each_subnode(child, _fdt, nodeoffset)
  290. {
  291. rt_err_t err;
  292. const char *uname;
  293. if (!rt_fdt_device_is_available(_fdt, child))
  294. {
  295. continue;
  296. }
  297. uname = fdt_get_name(_fdt, child, RT_NULL);
  298. err = fdt_reserved_memory_reg(child, uname);
  299. if (err == -RT_EEMPTY && fdt_getprop(_fdt, child, "size", RT_NULL))
  300. {
  301. reserve_memregion(fdt_get_name(_fdt, child, RT_NULL), 0, 0);
  302. }
  303. }
  304. }
  305. else
  306. {
  307. LOG_E("Reserved memory: unsupported node format, ignoring");
  308. }
  309. }
  310. }
  311. static rt_err_t fdt_scan_memory(void)
  312. {
  313. int nodeoffset, no;
  314. rt_region_t *region;
  315. rt_uint64_t base, size;
  316. rt_err_t err = -RT_EEMPTY;
  317. /* Process header /memreserve/ fields */
  318. for (no = 0; ; ++no)
  319. {
  320. fdt_get_mem_rsv(_fdt, no, &base, &size);
  321. if (!size)
  322. {
  323. break;
  324. }
  325. reserve_memregion("memreserve", base, size);
  326. }
  327. no = 0;
  328. fdt_for_each_subnode(nodeoffset, _fdt, 0)
  329. {
  330. int len;
  331. const fdt32_t *reg, *endptr;
  332. const char *name = fdt_get_name(_fdt, nodeoffset, RT_NULL);
  333. const char *type = fdt_getprop(_fdt, nodeoffset, "device_type", RT_NULL);
  334. if (!type || rt_strcmp(type, "memory"))
  335. {
  336. continue;
  337. }
  338. if (!rt_fdt_device_is_available(_fdt, nodeoffset))
  339. {
  340. continue;
  341. }
  342. reg = fdt_getprop(_fdt, nodeoffset, "reg", &len);
  343. if (!reg)
  344. {
  345. continue;
  346. }
  347. endptr = reg + (len / sizeof(fdt32_t));
  348. name = name ? name : "memory";
  349. while ((endptr - reg) >= (_root_addr_cells + _root_size_cells))
  350. {
  351. base = rt_fdt_next_cell(&reg, _root_addr_cells);
  352. size = rt_fdt_next_cell(&reg, _root_size_cells);
  353. if (!size)
  354. {
  355. continue;
  356. }
  357. err = commit_memregion(name, base, size, RT_FALSE);
  358. if (!err)
  359. {
  360. LOG_I("Memory node(%d) ranges: %p - %p%s", no, base, base + size, "");
  361. }
  362. else
  363. {
  364. LOG_W("Memory node(%d) ranges: %p - %p%s", no, base, base + size, " unable to record");
  365. }
  366. ++no;
  367. }
  368. }
  369. if (!err)
  370. {
  371. fdt_scan_reserved_memory();
  372. }
  373. region = &_memregion[0];
  374. for (no = 0; region->name; ++region)
  375. {
  376. /* We need check the memory region now. */
  377. for (int i = RT_ARRAY_SIZE(_memregion) - 1; i > no; --i)
  378. {
  379. rt_region_t *res_region = &_memregion[i];
  380. if (!res_region->name)
  381. {
  382. break;
  383. }
  384. /*
  385. * case 0: case 1:
  386. * +------------------+ +----------+
  387. * | memory | | memory |
  388. * +---+----------+---+ +---+----------+---+
  389. * | reserved | | reserved |
  390. * +----------+ +---+----------+---+
  391. *
  392. * case 2: case 3:
  393. * +------------------+ +------------------+
  394. * | memory | | memory |
  395. * +--------------+---+------+ +------+---+--------------+
  396. * | reserved | | reserved |
  397. * +----------+ +----------+
  398. */
  399. /* case 0 */
  400. if (res_region->start >= region->start && res_region->end <= region->end)
  401. {
  402. rt_size_t new_size = region->end - res_region->end;
  403. region->end = res_region->start;
  404. /* Commit part next block */
  405. if (new_size)
  406. {
  407. err = commit_memregion(region->name, res_region->end, new_size, RT_FALSE);
  408. }
  409. if (!err)
  410. {
  411. ++no;
  412. /* Scan again */
  413. region = &_memregion[0];
  414. --region;
  415. break;
  416. }
  417. continue;
  418. }
  419. /* case 1 */
  420. if (res_region->start <= region->start && res_region->end >= region->end)
  421. {
  422. region->name = RT_NULL;
  423. break;
  424. }
  425. /* case 2 */
  426. if (res_region->start <= region->end && res_region->end >= region->end)
  427. {
  428. region->end = res_region->start;
  429. continue;
  430. }
  431. /* case 3 */
  432. if (res_region->start <= region->start && res_region->end >= region->start)
  433. {
  434. region->start = res_region->end;
  435. continue;
  436. }
  437. }
  438. }
  439. return err;
  440. }
  441. rt_err_t rt_fdt_scan_memory(void)
  442. {
  443. rt_err_t err = -RT_EEMPTY;
  444. if (_fdt)
  445. {
  446. err = fdt_scan_memory();
  447. }
  448. return err;
  449. }
  450. rt_err_t rt_fdt_scan_initrd(rt_uint64_t *ranges)
  451. {
  452. rt_err_t err = -RT_EEMPTY;
  453. if (_fdt && ranges)
  454. {
  455. int s_len, e_len;
  456. const fdt32_t *start = RT_NULL, *end = RT_NULL;
  457. int offset = fdt_path_offset(_fdt, "/chosen");
  458. if (offset >= 0)
  459. {
  460. start = fdt_getprop(_fdt, offset, "linux,initrd-start", &s_len);
  461. end = fdt_getprop(_fdt, offset, "linux,initrd-end", &e_len);
  462. }
  463. if (start && end)
  464. {
  465. s_len /= sizeof(*start);
  466. e_len /= sizeof(*end);
  467. ranges[0] = rt_fdt_read_number(start, s_len);
  468. ranges[1] = rt_fdt_read_number(end, e_len);
  469. commit_memregion("initrd", ranges[0], ranges[1] - ranges[0], RT_TRUE);
  470. err = RT_EOK;
  471. }
  472. }
  473. else if (!ranges)
  474. {
  475. err = -RT_EINVAL;
  476. }
  477. return err;
  478. }
  479. rt_err_t rt_fdt_model_dump(void)
  480. {
  481. rt_err_t err = RT_EOK;
  482. int root = fdt_path_offset(_fdt, "/");
  483. if (root >= 0)
  484. {
  485. const char *mach_model = fdt_getprop(_fdt, root, "model", RT_NULL);
  486. if (!mach_model)
  487. {
  488. mach_model = fdt_getprop(_fdt, root, "compatible", RT_NULL);
  489. }
  490. LOG_I("Machine model: %s", mach_model ? mach_model : "<undefined>");
  491. }
  492. else
  493. {
  494. err = -RT_EEMPTY;
  495. }
  496. return err;
  497. }
  498. rt_weak rt_err_t rt_fdt_boot_dump(void)
  499. {
  500. LOG_I("Booting RT-Thread on physical CPU 0x%x", rt_hw_cpu_id());
  501. return RT_EOK;
  502. }
  503. void rt_fdt_earlycon_output(const char *str)
  504. {
  505. if (fdt_earlycon.console_putc)
  506. {
  507. while (*str)
  508. {
  509. fdt_earlycon.console_putc(fdt_earlycon.data, *str);
  510. if (*str == '\n')
  511. {
  512. /* Make sure return */
  513. fdt_earlycon.console_putc(fdt_earlycon.data, '\r');
  514. }
  515. ++str;
  516. }
  517. }
  518. else
  519. {
  520. /* We need a byte to save '\0' */
  521. while (*str && fdt_earlycon.msg_idx < sizeof(fdt_earlycon.msg) - 1)
  522. {
  523. fdt_earlycon.msg[fdt_earlycon.msg_idx++] = *str;
  524. ++str;
  525. }
  526. fdt_earlycon.msg[fdt_earlycon.msg_idx] = '\0';
  527. }
  528. }
  529. void rt_fdt_earlycon_kick(int why)
  530. {
  531. if (fdt_earlycon.console_kick)
  532. {
  533. fdt_earlycon.console_kick(&fdt_earlycon, why);
  534. }
  535. if (why == FDT_EARLYCON_KICK_COMPLETED && fdt_earlycon.msg_idx)
  536. {
  537. fdt_earlycon.msg_idx = 0;
  538. /* Dump old messages */
  539. rt_kputs(fdt_earlycon.msg);
  540. }
  541. }
  542. rt_err_t rt_fdt_scan_chosen_stdout(void)
  543. {
  544. rt_err_t err = RT_EOK;
  545. int offset;
  546. int len, options_len = 0;
  547. const char *options = RT_NULL, *con_type = RT_NULL;
  548. rt_memset(&fdt_earlycon, 0, sizeof(fdt_earlycon) - sizeof(fdt_earlycon.msg));
  549. fdt_earlycon.nodeoffset = -1;
  550. offset = fdt_path_offset(_fdt, "/chosen");
  551. if (offset >= 0)
  552. {
  553. const char *stdout_path = RT_NULL;
  554. const char *bootargs = fdt_getprop(_fdt, offset, "bootargs", &len);
  555. if (bootargs && (options = rt_strstr(bootargs, "earlycon")))
  556. {
  557. options += sizeof("earlycon") - 1;
  558. if (*options == '\0' || *options == ' ')
  559. {
  560. stdout_path = fdt_getprop(_fdt, offset, "stdout-path", &len);
  561. if (stdout_path && len)
  562. {
  563. const char *path_split = strchrnul(stdout_path, ':');
  564. if (*path_split != '\0')
  565. {
  566. options = path_split + 1;
  567. }
  568. len = path_split - stdout_path;
  569. /*
  570. * Will try 2 styles:
  571. * 1: stdout-path = "serialN:bbbbpnf";
  572. * 2: stdout-path = "/serial-path";
  573. */
  574. offset = fdt_path_offset_namelen(_fdt, stdout_path, len);
  575. if (offset < 0)
  576. {
  577. stdout_path = RT_NULL;
  578. }
  579. }
  580. else if (*options == '=')
  581. {
  582. ++options;
  583. }
  584. else
  585. {
  586. /* Maybe is error in bootargs or it is a new arg */
  587. options = RT_NULL;
  588. }
  589. if (!stdout_path)
  590. {
  591. /* We couldn't know how to setup the earlycon */
  592. options = RT_NULL;
  593. }
  594. }
  595. else
  596. {
  597. offset = -1;
  598. }
  599. if (options)
  600. {
  601. int type_len = 0;
  602. struct rt_fdt_earlycon_id *earlycon_id, *earlycon_id_end, *best_earlycon_id = RT_NULL;
  603. earlycon_id = (struct rt_fdt_earlycon_id *)&_earlycon_start;
  604. earlycon_id_end = (struct rt_fdt_earlycon_id *)&_earlycon_end;
  605. err = -RT_ENOSYS;
  606. /* Only "earlycon" in bootargs */
  607. if (stdout_path)
  608. {
  609. const fdt32_t *reg;
  610. options = RT_NULL;
  611. if ((reg = fdt_getprop(_fdt, offset, "reg", RT_NULL)))
  612. {
  613. rt_uint64_t address;
  614. int addr_cells = fdt_io_addr_cells(_fdt, offset);
  615. int size_cells = fdt_io_size_cells(_fdt, offset);
  616. address = rt_fdt_read_number(reg, addr_cells);
  617. fdt_earlycon.mmio = rt_fdt_translate_address(_fdt, offset, address);
  618. fdt_earlycon.size = rt_fdt_read_number(reg + addr_cells, size_cells);
  619. }
  620. }
  621. else
  622. {
  623. /* Pass split */
  624. while (*options && (*options == '=' || *options == ' '))
  625. {
  626. ++options;
  627. }
  628. if (*options)
  629. {
  630. type_len = strchrnul(options, ',') - options;
  631. }
  632. }
  633. if (options && *options && *options != ' ')
  634. {
  635. options_len = strchrnul(options, ' ') - options;
  636. }
  637. /* console > stdout-path */
  638. for (int max_score = 0; earlycon_id < earlycon_id_end; ++earlycon_id)
  639. {
  640. int score = 0;
  641. if (type_len && earlycon_id->type)
  642. {
  643. if (!rt_strncmp(earlycon_id->type, options, type_len))
  644. {
  645. score += 1;
  646. }
  647. }
  648. if (stdout_path && earlycon_id->compatible)
  649. {
  650. if (!fdt_node_check_compatible(_fdt, offset, earlycon_id->compatible))
  651. {
  652. score += 2;
  653. }
  654. }
  655. if (score > max_score)
  656. {
  657. max_score = score;
  658. best_earlycon_id = earlycon_id;
  659. if (score == 3)
  660. {
  661. break;
  662. }
  663. }
  664. }
  665. if (best_earlycon_id && best_earlycon_id->setup)
  666. {
  667. rt_bool_t used_options = RT_FALSE;
  668. if (!con_type)
  669. {
  670. con_type = best_earlycon_id->type;
  671. }
  672. fdt_earlycon.fdt = _fdt;
  673. fdt_earlycon.nodeoffset = offset;
  674. err = best_earlycon_id->setup(&fdt_earlycon, options);
  675. for (int i = 0; i < options_len; ++i)
  676. {
  677. if (options[i] == RT_FDT_EARLYCON_OPTION_SIGNATURE)
  678. {
  679. /* Restore ',' */
  680. ((char *)options)[i++] = ',';
  681. options = &options[i];
  682. options_len -= i;
  683. used_options = RT_TRUE;
  684. break;
  685. }
  686. }
  687. if (!used_options)
  688. {
  689. options = RT_NULL;
  690. options_len = 0;
  691. }
  692. }
  693. }
  694. }
  695. else
  696. {
  697. err = -RT_EEMPTY;
  698. }
  699. }
  700. else
  701. {
  702. err = -RT_EEMPTY;
  703. }
  704. if (fdt_earlycon.msg_idx)
  705. {
  706. fdt_earlycon.msg_idx = 0;
  707. rt_kputs(fdt_earlycon.msg);
  708. }
  709. rt_fdt_boot_dump();
  710. rt_fdt_model_dump();
  711. if (fdt_earlycon.mmio)
  712. {
  713. LOG_I("Earlycon: %s at MMIO/PIO %p (options '%.*s')",
  714. con_type, fdt_earlycon.mmio, options_len, options ? options : "");
  715. }
  716. return err;
  717. }
  718. static void system_node_init_flag(struct rt_ofw_node *np)
  719. {
  720. if (np)
  721. {
  722. rt_ofw_node_set_flag(np, RT_OFW_F_READLY);
  723. rt_ofw_node_set_flag(np, RT_OFW_F_SYSTEM);
  724. }
  725. }
  726. rt_err_t rt_fdt_unflatten(void)
  727. {
  728. rt_err_t err = RT_EOK;
  729. if (_fdt)
  730. {
  731. _phandle_min = OFW_PHANDLE_MAX;
  732. _phandle_max = OFW_PHANDLE_MIN;
  733. ofw_node_root = rt_fdt_unflatten_single(_fdt);
  734. if (ofw_node_root)
  735. {
  736. ofw_node_cpus = rt_ofw_find_node_by_path("/cpus");
  737. ofw_node_chosen = rt_ofw_find_node_by_path("/chosen");
  738. ofw_node_aliases = rt_ofw_find_node_by_path("/aliases");
  739. ofw_node_reserved_memory = rt_ofw_find_node_by_path("/reserved-memory");
  740. RT_ASSERT(ofw_node_cpus != RT_NULL);
  741. system_node_init_flag(ofw_node_root);
  742. system_node_init_flag(ofw_node_cpus);
  743. system_node_init_flag(ofw_node_chosen);
  744. system_node_init_flag(ofw_node_aliases);
  745. system_node_init_flag(ofw_node_reserved_memory);
  746. if (ofw_node_aliases)
  747. {
  748. err = ofw_alias_scan();
  749. }
  750. err = err ? : ofw_phandle_hash_reset(_phandle_min, _phandle_max);
  751. }
  752. }
  753. else
  754. {
  755. err = -RT_ERROR;
  756. }
  757. return err;
  758. }
  759. static rt_err_t fdt_unflatten_props(struct rt_ofw_node *np, int node_off)
  760. {
  761. rt_err_t err = RT_EOK;
  762. struct rt_ofw_prop *prop;
  763. int prop_off = fdt_first_property_offset(_fdt, node_off);
  764. if (prop_off >= 0)
  765. {
  766. np->props = rt_malloc(sizeof(struct rt_ofw_prop));
  767. }
  768. prop = np->props;
  769. while (prop_off >= 0)
  770. {
  771. if (!prop)
  772. {
  773. err = -RT_ENOMEM;
  774. break;
  775. }
  776. prop->value = (void *)fdt_getprop_by_offset(_fdt, prop_off, &prop->name, &prop->length);
  777. if (prop->name && !rt_strcmp(prop->name, "name"))
  778. {
  779. np->name = prop->value;
  780. }
  781. prop_off = fdt_next_property_offset(_fdt, prop_off);
  782. if (prop_off < 0)
  783. {
  784. prop->next = RT_NULL;
  785. break;
  786. }
  787. prop->next = rt_malloc(sizeof(struct rt_ofw_prop));
  788. prop = prop->next;
  789. }
  790. return err;
  791. }
  792. static rt_err_t fdt_unflatten_single(struct rt_ofw_node *np, int node_off)
  793. {
  794. int depth = 0;
  795. rt_err_t err = RT_EOK;
  796. struct rt_ofw_node *np_stack[OFW_NODE_MAX_DEPTH], *parent = RT_NULL;
  797. do {
  798. if (!np)
  799. {
  800. err = -RT_ENOMEM;
  801. break;
  802. }
  803. np->name = "<NULL>";
  804. np->full_name = fdt_get_name(_fdt, node_off, RT_NULL);
  805. np->phandle = fdt_get_phandle(_fdt, node_off);
  806. if (np->phandle >= OFW_PHANDLE_MIN)
  807. {
  808. if (np->phandle < _phandle_min)
  809. {
  810. _phandle_min = np->phandle;
  811. }
  812. if (np->phandle > _phandle_max)
  813. {
  814. _phandle_max = np->phandle;
  815. }
  816. }
  817. if ((err = fdt_unflatten_props(np, node_off)))
  818. {
  819. break;
  820. }
  821. np->parent = parent;
  822. rt_ref_init(&np->ref);
  823. np->flags = 0;
  824. if (!np->child)
  825. {
  826. /* Save node offset temp */
  827. rt_ofw_data(np) = (void *)(rt_ubase_t)node_off;
  828. /* Check children */
  829. node_off = fdt_first_subnode(_fdt, node_off);
  830. if (node_off >= 0)
  831. {
  832. parent = np;
  833. np_stack[depth++] = np;
  834. np->child = rt_calloc(1, sizeof(struct rt_ofw_node));
  835. np = np->child;
  836. continue;
  837. }
  838. }
  839. while (depth >= 0)
  840. {
  841. /* Restore node offset temp */
  842. node_off = (long)rt_ofw_data(np);
  843. rt_ofw_data(np) = RT_NULL;
  844. /* Next step */
  845. node_off = fdt_next_subnode(_fdt, node_off);
  846. if (node_off < 0)
  847. {
  848. np->sibling = RT_NULL;
  849. np = np_stack[--depth];
  850. }
  851. else
  852. {
  853. parent = np->parent;
  854. np->sibling = rt_calloc(1, sizeof(struct rt_ofw_node));
  855. np = np->sibling;
  856. break;
  857. }
  858. }
  859. } while (depth >= 0);
  860. return err;
  861. }
  862. struct rt_ofw_node *rt_fdt_unflatten_single(void *fdt)
  863. {
  864. int root_off;
  865. struct fdt_info *header;
  866. struct rt_ofw_node *root = RT_NULL;
  867. if (fdt && (root_off = fdt_path_offset(fdt, "/")) >= 0)
  868. {
  869. root = rt_calloc(1, sizeof(struct fdt_info) + sizeof(struct rt_ofw_node));
  870. }
  871. if (root)
  872. {
  873. header = (void *)root + sizeof(struct rt_ofw_node);
  874. rt_strncpy(header->name, "/", sizeof("/"));
  875. header->fdt = fdt;
  876. header->rsvmap = (struct fdt_reserve_entry *)((void *)fdt + fdt_off_mem_rsvmap(fdt));
  877. header->rsvmap_nr = fdt_num_mem_rsv(fdt);
  878. if (!fdt_unflatten_single(root, root_off))
  879. {
  880. root->name = (const char *)header;
  881. }
  882. else
  883. {
  884. rt_ofw_node_destroy(root);
  885. root = RT_NULL;
  886. }
  887. }
  888. return root;
  889. }