1 /* pdt.c: OF PROM device tree support code. 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 10 * Adapted for multiple architectures by Andres Salomon <dilinger@queued.net> 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> 24 #include <linux/of_pdt.h> 25 #include <asm/prom.h> 26 27 static struct of_pdt_ops *of_pdt_prom_ops __initdata; 28 29 void __initdata (*of_pdt_build_more)(struct device_node *dp, 30 struct device_node ***nextp); 31 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 */ 55 56 static struct property * __init of_pdt_build_one_prop(phandle node, char *prev, 57 char *special_name, 58 void *special_val, 59 int special_len) 60 { 61 static struct property *tmp = NULL; 62 struct property *p; 63 int err; 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); 71 of_pdt_incr_unique_id(p); 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 { 81 err = of_pdt_prom_ops->nextprop(node, prev, p->name); 82 if (err) { 83 tmp = p; 84 return NULL; 85 } 86 p->length = of_pdt_prom_ops->getproplen(node, p->name); 87 if (p->length <= 0) { 88 p->length = 0; 89 } else { 90 int len; 91 92 p->value = prom_early_alloc(p->length + 1); 93 len = of_pdt_prom_ops->getproperty(node, p->name, 94 p->value, p->length); 95 if (len <= 0) 96 p->length = 0; 97 ((unsigned char *)p->value)[p->length] = '\0'; 98 } 99 } 100 return p; 101 } 102 103 static struct property * __init of_pdt_build_prop_list(phandle node) 104 { 105 struct property *head, *tail; 106 107 head = tail = of_pdt_build_one_prop(node, NULL, 108 ".node", &node, sizeof(node)); 109 110 tail->next = of_pdt_build_one_prop(node, NULL, NULL, NULL, 0); 111 tail = tail->next; 112 while(tail) { 113 tail->next = of_pdt_build_one_prop(node, tail->name, 114 NULL, NULL, 0); 115 tail = tail->next; 116 } 117 118 return head; 119 } 120 121 static char * __init of_pdt_get_one_property(phandle node, const char *name) 122 { 123 char *buf = "<NULL>"; 124 int len; 125 126 len = of_pdt_prom_ops->getproplen(node, name); 127 if (len > 0) { 128 buf = prom_early_alloc(len); 129 len = of_pdt_prom_ops->getproperty(node, name, buf, len); 130 } 131 132 return buf; 133 } 134 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 176 static struct device_node * __init of_pdt_create_node(phandle node, 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)); 185 of_pdt_incr_unique_id(dp); 186 dp->parent = parent; 187 188 kref_init(&dp->kref); 189 190 dp->name = of_pdt_build_name(node); 191 dp->type = of_pdt_get_one_property(node, "device_type"); 192 dp->phandle = node; 193 194 dp->properties = of_pdt_build_prop_list(node); 195 196 irq_trans_init(dp); 197 198 return dp; 199 } 200 201 static char * __init of_pdt_build_full_name(struct device_node *dp) 202 { 203 int len, ourlen, plen; 204 char *n; 205 206 plen = strlen(dp->parent->full_name); 207 ourlen = strlen(of_pdt_node_name(dp)); 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 } 216 strcpy(n + plen, of_pdt_node_name(dp)); 217 218 return n; 219 } 220 221 static struct device_node * __init of_pdt_build_tree(struct device_node *parent, 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) { 229 dp = of_pdt_create_node(node, parent); 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 243 #if defined(CONFIG_SPARC) 244 dp->path_component_name = build_path_component(dp); 245 #endif 246 dp->full_name = of_pdt_build_full_name(dp); 247 248 dp->child = of_pdt_build_tree(dp, 249 of_pdt_prom_ops->getchild(node), nextp); 250 251 if (of_pdt_build_more) 252 of_pdt_build_more(dp, nextp); 253 254 node = of_pdt_prom_ops->getsibling(node); 255 } 256 257 return ret; 258 } 259 260 void __init of_pdt_build_devicetree(phandle root_node, struct of_pdt_ops *ops) 261 { 262 struct device_node **nextp; 263 264 BUG_ON(!ops); 265 of_pdt_prom_ops = ops; 266 267 allnodes = of_pdt_create_node(root_node, NULL); 268 #if defined(CONFIG_SPARC) 269 allnodes->path_component_name = ""; 270 #endif 271 allnodes->full_name = "/"; 272 273 nextp = &allnodes->allnext; 274 allnodes->child = of_pdt_build_tree(allnodes, 275 of_pdt_prom_ops->getchild(allnodes->phandle), &nextp); 276 } 277