fdt.c 28 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121
  1. /*
  2. * Copyright (c) 2006-2024, 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. for (; len >= t_len; 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. * +--------+ +--------+
  386. * | memory | | memory |
  387. * +--------+ +----------+ +----------+ +--------+
  388. * | reserved | | reserved |
  389. * +----------+ +----------+
  390. */
  391. if (res_region->start >= region->end || res_region->end <= region->start)
  392. {
  393. /* No adjustments needed */
  394. continue;
  395. }
  396. /*
  397. * case 0: case 1:
  398. * +------------------+ +----------+
  399. * | memory | | memory |
  400. * +---+----------+---+ +---+----------+---+
  401. * | reserved | | reserved |
  402. * +----------+ +---+----------+---+
  403. *
  404. * case 2: case 3:
  405. * +------------------+ +------------------+
  406. * | memory | | memory |
  407. * +--------------+---+------+ +------+---+--------------+
  408. * | reserved | | reserved |
  409. * +----------+ +----------+
  410. */
  411. if (res_region->start > region->start)
  412. {
  413. if (res_region->end < region->end)
  414. {
  415. /* case 0 */
  416. rt_size_t new_size = region->end - res_region->end;
  417. region->end = res_region->start;
  418. /* Commit part next block */
  419. err = commit_memregion(region->name, res_region->end, new_size, RT_FALSE);
  420. if (!err)
  421. {
  422. ++no;
  423. /* Scan again */
  424. region = &_memregion[0];
  425. --region;
  426. break;
  427. }
  428. }
  429. else
  430. {
  431. /* case 2 */
  432. region->end = res_region->start;
  433. }
  434. }
  435. else
  436. {
  437. if (res_region->end < region->end)
  438. {
  439. /* case 3 */
  440. region->start = res_region->end;
  441. }
  442. else
  443. {
  444. /* case 1 */
  445. region->name = RT_NULL;
  446. break;
  447. }
  448. }
  449. }
  450. }
  451. return err;
  452. }
  453. rt_err_t rt_fdt_scan_memory(void)
  454. {
  455. rt_err_t err = -RT_EEMPTY;
  456. if (_fdt)
  457. {
  458. err = fdt_scan_memory();
  459. }
  460. return err;
  461. }
  462. rt_err_t rt_fdt_scan_initrd(rt_uint64_t *ranges)
  463. {
  464. rt_err_t err = -RT_EEMPTY;
  465. if (_fdt && ranges)
  466. {
  467. int s_len, e_len;
  468. const fdt32_t *start = RT_NULL, *end = RT_NULL;
  469. int offset = fdt_path_offset(_fdt, "/chosen");
  470. if (offset >= 0)
  471. {
  472. start = fdt_getprop(_fdt, offset, "linux,initrd-start", &s_len);
  473. end = fdt_getprop(_fdt, offset, "linux,initrd-end", &e_len);
  474. }
  475. if (start && end)
  476. {
  477. s_len /= sizeof(*start);
  478. e_len /= sizeof(*end);
  479. ranges[0] = rt_fdt_read_number(start, s_len);
  480. ranges[1] = rt_fdt_read_number(end, e_len);
  481. commit_memregion("initrd", ranges[0], ranges[1] - ranges[0], RT_TRUE);
  482. err = RT_EOK;
  483. }
  484. }
  485. else if (!ranges)
  486. {
  487. err = -RT_EINVAL;
  488. }
  489. return err;
  490. }
  491. rt_err_t rt_fdt_model_dump(void)
  492. {
  493. rt_err_t err = RT_EOK;
  494. int root = fdt_path_offset(_fdt, "/");
  495. if (root >= 0)
  496. {
  497. const char *mach_model = fdt_getprop(_fdt, root, "model", RT_NULL);
  498. if (!mach_model)
  499. {
  500. mach_model = fdt_getprop(_fdt, root, "compatible", RT_NULL);
  501. }
  502. LOG_I("Machine model: %s", mach_model ? mach_model : "<undefined>");
  503. }
  504. else
  505. {
  506. err = -RT_EEMPTY;
  507. }
  508. return err;
  509. }
  510. rt_weak rt_err_t rt_fdt_boot_dump(void)
  511. {
  512. LOG_I("Booting RT-Thread on physical CPU 0x%x", rt_hw_cpu_id());
  513. return RT_EOK;
  514. }
  515. void rt_fdt_earlycon_output(const char *str)
  516. {
  517. if (fdt_earlycon.console_putc)
  518. {
  519. while (*str)
  520. {
  521. fdt_earlycon.console_putc(fdt_earlycon.data, *str);
  522. if (*str == '\n')
  523. {
  524. /* Make sure return */
  525. fdt_earlycon.console_putc(fdt_earlycon.data, '\r');
  526. }
  527. ++str;
  528. }
  529. }
  530. else
  531. {
  532. /* We need a byte to save '\0' */
  533. while (*str && fdt_earlycon.msg_idx < sizeof(fdt_earlycon.msg) - 1)
  534. {
  535. fdt_earlycon.msg[fdt_earlycon.msg_idx++] = *str;
  536. ++str;
  537. }
  538. fdt_earlycon.msg[fdt_earlycon.msg_idx] = '\0';
  539. }
  540. }
  541. void rt_fdt_earlycon_kick(int why)
  542. {
  543. if (fdt_earlycon.console_kick)
  544. {
  545. fdt_earlycon.console_kick(&fdt_earlycon, why);
  546. }
  547. if (why == FDT_EARLYCON_KICK_COMPLETED)
  548. {
  549. fdt_earlycon.console_putc = RT_NULL;
  550. if (fdt_earlycon.msg_idx)
  551. {
  552. fdt_earlycon.msg_idx = 0;
  553. /* Dump old messages */
  554. rt_kputs(fdt_earlycon.msg);
  555. }
  556. }
  557. }
  558. rt_err_t rt_fdt_scan_chosen_stdout(void)
  559. {
  560. rt_err_t err = RT_EOK;
  561. int offset;
  562. int len, options_len = 0;
  563. const char *options = RT_NULL, *con_type = RT_NULL;
  564. rt_memset(&fdt_earlycon, 0, sizeof(fdt_earlycon) - sizeof(fdt_earlycon.msg));
  565. fdt_earlycon.nodeoffset = -1;
  566. offset = fdt_path_offset(_fdt, "/chosen");
  567. if (offset >= 0)
  568. {
  569. const char *stdout_path = RT_NULL;
  570. const char *bootargs = fdt_getprop(_fdt, offset, "bootargs", &len);
  571. if (bootargs && (options = rt_strstr(bootargs, "earlycon")))
  572. {
  573. options += sizeof("earlycon") - 1;
  574. if (*options == '\0' || *options == ' ')
  575. {
  576. stdout_path = fdt_getprop(_fdt, offset, "stdout-path", &len);
  577. if (stdout_path && len)
  578. {
  579. const char *path_split = strchrnul(stdout_path, ':');
  580. if (*path_split != '\0')
  581. {
  582. options = path_split + 1;
  583. }
  584. len = path_split - stdout_path;
  585. /*
  586. * Will try 2 styles:
  587. * 1: stdout-path = "serialN:bbbbpnf";
  588. * 2: stdout-path = "/serial-path";
  589. */
  590. offset = fdt_path_offset_namelen(_fdt, stdout_path, len);
  591. if (offset < 0)
  592. {
  593. stdout_path = RT_NULL;
  594. }
  595. }
  596. else if (*options == '=')
  597. {
  598. ++options;
  599. }
  600. else
  601. {
  602. /* Maybe is error in bootargs or it is a new arg */
  603. options = RT_NULL;
  604. }
  605. if (!stdout_path)
  606. {
  607. /* We couldn't know how to setup the earlycon */
  608. options = RT_NULL;
  609. }
  610. }
  611. else
  612. {
  613. offset = -1;
  614. }
  615. if (options)
  616. {
  617. int type_len = 0;
  618. struct rt_fdt_earlycon_id *earlycon_id, *earlycon_id_end, *best_earlycon_id = RT_NULL;
  619. earlycon_id = (struct rt_fdt_earlycon_id *)&_earlycon_start;
  620. earlycon_id_end = (struct rt_fdt_earlycon_id *)&_earlycon_end;
  621. err = -RT_ENOSYS;
  622. /* Only "earlycon" in bootargs */
  623. if (stdout_path)
  624. {
  625. const fdt32_t *reg;
  626. options = RT_NULL;
  627. if ((reg = fdt_getprop(_fdt, offset, "reg", RT_NULL)))
  628. {
  629. rt_uint64_t address;
  630. int addr_cells = fdt_io_addr_cells(_fdt, offset);
  631. int size_cells = fdt_io_size_cells(_fdt, offset);
  632. address = rt_fdt_read_number(reg, addr_cells);
  633. fdt_earlycon.mmio = rt_fdt_translate_address(_fdt, offset, address);
  634. fdt_earlycon.size = rt_fdt_read_number(reg + addr_cells, size_cells);
  635. }
  636. }
  637. else
  638. {
  639. /* Pass split */
  640. while (*options && (*options == '=' || *options == ' '))
  641. {
  642. ++options;
  643. }
  644. if (*options)
  645. {
  646. type_len = strchrnul(options, ',') - options;
  647. }
  648. }
  649. if (options && *options && *options != ' ')
  650. {
  651. options_len = strchrnul(options, ' ') - options;
  652. rt_strncpy(fdt_earlycon.options, options, options_len);
  653. }
  654. /* console > stdout-path */
  655. for (int max_score = 0; earlycon_id < earlycon_id_end; ++earlycon_id)
  656. {
  657. int score = 0;
  658. if (type_len && earlycon_id->type)
  659. {
  660. if (!rt_strncmp(earlycon_id->type, options, type_len))
  661. {
  662. score += 1;
  663. }
  664. }
  665. if (stdout_path && earlycon_id->compatible)
  666. {
  667. if (!fdt_node_check_compatible(_fdt, offset, earlycon_id->compatible))
  668. {
  669. score += 2;
  670. }
  671. }
  672. if (score > max_score)
  673. {
  674. max_score = score;
  675. best_earlycon_id = earlycon_id;
  676. if (score == 3)
  677. {
  678. break;
  679. }
  680. }
  681. }
  682. if (best_earlycon_id && best_earlycon_id->setup)
  683. {
  684. const char earlycon_magic[] = { 'O', 'F', 'W', '\0' };
  685. if (!con_type)
  686. {
  687. con_type = best_earlycon_id->type;
  688. }
  689. fdt_earlycon.fdt = _fdt;
  690. fdt_earlycon.nodeoffset = offset;
  691. options = &fdt_earlycon.options[options_len + 1];
  692. rt_strncpy((void *)options, earlycon_magic, RT_ARRAY_SIZE(earlycon_magic));
  693. err = best_earlycon_id->setup(&fdt_earlycon, fdt_earlycon.options);
  694. if (rt_strncmp(options, earlycon_magic, RT_ARRAY_SIZE(earlycon_magic)))
  695. {
  696. const char *option_start = options - 1;
  697. while (option_start[-1] != '\0')
  698. {
  699. --option_start;
  700. }
  701. rt_memmove(fdt_earlycon.options, option_start, options - option_start);
  702. }
  703. else
  704. {
  705. fdt_earlycon.options[0] = '\0';
  706. }
  707. }
  708. }
  709. }
  710. else
  711. {
  712. err = -RT_EEMPTY;
  713. }
  714. }
  715. else
  716. {
  717. err = -RT_EEMPTY;
  718. }
  719. if (fdt_earlycon.msg_idx)
  720. {
  721. fdt_earlycon.msg_idx = 0;
  722. rt_kputs(fdt_earlycon.msg);
  723. }
  724. rt_fdt_boot_dump();
  725. rt_fdt_model_dump();
  726. if (fdt_earlycon.mmio)
  727. {
  728. LOG_I("Earlycon: %s at MMIO/PIO %p (options '%s')",
  729. con_type, fdt_earlycon.mmio, fdt_earlycon.options);
  730. }
  731. return err;
  732. }
  733. static void system_node_init_flag(struct rt_ofw_node *np)
  734. {
  735. if (np)
  736. {
  737. rt_ofw_node_set_flag(np, RT_OFW_F_READLY);
  738. rt_ofw_node_set_flag(np, RT_OFW_F_SYSTEM);
  739. }
  740. }
  741. rt_err_t rt_fdt_unflatten(void)
  742. {
  743. rt_err_t err = RT_EOK;
  744. if (_fdt)
  745. {
  746. _phandle_min = OFW_PHANDLE_MAX;
  747. _phandle_max = OFW_PHANDLE_MIN;
  748. ofw_node_root = rt_fdt_unflatten_single(_fdt);
  749. if (ofw_node_root)
  750. {
  751. ofw_node_cpus = rt_ofw_find_node_by_path("/cpus");
  752. ofw_node_chosen = rt_ofw_find_node_by_path("/chosen");
  753. ofw_node_aliases = rt_ofw_find_node_by_path("/aliases");
  754. ofw_node_reserved_memory = rt_ofw_find_node_by_path("/reserved-memory");
  755. RT_ASSERT(ofw_node_cpus != RT_NULL);
  756. system_node_init_flag(ofw_node_root);
  757. system_node_init_flag(ofw_node_cpus);
  758. system_node_init_flag(ofw_node_chosen);
  759. system_node_init_flag(ofw_node_aliases);
  760. system_node_init_flag(ofw_node_reserved_memory);
  761. if (ofw_node_aliases)
  762. {
  763. err = ofw_alias_scan();
  764. }
  765. err = err ? : ofw_phandle_hash_reset(_phandle_min, _phandle_max);
  766. }
  767. }
  768. else
  769. {
  770. err = -RT_ERROR;
  771. }
  772. return err;
  773. }
  774. static rt_err_t fdt_unflatten_props(struct rt_ofw_node *np, int node_off)
  775. {
  776. rt_err_t err = RT_EOK;
  777. struct rt_ofw_prop *prop;
  778. int prop_off = fdt_first_property_offset(_fdt, node_off);
  779. if (prop_off >= 0)
  780. {
  781. np->props = rt_malloc(sizeof(struct rt_ofw_prop));
  782. }
  783. prop = np->props;
  784. while (prop_off >= 0)
  785. {
  786. if (!prop)
  787. {
  788. err = -RT_ENOMEM;
  789. break;
  790. }
  791. prop->value = (void *)fdt_getprop_by_offset(_fdt, prop_off, &prop->name, &prop->length);
  792. if (prop->name && !rt_strcmp(prop->name, "name"))
  793. {
  794. np->name = prop->value;
  795. }
  796. prop_off = fdt_next_property_offset(_fdt, prop_off);
  797. if (prop_off < 0)
  798. {
  799. prop->next = RT_NULL;
  800. break;
  801. }
  802. prop->next = rt_malloc(sizeof(struct rt_ofw_prop));
  803. prop = prop->next;
  804. }
  805. return err;
  806. }
  807. static rt_err_t fdt_unflatten_single(struct rt_ofw_node *np, int node_off)
  808. {
  809. int depth = 0;
  810. rt_err_t err = RT_EOK;
  811. struct rt_ofw_node *np_stack[OFW_NODE_MAX_DEPTH], *parent = RT_NULL;
  812. do {
  813. if (!np)
  814. {
  815. err = -RT_ENOMEM;
  816. break;
  817. }
  818. np->name = "<NULL>";
  819. np->full_name = fdt_get_name(_fdt, node_off, RT_NULL);
  820. np->phandle = fdt_get_phandle(_fdt, node_off);
  821. if (np->phandle >= OFW_PHANDLE_MIN)
  822. {
  823. if (np->phandle < _phandle_min)
  824. {
  825. _phandle_min = np->phandle;
  826. }
  827. if (np->phandle > _phandle_max)
  828. {
  829. _phandle_max = np->phandle;
  830. }
  831. }
  832. if ((err = fdt_unflatten_props(np, node_off)))
  833. {
  834. break;
  835. }
  836. np->parent = parent;
  837. rt_ref_init(&np->ref);
  838. np->flags = 0;
  839. if (!np->child)
  840. {
  841. /* Save node offset temp */
  842. rt_ofw_data(np) = (void *)(rt_ubase_t)node_off;
  843. /* Check children */
  844. node_off = fdt_first_subnode(_fdt, node_off);
  845. if (node_off >= 0)
  846. {
  847. parent = np;
  848. np_stack[depth++] = np;
  849. np->child = rt_calloc(1, sizeof(struct rt_ofw_node));
  850. np = np->child;
  851. continue;
  852. }
  853. }
  854. while (depth >= 0)
  855. {
  856. /* Restore node offset temp */
  857. node_off = (long)rt_ofw_data(np);
  858. rt_ofw_data(np) = RT_NULL;
  859. /* Next step */
  860. node_off = fdt_next_subnode(_fdt, node_off);
  861. if (node_off < 0)
  862. {
  863. np->sibling = RT_NULL;
  864. np = np_stack[--depth];
  865. }
  866. else
  867. {
  868. parent = np->parent;
  869. np->sibling = rt_calloc(1, sizeof(struct rt_ofw_node));
  870. np = np->sibling;
  871. break;
  872. }
  873. }
  874. } while (depth >= 0);
  875. return err;
  876. }
  877. struct rt_ofw_node *rt_fdt_unflatten_single(void *fdt)
  878. {
  879. int root_off;
  880. struct fdt_info *header;
  881. struct rt_ofw_node *root = RT_NULL;
  882. if (fdt && (root_off = fdt_path_offset(fdt, "/")) >= 0)
  883. {
  884. root = rt_calloc(1, sizeof(struct fdt_info) + sizeof(struct rt_ofw_node));
  885. }
  886. if (root)
  887. {
  888. header = (void *)root + sizeof(struct rt_ofw_node);
  889. rt_strncpy(header->name, "/", sizeof("/"));
  890. header->fdt = fdt;
  891. header->rsvmap = (struct fdt_reserve_entry *)((void *)fdt + fdt_off_mem_rsvmap(fdt));
  892. header->rsvmap_nr = fdt_num_mem_rsv(fdt);
  893. if (!fdt_unflatten_single(root, root_off))
  894. {
  895. root->name = (const char *)header;
  896. }
  897. else
  898. {
  899. rt_ofw_node_destroy(root);
  900. root = RT_NULL;
  901. }
  902. }
  903. return root;
  904. }