devtree.c 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * devtree.c - convenience functions for device tree manipulation
  4. * Copyright 2007 David Gibson, IBM Corporation.
  5. * Copyright (c) 2007 Freescale Semiconductor, Inc.
  6. *
  7. * Authors: David Gibson <david@gibson.dropbear.id.au>
  8. * Scott Wood <scottwood@freescale.com>
  9. */
  10. #include <stdarg.h>
  11. #include <stddef.h>
  12. #include "types.h"
  13. #include "string.h"
  14. #include "stdio.h"
  15. #include "ops.h"
  16. #include "of.h"
  17. void dt_fixup_memory(u64 start, u64 size)
  18. {
  19. void *root, *memory;
  20. int naddr, nsize, i;
  21. u32 memreg[4];
  22. root = finddevice("/");
  23. if (getprop(root, "#address-cells", &naddr, sizeof(naddr)) < 0)
  24. naddr = 2;
  25. else
  26. naddr = be32_to_cpu(naddr);
  27. if (naddr < 1 || naddr > 2)
  28. fatal("Can't cope with #address-cells == %d in /\n\r", naddr);
  29. if (getprop(root, "#size-cells", &nsize, sizeof(nsize)) < 0)
  30. nsize = 1;
  31. else
  32. nsize = be32_to_cpu(nsize);
  33. if (nsize < 1 || nsize > 2)
  34. fatal("Can't cope with #size-cells == %d in /\n\r", nsize);
  35. i = 0;
  36. if (naddr == 2)
  37. memreg[i++] = cpu_to_be32(start >> 32);
  38. memreg[i++] = cpu_to_be32(start & 0xffffffff);
  39. if (nsize == 2)
  40. memreg[i++] = cpu_to_be32(size >> 32);
  41. memreg[i++] = cpu_to_be32(size & 0xffffffff);
  42. memory = finddevice("/memory");
  43. if (! memory) {
  44. memory = create_node(NULL, "memory");
  45. setprop_str(memory, "device_type", "memory");
  46. }
  47. printf("Memory <- <0x%x", be32_to_cpu(memreg[0]));
  48. for (i = 1; i < (naddr + nsize); i++)
  49. printf(" 0x%x", be32_to_cpu(memreg[i]));
  50. printf("> (%ldMB)\n\r", (unsigned long)(size >> 20));
  51. setprop(memory, "reg", memreg, (naddr + nsize)*sizeof(u32));
  52. }
  53. #define MHZ(x) ((x + 500000) / 1000000)
  54. void dt_fixup_cpu_clocks(u32 cpu, u32 tb, u32 bus)
  55. {
  56. void *devp = NULL;
  57. printf("CPU clock-frequency <- 0x%x (%dMHz)\n\r", cpu, MHZ(cpu));
  58. printf("CPU timebase-frequency <- 0x%x (%dMHz)\n\r", tb, MHZ(tb));
  59. if (bus > 0)
  60. printf("CPU bus-frequency <- 0x%x (%dMHz)\n\r", bus, MHZ(bus));
  61. while ((devp = find_node_by_devtype(devp, "cpu"))) {
  62. setprop_val(devp, "clock-frequency", cpu_to_be32(cpu));
  63. setprop_val(devp, "timebase-frequency", cpu_to_be32(tb));
  64. if (bus > 0)
  65. setprop_val(devp, "bus-frequency", cpu_to_be32(bus));
  66. }
  67. timebase_period_ns = 1000000000 / tb;
  68. }
  69. void dt_fixup_clock(const char *path, u32 freq)
  70. {
  71. void *devp = finddevice(path);
  72. if (devp) {
  73. printf("%s: clock-frequency <- %x (%dMHz)\n\r", path, freq, MHZ(freq));
  74. setprop_val(devp, "clock-frequency", cpu_to_be32(freq));
  75. }
  76. }
  77. void dt_fixup_mac_address_by_alias(const char *alias, const u8 *addr)
  78. {
  79. void *devp = find_node_by_alias(alias);
  80. if (devp) {
  81. printf("%s: local-mac-address <-"
  82. " %02x:%02x:%02x:%02x:%02x:%02x\n\r", alias,
  83. addr[0], addr[1], addr[2],
  84. addr[3], addr[4], addr[5]);
  85. setprop(devp, "local-mac-address", addr, 6);
  86. }
  87. }
  88. void dt_fixup_mac_address(u32 index, const u8 *addr)
  89. {
  90. void *devp = find_node_by_prop_value(NULL, "linux,network-index",
  91. (void*)&index, sizeof(index));
  92. if (devp) {
  93. printf("ENET%d: local-mac-address <-"
  94. " %02x:%02x:%02x:%02x:%02x:%02x\n\r", index,
  95. addr[0], addr[1], addr[2],
  96. addr[3], addr[4], addr[5]);
  97. setprop(devp, "local-mac-address", addr, 6);
  98. }
  99. }
  100. void __dt_fixup_mac_addresses(u32 startindex, ...)
  101. {
  102. va_list ap;
  103. u32 index = startindex;
  104. const u8 *addr;
  105. va_start(ap, startindex);
  106. while ((addr = va_arg(ap, const u8 *)))
  107. dt_fixup_mac_address(index++, addr);
  108. va_end(ap);
  109. }
  110. #define MAX_ADDR_CELLS 4
  111. void dt_get_reg_format(void *node, u32 *naddr, u32 *nsize)
  112. {
  113. if (getprop(node, "#address-cells", naddr, 4) != 4)
  114. *naddr = 2;
  115. else
  116. *naddr = be32_to_cpu(*naddr);
  117. if (getprop(node, "#size-cells", nsize, 4) != 4)
  118. *nsize = 1;
  119. else
  120. *nsize = be32_to_cpu(*nsize);
  121. }
  122. static void copy_val(u32 *dest, u32 *src, int naddr)
  123. {
  124. int pad = MAX_ADDR_CELLS - naddr;
  125. memset(dest, 0, pad * 4);
  126. memcpy(dest + pad, src, naddr * 4);
  127. }
  128. static int sub_reg(u32 *reg, u32 *sub)
  129. {
  130. int i, borrow = 0;
  131. for (i = MAX_ADDR_CELLS - 1; i >= 0; i--) {
  132. int prev_borrow = borrow;
  133. borrow = reg[i] < sub[i] + prev_borrow;
  134. reg[i] -= sub[i] + prev_borrow;
  135. }
  136. return !borrow;
  137. }
  138. static int add_reg(u32 *reg, u32 *add, int naddr)
  139. {
  140. int i, carry = 0;
  141. for (i = MAX_ADDR_CELLS - 1; i >= MAX_ADDR_CELLS - naddr; i--) {
  142. u64 tmp = (u64)be32_to_cpu(reg[i]) + be32_to_cpu(add[i]) + carry;
  143. carry = tmp >> 32;
  144. reg[i] = cpu_to_be32((u32)tmp);
  145. }
  146. return !carry;
  147. }
  148. /* It is assumed that if the first byte of reg fits in a
  149. * range, then the whole reg block fits.
  150. */
  151. static int compare_reg(u32 *reg, u32 *range, u32 *rangesize)
  152. {
  153. int i;
  154. u32 end;
  155. for (i = 0; i < MAX_ADDR_CELLS; i++) {
  156. if (be32_to_cpu(reg[i]) < be32_to_cpu(range[i]))
  157. return 0;
  158. if (be32_to_cpu(reg[i]) > be32_to_cpu(range[i]))
  159. break;
  160. }
  161. for (i = 0; i < MAX_ADDR_CELLS; i++) {
  162. end = be32_to_cpu(range[i]) + be32_to_cpu(rangesize[i]);
  163. if (be32_to_cpu(reg[i]) < end)
  164. break;
  165. if (be32_to_cpu(reg[i]) > end)
  166. return 0;
  167. }
  168. return reg[i] != end;
  169. }
  170. /* reg must be MAX_ADDR_CELLS */
  171. static int find_range(u32 *reg, u32 *ranges, int nregaddr,
  172. int naddr, int nsize, int buflen)
  173. {
  174. int nrange = nregaddr + naddr + nsize;
  175. int i;
  176. for (i = 0; i + nrange <= buflen; i += nrange) {
  177. u32 range_addr[MAX_ADDR_CELLS];
  178. u32 range_size[MAX_ADDR_CELLS];
  179. copy_val(range_addr, ranges + i, nregaddr);
  180. copy_val(range_size, ranges + i + nregaddr + naddr, nsize);
  181. if (compare_reg(reg, range_addr, range_size))
  182. return i;
  183. }
  184. return -1;
  185. }
  186. /* Currently only generic buses without special encodings are supported.
  187. * In particular, PCI is not supported. Also, only the beginning of the
  188. * reg block is tracked; size is ignored except in ranges.
  189. */
  190. static u32 prop_buf[MAX_PROP_LEN / 4];
  191. static int dt_xlate(void *node, int res, int reglen, unsigned long *addr,
  192. unsigned long *size)
  193. {
  194. u32 last_addr[MAX_ADDR_CELLS];
  195. u32 this_addr[MAX_ADDR_CELLS];
  196. void *parent;
  197. u64 ret_addr, ret_size;
  198. u32 naddr, nsize, prev_naddr, prev_nsize;
  199. int buflen, offset;
  200. parent = get_parent(node);
  201. if (!parent)
  202. return 0;
  203. dt_get_reg_format(parent, &naddr, &nsize);
  204. if (nsize > 2)
  205. return 0;
  206. offset = (naddr + nsize) * res;
  207. if (reglen < offset + naddr + nsize ||
  208. MAX_PROP_LEN < (offset + naddr + nsize) * 4)
  209. return 0;
  210. copy_val(last_addr, prop_buf + offset, naddr);
  211. ret_size = be32_to_cpu(prop_buf[offset + naddr]);
  212. if (nsize == 2) {
  213. ret_size <<= 32;
  214. ret_size |= be32_to_cpu(prop_buf[offset + naddr + 1]);
  215. }
  216. for (;;) {
  217. prev_naddr = naddr;
  218. prev_nsize = nsize;
  219. node = parent;
  220. parent = get_parent(node);
  221. if (!parent)
  222. break;
  223. dt_get_reg_format(parent, &naddr, &nsize);
  224. buflen = getprop(node, "ranges", prop_buf,
  225. sizeof(prop_buf));
  226. if (buflen == 0)
  227. continue;
  228. if (buflen < 0 || buflen > sizeof(prop_buf))
  229. return 0;
  230. offset = find_range(last_addr, prop_buf, prev_naddr,
  231. naddr, prev_nsize, buflen / 4);
  232. if (offset < 0)
  233. return 0;
  234. copy_val(this_addr, prop_buf + offset, prev_naddr);
  235. if (!sub_reg(last_addr, this_addr))
  236. return 0;
  237. copy_val(this_addr, prop_buf + offset + prev_naddr, naddr);
  238. if (!add_reg(last_addr, this_addr, naddr))
  239. return 0;
  240. }
  241. if (naddr > 2)
  242. return 0;
  243. ret_addr = ((u64)be32_to_cpu(last_addr[2]) << 32) | be32_to_cpu(last_addr[3]);
  244. if (sizeof(void *) == 4 &&
  245. (ret_addr >= 0x100000000ULL || ret_size > 0x100000000ULL ||
  246. ret_addr + ret_size > 0x100000000ULL))
  247. return 0;
  248. *addr = ret_addr;
  249. if (size)
  250. *size = ret_size;
  251. return 1;
  252. }
  253. int dt_xlate_reg(void *node, int res, unsigned long *addr, unsigned long *size)
  254. {
  255. int reglen;
  256. reglen = getprop(node, "reg", prop_buf, sizeof(prop_buf)) / 4;
  257. return dt_xlate(node, res, reglen, addr, size);
  258. }
  259. int dt_xlate_addr(void *node, u32 *buf, int buflen, unsigned long *xlated_addr)
  260. {
  261. if (buflen > sizeof(prop_buf))
  262. return 0;
  263. memcpy(prop_buf, buf, buflen);
  264. return dt_xlate(node, 0, buflen / 4, xlated_addr, NULL);
  265. }
  266. int dt_is_compatible(void *node, const char *compat)
  267. {
  268. char *buf = (char *)prop_buf;
  269. int len, pos;
  270. len = getprop(node, "compatible", buf, MAX_PROP_LEN);
  271. if (len < 0)
  272. return 0;
  273. for (pos = 0; pos < len; pos++) {
  274. if (!strcmp(buf + pos, compat))
  275. return 1;
  276. pos += strnlen(&buf[pos], len - pos);
  277. }
  278. return 0;
  279. }
  280. int dt_get_virtual_reg(void *node, void **addr, int nres)
  281. {
  282. unsigned long xaddr;
  283. int n, i;
  284. n = getprop(node, "virtual-reg", addr, nres * 4);
  285. if (n > 0) {
  286. for (i = 0; i < n/4; i ++)
  287. ((u32 *)addr)[i] = be32_to_cpu(((u32 *)addr)[i]);
  288. return n / 4;
  289. }
  290. for (n = 0; n < nres; n++) {
  291. if (!dt_xlate_reg(node, n, &xaddr, NULL))
  292. break;
  293. addr[n] = (void *)xaddr;
  294. }
  295. return n;
  296. }