ofnode.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998
  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, index,
  335. &args);
  336. if (ret)
  337. return ret;
  338. ofnode_from_of_phandle_args(&args, out_args);
  339. } else {
  340. struct fdtdec_phandle_args args;
  341. int ret;
  342. ret = fdtdec_parse_phandle_with_args(gd->fdt_blob,
  343. ofnode_to_offset(node),
  344. list_name, cells_name,
  345. cell_count, index, &args);
  346. if (ret)
  347. return ret;
  348. ofnode_from_fdtdec_phandle_args(&args, out_args);
  349. }
  350. return 0;
  351. }
  352. int ofnode_count_phandle_with_args(ofnode node, const char *list_name,
  353. const char *cells_name)
  354. {
  355. if (ofnode_is_np(node))
  356. return of_count_phandle_with_args(ofnode_to_np(node),
  357. list_name, cells_name);
  358. else
  359. return fdtdec_parse_phandle_with_args(gd->fdt_blob,
  360. ofnode_to_offset(node), list_name, cells_name,
  361. 0, -1, NULL);
  362. }
  363. ofnode ofnode_path(const char *path)
  364. {
  365. if (of_live_active())
  366. return np_to_ofnode(of_find_node_by_path(path));
  367. else
  368. return offset_to_ofnode(fdt_path_offset(gd->fdt_blob, path));
  369. }
  370. const void *ofnode_read_chosen_prop(const char *propname, int *sizep)
  371. {
  372. ofnode chosen_node;
  373. chosen_node = ofnode_path("/chosen");
  374. return ofnode_read_prop(chosen_node, propname, sizep);
  375. }
  376. const char *ofnode_read_chosen_string(const char *propname)
  377. {
  378. return ofnode_read_chosen_prop(propname, NULL);
  379. }
  380. ofnode ofnode_get_chosen_node(const char *name)
  381. {
  382. const char *prop;
  383. prop = ofnode_read_chosen_prop(name, NULL);
  384. if (!prop)
  385. return ofnode_null();
  386. return ofnode_path(prop);
  387. }
  388. int ofnode_get_child_count(ofnode parent)
  389. {
  390. ofnode child;
  391. int num = 0;
  392. ofnode_for_each_subnode(child, parent)
  393. num++;
  394. return num;
  395. }
  396. static int decode_timing_property(ofnode node, const char *name,
  397. struct timing_entry *result)
  398. {
  399. int length, ret = 0;
  400. length = ofnode_read_size(node, name);
  401. if (length < 0) {
  402. debug("%s: could not find property %s\n",
  403. ofnode_get_name(node), name);
  404. return length;
  405. }
  406. if (length == sizeof(u32)) {
  407. result->typ = ofnode_read_u32_default(node, name, 0);
  408. result->min = result->typ;
  409. result->max = result->typ;
  410. } else {
  411. ret = ofnode_read_u32_array(node, name, &result->min, 3);
  412. }
  413. return ret;
  414. }
  415. int ofnode_decode_display_timing(ofnode parent, int index,
  416. struct display_timing *dt)
  417. {
  418. int i;
  419. ofnode timings, node;
  420. u32 val = 0;
  421. int ret = 0;
  422. timings = ofnode_find_subnode(parent, "display-timings");
  423. if (!ofnode_valid(timings))
  424. return -EINVAL;
  425. i = 0;
  426. ofnode_for_each_subnode(node, timings) {
  427. if (i++ == index)
  428. break;
  429. }
  430. if (!ofnode_valid(node))
  431. return -EINVAL;
  432. memset(dt, 0, sizeof(*dt));
  433. ret |= decode_timing_property(node, "hback-porch", &dt->hback_porch);
  434. ret |= decode_timing_property(node, "hfront-porch", &dt->hfront_porch);
  435. ret |= decode_timing_property(node, "hactive", &dt->hactive);
  436. ret |= decode_timing_property(node, "hsync-len", &dt->hsync_len);
  437. ret |= decode_timing_property(node, "vback-porch", &dt->vback_porch);
  438. ret |= decode_timing_property(node, "vfront-porch", &dt->vfront_porch);
  439. ret |= decode_timing_property(node, "vactive", &dt->vactive);
  440. ret |= decode_timing_property(node, "vsync-len", &dt->vsync_len);
  441. ret |= decode_timing_property(node, "clock-frequency", &dt->pixelclock);
  442. dt->flags = 0;
  443. val = ofnode_read_u32_default(node, "vsync-active", -1);
  444. if (val != -1) {
  445. dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
  446. DISPLAY_FLAGS_VSYNC_LOW;
  447. }
  448. val = ofnode_read_u32_default(node, "hsync-active", -1);
  449. if (val != -1) {
  450. dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
  451. DISPLAY_FLAGS_HSYNC_LOW;
  452. }
  453. val = ofnode_read_u32_default(node, "de-active", -1);
  454. if (val != -1) {
  455. dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
  456. DISPLAY_FLAGS_DE_LOW;
  457. }
  458. val = ofnode_read_u32_default(node, "pixelclk-active", -1);
  459. if (val != -1) {
  460. dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
  461. DISPLAY_FLAGS_PIXDATA_NEGEDGE;
  462. }
  463. if (ofnode_read_bool(node, "interlaced"))
  464. dt->flags |= DISPLAY_FLAGS_INTERLACED;
  465. if (ofnode_read_bool(node, "doublescan"))
  466. dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
  467. if (ofnode_read_bool(node, "doubleclk"))
  468. dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
  469. return ret;
  470. }
  471. const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
  472. {
  473. if (ofnode_is_np(node))
  474. return of_get_property(ofnode_to_np(node), propname, lenp);
  475. else
  476. return fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
  477. propname, lenp);
  478. }
  479. int ofnode_get_first_property(ofnode node, struct ofprop *prop)
  480. {
  481. prop->node = node;
  482. if (ofnode_is_np(node)) {
  483. prop->prop = of_get_first_property(ofnode_to_np(prop->node));
  484. if (!prop->prop)
  485. return -FDT_ERR_NOTFOUND;
  486. } else {
  487. prop->offset =
  488. fdt_first_property_offset(gd->fdt_blob,
  489. ofnode_to_offset(prop->node));
  490. if (prop->offset < 0)
  491. return prop->offset;
  492. }
  493. return 0;
  494. }
  495. int ofnode_get_next_property(struct ofprop *prop)
  496. {
  497. if (ofnode_is_np(prop->node)) {
  498. prop->prop = of_get_next_property(ofnode_to_np(prop->node),
  499. prop->prop);
  500. if (!prop->prop)
  501. return -FDT_ERR_NOTFOUND;
  502. } else {
  503. prop->offset = fdt_next_property_offset(gd->fdt_blob,
  504. prop->offset);
  505. if (prop->offset < 0)
  506. return prop->offset;
  507. }
  508. return 0;
  509. }
  510. const void *ofnode_get_property_by_prop(const struct ofprop *prop,
  511. const char **propname, int *lenp)
  512. {
  513. if (ofnode_is_np(prop->node))
  514. return of_get_property_by_prop(ofnode_to_np(prop->node),
  515. prop->prop, propname, lenp);
  516. else
  517. return fdt_getprop_by_offset(gd->fdt_blob,
  518. prop->offset,
  519. propname, lenp);
  520. }
  521. bool ofnode_is_available(ofnode node)
  522. {
  523. if (ofnode_is_np(node))
  524. return of_device_is_available(ofnode_to_np(node));
  525. else
  526. return fdtdec_get_is_enabled(gd->fdt_blob,
  527. ofnode_to_offset(node));
  528. }
  529. fdt_addr_t ofnode_get_addr_size(ofnode node, const char *property,
  530. fdt_size_t *sizep)
  531. {
  532. if (ofnode_is_np(node)) {
  533. int na, ns;
  534. int psize;
  535. const struct device_node *np = ofnode_to_np(node);
  536. const __be32 *prop = of_get_property(np, property, &psize);
  537. if (!prop)
  538. return FDT_ADDR_T_NONE;
  539. na = of_n_addr_cells(np);
  540. ns = of_n_size_cells(np);
  541. *sizep = of_read_number(prop + na, ns);
  542. if (CONFIG_IS_ENABLED(OF_TRANSLATE) && ns > 0)
  543. return of_translate_address(np, prop);
  544. else
  545. return of_read_number(prop, na);
  546. } else {
  547. return fdtdec_get_addr_size(gd->fdt_blob,
  548. ofnode_to_offset(node), property,
  549. sizep);
  550. }
  551. }
  552. const uint8_t *ofnode_read_u8_array_ptr(ofnode node, const char *propname,
  553. size_t sz)
  554. {
  555. if (ofnode_is_np(node)) {
  556. const struct device_node *np = ofnode_to_np(node);
  557. int psize;
  558. const __be32 *prop = of_get_property(np, propname, &psize);
  559. if (!prop || sz != psize)
  560. return NULL;
  561. return (uint8_t *)prop;
  562. } else {
  563. return fdtdec_locate_byte_array(gd->fdt_blob,
  564. ofnode_to_offset(node), propname, sz);
  565. }
  566. }
  567. int ofnode_read_pci_addr(ofnode node, enum fdt_pci_space type,
  568. const char *propname, struct fdt_pci_addr *addr)
  569. {
  570. const fdt32_t *cell;
  571. int len;
  572. int ret = -ENOENT;
  573. debug("%s: %s: ", __func__, propname);
  574. /*
  575. * If we follow the pci bus bindings strictly, we should check
  576. * the value of the node's parent node's #address-cells and
  577. * #size-cells. They need to be 3 and 2 accordingly. However,
  578. * for simplicity we skip the check here.
  579. */
  580. cell = ofnode_get_property(node, propname, &len);
  581. if (!cell)
  582. goto fail;
  583. if ((len % FDT_PCI_REG_SIZE) == 0) {
  584. int num = len / FDT_PCI_REG_SIZE;
  585. int i;
  586. for (i = 0; i < num; i++) {
  587. debug("pci address #%d: %08lx %08lx %08lx\n", i,
  588. (ulong)fdt32_to_cpu(cell[0]),
  589. (ulong)fdt32_to_cpu(cell[1]),
  590. (ulong)fdt32_to_cpu(cell[2]));
  591. if ((fdt32_to_cpu(*cell) & type) == type) {
  592. addr->phys_hi = fdt32_to_cpu(cell[0]);
  593. addr->phys_mid = fdt32_to_cpu(cell[1]);
  594. addr->phys_lo = fdt32_to_cpu(cell[2]);
  595. break;
  596. }
  597. cell += (FDT_PCI_ADDR_CELLS +
  598. FDT_PCI_SIZE_CELLS);
  599. }
  600. if (i == num) {
  601. ret = -ENXIO;
  602. goto fail;
  603. }
  604. return 0;
  605. }
  606. ret = -EINVAL;
  607. fail:
  608. debug("(not found)\n");
  609. return ret;
  610. }
  611. int ofnode_read_pci_vendev(ofnode node, u16 *vendor, u16 *device)
  612. {
  613. const char *list, *end;
  614. int len;
  615. list = ofnode_get_property(node, "compatible", &len);
  616. if (!list)
  617. return -ENOENT;
  618. end = list + len;
  619. while (list < end) {
  620. len = strlen(list);
  621. if (len >= strlen("pciVVVV,DDDD")) {
  622. char *s = strstr(list, "pci");
  623. /*
  624. * check if the string is something like pciVVVV,DDDD.RR
  625. * or just pciVVVV,DDDD
  626. */
  627. if (s && s[7] == ',' &&
  628. (s[12] == '.' || s[12] == 0)) {
  629. s += 3;
  630. *vendor = simple_strtol(s, NULL, 16);
  631. s += 5;
  632. *device = simple_strtol(s, NULL, 16);
  633. return 0;
  634. }
  635. }
  636. list += (len + 1);
  637. }
  638. return -ENOENT;
  639. }
  640. int ofnode_read_addr_cells(ofnode node)
  641. {
  642. if (ofnode_is_np(node)) {
  643. return of_n_addr_cells(ofnode_to_np(node));
  644. } else {
  645. int parent = fdt_parent_offset(gd->fdt_blob,
  646. ofnode_to_offset(node));
  647. return fdt_address_cells(gd->fdt_blob, parent);
  648. }
  649. }
  650. int ofnode_read_size_cells(ofnode node)
  651. {
  652. if (ofnode_is_np(node)) {
  653. return of_n_size_cells(ofnode_to_np(node));
  654. } else {
  655. int parent = fdt_parent_offset(gd->fdt_blob,
  656. ofnode_to_offset(node));
  657. return fdt_size_cells(gd->fdt_blob, parent);
  658. }
  659. }
  660. int ofnode_read_simple_addr_cells(ofnode node)
  661. {
  662. if (ofnode_is_np(node))
  663. return of_simple_addr_cells(ofnode_to_np(node));
  664. else
  665. return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
  666. }
  667. int ofnode_read_simple_size_cells(ofnode node)
  668. {
  669. if (ofnode_is_np(node))
  670. return of_simple_size_cells(ofnode_to_np(node));
  671. else
  672. return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
  673. }
  674. bool ofnode_pre_reloc(ofnode node)
  675. {
  676. #if defined(CONFIG_SPL_BUILD) || defined(CONFIG_TPL_BUILD)
  677. /* for SPL and TPL the remaining nodes after the fdtgrep 1st pass
  678. * had property dm-pre-reloc or u-boot,dm-spl/tpl.
  679. * They are removed in final dtb (fdtgrep 2nd pass)
  680. */
  681. return true;
  682. #else
  683. if (ofnode_read_bool(node, "u-boot,dm-pre-reloc"))
  684. return true;
  685. if (ofnode_read_bool(node, "u-boot,dm-pre-proper"))
  686. return true;
  687. /*
  688. * In regular builds individual spl and tpl handling both
  689. * count as handled pre-relocation for later second init.
  690. */
  691. if (ofnode_read_bool(node, "u-boot,dm-spl") ||
  692. ofnode_read_bool(node, "u-boot,dm-tpl"))
  693. return true;
  694. return false;
  695. #endif
  696. }
  697. int ofnode_read_resource(ofnode node, uint index, struct resource *res)
  698. {
  699. if (ofnode_is_np(node)) {
  700. return of_address_to_resource(ofnode_to_np(node), index, res);
  701. } else {
  702. struct fdt_resource fres;
  703. int ret;
  704. ret = fdt_get_resource(gd->fdt_blob, ofnode_to_offset(node),
  705. "reg", index, &fres);
  706. if (ret < 0)
  707. return -EINVAL;
  708. memset(res, '\0', sizeof(*res));
  709. res->start = fres.start;
  710. res->end = fres.end;
  711. return 0;
  712. }
  713. }
  714. int ofnode_read_resource_byname(ofnode node, const char *name,
  715. struct resource *res)
  716. {
  717. int index;
  718. index = ofnode_stringlist_search(node, "reg-names", name);
  719. if (index < 0)
  720. return index;
  721. return ofnode_read_resource(node, index, res);
  722. }
  723. u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr)
  724. {
  725. if (ofnode_is_np(node))
  726. return of_translate_address(ofnode_to_np(node), in_addr);
  727. else
  728. return fdt_translate_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
  729. }
  730. u64 ofnode_translate_dma_address(ofnode node, const fdt32_t *in_addr)
  731. {
  732. if (ofnode_is_np(node))
  733. return of_translate_dma_address(ofnode_to_np(node), in_addr);
  734. else
  735. return fdt_translate_dma_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
  736. }
  737. int ofnode_device_is_compatible(ofnode node, const char *compat)
  738. {
  739. if (ofnode_is_np(node))
  740. return of_device_is_compatible(ofnode_to_np(node), compat,
  741. NULL, NULL);
  742. else
  743. return !fdt_node_check_compatible(gd->fdt_blob,
  744. ofnode_to_offset(node),
  745. compat);
  746. }
  747. ofnode ofnode_by_compatible(ofnode from, const char *compat)
  748. {
  749. if (of_live_active()) {
  750. return np_to_ofnode(of_find_compatible_node(
  751. (struct device_node *)ofnode_to_np(from), NULL,
  752. compat));
  753. } else {
  754. return offset_to_ofnode(fdt_node_offset_by_compatible(
  755. gd->fdt_blob, ofnode_to_offset(from), compat));
  756. }
  757. }
  758. ofnode ofnode_by_prop_value(ofnode from, const char *propname,
  759. const void *propval, int proplen)
  760. {
  761. if (of_live_active()) {
  762. return np_to_ofnode(of_find_node_by_prop_value(
  763. (struct device_node *)ofnode_to_np(from), propname,
  764. propval, proplen));
  765. } else {
  766. return offset_to_ofnode(fdt_node_offset_by_prop_value(
  767. gd->fdt_blob, ofnode_to_offset(from),
  768. propname, propval, proplen));
  769. }
  770. }
  771. int ofnode_write_prop(ofnode node, const char *propname, int len,
  772. const void *value)
  773. {
  774. const struct device_node *np = ofnode_to_np(node);
  775. struct property *pp;
  776. struct property *pp_last = NULL;
  777. struct property *new;
  778. if (!of_live_active())
  779. return -ENOSYS;
  780. if (!np)
  781. return -EINVAL;
  782. for (pp = np->properties; pp; pp = pp->next) {
  783. if (strcmp(pp->name, propname) == 0) {
  784. /* Property exists -> change value */
  785. pp->value = (void *)value;
  786. pp->length = len;
  787. return 0;
  788. }
  789. pp_last = pp;
  790. }
  791. if (!pp_last)
  792. return -ENOENT;
  793. /* Property does not exist -> append new property */
  794. new = malloc(sizeof(struct property));
  795. if (!new)
  796. return -ENOMEM;
  797. new->name = strdup(propname);
  798. if (!new->name) {
  799. free(new);
  800. return -ENOMEM;
  801. }
  802. new->value = (void *)value;
  803. new->length = len;
  804. new->next = NULL;
  805. pp_last->next = new;
  806. return 0;
  807. }
  808. int ofnode_write_string(ofnode node, const char *propname, const char *value)
  809. {
  810. if (!of_live_active())
  811. return -ENOSYS;
  812. assert(ofnode_valid(node));
  813. debug("%s: %s = %s", __func__, propname, value);
  814. return ofnode_write_prop(node, propname, strlen(value) + 1, value);
  815. }
  816. int ofnode_set_enabled(ofnode node, bool value)
  817. {
  818. if (!of_live_active())
  819. return -ENOSYS;
  820. assert(ofnode_valid(node));
  821. if (value)
  822. return ofnode_write_string(node, "status", "okay");
  823. else
  824. return ofnode_write_string(node, "status", "disabled");
  825. }