ofnode.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2017 Google, Inc
  4. * Written by Simon Glass <sjg@chromium.org>
  5. */
  6. #include <common.h>
  7. #include <dm.h>
  8. #include <fdtdec.h>
  9. #include <fdt_support.h>
  10. #include <log.h>
  11. #include <malloc.h>
  12. #include <linux/libfdt.h>
  13. #include <dm/of_access.h>
  14. #include <dm/of_addr.h>
  15. #include <dm/ofnode.h>
  16. #include <linux/err.h>
  17. #include <linux/ioport.h>
  18. int ofnode_read_u32(ofnode node, const char *propname, u32 *outp)
  19. {
  20. return ofnode_read_u32_index(node, propname, 0, outp);
  21. }
  22. u32 ofnode_read_u32_default(ofnode node, const char *propname, u32 def)
  23. {
  24. assert(ofnode_valid(node));
  25. ofnode_read_u32_index(node, propname, 0, &def);
  26. return def;
  27. }
  28. int ofnode_read_u32_index(ofnode node, const char *propname, int index,
  29. u32 *outp)
  30. {
  31. const fdt32_t *cell;
  32. int len;
  33. assert(ofnode_valid(node));
  34. debug("%s: %s: ", __func__, propname);
  35. if (ofnode_is_np(node))
  36. return of_read_u32_index(ofnode_to_np(node), propname, index,
  37. outp);
  38. cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
  39. &len);
  40. if (!cell) {
  41. debug("(not found)\n");
  42. return -EINVAL;
  43. }
  44. if (len < (sizeof(int) * (index + 1))) {
  45. debug("(not large enough)\n");
  46. return -EOVERFLOW;
  47. }
  48. *outp = fdt32_to_cpu(cell[index]);
  49. debug("%#x (%d)\n", *outp, *outp);
  50. return 0;
  51. }
  52. u32 ofnode_read_u32_index_default(ofnode node, const char *propname, int index,
  53. u32 def)
  54. {
  55. assert(ofnode_valid(node));
  56. ofnode_read_u32_index(node, propname, index, &def);
  57. return def;
  58. }
  59. int ofnode_read_s32_default(ofnode node, const char *propname, s32 def)
  60. {
  61. assert(ofnode_valid(node));
  62. ofnode_read_u32(node, propname, (u32 *)&def);
  63. return def;
  64. }
  65. int ofnode_read_u64(ofnode node, const char *propname, u64 *outp)
  66. {
  67. const unaligned_fdt64_t *cell;
  68. int len;
  69. assert(ofnode_valid(node));
  70. debug("%s: %s: ", __func__, propname);
  71. if (ofnode_is_np(node))
  72. return of_read_u64(ofnode_to_np(node), propname, outp);
  73. cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
  74. &len);
  75. if (!cell || len < sizeof(*cell)) {
  76. debug("(not found)\n");
  77. return -EINVAL;
  78. }
  79. *outp = fdt64_to_cpu(cell[0]);
  80. debug("%#llx (%lld)\n", (unsigned long long)*outp,
  81. (unsigned long long)*outp);
  82. return 0;
  83. }
  84. u64 ofnode_read_u64_default(ofnode node, const char *propname, u64 def)
  85. {
  86. assert(ofnode_valid(node));
  87. ofnode_read_u64(node, propname, &def);
  88. return def;
  89. }
  90. bool ofnode_read_bool(ofnode node, const char *propname)
  91. {
  92. const void *prop;
  93. assert(ofnode_valid(node));
  94. debug("%s: %s: ", __func__, propname);
  95. prop = ofnode_get_property(node, propname, NULL);
  96. debug("%s\n", prop ? "true" : "false");
  97. return prop ? true : false;
  98. }
  99. const void *ofnode_read_prop(ofnode node, const char *propname, int *sizep)
  100. {
  101. const char *val = NULL;
  102. int len;
  103. assert(ofnode_valid(node));
  104. debug("%s: %s: ", __func__, propname);
  105. if (ofnode_is_np(node)) {
  106. struct property *prop = of_find_property(
  107. ofnode_to_np(node), propname, &len);
  108. if (prop) {
  109. val = prop->value;
  110. len = prop->length;
  111. }
  112. } else {
  113. val = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
  114. propname, &len);
  115. }
  116. if (!val) {
  117. debug("<not found>\n");
  118. if (sizep)
  119. *sizep = -FDT_ERR_NOTFOUND;
  120. return NULL;
  121. }
  122. if (sizep)
  123. *sizep = len;
  124. return val;
  125. }
  126. const char *ofnode_read_string(ofnode node, const char *propname)
  127. {
  128. const char *str;
  129. int len;
  130. str = ofnode_read_prop(node, propname, &len);
  131. if (!str)
  132. return NULL;
  133. if (strnlen(str, len) >= len) {
  134. debug("<invalid>\n");
  135. return NULL;
  136. }
  137. debug("%s\n", str);
  138. return str;
  139. }
  140. int ofnode_read_size(ofnode node, const char *propname)
  141. {
  142. int len;
  143. if (!ofnode_read_prop(node, propname, &len))
  144. return -EINVAL;
  145. return len;
  146. }
  147. ofnode ofnode_find_subnode(ofnode node, const char *subnode_name)
  148. {
  149. ofnode subnode;
  150. assert(ofnode_valid(node));
  151. debug("%s: %s: ", __func__, subnode_name);
  152. if (ofnode_is_np(node)) {
  153. const struct device_node *np = ofnode_to_np(node);
  154. for (np = np->child; np; np = np->sibling) {
  155. if (!strcmp(subnode_name, np->name))
  156. break;
  157. }
  158. subnode = np_to_ofnode(np);
  159. } else {
  160. int ooffset = fdt_subnode_offset(gd->fdt_blob,
  161. ofnode_to_offset(node), subnode_name);
  162. subnode = offset_to_ofnode(ooffset);
  163. }
  164. debug("%s\n", ofnode_valid(subnode) ?
  165. ofnode_get_name(subnode) : "<none>");
  166. return subnode;
  167. }
  168. int ofnode_read_u32_array(ofnode node, const char *propname,
  169. u32 *out_values, size_t sz)
  170. {
  171. assert(ofnode_valid(node));
  172. debug("%s: %s: ", __func__, propname);
  173. if (ofnode_is_np(node)) {
  174. return of_read_u32_array(ofnode_to_np(node), propname,
  175. out_values, sz);
  176. } else {
  177. return fdtdec_get_int_array(gd->fdt_blob,
  178. ofnode_to_offset(node), propname,
  179. out_values, sz);
  180. }
  181. }
  182. ofnode ofnode_first_subnode(ofnode node)
  183. {
  184. assert(ofnode_valid(node));
  185. if (ofnode_is_np(node))
  186. return np_to_ofnode(node.np->child);
  187. return offset_to_ofnode(
  188. fdt_first_subnode(gd->fdt_blob, ofnode_to_offset(node)));
  189. }
  190. ofnode ofnode_next_subnode(ofnode node)
  191. {
  192. assert(ofnode_valid(node));
  193. if (ofnode_is_np(node))
  194. return np_to_ofnode(node.np->sibling);
  195. return offset_to_ofnode(
  196. fdt_next_subnode(gd->fdt_blob, ofnode_to_offset(node)));
  197. }
  198. ofnode ofnode_get_parent(ofnode node)
  199. {
  200. ofnode parent;
  201. assert(ofnode_valid(node));
  202. if (ofnode_is_np(node))
  203. parent = np_to_ofnode(of_get_parent(ofnode_to_np(node)));
  204. else
  205. parent.of_offset = fdt_parent_offset(gd->fdt_blob,
  206. ofnode_to_offset(node));
  207. return parent;
  208. }
  209. const char *ofnode_get_name(ofnode node)
  210. {
  211. if (!ofnode_valid(node)) {
  212. debug("%s node not valid\n", __func__);
  213. return NULL;
  214. }
  215. if (ofnode_is_np(node))
  216. return strrchr(node.np->full_name, '/') + 1;
  217. return fdt_get_name(gd->fdt_blob, ofnode_to_offset(node), NULL);
  218. }
  219. ofnode ofnode_get_by_phandle(uint phandle)
  220. {
  221. ofnode node;
  222. if (of_live_active())
  223. node = np_to_ofnode(of_find_node_by_phandle(phandle));
  224. else
  225. node.of_offset = fdt_node_offset_by_phandle(gd->fdt_blob,
  226. phandle);
  227. return node;
  228. }
  229. fdt_addr_t ofnode_get_addr_size_index(ofnode node, int index, fdt_size_t *size)
  230. {
  231. int na, ns;
  232. if (ofnode_is_np(node)) {
  233. const __be32 *prop_val;
  234. u64 size64;
  235. uint flags;
  236. prop_val = of_get_address(ofnode_to_np(node), index, &size64,
  237. &flags);
  238. if (!prop_val)
  239. return FDT_ADDR_T_NONE;
  240. if (size)
  241. *size = size64;
  242. ns = of_n_size_cells(ofnode_to_np(node));
  243. if (IS_ENABLED(CONFIG_OF_TRANSLATE) && ns > 0) {
  244. return of_translate_address(ofnode_to_np(node), prop_val);
  245. } else {
  246. na = of_n_addr_cells(ofnode_to_np(node));
  247. return of_read_number(prop_val, na);
  248. }
  249. } else {
  250. na = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
  251. ns = ofnode_read_simple_size_cells(ofnode_get_parent(node));
  252. return fdtdec_get_addr_size_fixed(gd->fdt_blob,
  253. ofnode_to_offset(node), "reg",
  254. index, na, ns, size, true);
  255. }
  256. return FDT_ADDR_T_NONE;
  257. }
  258. fdt_addr_t ofnode_get_addr_index(ofnode node, int index)
  259. {
  260. fdt_size_t size;
  261. return ofnode_get_addr_size_index(node, index, &size);
  262. }
  263. fdt_addr_t ofnode_get_addr(ofnode node)
  264. {
  265. return ofnode_get_addr_index(node, 0);
  266. }
  267. int ofnode_stringlist_search(ofnode node, const char *property,
  268. const char *string)
  269. {
  270. if (ofnode_is_np(node)) {
  271. return of_property_match_string(ofnode_to_np(node),
  272. property, string);
  273. } else {
  274. int ret;
  275. ret = fdt_stringlist_search(gd->fdt_blob,
  276. ofnode_to_offset(node), property,
  277. string);
  278. if (ret == -FDT_ERR_NOTFOUND)
  279. return -ENODATA;
  280. else if (ret < 0)
  281. return -EINVAL;
  282. return ret;
  283. }
  284. }
  285. int ofnode_read_string_index(ofnode node, const char *property, int index,
  286. const char **outp)
  287. {
  288. if (ofnode_is_np(node)) {
  289. return of_property_read_string_index(ofnode_to_np(node),
  290. property, index, outp);
  291. } else {
  292. int len;
  293. *outp = fdt_stringlist_get(gd->fdt_blob, ofnode_to_offset(node),
  294. property, index, &len);
  295. if (len < 0)
  296. return -EINVAL;
  297. return 0;
  298. }
  299. }
  300. int ofnode_read_string_count(ofnode node, const char *property)
  301. {
  302. if (ofnode_is_np(node)) {
  303. return of_property_count_strings(ofnode_to_np(node), property);
  304. } else {
  305. return fdt_stringlist_count(gd->fdt_blob,
  306. ofnode_to_offset(node), property);
  307. }
  308. }
  309. static void ofnode_from_fdtdec_phandle_args(struct fdtdec_phandle_args *in,
  310. struct ofnode_phandle_args *out)
  311. {
  312. assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
  313. out->node = offset_to_ofnode(in->node);
  314. out->args_count = in->args_count;
  315. memcpy(out->args, in->args, sizeof(out->args));
  316. }
  317. static void ofnode_from_of_phandle_args(struct of_phandle_args *in,
  318. struct ofnode_phandle_args *out)
  319. {
  320. assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
  321. out->node = np_to_ofnode(in->np);
  322. out->args_count = in->args_count;
  323. memcpy(out->args, in->args, sizeof(out->args));
  324. }
  325. int ofnode_parse_phandle_with_args(ofnode node, const char *list_name,
  326. const char *cells_name, int cell_count,
  327. int index,
  328. struct ofnode_phandle_args *out_args)
  329. {
  330. if (ofnode_is_np(node)) {
  331. struct of_phandle_args args;
  332. int ret;
  333. ret = of_parse_phandle_with_args(ofnode_to_np(node),
  334. list_name, cells_name,
  335. cell_count, index,
  336. &args);
  337. if (ret)
  338. return ret;
  339. ofnode_from_of_phandle_args(&args, out_args);
  340. } else {
  341. struct fdtdec_phandle_args args;
  342. int ret;
  343. ret = fdtdec_parse_phandle_with_args(gd->fdt_blob,
  344. ofnode_to_offset(node),
  345. list_name, cells_name,
  346. cell_count, index, &args);
  347. if (ret)
  348. return ret;
  349. ofnode_from_fdtdec_phandle_args(&args, out_args);
  350. }
  351. return 0;
  352. }
  353. int ofnode_count_phandle_with_args(ofnode node, const char *list_name,
  354. const char *cells_name)
  355. {
  356. if (ofnode_is_np(node))
  357. return of_count_phandle_with_args(ofnode_to_np(node),
  358. list_name, cells_name);
  359. else
  360. return fdtdec_parse_phandle_with_args(gd->fdt_blob,
  361. ofnode_to_offset(node), list_name, cells_name,
  362. 0, -1, NULL);
  363. }
  364. ofnode ofnode_path(const char *path)
  365. {
  366. if (of_live_active())
  367. return np_to_ofnode(of_find_node_by_path(path));
  368. else
  369. return offset_to_ofnode(fdt_path_offset(gd->fdt_blob, path));
  370. }
  371. const void *ofnode_read_chosen_prop(const char *propname, int *sizep)
  372. {
  373. ofnode chosen_node;
  374. chosen_node = ofnode_path("/chosen");
  375. return ofnode_read_prop(chosen_node, propname, sizep);
  376. }
  377. const char *ofnode_read_chosen_string(const char *propname)
  378. {
  379. return ofnode_read_chosen_prop(propname, NULL);
  380. }
  381. ofnode ofnode_get_chosen_node(const char *name)
  382. {
  383. const char *prop;
  384. prop = ofnode_read_chosen_prop(name, NULL);
  385. if (!prop)
  386. return ofnode_null();
  387. return ofnode_path(prop);
  388. }
  389. int ofnode_get_child_count(ofnode parent)
  390. {
  391. ofnode child;
  392. int num = 0;
  393. ofnode_for_each_subnode(child, parent)
  394. num++;
  395. return num;
  396. }
  397. static int decode_timing_property(ofnode node, const char *name,
  398. struct timing_entry *result)
  399. {
  400. int length, ret = 0;
  401. length = ofnode_read_size(node, name);
  402. if (length < 0) {
  403. debug("%s: could not find property %s\n",
  404. ofnode_get_name(node), name);
  405. return length;
  406. }
  407. if (length == sizeof(u32)) {
  408. result->typ = ofnode_read_u32_default(node, name, 0);
  409. result->min = result->typ;
  410. result->max = result->typ;
  411. } else {
  412. ret = ofnode_read_u32_array(node, name, &result->min, 3);
  413. }
  414. return ret;
  415. }
  416. int ofnode_decode_display_timing(ofnode parent, int index,
  417. struct display_timing *dt)
  418. {
  419. int i;
  420. ofnode timings, node;
  421. u32 val = 0;
  422. int ret = 0;
  423. timings = ofnode_find_subnode(parent, "display-timings");
  424. if (!ofnode_valid(timings))
  425. return -EINVAL;
  426. i = 0;
  427. ofnode_for_each_subnode(node, timings) {
  428. if (i++ == index)
  429. break;
  430. }
  431. if (!ofnode_valid(node))
  432. return -EINVAL;
  433. memset(dt, 0, sizeof(*dt));
  434. ret |= decode_timing_property(node, "hback-porch", &dt->hback_porch);
  435. ret |= decode_timing_property(node, "hfront-porch", &dt->hfront_porch);
  436. ret |= decode_timing_property(node, "hactive", &dt->hactive);
  437. ret |= decode_timing_property(node, "hsync-len", &dt->hsync_len);
  438. ret |= decode_timing_property(node, "vback-porch", &dt->vback_porch);
  439. ret |= decode_timing_property(node, "vfront-porch", &dt->vfront_porch);
  440. ret |= decode_timing_property(node, "vactive", &dt->vactive);
  441. ret |= decode_timing_property(node, "vsync-len", &dt->vsync_len);
  442. ret |= decode_timing_property(node, "clock-frequency", &dt->pixelclock);
  443. dt->flags = 0;
  444. val = ofnode_read_u32_default(node, "vsync-active", -1);
  445. if (val != -1) {
  446. dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
  447. DISPLAY_FLAGS_VSYNC_LOW;
  448. }
  449. val = ofnode_read_u32_default(node, "hsync-active", -1);
  450. if (val != -1) {
  451. dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
  452. DISPLAY_FLAGS_HSYNC_LOW;
  453. }
  454. val = ofnode_read_u32_default(node, "de-active", -1);
  455. if (val != -1) {
  456. dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
  457. DISPLAY_FLAGS_DE_LOW;
  458. }
  459. val = ofnode_read_u32_default(node, "pixelclk-active", -1);
  460. if (val != -1) {
  461. dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
  462. DISPLAY_FLAGS_PIXDATA_NEGEDGE;
  463. }
  464. if (ofnode_read_bool(node, "interlaced"))
  465. dt->flags |= DISPLAY_FLAGS_INTERLACED;
  466. if (ofnode_read_bool(node, "doublescan"))
  467. dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
  468. if (ofnode_read_bool(node, "doubleclk"))
  469. dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
  470. return ret;
  471. }
  472. const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
  473. {
  474. if (ofnode_is_np(node))
  475. return of_get_property(ofnode_to_np(node), propname, lenp);
  476. else
  477. return fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
  478. propname, lenp);
  479. }
  480. int ofnode_get_first_property(ofnode node, struct ofprop *prop)
  481. {
  482. prop->node = node;
  483. if (ofnode_is_np(node)) {
  484. prop->prop = of_get_first_property(ofnode_to_np(prop->node));
  485. if (!prop->prop)
  486. return -FDT_ERR_NOTFOUND;
  487. } else {
  488. prop->offset =
  489. fdt_first_property_offset(gd->fdt_blob,
  490. ofnode_to_offset(prop->node));
  491. if (prop->offset < 0)
  492. return prop->offset;
  493. }
  494. return 0;
  495. }
  496. int ofnode_get_next_property(struct ofprop *prop)
  497. {
  498. if (ofnode_is_np(prop->node)) {
  499. prop->prop = of_get_next_property(ofnode_to_np(prop->node),
  500. prop->prop);
  501. if (!prop->prop)
  502. return -FDT_ERR_NOTFOUND;
  503. } else {
  504. prop->offset = fdt_next_property_offset(gd->fdt_blob,
  505. prop->offset);
  506. if (prop->offset < 0)
  507. return prop->offset;
  508. }
  509. return 0;
  510. }
  511. const void *ofnode_get_property_by_prop(const struct ofprop *prop,
  512. const char **propname, int *lenp)
  513. {
  514. if (ofnode_is_np(prop->node))
  515. return of_get_property_by_prop(ofnode_to_np(prop->node),
  516. prop->prop, propname, lenp);
  517. else
  518. return fdt_getprop_by_offset(gd->fdt_blob,
  519. prop->offset,
  520. propname, lenp);
  521. }
  522. bool ofnode_is_available(ofnode node)
  523. {
  524. if (ofnode_is_np(node))
  525. return of_device_is_available(ofnode_to_np(node));
  526. else
  527. return fdtdec_get_is_enabled(gd->fdt_blob,
  528. ofnode_to_offset(node));
  529. }
  530. fdt_addr_t ofnode_get_addr_size(ofnode node, const char *property,
  531. fdt_size_t *sizep)
  532. {
  533. if (ofnode_is_np(node)) {
  534. int na, ns;
  535. int psize;
  536. const struct device_node *np = ofnode_to_np(node);
  537. const __be32 *prop = of_get_property(np, property, &psize);
  538. if (!prop)
  539. return FDT_ADDR_T_NONE;
  540. na = of_n_addr_cells(np);
  541. ns = of_n_size_cells(np);
  542. *sizep = of_read_number(prop + na, ns);
  543. if (CONFIG_IS_ENABLED(OF_TRANSLATE) && ns > 0)
  544. return of_translate_address(np, prop);
  545. else
  546. return of_read_number(prop, na);
  547. } else {
  548. return fdtdec_get_addr_size(gd->fdt_blob,
  549. ofnode_to_offset(node), property,
  550. sizep);
  551. }
  552. }
  553. const uint8_t *ofnode_read_u8_array_ptr(ofnode node, const char *propname,
  554. size_t sz)
  555. {
  556. if (ofnode_is_np(node)) {
  557. const struct device_node *np = ofnode_to_np(node);
  558. int psize;
  559. const __be32 *prop = of_get_property(np, propname, &psize);
  560. if (!prop || sz != psize)
  561. return NULL;
  562. return (uint8_t *)prop;
  563. } else {
  564. return fdtdec_locate_byte_array(gd->fdt_blob,
  565. ofnode_to_offset(node), propname, sz);
  566. }
  567. }
  568. int ofnode_read_pci_addr(ofnode node, enum fdt_pci_space type,
  569. const char *propname, struct fdt_pci_addr *addr)
  570. {
  571. const fdt32_t *cell;
  572. int len;
  573. int ret = -ENOENT;
  574. debug("%s: %s: ", __func__, propname);
  575. /*
  576. * If we follow the pci bus bindings strictly, we should check
  577. * the value of the node's parent node's #address-cells and
  578. * #size-cells. They need to be 3 and 2 accordingly. However,
  579. * for simplicity we skip the check here.
  580. */
  581. cell = ofnode_get_property(node, propname, &len);
  582. if (!cell)
  583. goto fail;
  584. if ((len % FDT_PCI_REG_SIZE) == 0) {
  585. int num = len / FDT_PCI_REG_SIZE;
  586. int i;
  587. for (i = 0; i < num; i++) {
  588. debug("pci address #%d: %08lx %08lx %08lx\n", i,
  589. (ulong)fdt32_to_cpu(cell[0]),
  590. (ulong)fdt32_to_cpu(cell[1]),
  591. (ulong)fdt32_to_cpu(cell[2]));
  592. if ((fdt32_to_cpu(*cell) & type) == type) {
  593. addr->phys_hi = fdt32_to_cpu(cell[0]);
  594. addr->phys_mid = fdt32_to_cpu(cell[1]);
  595. addr->phys_lo = fdt32_to_cpu(cell[2]);
  596. break;
  597. }
  598. cell += (FDT_PCI_ADDR_CELLS +
  599. FDT_PCI_SIZE_CELLS);
  600. }
  601. if (i == num) {
  602. ret = -ENXIO;
  603. goto fail;
  604. }
  605. return 0;
  606. }
  607. ret = -EINVAL;
  608. fail:
  609. debug("(not found)\n");
  610. return ret;
  611. }
  612. int ofnode_read_pci_vendev(ofnode node, u16 *vendor, u16 *device)
  613. {
  614. const char *list, *end;
  615. int len;
  616. list = ofnode_get_property(node, "compatible", &len);
  617. if (!list)
  618. return -ENOENT;
  619. end = list + len;
  620. while (list < end) {
  621. len = strlen(list);
  622. if (len >= strlen("pciVVVV,DDDD")) {
  623. char *s = strstr(list, "pci");
  624. /*
  625. * check if the string is something like pciVVVV,DDDD.RR
  626. * or just pciVVVV,DDDD
  627. */
  628. if (s && s[7] == ',' &&
  629. (s[12] == '.' || s[12] == 0)) {
  630. s += 3;
  631. *vendor = simple_strtol(s, NULL, 16);
  632. s += 5;
  633. *device = simple_strtol(s, NULL, 16);
  634. return 0;
  635. }
  636. }
  637. list += (len + 1);
  638. }
  639. return -ENOENT;
  640. }
  641. int ofnode_read_addr_cells(ofnode node)
  642. {
  643. if (ofnode_is_np(node)) {
  644. return of_n_addr_cells(ofnode_to_np(node));
  645. } else {
  646. int parent = fdt_parent_offset(gd->fdt_blob,
  647. ofnode_to_offset(node));
  648. return fdt_address_cells(gd->fdt_blob, parent);
  649. }
  650. }
  651. int ofnode_read_size_cells(ofnode node)
  652. {
  653. if (ofnode_is_np(node)) {
  654. return of_n_size_cells(ofnode_to_np(node));
  655. } else {
  656. int parent = fdt_parent_offset(gd->fdt_blob,
  657. ofnode_to_offset(node));
  658. return fdt_size_cells(gd->fdt_blob, parent);
  659. }
  660. }
  661. int ofnode_read_simple_addr_cells(ofnode node)
  662. {
  663. if (ofnode_is_np(node))
  664. return of_simple_addr_cells(ofnode_to_np(node));
  665. else
  666. return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
  667. }
  668. int ofnode_read_simple_size_cells(ofnode node)
  669. {
  670. if (ofnode_is_np(node))
  671. return of_simple_size_cells(ofnode_to_np(node));
  672. else
  673. return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
  674. }
  675. bool ofnode_pre_reloc(ofnode node)
  676. {
  677. #if defined(CONFIG_SPL_BUILD) || defined(CONFIG_TPL_BUILD)
  678. /* for SPL and TPL the remaining nodes after the fdtgrep 1st pass
  679. * had property dm-pre-reloc or u-boot,dm-spl/tpl.
  680. * They are removed in final dtb (fdtgrep 2nd pass)
  681. */
  682. return true;
  683. #else
  684. if (ofnode_read_bool(node, "u-boot,dm-pre-reloc"))
  685. return true;
  686. if (ofnode_read_bool(node, "u-boot,dm-pre-proper"))
  687. return true;
  688. /*
  689. * In regular builds individual spl and tpl handling both
  690. * count as handled pre-relocation for later second init.
  691. */
  692. if (ofnode_read_bool(node, "u-boot,dm-spl") ||
  693. ofnode_read_bool(node, "u-boot,dm-tpl"))
  694. return true;
  695. return false;
  696. #endif
  697. }
  698. int ofnode_read_resource(ofnode node, uint index, struct resource *res)
  699. {
  700. if (ofnode_is_np(node)) {
  701. return of_address_to_resource(ofnode_to_np(node), index, res);
  702. } else {
  703. struct fdt_resource fres;
  704. int ret;
  705. ret = fdt_get_resource(gd->fdt_blob, ofnode_to_offset(node),
  706. "reg", index, &fres);
  707. if (ret < 0)
  708. return -EINVAL;
  709. memset(res, '\0', sizeof(*res));
  710. res->start = fres.start;
  711. res->end = fres.end;
  712. return 0;
  713. }
  714. }
  715. int ofnode_read_resource_byname(ofnode node, const char *name,
  716. struct resource *res)
  717. {
  718. int index;
  719. index = ofnode_stringlist_search(node, "reg-names", name);
  720. if (index < 0)
  721. return index;
  722. return ofnode_read_resource(node, index, res);
  723. }
  724. u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr)
  725. {
  726. if (ofnode_is_np(node))
  727. return of_translate_address(ofnode_to_np(node), in_addr);
  728. else
  729. return fdt_translate_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
  730. }
  731. u64 ofnode_translate_dma_address(ofnode node, const fdt32_t *in_addr)
  732. {
  733. if (ofnode_is_np(node))
  734. return of_translate_dma_address(ofnode_to_np(node), in_addr);
  735. else
  736. return fdt_translate_dma_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
  737. }
  738. int ofnode_device_is_compatible(ofnode node, const char *compat)
  739. {
  740. if (ofnode_is_np(node))
  741. return of_device_is_compatible(ofnode_to_np(node), compat,
  742. NULL, NULL);
  743. else
  744. return !fdt_node_check_compatible(gd->fdt_blob,
  745. ofnode_to_offset(node),
  746. compat);
  747. }
  748. ofnode ofnode_by_compatible(ofnode from, const char *compat)
  749. {
  750. if (of_live_active()) {
  751. return np_to_ofnode(of_find_compatible_node(
  752. (struct device_node *)ofnode_to_np(from), NULL,
  753. compat));
  754. } else {
  755. return offset_to_ofnode(fdt_node_offset_by_compatible(
  756. gd->fdt_blob, ofnode_to_offset(from), compat));
  757. }
  758. }
  759. ofnode ofnode_by_prop_value(ofnode from, const char *propname,
  760. const void *propval, int proplen)
  761. {
  762. if (of_live_active()) {
  763. return np_to_ofnode(of_find_node_by_prop_value(
  764. (struct device_node *)ofnode_to_np(from), propname,
  765. propval, proplen));
  766. } else {
  767. return offset_to_ofnode(fdt_node_offset_by_prop_value(
  768. gd->fdt_blob, ofnode_to_offset(from),
  769. propname, propval, proplen));
  770. }
  771. }
  772. int ofnode_write_prop(ofnode node, const char *propname, int len,
  773. const void *value)
  774. {
  775. const struct device_node *np = ofnode_to_np(node);
  776. struct property *pp;
  777. struct property *pp_last = NULL;
  778. struct property *new;
  779. if (!of_live_active())
  780. return -ENOSYS;
  781. if (!np)
  782. return -EINVAL;
  783. for (pp = np->properties; pp; pp = pp->next) {
  784. if (strcmp(pp->name, propname) == 0) {
  785. /* Property exists -> change value */
  786. pp->value = (void *)value;
  787. pp->length = len;
  788. return 0;
  789. }
  790. pp_last = pp;
  791. }
  792. if (!pp_last)
  793. return -ENOENT;
  794. /* Property does not exist -> append new property */
  795. new = malloc(sizeof(struct property));
  796. if (!new)
  797. return -ENOMEM;
  798. new->name = strdup(propname);
  799. if (!new->name) {
  800. free(new);
  801. return -ENOMEM;
  802. }
  803. new->value = (void *)value;
  804. new->length = len;
  805. new->next = NULL;
  806. pp_last->next = new;
  807. return 0;
  808. }
  809. int ofnode_write_string(ofnode node, const char *propname, const char *value)
  810. {
  811. if (!of_live_active())
  812. return -ENOSYS;
  813. assert(ofnode_valid(node));
  814. debug("%s: %s = %s", __func__, propname, value);
  815. return ofnode_write_prop(node, propname, strlen(value) + 1, value);
  816. }
  817. int ofnode_set_enabled(ofnode node, bool value)
  818. {
  819. if (!of_live_active())
  820. return -ENOSYS;
  821. assert(ofnode_valid(node));
  822. if (value)
  823. return ofnode_write_string(node, "status", "okay");
  824. else
  825. return ofnode_write_string(node, "status", "disabled");
  826. }