Merge branches 'core/futexes', 'core/locking', 'core/rcu' and 'linus' into core/urgent
[linux-2.6] / arch / sparc / kernel / prom_64.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 sparc64 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/module.h>
23 #include <linux/lmb.h>
24 #include <linux/of_device.h>
25
26 #include <asm/prom.h>
27 #include <asm/oplib.h>
28 #include <asm/irq.h>
29 #include <asm/asi.h>
30 #include <asm/upa.h>
31 #include <asm/smp.h>
32
33 #include "prom.h"
34
35 void * __init prom_early_alloc(unsigned long size)
36 {
37         unsigned long paddr = lmb_alloc(size, SMP_CACHE_BYTES);
38         void *ret;
39
40         if (!paddr) {
41                 prom_printf("prom_early_alloc(%lu) failed\n");
42                 prom_halt();
43         }
44
45         ret = __va(paddr);
46         memset(ret, 0, size);
47         prom_early_allocated += size;
48
49         return ret;
50 }
51
52 /* The following routines deal with the black magic of fully naming a
53  * node.
54  *
55  * Certain well known named nodes are just the simple name string.
56  *
57  * Actual devices have an address specifier appended to the base name
58  * string, like this "foo@addr".  The "addr" can be in any number of
59  * formats, and the platform plus the type of the node determine the
60  * format and how it is constructed.
61  *
62  * For children of the ROOT node, the naming convention is fixed and
63  * determined by whether this is a sun4u or sun4v system.
64  *
65  * For children of other nodes, it is bus type specific.  So
66  * we walk up the tree until we discover a "device_type" property
67  * we recognize and we go from there.
68  *
69  * As an example, the boot device on my workstation has a full path:
70  *
71  *      /pci@1e,600000/ide@d/disk@0,0:c
72  */
73 static void __init sun4v_path_component(struct device_node *dp, char *tmp_buf)
74 {
75         struct linux_prom64_registers *regs;
76         struct property *rprop;
77         u32 high_bits, low_bits, type;
78
79         rprop = of_find_property(dp, "reg", NULL);
80         if (!rprop)
81                 return;
82
83         regs = rprop->value;
84         if (!is_root_node(dp->parent)) {
85                 sprintf(tmp_buf, "%s@%x,%x",
86                         dp->name,
87                         (unsigned int) (regs->phys_addr >> 32UL),
88                         (unsigned int) (regs->phys_addr & 0xffffffffUL));
89                 return;
90         }
91
92         type = regs->phys_addr >> 60UL;
93         high_bits = (regs->phys_addr >> 32UL) & 0x0fffffffUL;
94         low_bits = (regs->phys_addr & 0xffffffffUL);
95
96         if (type == 0 || type == 8) {
97                 const char *prefix = (type == 0) ? "m" : "i";
98
99                 if (low_bits)
100                         sprintf(tmp_buf, "%s@%s%x,%x",
101                                 dp->name, prefix,
102                                 high_bits, low_bits);
103                 else
104                         sprintf(tmp_buf, "%s@%s%x",
105                                 dp->name,
106                                 prefix,
107                                 high_bits);
108         } else if (type == 12) {
109                 sprintf(tmp_buf, "%s@%x",
110                         dp->name, high_bits);
111         }
112 }
113
114 static void __init sun4u_path_component(struct device_node *dp, char *tmp_buf)
115 {
116         struct linux_prom64_registers *regs;
117         struct property *prop;
118
119         prop = of_find_property(dp, "reg", NULL);
120         if (!prop)
121                 return;
122
123         regs = prop->value;
124         if (!is_root_node(dp->parent)) {
125                 sprintf(tmp_buf, "%s@%x,%x",
126                         dp->name,
127                         (unsigned int) (regs->phys_addr >> 32UL),
128                         (unsigned int) (regs->phys_addr & 0xffffffffUL));
129                 return;
130         }
131
132         prop = of_find_property(dp, "upa-portid", NULL);
133         if (!prop)
134                 prop = of_find_property(dp, "portid", NULL);
135         if (prop) {
136                 unsigned long mask = 0xffffffffUL;
137
138                 if (tlb_type >= cheetah)
139                         mask = 0x7fffff;
140
141                 sprintf(tmp_buf, "%s@%x,%x",
142                         dp->name,
143                         *(u32 *)prop->value,
144                         (unsigned int) (regs->phys_addr & mask));
145         }
146 }
147
148 /* "name@slot,offset"  */
149 static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
150 {
151         struct linux_prom_registers *regs;
152         struct property *prop;
153
154         prop = of_find_property(dp, "reg", NULL);
155         if (!prop)
156                 return;
157
158         regs = prop->value;
159         sprintf(tmp_buf, "%s@%x,%x",
160                 dp->name,
161                 regs->which_io,
162                 regs->phys_addr);
163 }
164
165 /* "name@devnum[,func]" */
166 static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
167 {
168         struct linux_prom_pci_registers *regs;
169         struct property *prop;
170         unsigned int devfn;
171
172         prop = of_find_property(dp, "reg", NULL);
173         if (!prop)
174                 return;
175
176         regs = prop->value;
177         devfn = (regs->phys_hi >> 8) & 0xff;
178         if (devfn & 0x07) {
179                 sprintf(tmp_buf, "%s@%x,%x",
180                         dp->name,
181                         devfn >> 3,
182                         devfn & 0x07);
183         } else {
184                 sprintf(tmp_buf, "%s@%x",
185                         dp->name,
186                         devfn >> 3);
187         }
188 }
189
190 /* "name@UPA_PORTID,offset" */
191 static void __init upa_path_component(struct device_node *dp, char *tmp_buf)
192 {
193         struct linux_prom64_registers *regs;
194         struct property *prop;
195
196         prop = of_find_property(dp, "reg", NULL);
197         if (!prop)
198                 return;
199
200         regs = prop->value;
201
202         prop = of_find_property(dp, "upa-portid", NULL);
203         if (!prop)
204                 return;
205
206         sprintf(tmp_buf, "%s@%x,%x",
207                 dp->name,
208                 *(u32 *) prop->value,
209                 (unsigned int) (regs->phys_addr & 0xffffffffUL));
210 }
211
212 /* "name@reg" */
213 static void __init vdev_path_component(struct device_node *dp, char *tmp_buf)
214 {
215         struct property *prop;
216         u32 *regs;
217
218         prop = of_find_property(dp, "reg", NULL);
219         if (!prop)
220                 return;
221
222         regs = prop->value;
223
224         sprintf(tmp_buf, "%s@%x", dp->name, *regs);
225 }
226
227 /* "name@addrhi,addrlo" */
228 static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
229 {
230         struct linux_prom64_registers *regs;
231         struct property *prop;
232
233         prop = of_find_property(dp, "reg", NULL);
234         if (!prop)
235                 return;
236
237         regs = prop->value;
238
239         sprintf(tmp_buf, "%s@%x,%x",
240                 dp->name,
241                 (unsigned int) (regs->phys_addr >> 32UL),
242                 (unsigned int) (regs->phys_addr & 0xffffffffUL));
243 }
244
245 /* "name@bus,addr" */
246 static void __init i2c_path_component(struct device_node *dp, char *tmp_buf)
247 {
248         struct property *prop;
249         u32 *regs;
250
251         prop = of_find_property(dp, "reg", NULL);
252         if (!prop)
253                 return;
254
255         regs = prop->value;
256
257         /* This actually isn't right... should look at the #address-cells
258          * property of the i2c bus node etc. etc.
259          */
260         sprintf(tmp_buf, "%s@%x,%x",
261                 dp->name, regs[0], regs[1]);
262 }
263
264 /* "name@reg0[,reg1]" */
265 static void __init usb_path_component(struct device_node *dp, char *tmp_buf)
266 {
267         struct property *prop;
268         u32 *regs;
269
270         prop = of_find_property(dp, "reg", NULL);
271         if (!prop)
272                 return;
273
274         regs = prop->value;
275
276         if (prop->length == sizeof(u32) || regs[1] == 1) {
277                 sprintf(tmp_buf, "%s@%x",
278                         dp->name, regs[0]);
279         } else {
280                 sprintf(tmp_buf, "%s@%x,%x",
281                         dp->name, regs[0], regs[1]);
282         }
283 }
284
285 /* "name@reg0reg1[,reg2reg3]" */
286 static void __init ieee1394_path_component(struct device_node *dp, char *tmp_buf)
287 {
288         struct property *prop;
289         u32 *regs;
290
291         prop = of_find_property(dp, "reg", NULL);
292         if (!prop)
293                 return;
294
295         regs = prop->value;
296
297         if (regs[2] || regs[3]) {
298                 sprintf(tmp_buf, "%s@%08x%08x,%04x%08x",
299                         dp->name, regs[0], regs[1], regs[2], regs[3]);
300         } else {
301                 sprintf(tmp_buf, "%s@%08x%08x",
302                         dp->name, regs[0], regs[1]);
303         }
304 }
305
306 static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
307 {
308         struct device_node *parent = dp->parent;
309
310         if (parent != NULL) {
311                 if (!strcmp(parent->type, "pci") ||
312                     !strcmp(parent->type, "pciex")) {
313                         pci_path_component(dp, tmp_buf);
314                         return;
315                 }
316                 if (!strcmp(parent->type, "sbus")) {
317                         sbus_path_component(dp, tmp_buf);
318                         return;
319                 }
320                 if (!strcmp(parent->type, "upa")) {
321                         upa_path_component(dp, tmp_buf);
322                         return;
323                 }
324                 if (!strcmp(parent->type, "ebus")) {
325                         ebus_path_component(dp, tmp_buf);
326                         return;
327                 }
328                 if (!strcmp(parent->name, "usb") ||
329                     !strcmp(parent->name, "hub")) {
330                         usb_path_component(dp, tmp_buf);
331                         return;
332                 }
333                 if (!strcmp(parent->type, "i2c")) {
334                         i2c_path_component(dp, tmp_buf);
335                         return;
336                 }
337                 if (!strcmp(parent->type, "firewire")) {
338                         ieee1394_path_component(dp, tmp_buf);
339                         return;
340                 }
341                 if (!strcmp(parent->type, "virtual-devices")) {
342                         vdev_path_component(dp, tmp_buf);
343                         return;
344                 }
345                 /* "isa" is handled with platform naming */
346         }
347
348         /* Use platform naming convention.  */
349         if (tlb_type == hypervisor) {
350                 sun4v_path_component(dp, tmp_buf);
351                 return;
352         } else {
353                 sun4u_path_component(dp, tmp_buf);
354         }
355 }
356
357 char * __init build_path_component(struct device_node *dp)
358 {
359         char tmp_buf[64], *n;
360
361         tmp_buf[0] = '\0';
362         __build_path_component(dp, tmp_buf);
363         if (tmp_buf[0] == '\0')
364                 strcpy(tmp_buf, dp->name);
365
366         n = prom_early_alloc(strlen(tmp_buf) + 1);
367         strcpy(n, tmp_buf);
368
369         return n;
370 }
371
372 static const char *get_mid_prop(void)
373 {
374         return (tlb_type == spitfire ? "upa-portid" : "portid");
375 }
376
377 struct device_node *of_find_node_by_cpuid(int cpuid)
378 {
379         struct device_node *dp;
380         const char *mid_prop = get_mid_prop();
381
382         for_each_node_by_type(dp, "cpu") {
383                 int id = of_getintprop_default(dp, mid_prop, -1);
384                 const char *this_mid_prop = mid_prop;
385
386                 if (id < 0) {
387                         this_mid_prop = "cpuid";
388                         id = of_getintprop_default(dp, this_mid_prop, -1);
389                 }
390
391                 if (id < 0) {
392                         prom_printf("OF: Serious problem, cpu lacks "
393                                     "%s property", this_mid_prop);
394                         prom_halt();
395                 }
396                 if (cpuid == id)
397                         return dp;
398         }
399         return NULL;
400 }
401
402 void __init of_fill_in_cpu_data(void)
403 {
404         struct device_node *dp;
405         const char *mid_prop;
406
407         if (tlb_type == hypervisor)
408                 return;
409
410         mid_prop = get_mid_prop();
411         ncpus_probed = 0;
412         for_each_node_by_type(dp, "cpu") {
413                 int cpuid = of_getintprop_default(dp, mid_prop, -1);
414                 const char *this_mid_prop = mid_prop;
415                 struct device_node *portid_parent;
416                 int portid = -1;
417
418                 portid_parent = NULL;
419                 if (cpuid < 0) {
420                         this_mid_prop = "cpuid";
421                         cpuid = of_getintprop_default(dp, this_mid_prop, -1);
422                         if (cpuid >= 0) {
423                                 int limit = 2;
424
425                                 portid_parent = dp;
426                                 while (limit--) {
427                                         portid_parent = portid_parent->parent;
428                                         if (!portid_parent)
429                                                 break;
430                                         portid = of_getintprop_default(portid_parent,
431                                                                        "portid", -1);
432                                         if (portid >= 0)
433                                                 break;
434                                 }
435                         }
436                 }
437
438                 if (cpuid < 0) {
439                         prom_printf("OF: Serious problem, cpu lacks "
440                                     "%s property", this_mid_prop);
441                         prom_halt();
442                 }
443
444                 ncpus_probed++;
445
446 #ifdef CONFIG_SMP
447                 if (cpuid >= NR_CPUS) {
448                         printk(KERN_WARNING "Ignoring CPU %d which is "
449                                ">= NR_CPUS (%d)\n",
450                                cpuid, NR_CPUS);
451                         continue;
452                 }
453 #else
454                 /* On uniprocessor we only want the values for the
455                  * real physical cpu the kernel booted onto, however
456                  * cpu_data() only has one entry at index 0.
457                  */
458                 if (cpuid != real_hard_smp_processor_id())
459                         continue;
460                 cpuid = 0;
461 #endif
462
463                 cpu_data(cpuid).clock_tick =
464                         of_getintprop_default(dp, "clock-frequency", 0);
465
466                 if (portid_parent) {
467                         cpu_data(cpuid).dcache_size =
468                                 of_getintprop_default(dp, "l1-dcache-size",
469                                                       16 * 1024);
470                         cpu_data(cpuid).dcache_line_size =
471                                 of_getintprop_default(dp, "l1-dcache-line-size",
472                                                       32);
473                         cpu_data(cpuid).icache_size =
474                                 of_getintprop_default(dp, "l1-icache-size",
475                                                       8 * 1024);
476                         cpu_data(cpuid).icache_line_size =
477                                 of_getintprop_default(dp, "l1-icache-line-size",
478                                                       32);
479                         cpu_data(cpuid).ecache_size =
480                                 of_getintprop_default(dp, "l2-cache-size", 0);
481                         cpu_data(cpuid).ecache_line_size =
482                                 of_getintprop_default(dp, "l2-cache-line-size", 0);
483                         if (!cpu_data(cpuid).ecache_size ||
484                             !cpu_data(cpuid).ecache_line_size) {
485                                 cpu_data(cpuid).ecache_size =
486                                         of_getintprop_default(portid_parent,
487                                                               "l2-cache-size",
488                                                               (4 * 1024 * 1024));
489                                 cpu_data(cpuid).ecache_line_size =
490                                         of_getintprop_default(portid_parent,
491                                                               "l2-cache-line-size", 64);
492                         }
493
494                         cpu_data(cpuid).core_id = portid + 1;
495                         cpu_data(cpuid).proc_id = portid;
496 #ifdef CONFIG_SMP
497                         sparc64_multi_core = 1;
498 #endif
499                 } else {
500                         cpu_data(cpuid).dcache_size =
501                                 of_getintprop_default(dp, "dcache-size", 16 * 1024);
502                         cpu_data(cpuid).dcache_line_size =
503                                 of_getintprop_default(dp, "dcache-line-size", 32);
504
505                         cpu_data(cpuid).icache_size =
506                                 of_getintprop_default(dp, "icache-size", 16 * 1024);
507                         cpu_data(cpuid).icache_line_size =
508                                 of_getintprop_default(dp, "icache-line-size", 32);
509
510                         cpu_data(cpuid).ecache_size =
511                                 of_getintprop_default(dp, "ecache-size",
512                                                       (4 * 1024 * 1024));
513                         cpu_data(cpuid).ecache_line_size =
514                                 of_getintprop_default(dp, "ecache-line-size", 64);
515
516                         cpu_data(cpuid).core_id = 0;
517                         cpu_data(cpuid).proc_id = -1;
518                 }
519
520 #ifdef CONFIG_SMP
521                 cpu_set(cpuid, cpu_present_map);
522                 cpu_set(cpuid, cpu_possible_map);
523 #endif
524         }
525
526         smp_fill_in_sib_core_maps();
527 }
528
529 void __init of_console_init(void)
530 {
531         char *msg = "OF stdout device is: %s\n";
532         struct device_node *dp;
533         const char *type;
534         phandle node;
535
536         of_console_path = prom_early_alloc(256);
537         if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
538                 prom_printf("Cannot obtain path of stdout.\n");
539                 prom_halt();
540         }
541         of_console_options = strrchr(of_console_path, ':');
542         if (of_console_options) {
543                 of_console_options++;
544                 if (*of_console_options == '\0')
545                         of_console_options = NULL;
546         }
547
548         node = prom_inst2pkg(prom_stdout);
549         if (!node) {
550                 prom_printf("Cannot resolve stdout node from "
551                             "instance %08x.\n", prom_stdout);
552                 prom_halt();
553         }
554
555         dp = of_find_node_by_phandle(node);
556         type = of_get_property(dp, "device_type", NULL);
557         if (!type) {
558                 prom_printf("Console stdout lacks device_type property.\n");
559                 prom_halt();
560         }
561
562         if (strcmp(type, "display") && strcmp(type, "serial")) {
563                 prom_printf("Console device_type is neither display "
564                             "nor serial.\n");
565                 prom_halt();
566         }
567
568         of_console_device = dp;
569
570         printk(msg, of_console_path);
571 }