~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/sparc/kernel/prom_64.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp