Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 1 | /* pdt.c: OF PROM device tree support code. |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 2 | * |
| 3 | * Paul Mackerras August 1996. |
| 4 | * Copyright (C) 1996-2005 Paul Mackerras. |
| 5 | * |
| 6 | * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. |
| 7 | * {engebret|bergner}@us.ibm.com |
| 8 | * |
| 9 | * Adapted for sparc by David S. Miller davem@davemloft.net |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 10 | * Adapted for multiple architectures by Andres Salomon <dilinger@queued.net> |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 11 | * |
| 12 | * This program is free software; you can redistribute it and/or |
| 13 | * modify it under the terms of the GNU General Public License |
| 14 | * as published by the Free Software Foundation; either version |
| 15 | * 2 of the License, or (at your option) any later version. |
| 16 | */ |
| 17 | |
| 18 | #include <linux/kernel.h> |
| 19 | #include <linux/module.h> |
| 20 | #include <linux/errno.h> |
| 21 | #include <linux/mutex.h> |
| 22 | #include <linux/slab.h> |
| 23 | #include <linux/of.h> |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 24 | #include <linux/of_pdt.h> |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 25 | #include <asm/prom.h> |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 26 | |
| 27 | static struct of_pdt_ops *of_pdt_prom_ops __initdata; |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 28 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 29 | void __initdata (*of_pdt_build_more)(struct device_node *dp, |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 30 | struct device_node ***nextp); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 31 | |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 32 | #if defined(CONFIG_SPARC) |
| 33 | unsigned int of_pdt_unique_id __initdata; |
| 34 | |
| 35 | #define of_pdt_incr_unique_id(p) do { \ |
| 36 | (p)->unique_id = of_pdt_unique_id++; \ |
| 37 | } while (0) |
| 38 | |
| 39 | static inline const char *of_pdt_node_name(struct device_node *dp) |
| 40 | { |
| 41 | return dp->path_component_name; |
| 42 | } |
| 43 | |
| 44 | #else |
| 45 | |
| 46 | static inline void of_pdt_incr_unique_id(void *p) { } |
| 47 | static inline void irq_trans_init(struct device_node *dp) { } |
| 48 | |
| 49 | static inline const char *of_pdt_node_name(struct device_node *dp) |
| 50 | { |
| 51 | return dp->name; |
| 52 | } |
| 53 | |
| 54 | #endif /* !CONFIG_SPARC */ |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 55 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 56 | static struct property * __init of_pdt_build_one_prop(phandle node, char *prev, |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 57 | char *special_name, |
| 58 | void *special_val, |
| 59 | int special_len) |
| 60 | { |
| 61 | static struct property *tmp = NULL; |
| 62 | struct property *p; |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 63 | int err; |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 64 | |
| 65 | if (tmp) { |
| 66 | p = tmp; |
| 67 | memset(p, 0, sizeof(*p) + 32); |
| 68 | tmp = NULL; |
| 69 | } else { |
| 70 | p = prom_early_alloc(sizeof(struct property) + 32); |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 71 | of_pdt_incr_unique_id(p); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 72 | } |
| 73 | |
| 74 | p->name = (char *) (p + 1); |
| 75 | if (special_name) { |
| 76 | strcpy(p->name, special_name); |
| 77 | p->length = special_len; |
| 78 | p->value = prom_early_alloc(special_len); |
| 79 | memcpy(p->value, special_val, special_len); |
| 80 | } else { |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 81 | err = of_pdt_prom_ops->nextprop(node, prev, p->name); |
| 82 | if (err) { |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 83 | tmp = p; |
| 84 | return NULL; |
| 85 | } |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 86 | p->length = of_pdt_prom_ops->getproplen(node, p->name); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 87 | if (p->length <= 0) { |
| 88 | p->length = 0; |
| 89 | } else { |
| 90 | int len; |
| 91 | |
| 92 | p->value = prom_early_alloc(p->length + 1); |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 93 | len = of_pdt_prom_ops->getproperty(node, p->name, |
| 94 | p->value, p->length); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 95 | if (len <= 0) |
| 96 | p->length = 0; |
| 97 | ((unsigned char *)p->value)[p->length] = '\0'; |
| 98 | } |
| 99 | } |
| 100 | return p; |
| 101 | } |
| 102 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 103 | static struct property * __init of_pdt_build_prop_list(phandle node) |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 104 | { |
| 105 | struct property *head, *tail; |
| 106 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 107 | head = tail = of_pdt_build_one_prop(node, NULL, |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 108 | ".node", &node, sizeof(node)); |
| 109 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 110 | tail->next = of_pdt_build_one_prop(node, NULL, NULL, NULL, 0); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 111 | tail = tail->next; |
| 112 | while(tail) { |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 113 | tail->next = of_pdt_build_one_prop(node, tail->name, |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 114 | NULL, NULL, 0); |
| 115 | tail = tail->next; |
| 116 | } |
| 117 | |
| 118 | return head; |
| 119 | } |
| 120 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 121 | static char * __init of_pdt_get_one_property(phandle node, const char *name) |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 122 | { |
| 123 | char *buf = "<NULL>"; |
| 124 | int len; |
| 125 | |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 126 | len = of_pdt_prom_ops->getproplen(node, name); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 127 | if (len > 0) { |
| 128 | buf = prom_early_alloc(len); |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 129 | len = of_pdt_prom_ops->getproperty(node, name, buf, len); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | return buf; |
| 133 | } |
| 134 | |
Andres Salomon | e2f2a93 | 2010-10-10 21:52:57 -0600 | [diff] [blame] | 135 | static char * __init of_pdt_try_pkg2path(phandle node) |
| 136 | { |
| 137 | char *res, *buf = NULL; |
| 138 | int len; |
| 139 | |
| 140 | if (!of_pdt_prom_ops->pkg2path) |
| 141 | return NULL; |
| 142 | |
| 143 | if (of_pdt_prom_ops->pkg2path(node, buf, 0, &len)) |
| 144 | return NULL; |
| 145 | buf = prom_early_alloc(len + 1); |
| 146 | if (of_pdt_prom_ops->pkg2path(node, buf, len, &len)) { |
| 147 | pr_err("%s: package-to-path failed\n", __func__); |
| 148 | return NULL; |
| 149 | } |
| 150 | |
| 151 | res = strrchr(buf, '/'); |
| 152 | if (!res) { |
| 153 | pr_err("%s: couldn't find / in %s\n", __func__, buf); |
| 154 | return NULL; |
| 155 | } |
| 156 | return res+1; |
| 157 | } |
| 158 | |
| 159 | /* |
| 160 | * When fetching the node's name, first try using package-to-path; if |
| 161 | * that fails (either because the arch hasn't supplied a PROM callback, |
| 162 | * or some other random failure), fall back to just looking at the node's |
| 163 | * 'name' property. |
| 164 | */ |
| 165 | static char * __init of_pdt_build_name(phandle node) |
| 166 | { |
| 167 | char *buf; |
| 168 | |
| 169 | buf = of_pdt_try_pkg2path(node); |
| 170 | if (!buf) |
| 171 | buf = of_pdt_get_one_property(node, "name"); |
| 172 | |
| 173 | return buf; |
| 174 | } |
| 175 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 176 | static struct device_node * __init of_pdt_create_node(phandle node, |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 177 | struct device_node *parent) |
| 178 | { |
| 179 | struct device_node *dp; |
| 180 | |
| 181 | if (!node) |
| 182 | return NULL; |
| 183 | |
| 184 | dp = prom_early_alloc(sizeof(*dp)); |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 185 | of_pdt_incr_unique_id(dp); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 186 | dp->parent = parent; |
| 187 | |
| 188 | kref_init(&dp->kref); |
| 189 | |
Andres Salomon | e2f2a93 | 2010-10-10 21:52:57 -0600 | [diff] [blame] | 190 | dp->name = of_pdt_build_name(node); |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 191 | dp->type = of_pdt_get_one_property(node, "device_type"); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 192 | dp->phandle = node; |
| 193 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 194 | dp->properties = of_pdt_build_prop_list(node); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 195 | |
| 196 | irq_trans_init(dp); |
| 197 | |
| 198 | return dp; |
| 199 | } |
| 200 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 201 | static char * __init of_pdt_build_full_name(struct device_node *dp) |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 202 | { |
| 203 | int len, ourlen, plen; |
| 204 | char *n; |
| 205 | |
| 206 | plen = strlen(dp->parent->full_name); |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 207 | ourlen = strlen(of_pdt_node_name(dp)); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 208 | len = ourlen + plen + 2; |
| 209 | |
| 210 | n = prom_early_alloc(len); |
| 211 | strcpy(n, dp->parent->full_name); |
| 212 | if (!of_node_is_root(dp->parent)) { |
| 213 | strcpy(n + plen, "/"); |
| 214 | plen++; |
| 215 | } |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 216 | strcpy(n + plen, of_pdt_node_name(dp)); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 217 | |
| 218 | return n; |
| 219 | } |
| 220 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 221 | static struct device_node * __init of_pdt_build_tree(struct device_node *parent, |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 222 | phandle node, |
| 223 | struct device_node ***nextp) |
| 224 | { |
| 225 | struct device_node *ret = NULL, *prev_sibling = NULL; |
| 226 | struct device_node *dp; |
| 227 | |
| 228 | while (1) { |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 229 | dp = of_pdt_create_node(node, parent); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 230 | if (!dp) |
| 231 | break; |
| 232 | |
| 233 | if (prev_sibling) |
| 234 | prev_sibling->sibling = dp; |
| 235 | |
| 236 | if (!ret) |
| 237 | ret = dp; |
| 238 | prev_sibling = dp; |
| 239 | |
| 240 | *(*nextp) = dp; |
| 241 | *nextp = &dp->allnext; |
| 242 | |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 243 | #if defined(CONFIG_SPARC) |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 244 | dp->path_component_name = build_path_component(dp); |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 245 | #endif |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 246 | dp->full_name = of_pdt_build_full_name(dp); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 247 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 248 | dp->child = of_pdt_build_tree(dp, |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 249 | of_pdt_prom_ops->getchild(node), nextp); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 250 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 251 | if (of_pdt_build_more) |
| 252 | of_pdt_build_more(dp, nextp); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 253 | |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 254 | node = of_pdt_prom_ops->getsibling(node); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 255 | } |
| 256 | |
| 257 | return ret; |
| 258 | } |
| 259 | |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 260 | void __init of_pdt_build_devicetree(phandle root_node, struct of_pdt_ops *ops) |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 261 | { |
| 262 | struct device_node **nextp; |
| 263 | |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 264 | BUG_ON(!ops); |
| 265 | of_pdt_prom_ops = ops; |
| 266 | |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 267 | allnodes = of_pdt_create_node(root_node, NULL); |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 268 | #if defined(CONFIG_SPARC) |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 269 | allnodes->path_component_name = ""; |
Andres Salomon | 3cfc535 | 2010-10-10 21:42:33 -0600 | [diff] [blame] | 270 | #endif |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 271 | allnodes->full_name = "/"; |
| 272 | |
| 273 | nextp = &allnodes->allnext; |
Andres Salomon | ed41850 | 2010-10-10 21:51:25 -0600 | [diff] [blame] | 274 | allnodes->child = of_pdt_build_tree(allnodes, |
Andres Salomon | f90c34bd | 2010-10-10 21:49:45 -0600 | [diff] [blame] | 275 | of_pdt_prom_ops->getchild(allnodes->phandle), &nextp); |
Andres Salomon | 9bdf6ba | 2010-08-30 03:57:28 +0000 | [diff] [blame] | 276 | } |