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

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

Version: ~ [ linux-4.16-rc2 ] ~ [ linux-4.15.4 ] ~ [ linux-4.14.20 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.82 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.116 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.49 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.95 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.54 ] ~ [ 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.99 ] ~ [ 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.27.62 ] ~ [ 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_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         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 (!of_node_is_root(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 (!of_node_is_root(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 bool arch_find_n_match_cpu_physical_id(struct device_node *cpun,
378                                        int cpu, unsigned int *thread)
379 {
380         const char *mid_prop = get_mid_prop();
381         int this_cpu_id;
382 
383         /* On hypervisor based platforms we interrogate the 'reg'
384          * property.  On everything else we look for a 'upa-portid',
385          * 'portid', or 'cpuid' property.
386          */
387 
388         if (tlb_type == hypervisor) {
389                 struct property *prop = of_find_property(cpun, "reg", NULL);
390                 u32 *regs;
391 
392                 if (!prop) {
393                         pr_warn("CPU node missing reg property\n");
394                         return false;
395                 }
396                 regs = prop->value;
397                 this_cpu_id = regs[0] & 0x0fffffff;
398         } else {
399                 this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
400 
401                 if (this_cpu_id < 0) {
402                         mid_prop = "cpuid";
403                         this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
404                 }
405                 if (this_cpu_id < 0) {
406                         pr_warn("CPU node missing cpu ID property\n");
407                         return false;
408                 }
409         }
410         if (this_cpu_id == cpu) {
411                 if (thread) {
412                         int proc_id = cpu_data(cpu).proc_id;
413 
414                         /* On sparc64, the cpu thread information is obtained
415                          * either from OBP or the machine description.  We've
416                          * actually probed this information already long before
417                          * this interface gets called so instead of interrogating
418                          * both the OF node and the MDESC again, just use what
419                          * we discovered already.
420                          */
421                         if (proc_id < 0)
422                                 proc_id = 0;
423                         *thread = proc_id;
424                 }
425                 return true;
426         }
427         return false;
428 }
429 
430 static void *of_iterate_over_cpus(void *(*func)(struct device_node *, int, int), int arg)
431 {
432         struct device_node *dp;
433         const char *mid_prop;
434 
435         mid_prop = get_mid_prop();
436         for_each_node_by_type(dp, "cpu") {
437                 int cpuid = of_getintprop_default(dp, mid_prop, -1);
438                 const char *this_mid_prop = mid_prop;
439                 void *ret;
440 
441                 if (cpuid < 0) {
442                         this_mid_prop = "cpuid";
443                         cpuid = of_getintprop_default(dp, this_mid_prop, -1);
444                 }
445                 if (cpuid < 0) {
446                         prom_printf("OF: Serious problem, cpu lacks "
447                                     "%s property", this_mid_prop);
448                         prom_halt();
449                 }
450 #ifdef CONFIG_SMP
451                 if (cpuid >= NR_CPUS) {
452                         printk(KERN_WARNING "Ignoring CPU %d which is "
453                                ">= NR_CPUS (%d)\n",
454                                cpuid, NR_CPUS);
455                         continue;
456                 }
457 #endif
458                 ret = func(dp, cpuid, arg);
459                 if (ret)
460                         return ret;
461         }
462         return NULL;
463 }
464 
465 static void *check_cpu_node(struct device_node *dp, int cpuid, int id)
466 {
467         if (id == cpuid)
468                 return dp;
469         return NULL;
470 }
471 
472 struct device_node *of_find_node_by_cpuid(int cpuid)
473 {
474         return of_iterate_over_cpus(check_cpu_node, cpuid);
475 }
476 
477 static void *record_one_cpu(struct device_node *dp, int cpuid, int arg)
478 {
479         ncpus_probed++;
480 #ifdef CONFIG_SMP
481         set_cpu_present(cpuid, true);
482         set_cpu_possible(cpuid, true);
483 #endif
484         return NULL;
485 }
486 
487 void __init of_populate_present_mask(void)
488 {
489         if (tlb_type == hypervisor)
490                 return;
491 
492         ncpus_probed = 0;
493         of_iterate_over_cpus(record_one_cpu, 0);
494 }
495 
496 static void *fill_in_one_cpu(struct device_node *dp, int cpuid, int arg)
497 {
498         struct device_node *portid_parent = NULL;
499         int portid = -1;
500 
501         if (of_find_property(dp, "cpuid", NULL)) {
502                 int limit = 2;
503 
504                 portid_parent = dp;
505                 while (limit--) {
506                         portid_parent = portid_parent->parent;
507                         if (!portid_parent)
508                                 break;
509                         portid = of_getintprop_default(portid_parent,
510                                                        "portid", -1);
511                         if (portid >= 0)
512                                 break;
513                 }
514         }
515 
516 #ifndef CONFIG_SMP
517         /* On uniprocessor we only want the values for the
518          * real physical cpu the kernel booted onto, however
519          * cpu_data() only has one entry at index 0.
520          */
521         if (cpuid != real_hard_smp_processor_id())
522                 return NULL;
523         cpuid = 0;
524 #endif
525 
526         cpu_data(cpuid).clock_tick =
527                 of_getintprop_default(dp, "clock-frequency", 0);
528 
529         if (portid_parent) {
530                 cpu_data(cpuid).dcache_size =
531                         of_getintprop_default(dp, "l1-dcache-size",
532                                               16 * 1024);
533                 cpu_data(cpuid).dcache_line_size =
534                         of_getintprop_default(dp, "l1-dcache-line-size",
535                                               32);
536                 cpu_data(cpuid).icache_size =
537                         of_getintprop_default(dp, "l1-icache-size",
538                                               8 * 1024);
539                 cpu_data(cpuid).icache_line_size =
540                         of_getintprop_default(dp, "l1-icache-line-size",
541                                               32);
542                 cpu_data(cpuid).ecache_size =
543                         of_getintprop_default(dp, "l2-cache-size", 0);
544                 cpu_data(cpuid).ecache_line_size =
545                         of_getintprop_default(dp, "l2-cache-line-size", 0);
546                 if (!cpu_data(cpuid).ecache_size ||
547                     !cpu_data(cpuid).ecache_line_size) {
548                         cpu_data(cpuid).ecache_size =
549                                 of_getintprop_default(portid_parent,
550                                                       "l2-cache-size",
551                                                       (4 * 1024 * 1024));
552                         cpu_data(cpuid).ecache_line_size =
553                                 of_getintprop_default(portid_parent,
554                                                       "l2-cache-line-size", 64);
555                 }
556 
557                 cpu_data(cpuid).core_id = portid + 1;
558                 cpu_data(cpuid).proc_id = portid;
559         } else {
560                 cpu_data(cpuid).dcache_size =
561                         of_getintprop_default(dp, "dcache-size", 16 * 1024);
562                 cpu_data(cpuid).dcache_line_size =
563                         of_getintprop_default(dp, "dcache-line-size", 32);
564 
565                 cpu_data(cpuid).icache_size =
566                         of_getintprop_default(dp, "icache-size", 16 * 1024);
567                 cpu_data(cpuid).icache_line_size =
568                         of_getintprop_default(dp, "icache-line-size", 32);
569 
570                 cpu_data(cpuid).ecache_size =
571                         of_getintprop_default(dp, "ecache-size",
572                                               (4 * 1024 * 1024));
573                 cpu_data(cpuid).ecache_line_size =
574                         of_getintprop_default(dp, "ecache-line-size", 64);
575 
576                 cpu_data(cpuid).core_id = 0;
577                 cpu_data(cpuid).proc_id = -1;
578         }
579 
580         return NULL;
581 }
582 
583 void __init of_fill_in_cpu_data(void)
584 {
585         if (tlb_type == hypervisor)
586                 return;
587 
588         of_iterate_over_cpus(fill_in_one_cpu, 0);
589 
590         smp_fill_in_sib_core_maps();
591 }
592 
593 void __init of_console_init(void)
594 {
595         char *msg = "OF stdout device is: %s\n";
596         struct device_node *dp;
597         const char *type;
598         phandle node;
599 
600         of_console_path = prom_early_alloc(256);
601         if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
602                 prom_printf("Cannot obtain path of stdout.\n");
603                 prom_halt();
604         }
605         of_console_options = strrchr(of_console_path, ':');
606         if (of_console_options) {
607                 of_console_options++;
608                 if (*of_console_options == '\0')
609                         of_console_options = NULL;
610         }
611 
612         node = prom_inst2pkg(prom_stdout);
613         if (!node) {
614                 prom_printf("Cannot resolve stdout node from "
615                             "instance %08x.\n", prom_stdout);
616                 prom_halt();
617         }
618 
619         dp = of_find_node_by_phandle(node);
620         type = of_get_property(dp, "device_type", NULL);
621         if (!type) {
622                 prom_printf("Console stdout lacks device_type property.\n");
623                 prom_halt();
624         }
625 
626         if (strcmp(type, "display") && strcmp(type, "serial")) {
627                 prom_printf("Console device_type is neither display "
628                             "nor serial.\n");
629                 prom_halt();
630         }
631 
632         of_console_device = dp;
633 
634         printk(msg, of_console_path);
635 }
636 

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