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