eee5efcfe50eea300a42d43e887bf4a7b5a54c6a
[linux-2.6.git] / arch / sparc / kernel / prom.c
1 /*
2  * Procedures for creating, accessing and interpreting the device tree.
3  *
4  * Paul Mackerras       August 1996.
5  * Copyright (C) 1996-2005 Paul Mackerras.
6  * 
7  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8  *    {engebret|bergner}@us.ibm.com 
9  *
10  *  Adapted for sparc32 by David S. Miller davem@davemloft.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/types.h>
20 #include <linux/string.h>
21 #include <linux/mm.h>
22 #include <linux/bootmem.h>
23 #include <linux/module.h>
24
25 #include <asm/prom.h>
26 #include <asm/oplib.h>
27
28 extern struct device_node *allnodes;    /* temporary while merging */
29
30 extern rwlock_t devtree_lock;   /* temporary while merging */
31
32 struct device_node *of_find_node_by_phandle(phandle handle)
33 {
34         struct device_node *np;
35
36         for (np = allnodes; np != 0; np = np->allnext)
37                 if (np->node == handle)
38                         break;
39
40         return np;
41 }
42 EXPORT_SYMBOL(of_find_node_by_phandle);
43
44 int of_getintprop_default(struct device_node *np, const char *name, int def)
45 {
46         struct property *prop;
47         int len;
48
49         prop = of_find_property(np, name, &len);
50         if (!prop || len != 4)
51                 return def;
52
53         return *(int *) prop->value;
54 }
55 EXPORT_SYMBOL(of_getintprop_default);
56
57 DEFINE_MUTEX(of_set_property_mutex);
58 EXPORT_SYMBOL(of_set_property_mutex);
59
60 int of_set_property(struct device_node *dp, const char *name, void *val, int len)
61 {
62         struct property **prevp;
63         void *new_val;
64         int err;
65
66         new_val = kmalloc(len, GFP_KERNEL);
67         if (!new_val)
68                 return -ENOMEM;
69
70         memcpy(new_val, val, len);
71
72         err = -ENODEV;
73
74         write_lock(&devtree_lock);
75         prevp = &dp->properties;
76         while (*prevp) {
77                 struct property *prop = *prevp;
78
79                 if (!strcasecmp(prop->name, name)) {
80                         void *old_val = prop->value;
81                         int ret;
82
83                         mutex_lock(&of_set_property_mutex);
84                         ret = prom_setprop(dp->node, (char *) name, val, len);
85                         mutex_unlock(&of_set_property_mutex);
86
87                         err = -EINVAL;
88                         if (ret >= 0) {
89                                 prop->value = new_val;
90                                 prop->length = len;
91
92                                 if (OF_IS_DYNAMIC(prop))
93                                         kfree(old_val);
94
95                                 OF_MARK_DYNAMIC(prop);
96
97                                 err = 0;
98                         }
99                         break;
100                 }
101                 prevp = &(*prevp)->next;
102         }
103         write_unlock(&devtree_lock);
104
105         /* XXX Upate procfs if necessary... */
106
107         return err;
108 }
109 EXPORT_SYMBOL(of_set_property);
110
111 int of_find_in_proplist(const char *list, const char *match, int len)
112 {
113         while (len > 0) {
114                 int l;
115
116                 if (!strcmp(list, match))
117                         return 1;
118                 l = strlen(list) + 1;
119                 list += l;
120                 len -= l;
121         }
122         return 0;
123 }
124 EXPORT_SYMBOL(of_find_in_proplist);
125
126 static unsigned int prom_early_allocated;
127
128 static void * __init prom_early_alloc(unsigned long size)
129 {
130         void *ret;
131
132         ret = __alloc_bootmem(size, SMP_CACHE_BYTES, 0UL);
133         if (ret != NULL)
134                 memset(ret, 0, size);
135
136         prom_early_allocated += size;
137
138         return ret;
139 }
140
141 static int is_root_node(const struct device_node *dp)
142 {
143         if (!dp)
144                 return 0;
145
146         return (dp->parent == NULL);
147 }
148
149 /* The following routines deal with the black magic of fully naming a
150  * node.
151  *
152  * Certain well known named nodes are just the simple name string.
153  *
154  * Actual devices have an address specifier appended to the base name
155  * string, like this "foo@addr".  The "addr" can be in any number of
156  * formats, and the platform plus the type of the node determine the
157  * format and how it is constructed.
158  *
159  * For children of the ROOT node, the naming convention is fixed and
160  * determined by whether this is a sun4u or sun4v system.
161  *
162  * For children of other nodes, it is bus type specific.  So
163  * we walk up the tree until we discover a "device_type" property
164  * we recognize and we go from there.
165  */
166 static void __init sparc32_path_component(struct device_node *dp, char *tmp_buf)
167 {
168         struct linux_prom_registers *regs;
169         struct property *rprop;
170
171         rprop = of_find_property(dp, "reg", NULL);
172         if (!rprop)
173                 return;
174
175         regs = rprop->value;
176         sprintf(tmp_buf, "%s@%x,%x",
177                 dp->name,
178                 regs->which_io, regs->phys_addr);
179 }
180
181 /* "name@slot,offset"  */
182 static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
183 {
184         struct linux_prom_registers *regs;
185         struct property *prop;
186
187         prop = of_find_property(dp, "reg", NULL);
188         if (!prop)
189                 return;
190
191         regs = prop->value;
192         sprintf(tmp_buf, "%s@%x,%x",
193                 dp->name,
194                 regs->which_io,
195                 regs->phys_addr);
196 }
197
198 /* "name@devnum[,func]" */
199 static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
200 {
201         struct linux_prom_pci_registers *regs;
202         struct property *prop;
203         unsigned int devfn;
204
205         prop = of_find_property(dp, "reg", NULL);
206         if (!prop)
207                 return;
208
209         regs = prop->value;
210         devfn = (regs->phys_hi >> 8) & 0xff;
211         if (devfn & 0x07) {
212                 sprintf(tmp_buf, "%s@%x,%x",
213                         dp->name,
214                         devfn >> 3,
215                         devfn & 0x07);
216         } else {
217                 sprintf(tmp_buf, "%s@%x",
218                         dp->name,
219                         devfn >> 3);
220         }
221 }
222
223 /* "name@addrhi,addrlo" */
224 static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
225 {
226         struct linux_prom_registers *regs;
227         struct property *prop;
228
229         prop = of_find_property(dp, "reg", NULL);
230         if (!prop)
231                 return;
232
233         regs = prop->value;
234
235         sprintf(tmp_buf, "%s@%x,%x",
236                 dp->name,
237                 regs->which_io, regs->phys_addr);
238 }
239
240 static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
241 {
242         struct device_node *parent = dp->parent;
243
244         if (parent != NULL) {
245                 if (!strcmp(parent->type, "pci") ||
246                     !strcmp(parent->type, "pciex"))
247                         return pci_path_component(dp, tmp_buf);
248                 if (!strcmp(parent->type, "sbus"))
249                         return sbus_path_component(dp, tmp_buf);
250                 if (!strcmp(parent->type, "ebus"))
251                         return ebus_path_component(dp, tmp_buf);
252
253                 /* "isa" is handled with platform naming */
254         }
255
256         /* Use platform naming convention.  */
257         return sparc32_path_component(dp, tmp_buf);
258 }
259
260 static char * __init build_path_component(struct device_node *dp)
261 {
262         char tmp_buf[64], *n;
263
264         tmp_buf[0] = '\0';
265         __build_path_component(dp, tmp_buf);
266         if (tmp_buf[0] == '\0')
267                 strcpy(tmp_buf, dp->name);
268
269         n = prom_early_alloc(strlen(tmp_buf) + 1);
270         strcpy(n, tmp_buf);
271
272         return n;
273 }
274
275 static char * __init build_full_name(struct device_node *dp)
276 {
277         int len, ourlen, plen;
278         char *n;
279
280         plen = strlen(dp->parent->full_name);
281         ourlen = strlen(dp->path_component_name);
282         len = ourlen + plen + 2;
283
284         n = prom_early_alloc(len);
285         strcpy(n, dp->parent->full_name);
286         if (!is_root_node(dp->parent)) {
287                 strcpy(n + plen, "/");
288                 plen++;
289         }
290         strcpy(n + plen, dp->path_component_name);
291
292         return n;
293 }
294
295 static unsigned int unique_id;
296
297 static struct property * __init build_one_prop(phandle node, char *prev, char *special_name, void *special_val, int special_len)
298 {
299         static struct property *tmp = NULL;
300         struct property *p;
301         int len;
302         const char *name;
303
304         if (tmp) {
305                 p = tmp;
306                 memset(p, 0, sizeof(*p) + 32);
307                 tmp = NULL;
308         } else {
309                 p = prom_early_alloc(sizeof(struct property) + 32);
310                 p->unique_id = unique_id++;
311         }
312
313         p->name = (char *) (p + 1);
314         if (special_name) {
315                 strcpy(p->name, special_name);
316                 p->length = special_len;
317                 p->value = prom_early_alloc(special_len);
318                 memcpy(p->value, special_val, special_len);
319         } else {
320                 if (prev == NULL) {
321                         name = prom_firstprop(node, NULL);
322                 } else {
323                         name = prom_nextprop(node, prev, NULL);
324                 }
325                 if (strlen(name) == 0) {
326                         tmp = p;
327                         return NULL;
328                 }
329                 strcpy(p->name, name);
330                 p->length = prom_getproplen(node, p->name);
331                 if (p->length <= 0) {
332                         p->length = 0;
333                 } else {
334                         p->value = prom_early_alloc(p->length + 1);
335                         len = prom_getproperty(node, p->name, p->value,
336                                                p->length);
337                         if (len <= 0)
338                                 p->length = 0;
339                         ((unsigned char *)p->value)[p->length] = '\0';
340                 }
341         }
342         return p;
343 }
344
345 static struct property * __init build_prop_list(phandle node)
346 {
347         struct property *head, *tail;
348
349         head = tail = build_one_prop(node, NULL,
350                                      ".node", &node, sizeof(node));
351
352         tail->next = build_one_prop(node, NULL, NULL, NULL, 0);
353         tail = tail->next;
354         while(tail) {
355                 tail->next = build_one_prop(node, tail->name,
356                                             NULL, NULL, 0);
357                 tail = tail->next;
358         }
359
360         return head;
361 }
362
363 static char * __init get_one_property(phandle node, char *name)
364 {
365         char *buf = "<NULL>";
366         int len;
367
368         len = prom_getproplen(node, name);
369         if (len > 0) {
370                 buf = prom_early_alloc(len);
371                 len = prom_getproperty(node, name, buf, len);
372         }
373
374         return buf;
375 }
376
377 static struct device_node * __init create_node(phandle node)
378 {
379         struct device_node *dp;
380
381         if (!node)
382                 return NULL;
383
384         dp = prom_early_alloc(sizeof(*dp));
385         dp->unique_id = unique_id++;
386
387         kref_init(&dp->kref);
388
389         dp->name = get_one_property(node, "name");
390         dp->type = get_one_property(node, "device_type");
391         dp->node = node;
392
393         /* Build interrupts later... */
394
395         dp->properties = build_prop_list(node);
396
397         return dp;
398 }
399
400 static struct device_node * __init build_tree(struct device_node *parent, phandle node, struct device_node ***nextp)
401 {
402         struct device_node *dp;
403
404         dp = create_node(node);
405         if (dp) {
406                 *(*nextp) = dp;
407                 *nextp = &dp->allnext;
408
409                 dp->parent = parent;
410                 dp->path_component_name = build_path_component(dp);
411                 dp->full_name = build_full_name(dp);
412
413                 dp->child = build_tree(dp, prom_getchild(node), nextp);
414
415                 dp->sibling = build_tree(parent, prom_getsibling(node), nextp);
416         }
417
418         return dp;
419 }
420
421 struct device_node *of_console_device;
422 EXPORT_SYMBOL(of_console_device);
423
424 char *of_console_path;
425 EXPORT_SYMBOL(of_console_path);
426
427 char *of_console_options;
428 EXPORT_SYMBOL(of_console_options);
429
430 extern void restore_current(void);
431
432 static void __init of_console_init(void)
433 {
434         char *msg = "OF stdout device is: %s\n";
435         struct device_node *dp;
436         unsigned long flags;
437         const char *type;
438         phandle node;
439         int skip, tmp, fd;
440
441         of_console_path = prom_early_alloc(256);
442
443         switch (prom_vers) {
444         case PROM_V0:
445                 skip = 0;
446                 switch (*romvec->pv_stdout) {
447                 case PROMDEV_SCREEN:
448                         type = "display";
449                         break;
450
451                 case PROMDEV_TTYB:
452                         skip = 1;
453                         /* FALLTHRU */
454
455                 case PROMDEV_TTYA:
456                         type = "serial";
457                         break;
458
459                 default:
460                         prom_printf("Invalid PROM_V0 stdout value %u\n",
461                                     *romvec->pv_stdout);
462                         prom_halt();
463                 }
464
465                 tmp = skip;
466                 for_each_node_by_type(dp, type) {
467                         if (!tmp--)
468                                 break;
469                 }
470                 if (!dp) {
471                         prom_printf("Cannot find PROM_V0 console node.\n");
472                         prom_halt();
473                 }
474                 of_console_device = dp;
475
476                 strcpy(of_console_path, dp->full_name);
477                 if (!strcmp(type, "serial")) {
478                         strcat(of_console_path,
479                                (skip ? ":b" : ":a"));
480                 }
481                 break;
482
483         default:
484         case PROM_V2:
485         case PROM_V3:
486                 fd = *romvec->pv_v2bootargs.fd_stdout;
487
488                 spin_lock_irqsave(&prom_lock, flags);
489                 node = (*romvec->pv_v2devops.v2_inst2pkg)(fd);
490                 restore_current();
491                 spin_unlock_irqrestore(&prom_lock, flags);
492
493                 if (!node) {
494                         prom_printf("Cannot resolve stdout node from "
495                                     "instance %08x.\n", fd);
496                         prom_halt();
497                 }
498                 dp = of_find_node_by_phandle(node);
499                 type = of_get_property(dp, "device_type", NULL);
500
501                 if (!type) {
502                         prom_printf("Console stdout lacks "
503                                     "device_type property.\n");
504                         prom_halt();
505                 }
506
507                 if (strcmp(type, "display") && strcmp(type, "serial")) {
508                         prom_printf("Console device_type is neither display "
509                                     "nor serial.\n");
510                         prom_halt();
511                 }
512
513                 of_console_device = dp;
514
515                 if (prom_vers == PROM_V2) {
516                         strcpy(of_console_path, dp->full_name);
517                         switch (*romvec->pv_stdout) {
518                         case PROMDEV_TTYA:
519                                 strcat(of_console_path, ":a");
520                                 break;
521                         case PROMDEV_TTYB:
522                                 strcat(of_console_path, ":b");
523                                 break;
524                         }
525                 } else {
526                         const char *path;
527
528                         dp = of_find_node_by_path("/");
529                         path = of_get_property(dp, "stdout-path", NULL);
530                         if (!path) {
531                                 prom_printf("No stdout-path in root node.\n");
532                                 prom_halt();
533                         }
534                         strcpy(of_console_path, path);
535                 }
536                 break;
537         }
538
539         of_console_options = strrchr(of_console_path, ':');
540         if (of_console_options) {
541                 of_console_options++;
542                 if (*of_console_options == '\0')
543                         of_console_options = NULL;
544         }
545
546         prom_printf(msg, of_console_path);
547         printk(msg, of_console_path);
548 }
549
550 void __init prom_build_devicetree(void)
551 {
552         struct device_node **nextp;
553
554         allnodes = create_node(prom_root_node);
555         allnodes->path_component_name = "";
556         allnodes->full_name = "/";
557
558         nextp = &allnodes->allnext;
559         allnodes->child = build_tree(allnodes,
560                                      prom_getchild(allnodes->node),
561                                      &nextp);
562         of_console_init();
563
564         printk("PROM: Built device tree with %u bytes of memory.\n",
565                prom_early_allocated);
566 }