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

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

Version: ~ [ linux-5.0-rc6 ] ~ [ linux-4.20.10 ] ~ [ linux-4.19.23 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.101 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.158 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.174 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.134 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ 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.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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/memblock.h>
 19 #include <linux/kernel.h>
 20 #include <linux/string.h>
 21 #include <linux/types.h>
 22 #include <linux/cpu.h>
 23 #include <linux/mm.h>
 24 #include <linux/of.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 = memblock_phys_alloc(size, SMP_CACHE_BYTES);
 38         void *ret;
 39 
 40         if (!paddr) {
 41                 prom_printf("prom_early_alloc(%lu) failed\n", size);
 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         const char *name = of_get_property(dp, "name", NULL);
 76         struct linux_prom64_registers *regs;
 77         struct property *rprop;
 78         u32 high_bits, low_bits, type;
 79 
 80         rprop = of_find_property(dp, "reg", NULL);
 81         if (!rprop)
 82                 return;
 83 
 84         regs = rprop->value;
 85         if (!of_node_is_root(dp->parent)) {
 86                 sprintf(tmp_buf, "%s@%x,%x",
 87                         name,
 88                         (unsigned int) (regs->phys_addr >> 32UL),
 89                         (unsigned int) (regs->phys_addr & 0xffffffffUL));
 90                 return;
 91         }
 92 
 93         type = regs->phys_addr >> 60UL;
 94         high_bits = (regs->phys_addr >> 32UL) & 0x0fffffffUL;
 95         low_bits = (regs->phys_addr & 0xffffffffUL);
 96 
 97         if (type == 0 || type == 8) {
 98                 const char *prefix = (type == 0) ? "m" : "i";
 99 
100                 if (low_bits)
101                         sprintf(tmp_buf, "%s@%s%x,%x",
102                                 name, prefix,
103                                 high_bits, low_bits);
104                 else
105                         sprintf(tmp_buf, "%s@%s%x",
106                                 name,
107                                 prefix,
108                                 high_bits);
109         } else if (type == 12) {
110                 sprintf(tmp_buf, "%s@%x",
111                         name, high_bits);
112         }
113 }
114 
115 static void __init sun4u_path_component(struct device_node *dp, char *tmp_buf)
116 {
117         const char *name = of_get_property(dp, "name", NULL);
118         struct linux_prom64_registers *regs;
119         struct property *prop;
120 
121         prop = of_find_property(dp, "reg", NULL);
122         if (!prop)
123                 return;
124 
125         regs = prop->value;
126         if (!of_node_is_root(dp->parent)) {
127                 sprintf(tmp_buf, "%s@%x,%x",
128                         name,
129                         (unsigned int) (regs->phys_addr >> 32UL),
130                         (unsigned int) (regs->phys_addr & 0xffffffffUL));
131                 return;
132         }
133 
134         prop = of_find_property(dp, "upa-portid", NULL);
135         if (!prop)
136                 prop = of_find_property(dp, "portid", NULL);
137         if (prop) {
138                 unsigned long mask = 0xffffffffUL;
139 
140                 if (tlb_type >= cheetah)
141                         mask = 0x7fffff;
142 
143                 sprintf(tmp_buf, "%s@%x,%x",
144                         name,
145                         *(u32 *)prop->value,
146                         (unsigned int) (regs->phys_addr & mask));
147         }
148 }
149 
150 /* "name@slot,offset"  */
151 static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
152 {
153         const char *name = of_get_property(dp, "name", NULL);
154         struct linux_prom_registers *regs;
155         struct property *prop;
156 
157         prop = of_find_property(dp, "reg", NULL);
158         if (!prop)
159                 return;
160 
161         regs = prop->value;
162         sprintf(tmp_buf, "%s@%x,%x",
163                 name,
164                 regs->which_io,
165                 regs->phys_addr);
166 }
167 
168 /* "name@devnum[,func]" */
169 static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
170 {
171         const char *name = of_get_property(dp, "name", NULL);
172         struct linux_prom_pci_registers *regs;
173         struct property *prop;
174         unsigned int devfn;
175 
176         prop = of_find_property(dp, "reg", NULL);
177         if (!prop)
178                 return;
179 
180         regs = prop->value;
181         devfn = (regs->phys_hi >> 8) & 0xff;
182         if (devfn & 0x07) {
183                 sprintf(tmp_buf, "%s@%x,%x",
184                         name,
185                         devfn >> 3,
186                         devfn & 0x07);
187         } else {
188                 sprintf(tmp_buf, "%s@%x",
189                         name,
190                         devfn >> 3);
191         }
192 }
193 
194 /* "name@UPA_PORTID,offset" */
195 static void __init upa_path_component(struct device_node *dp, char *tmp_buf)
196 {
197         const char *name = of_get_property(dp, "name", NULL);
198         struct linux_prom64_registers *regs;
199         struct property *prop;
200 
201         prop = of_find_property(dp, "reg", NULL);
202         if (!prop)
203                 return;
204 
205         regs = prop->value;
206 
207         prop = of_find_property(dp, "upa-portid", NULL);
208         if (!prop)
209                 return;
210 
211         sprintf(tmp_buf, "%s@%x,%x",
212                 name,
213                 *(u32 *) prop->value,
214                 (unsigned int) (regs->phys_addr & 0xffffffffUL));
215 }
216 
217 /* "name@reg" */
218 static void __init vdev_path_component(struct device_node *dp, char *tmp_buf)
219 {
220         const char *name = of_get_property(dp, "name", NULL);
221         struct property *prop;
222         u32 *regs;
223 
224         prop = of_find_property(dp, "reg", NULL);
225         if (!prop)
226                 return;
227 
228         regs = prop->value;
229 
230         sprintf(tmp_buf, "%s@%x", name, *regs);
231 }
232 
233 /* "name@addrhi,addrlo" */
234 static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
235 {
236         const char *name = of_get_property(dp, "name", NULL);
237         struct linux_prom64_registers *regs;
238         struct property *prop;
239 
240         prop = of_find_property(dp, "reg", NULL);
241         if (!prop)
242                 return;
243 
244         regs = prop->value;
245 
246         sprintf(tmp_buf, "%s@%x,%x",
247                 name,
248                 (unsigned int) (regs->phys_addr >> 32UL),
249                 (unsigned int) (regs->phys_addr & 0xffffffffUL));
250 }
251 
252 /* "name@bus,addr" */
253 static void __init i2c_path_component(struct device_node *dp, char *tmp_buf)
254 {
255         const char *name = of_get_property(dp, "name", NULL);
256         struct property *prop;
257         u32 *regs;
258 
259         prop = of_find_property(dp, "reg", NULL);
260         if (!prop)
261                 return;
262 
263         regs = prop->value;
264 
265         /* This actually isn't right... should look at the #address-cells
266          * property of the i2c bus node etc. etc.
267          */
268         sprintf(tmp_buf, "%s@%x,%x",
269                 name, regs[0], regs[1]);
270 }
271 
272 /* "name@reg0[,reg1]" */
273 static void __init usb_path_component(struct device_node *dp, char *tmp_buf)
274 {
275         const char *name = of_get_property(dp, "name", NULL);
276         struct property *prop;
277         u32 *regs;
278 
279         prop = of_find_property(dp, "reg", NULL);
280         if (!prop)
281                 return;
282 
283         regs = prop->value;
284 
285         if (prop->length == sizeof(u32) || regs[1] == 1) {
286                 sprintf(tmp_buf, "%s@%x",
287                         name, regs[0]);
288         } else {
289                 sprintf(tmp_buf, "%s@%x,%x",
290                         name, regs[0], regs[1]);
291         }
292 }
293 
294 /* "name@reg0reg1[,reg2reg3]" */
295 static void __init ieee1394_path_component(struct device_node *dp, char *tmp_buf)
296 {
297         const char *name = of_get_property(dp, "name", NULL);
298         struct property *prop;
299         u32 *regs;
300 
301         prop = of_find_property(dp, "reg", NULL);
302         if (!prop)
303                 return;
304 
305         regs = prop->value;
306 
307         if (regs[2] || regs[3]) {
308                 sprintf(tmp_buf, "%s@%08x%08x,%04x%08x",
309                         name, regs[0], regs[1], regs[2], regs[3]);
310         } else {
311                 sprintf(tmp_buf, "%s@%08x%08x",
312                         name, regs[0], regs[1]);
313         }
314 }
315 
316 static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
317 {
318         struct device_node *parent = dp->parent;
319 
320         if (parent != NULL) {
321                 if (of_node_is_type(parent, "pci") ||
322                     of_node_is_type(parent, "pciex")) {
323                         pci_path_component(dp, tmp_buf);
324                         return;
325                 }
326                 if (of_node_is_type(parent, "sbus")) {
327                         sbus_path_component(dp, tmp_buf);
328                         return;
329                 }
330                 if (of_node_is_type(parent, "upa")) {
331                         upa_path_component(dp, tmp_buf);
332                         return;
333                 }
334                 if (of_node_is_type(parent, "ebus")) {
335                         ebus_path_component(dp, tmp_buf);
336                         return;
337                 }
338                 if (of_node_name_eq(parent, "usb") ||
339                     of_node_name_eq(parent, "hub")) {
340                         usb_path_component(dp, tmp_buf);
341                         return;
342                 }
343                 if (of_node_is_type(parent, "i2c")) {
344                         i2c_path_component(dp, tmp_buf);
345                         return;
346                 }
347                 if (of_node_is_type(parent, "firewire")) {
348                         ieee1394_path_component(dp, tmp_buf);
349                         return;
350                 }
351                 if (of_node_is_type(parent, "virtual-devices")) {
352                         vdev_path_component(dp, tmp_buf);
353                         return;
354                 }
355                 /* "isa" is handled with platform naming */
356         }
357 
358         /* Use platform naming convention.  */
359         if (tlb_type == hypervisor) {
360                 sun4v_path_component(dp, tmp_buf);
361                 return;
362         } else {
363                 sun4u_path_component(dp, tmp_buf);
364         }
365 }
366 
367 char * __init build_path_component(struct device_node *dp)
368 {
369         const char *name = of_get_property(dp, "name", NULL);
370         char tmp_buf[64], *n;
371 
372         tmp_buf[0] = '\0';
373         __build_path_component(dp, tmp_buf);
374         if (tmp_buf[0] == '\0')
375                 strcpy(tmp_buf, name);
376 
377         n = prom_early_alloc(strlen(tmp_buf) + 1);
378         strcpy(n, tmp_buf);
379 
380         return n;
381 }
382 
383 static const char *get_mid_prop(void)
384 {
385         return (tlb_type == spitfire ? "upa-portid" : "portid");
386 }
387 
388 bool arch_find_n_match_cpu_physical_id(struct device_node *cpun,
389                                        int cpu, unsigned int *thread)
390 {
391         const char *mid_prop = get_mid_prop();
392         int this_cpu_id;
393 
394         /* On hypervisor based platforms we interrogate the 'reg'
395          * property.  On everything else we look for a 'upa-portid',
396          * 'portid', or 'cpuid' property.
397          */
398 
399         if (tlb_type == hypervisor) {
400                 struct property *prop = of_find_property(cpun, "reg", NULL);
401                 u32 *regs;
402 
403                 if (!prop) {
404                         pr_warn("CPU node missing reg property\n");
405                         return false;
406                 }
407                 regs = prop->value;
408                 this_cpu_id = regs[0] & 0x0fffffff;
409         } else {
410                 this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
411 
412                 if (this_cpu_id < 0) {
413                         mid_prop = "cpuid";
414                         this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
415                 }
416                 if (this_cpu_id < 0) {
417                         pr_warn("CPU node missing cpu ID property\n");
418                         return false;
419                 }
420         }
421         if (this_cpu_id == cpu) {
422                 if (thread) {
423                         int proc_id = cpu_data(cpu).proc_id;
424 
425                         /* On sparc64, the cpu thread information is obtained
426                          * either from OBP or the machine description.  We've
427                          * actually probed this information already long before
428                          * this interface gets called so instead of interrogating
429                          * both the OF node and the MDESC again, just use what
430                          * we discovered already.
431                          */
432                         if (proc_id < 0)
433                                 proc_id = 0;
434                         *thread = proc_id;
435                 }
436                 return true;
437         }
438         return false;
439 }
440 
441 static void *of_iterate_over_cpus(void *(*func)(struct device_node *, int, int), int arg)
442 {
443         struct device_node *dp;
444         const char *mid_prop;
445 
446         mid_prop = get_mid_prop();
447         for_each_node_by_type(dp, "cpu") {
448                 int cpuid = of_getintprop_default(dp, mid_prop, -1);
449                 const char *this_mid_prop = mid_prop;
450                 void *ret;
451 
452                 if (cpuid < 0) {
453                         this_mid_prop = "cpuid";
454                         cpuid = of_getintprop_default(dp, this_mid_prop, -1);
455                 }
456                 if (cpuid < 0) {
457                         prom_printf("OF: Serious problem, cpu lacks "
458                                     "%s property", this_mid_prop);
459                         prom_halt();
460                 }
461 #ifdef CONFIG_SMP
462                 if (cpuid >= NR_CPUS) {
463                         printk(KERN_WARNING "Ignoring CPU %d which is "
464                                ">= NR_CPUS (%d)\n",
465                                cpuid, NR_CPUS);
466                         continue;
467                 }
468 #endif
469                 ret = func(dp, cpuid, arg);
470                 if (ret)
471                         return ret;
472         }
473         return NULL;
474 }
475 
476 static void *check_cpu_node(struct device_node *dp, int cpuid, int id)
477 {
478         if (id == cpuid)
479                 return dp;
480         return NULL;
481 }
482 
483 struct device_node *of_find_node_by_cpuid(int cpuid)
484 {
485         return of_iterate_over_cpus(check_cpu_node, cpuid);
486 }
487 
488 static void *record_one_cpu(struct device_node *dp, int cpuid, int arg)
489 {
490         ncpus_probed++;
491 #ifdef CONFIG_SMP
492         set_cpu_present(cpuid, true);
493         set_cpu_possible(cpuid, true);
494 #endif
495         return NULL;
496 }
497 
498 void __init of_populate_present_mask(void)
499 {
500         if (tlb_type == hypervisor)
501                 return;
502 
503         ncpus_probed = 0;
504         of_iterate_over_cpus(record_one_cpu, 0);
505 }
506 
507 static void *fill_in_one_cpu(struct device_node *dp, int cpuid, int arg)
508 {
509         struct device_node *portid_parent = NULL;
510         int portid = -1;
511 
512         if (of_find_property(dp, "cpuid", NULL)) {
513                 int limit = 2;
514 
515                 portid_parent = dp;
516                 while (limit--) {
517                         portid_parent = portid_parent->parent;
518                         if (!portid_parent)
519                                 break;
520                         portid = of_getintprop_default(portid_parent,
521                                                        "portid", -1);
522                         if (portid >= 0)
523                                 break;
524                 }
525         }
526 
527 #ifndef CONFIG_SMP
528         /* On uniprocessor we only want the values for the
529          * real physical cpu the kernel booted onto, however
530          * cpu_data() only has one entry at index 0.
531          */
532         if (cpuid != real_hard_smp_processor_id())
533                 return NULL;
534         cpuid = 0;
535 #endif
536 
537         cpu_data(cpuid).clock_tick =
538                 of_getintprop_default(dp, "clock-frequency", 0);
539 
540         if (portid_parent) {
541                 cpu_data(cpuid).dcache_size =
542                         of_getintprop_default(dp, "l1-dcache-size",
543                                               16 * 1024);
544                 cpu_data(cpuid).dcache_line_size =
545                         of_getintprop_default(dp, "l1-dcache-line-size",
546                                               32);
547                 cpu_data(cpuid).icache_size =
548                         of_getintprop_default(dp, "l1-icache-size",
549                                               8 * 1024);
550                 cpu_data(cpuid).icache_line_size =
551                         of_getintprop_default(dp, "l1-icache-line-size",
552                                               32);
553                 cpu_data(cpuid).ecache_size =
554                         of_getintprop_default(dp, "l2-cache-size", 0);
555                 cpu_data(cpuid).ecache_line_size =
556                         of_getintprop_default(dp, "l2-cache-line-size", 0);
557                 if (!cpu_data(cpuid).ecache_size ||
558                     !cpu_data(cpuid).ecache_line_size) {
559                         cpu_data(cpuid).ecache_size =
560                                 of_getintprop_default(portid_parent,
561                                                       "l2-cache-size",
562                                                       (4 * 1024 * 1024));
563                         cpu_data(cpuid).ecache_line_size =
564                                 of_getintprop_default(portid_parent,
565                                                       "l2-cache-line-size", 64);
566                 }
567 
568                 cpu_data(cpuid).core_id = portid + 1;
569                 cpu_data(cpuid).proc_id = portid;
570         } else {
571                 cpu_data(cpuid).dcache_size =
572                         of_getintprop_default(dp, "dcache-size", 16 * 1024);
573                 cpu_data(cpuid).dcache_line_size =
574                         of_getintprop_default(dp, "dcache-line-size", 32);
575 
576                 cpu_data(cpuid).icache_size =
577                         of_getintprop_default(dp, "icache-size", 16 * 1024);
578                 cpu_data(cpuid).icache_line_size =
579                         of_getintprop_default(dp, "icache-line-size", 32);
580 
581                 cpu_data(cpuid).ecache_size =
582                         of_getintprop_default(dp, "ecache-size",
583                                               (4 * 1024 * 1024));
584                 cpu_data(cpuid).ecache_line_size =
585                         of_getintprop_default(dp, "ecache-line-size", 64);
586 
587                 cpu_data(cpuid).core_id = 0;
588                 cpu_data(cpuid).proc_id = -1;
589         }
590 
591         return NULL;
592 }
593 
594 void __init of_fill_in_cpu_data(void)
595 {
596         if (tlb_type == hypervisor)
597                 return;
598 
599         of_iterate_over_cpus(fill_in_one_cpu, 0);
600 
601         smp_fill_in_sib_core_maps();
602 }
603 
604 void __init of_console_init(void)
605 {
606         char *msg = "OF stdout device is: %s\n";
607         struct device_node *dp;
608         phandle node;
609 
610         of_console_path = prom_early_alloc(256);
611         if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
612                 prom_printf("Cannot obtain path of stdout.\n");
613                 prom_halt();
614         }
615         of_console_options = strrchr(of_console_path, ':');
616         if (of_console_options) {
617                 of_console_options++;
618                 if (*of_console_options == '\0')
619                         of_console_options = NULL;
620         }
621 
622         node = prom_inst2pkg(prom_stdout);
623         if (!node) {
624                 prom_printf("Cannot resolve stdout node from "
625                             "instance %08x.\n", prom_stdout);
626                 prom_halt();
627         }
628 
629         dp = of_find_node_by_phandle(node);
630 
631         if (!of_node_is_type(dp, "display") && !of_node_is_type(dp, "serial")) {
632                 prom_printf("Console device_type is neither display "
633                             "nor serial.\n");
634                 prom_halt();
635         }
636 
637         of_console_device = dp;
638 
639         printk(msg, of_console_path);
640 }
641 

~ [ 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