blob: f8782c7ef50f1350a58b4fb28e303cb7f8a68f2e [file] [log] [blame]
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001/*
2 * Procedures for interfacing to Open Firmware.
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 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16#undef DEBUG_PROM
17
Daniel Axtens054f3672017-07-12 14:36:04 -070018/* we cannot use FORTIFY as it brings in new symbols */
19#define __NO_FORTIFY
20
Paul Mackerras9b6b5632005-10-06 12:06:20 +100021#include <stdarg.h>
Paul Mackerras9b6b5632005-10-06 12:06:20 +100022#include <linux/kernel.h>
23#include <linux/string.h>
24#include <linux/init.h>
25#include <linux/threads.h>
26#include <linux/spinlock.h>
27#include <linux/types.h>
28#include <linux/pci.h>
29#include <linux/proc_fs.h>
30#include <linux/stringify.h>
31#include <linux/delay.h>
32#include <linux/initrd.h>
33#include <linux/bitops.h>
34#include <asm/prom.h>
35#include <asm/rtas.h>
36#include <asm/page.h>
37#include <asm/processor.h>
38#include <asm/irq.h>
39#include <asm/io.h>
40#include <asm/smp.h>
Paul Mackerras9b6b5632005-10-06 12:06:20 +100041#include <asm/mmu.h>
42#include <asm/pgtable.h>
Paul Mackerras9b6b5632005-10-06 12:06:20 +100043#include <asm/iommu.h>
Paul Mackerras9b6b5632005-10-06 12:06:20 +100044#include <asm/btext.h>
45#include <asm/sections.h>
46#include <asm/machdep.h>
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +000047#include <asm/opal.h>
Daniel Axtens0545d542016-09-06 15:32:43 +100048#include <asm/asm-prototypes.h>
Paul Mackerras9b6b5632005-10-06 12:06:20 +100049
Paul Mackerras9b6b5632005-10-06 12:06:20 +100050#include <linux/linux_logo.h>
Paul Mackerras9b6b5632005-10-06 12:06:20 +100051
52/*
Paul Mackerras9b6b5632005-10-06 12:06:20 +100053 * Eventually bump that one up
54 */
55#define DEVTREE_CHUNK_SIZE 0x100000
56
57/*
58 * This is the size of the local memory reserve map that gets copied
59 * into the boot params passed to the kernel. That size is totally
60 * flexible as the kernel just reads the list until it encounters an
61 * entry with size 0, so it can be changed without breaking binary
62 * compatibility
63 */
64#define MEM_RESERVE_MAP_SIZE 8
65
66/*
67 * prom_init() is called very early on, before the kernel text
68 * and data have been mapped to KERNELBASE. At this point the code
69 * is running at whatever address it has been loaded at.
70 * On ppc32 we compile with -mrelocatable, which means that references
71 * to extern and static variables get relocated automatically.
Anton Blanchard5ac47f72012-11-26 17:39:03 +000072 * ppc64 objects are always relocatable, we just need to relocate the
73 * TOC.
Paul Mackerras9b6b5632005-10-06 12:06:20 +100074 *
75 * Because OF may have mapped I/O devices into the area starting at
76 * KERNELBASE, particularly on CHRP machines, we can't safely call
77 * OF once the kernel has been mapped to KERNELBASE. Therefore all
78 * OF calls must be done within prom_init().
79 *
80 * ADDR is used in calls to call_prom. The 4th and following
81 * arguments to call_prom should be 32-bit values.
82 * On ppc64, 64 bit values are truncated to 32 bits (and
83 * fortunately don't get interpreted as two arguments).
84 */
Anton Blanchard5ac47f72012-11-26 17:39:03 +000085#define ADDR(x) (u32)(unsigned long)(x)
86
Paul Mackerras9b6b5632005-10-06 12:06:20 +100087#ifdef CONFIG_PPC64
Paul Mackerrasa23414b2005-11-10 12:00:55 +110088#define OF_WORKAROUNDS 0
Paul Mackerras9b6b5632005-10-06 12:06:20 +100089#else
Paul Mackerrasa23414b2005-11-10 12:00:55 +110090#define OF_WORKAROUNDS of_workarounds
91int of_workarounds;
Paul Mackerras9b6b5632005-10-06 12:06:20 +100092#endif
93
Paul Mackerrasa23414b2005-11-10 12:00:55 +110094#define OF_WA_CLAIM 1 /* do phys/virt claim separately, then map */
95#define OF_WA_LONGTRAIL 2 /* work around longtrail bugs */
96
Paul Mackerras9b6b5632005-10-06 12:06:20 +100097#define PROM_BUG() do { \
98 prom_printf("kernel BUG at %s line 0x%x!\n", \
Anton Blanchard5827d412012-11-26 17:40:03 +000099 __FILE__, __LINE__); \
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000100 __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR); \
101} while (0)
102
103#ifdef DEBUG_PROM
104#define prom_debug(x...) prom_printf(x)
105#else
106#define prom_debug(x...)
107#endif
108
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000109
110typedef u32 prom_arg_t;
111
112struct prom_args {
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000113 __be32 service;
114 __be32 nargs;
115 __be32 nret;
116 __be32 args[10];
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000117};
118
119struct prom_t {
120 ihandle root;
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100121 phandle chosen;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000122 int cpu;
123 ihandle stdout;
Paul Mackerrasa575b802005-10-23 17:23:21 +1000124 ihandle mmumap;
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100125 ihandle memory;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000126};
127
128struct mem_map_entry {
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000129 __be64 base;
130 __be64 size;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000131};
132
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000133typedef __be32 cell_t;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000134
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +0000135extern void __start(unsigned long r3, unsigned long r4, unsigned long r5,
136 unsigned long r6, unsigned long r7, unsigned long r8,
137 unsigned long r9);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000138
139#ifdef CONFIG_PPC64
Paul Mackerrasc49888202005-10-26 21:52:53 +1000140extern int enter_prom(struct prom_args *args, unsigned long entry);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000141#else
Paul Mackerrasc49888202005-10-26 21:52:53 +1000142static inline int enter_prom(struct prom_args *args, unsigned long entry)
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000143{
Paul Mackerrasc49888202005-10-26 21:52:53 +1000144 return ((int (*)(struct prom_args *))entry)(args);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000145}
146#endif
147
148extern void copy_and_flush(unsigned long dest, unsigned long src,
149 unsigned long size, unsigned long offset);
150
151/* prom structure */
152static struct prom_t __initdata prom;
153
154static unsigned long prom_entry __initdata;
155
156#define PROM_SCRATCH_SIZE 256
157
158static char __initdata of_stdout_device[256];
159static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
160
161static unsigned long __initdata dt_header_start;
162static unsigned long __initdata dt_struct_start, dt_struct_end;
163static unsigned long __initdata dt_string_start, dt_string_end;
164
165static unsigned long __initdata prom_initrd_start, prom_initrd_end;
166
167#ifdef CONFIG_PPC64
Jeremy Kerr165785e2006-11-11 17:25:18 +1100168static int __initdata prom_iommu_force_on;
169static int __initdata prom_iommu_off;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000170static unsigned long __initdata prom_tce_alloc_start;
171static unsigned long __initdata prom_tce_alloc_end;
172#endif
173
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +1100174static bool __initdata prom_radix_disable;
175
176struct platform_support {
177 bool hash_mmu;
178 bool radix_mmu;
179 bool radix_gtse;
Cédric Le Goaterac5e5a52017-08-30 21:46:16 +0200180 bool xive;
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +1100181};
182
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +1100183/* Platforms codes are now obsolete in the kernel. Now only used within this
184 * file and ultimately gone too. Feel free to change them if you need, they
185 * are not shared with anything outside of this file anymore
186 */
187#define PLATFORM_PSERIES 0x0100
188#define PLATFORM_PSERIES_LPAR 0x0101
189#define PLATFORM_LPAR 0x0001
190#define PLATFORM_POWERMAC 0x0400
191#define PLATFORM_GENERIC 0x0500
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +0000192#define PLATFORM_OPAL 0x0600
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +1100193
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000194static int __initdata of_platform;
195
196static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
197
Benjamin Krillcf687872009-07-27 22:02:39 +0000198static unsigned long __initdata prom_memory_limit;
199
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000200static unsigned long __initdata alloc_top;
201static unsigned long __initdata alloc_top_high;
202static unsigned long __initdata alloc_bottom;
203static unsigned long __initdata rmo_top;
204static unsigned long __initdata ram_top;
205
206static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
207static int __initdata mem_reserve_cnt;
208
209static cell_t __initdata regbuf[1024];
210
Benjamin Herrenschmidtdbe78b42013-09-25 14:02:50 +1000211static bool rtas_has_query_cpu_stopped;
212
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000213
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000214/*
215 * Error results ... some OF calls will return "-1" on error, some
216 * will return 0, some will return either. To simplify, here are
217 * macros to use with any ihandle or phandle return value to check if
218 * it is valid
219 */
220
221#define PROM_ERROR (-1u)
222#define PHANDLE_VALID(p) ((p) != 0 && (p) != PROM_ERROR)
223#define IHANDLE_VALID(i) ((i) != 0 && (i) != PROM_ERROR)
224
225
226/* This is the one and *ONLY* place where we actually call open
227 * firmware.
228 */
229
230static int __init call_prom(const char *service, int nargs, int nret, ...)
231{
232 int i;
233 struct prom_args args;
234 va_list list;
235
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000236 args.service = cpu_to_be32(ADDR(service));
237 args.nargs = cpu_to_be32(nargs);
238 args.nret = cpu_to_be32(nret);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000239
240 va_start(list, nret);
241 for (i = 0; i < nargs; i++)
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000242 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t));
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000243 va_end(list);
244
245 for (i = 0; i < nret; i++)
246 args.args[nargs+i] = 0;
247
Anton Blanchard5827d412012-11-26 17:40:03 +0000248 if (enter_prom(&args, prom_entry) < 0)
Paul Mackerrasc49888202005-10-26 21:52:53 +1000249 return PROM_ERROR;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000250
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000251 return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000252}
253
254static int __init call_prom_ret(const char *service, int nargs, int nret,
255 prom_arg_t *rets, ...)
256{
257 int i;
258 struct prom_args args;
259 va_list list;
260
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000261 args.service = cpu_to_be32(ADDR(service));
262 args.nargs = cpu_to_be32(nargs);
263 args.nret = cpu_to_be32(nret);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000264
265 va_start(list, rets);
266 for (i = 0; i < nargs; i++)
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000267 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t));
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000268 va_end(list);
269
270 for (i = 0; i < nret; i++)
Olaf Heringed1189b2005-11-29 14:04:05 +0100271 args.args[nargs+i] = 0;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000272
Anton Blanchard5827d412012-11-26 17:40:03 +0000273 if (enter_prom(&args, prom_entry) < 0)
Paul Mackerrasc49888202005-10-26 21:52:53 +1000274 return PROM_ERROR;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000275
276 if (rets != NULL)
277 for (i = 1; i < nret; ++i)
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000278 rets[i-1] = be32_to_cpu(args.args[nargs+i]);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000279
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000280 return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000281}
282
283
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000284static void __init prom_print(const char *msg)
285{
286 const char *p, *q;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000287
Anton Blanchard5827d412012-11-26 17:40:03 +0000288 if (prom.stdout == 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000289 return;
290
291 for (p = msg; *p != 0; p = q) {
292 for (q = p; *q != 0 && *q != '\n'; ++q)
293 ;
294 if (q > p)
Anton Blanchard5827d412012-11-26 17:40:03 +0000295 call_prom("write", 3, 1, prom.stdout, p, q - p);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000296 if (*q == 0)
297 break;
298 ++q;
Anton Blanchard5827d412012-11-26 17:40:03 +0000299 call_prom("write", 3, 1, prom.stdout, ADDR("\r\n"), 2);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000300 }
301}
302
303
304static void __init prom_print_hex(unsigned long val)
305{
306 int i, nibbles = sizeof(val)*2;
307 char buf[sizeof(val)*2+1];
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000308
309 for (i = nibbles-1; i >= 0; i--) {
310 buf[i] = (val & 0xf) + '0';
311 if (buf[i] > '9')
312 buf[i] += ('a'-'0'-10);
313 val >>= 4;
314 }
315 buf[nibbles] = '\0';
Anton Blanchard5827d412012-11-26 17:40:03 +0000316 call_prom("write", 3, 1, prom.stdout, buf, nibbles);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000317}
318
Michael Neuling2c48a7d2010-07-27 18:26:21 +0000319/* max number of decimal digits in an unsigned long */
320#define UL_DIGITS 21
321static void __init prom_print_dec(unsigned long val)
322{
323 int i, size;
324 char buf[UL_DIGITS+1];
Michael Neuling2c48a7d2010-07-27 18:26:21 +0000325
326 for (i = UL_DIGITS-1; i >= 0; i--) {
327 buf[i] = (val % 10) + '0';
328 val = val/10;
329 if (val == 0)
330 break;
331 }
332 /* shift stuff down */
333 size = UL_DIGITS - i;
Anton Blanchard5827d412012-11-26 17:40:03 +0000334 call_prom("write", 3, 1, prom.stdout, buf+i, size);
Michael Neuling2c48a7d2010-07-27 18:26:21 +0000335}
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000336
Mathieu Malaterre7eda3182018-04-06 22:12:19 +0200337__printf(1, 2)
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000338static void __init prom_printf(const char *format, ...)
339{
340 const char *p, *q, *s;
341 va_list args;
342 unsigned long v;
Benjamin Herrenschmidtaf277142011-04-06 10:51:17 +1000343 long vs;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000344
345 va_start(args, format);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000346 for (p = format; *p != 0; p = q) {
347 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
348 ;
349 if (q > p)
Anton Blanchard5827d412012-11-26 17:40:03 +0000350 call_prom("write", 3, 1, prom.stdout, p, q - p);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000351 if (*q == 0)
352 break;
353 if (*q == '\n') {
354 ++q;
Anton Blanchard5827d412012-11-26 17:40:03 +0000355 call_prom("write", 3, 1, prom.stdout,
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000356 ADDR("\r\n"), 2);
357 continue;
358 }
359 ++q;
360 if (*q == 0)
361 break;
362 switch (*q) {
363 case 's':
364 ++q;
365 s = va_arg(args, const char *);
366 prom_print(s);
367 break;
368 case 'x':
369 ++q;
370 v = va_arg(args, unsigned long);
371 prom_print_hex(v);
372 break;
Benjamin Herrenschmidtaf277142011-04-06 10:51:17 +1000373 case 'd':
374 ++q;
375 vs = va_arg(args, int);
376 if (vs < 0) {
Anton Blanchard5827d412012-11-26 17:40:03 +0000377 prom_print("-");
Benjamin Herrenschmidtaf277142011-04-06 10:51:17 +1000378 vs = -vs;
379 }
380 prom_print_dec(vs);
381 break;
Michael Neuling2c48a7d2010-07-27 18:26:21 +0000382 case 'l':
383 ++q;
Benjamin Herrenschmidtaf277142011-04-06 10:51:17 +1000384 if (*q == 0)
385 break;
386 else if (*q == 'x') {
387 ++q;
388 v = va_arg(args, unsigned long);
389 prom_print_hex(v);
390 } else if (*q == 'u') { /* '%lu' */
Michael Neuling2c48a7d2010-07-27 18:26:21 +0000391 ++q;
392 v = va_arg(args, unsigned long);
393 prom_print_dec(v);
Benjamin Herrenschmidtaf277142011-04-06 10:51:17 +1000394 } else if (*q == 'd') { /* %ld */
395 ++q;
396 vs = va_arg(args, long);
397 if (vs < 0) {
Anton Blanchard5827d412012-11-26 17:40:03 +0000398 prom_print("-");
Benjamin Herrenschmidtaf277142011-04-06 10:51:17 +1000399 vs = -vs;
400 }
401 prom_print_dec(vs);
Michael Neuling2c48a7d2010-07-27 18:26:21 +0000402 }
403 break;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000404 }
405 }
Daniel Axtens1b855e12015-12-17 19:41:00 +1100406 va_end(args);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000407}
408
409
Paul Mackerrasa575b802005-10-23 17:23:21 +1000410static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
411 unsigned long align)
412{
Paul Mackerrasa575b802005-10-23 17:23:21 +1000413
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100414 if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) {
415 /*
416 * Old OF requires we claim physical and virtual separately
417 * and then map explicitly (assuming virtual mode)
418 */
419 int ret;
420 prom_arg_t result;
421
422 ret = call_prom_ret("call-method", 5, 2, &result,
Anton Blanchard5827d412012-11-26 17:40:03 +0000423 ADDR("claim"), prom.memory,
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100424 align, size, virt);
425 if (ret != 0 || result == -1)
426 return -1;
427 ret = call_prom_ret("call-method", 5, 2, &result,
Anton Blanchard5827d412012-11-26 17:40:03 +0000428 ADDR("claim"), prom.mmumap,
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100429 align, size, virt);
430 if (ret != 0) {
431 call_prom("call-method", 4, 1, ADDR("release"),
Anton Blanchard5827d412012-11-26 17:40:03 +0000432 prom.memory, size, virt);
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100433 return -1;
434 }
435 /* the 0x12 is M (coherence) + PP == read/write */
Paul Mackerrasa575b802005-10-23 17:23:21 +1000436 call_prom("call-method", 6, 1,
Anton Blanchard5827d412012-11-26 17:40:03 +0000437 ADDR("map"), prom.mmumap, 0x12, size, virt, virt);
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100438 return virt;
439 }
440 return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size,
441 (prom_arg_t)align);
Paul Mackerrasa575b802005-10-23 17:23:21 +1000442}
443
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000444static void __init __attribute__((noreturn)) prom_panic(const char *reason)
445{
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000446 prom_print(reason);
Olaf Heringadd60ef2006-03-23 22:03:57 +0100447 /* Do not call exit because it clears the screen on pmac
448 * it also causes some sort of double-fault on early pmacs */
Anton Blanchard5827d412012-11-26 17:40:03 +0000449 if (of_platform == PLATFORM_POWERMAC)
Olaf Heringadd60ef2006-03-23 22:03:57 +0100450 asm("trap\n");
451
Stephen Rothwell1d9a4732012-03-21 18:23:27 +0000452 /* ToDo: should put up an SRC here on pSeries */
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000453 call_prom("exit", 0, 0);
454
455 for (;;) /* should never get here */
456 ;
457}
458
459
460static int __init prom_next_node(phandle *nodep)
461{
462 phandle node;
463
464 if ((node = *nodep) != 0
465 && (*nodep = call_prom("child", 1, 1, node)) != 0)
466 return 1;
467 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
468 return 1;
469 for (;;) {
470 if ((node = call_prom("parent", 1, 1, node)) == 0)
471 return 0;
472 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
473 return 1;
474 }
475}
476
Tobias Klauser60d862e2016-11-17 17:20:24 +0100477static inline int prom_getprop(phandle node, const char *pname,
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000478 void *value, size_t valuelen)
479{
480 return call_prom("getprop", 4, 1, node, ADDR(pname),
481 (u32)(unsigned long) value, (u32) valuelen);
482}
483
Tobias Klauser60d862e2016-11-17 17:20:24 +0100484static inline int prom_getproplen(phandle node, const char *pname)
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000485{
486 return call_prom("getproplen", 2, 1, node, ADDR(pname));
487}
488
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100489static void add_string(char **str, const char *q)
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000490{
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100491 char *p = *str;
492
493 while (*q)
494 *p++ = *q++;
495 *p++ = ' ';
496 *str = p;
497}
498
499static char *tohex(unsigned int x)
500{
501 static char digits[] = "0123456789abcdef";
502 static char result[9];
503 int i;
504
505 result[8] = 0;
506 i = 8;
507 do {
508 --i;
509 result[i] = digits[x & 0xf];
510 x >>= 4;
511 } while (x != 0 && i > 0);
512 return &result[i];
513}
514
515static int __init prom_setprop(phandle node, const char *nodename,
516 const char *pname, void *value, size_t valuelen)
517{
518 char cmd[256], *p;
519
520 if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL))
521 return call_prom("setprop", 4, 1, node, ADDR(pname),
522 (u32)(unsigned long) value, (u32) valuelen);
523
524 /* gah... setprop doesn't work on longtrail, have to use interpret */
525 p = cmd;
526 add_string(&p, "dev");
527 add_string(&p, nodename);
528 add_string(&p, tohex((u32)(unsigned long) value));
529 add_string(&p, tohex(valuelen));
530 add_string(&p, tohex(ADDR(pname)));
Anton Blanchard5827d412012-11-26 17:40:03 +0000531 add_string(&p, tohex(strlen(pname)));
Paul Mackerrasa23414b2005-11-10 12:00:55 +1100532 add_string(&p, "property");
533 *p = 0;
534 return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000535}
536
Anton Blanchard5827d412012-11-26 17:40:03 +0000537/* We can't use the standard versions because of relocation headaches. */
Benjamin Krillcf687872009-07-27 22:02:39 +0000538#define isxdigit(c) (('0' <= (c) && (c) <= '9') \
539 || ('a' <= (c) && (c) <= 'f') \
540 || ('A' <= (c) && (c) <= 'F'))
541
542#define isdigit(c) ('0' <= (c) && (c) <= '9')
543#define islower(c) ('a' <= (c) && (c) <= 'z')
544#define toupper(c) (islower(c) ? ((c) - 'a' + 'A') : (c))
545
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000546static unsigned long prom_strtoul(const char *cp, const char **endp)
Benjamin Krillcf687872009-07-27 22:02:39 +0000547{
548 unsigned long result = 0, base = 10, value;
549
550 if (*cp == '0') {
551 base = 8;
552 cp++;
553 if (toupper(*cp) == 'X') {
554 cp++;
555 base = 16;
556 }
557 }
558
559 while (isxdigit(*cp) &&
560 (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
561 result = result * base + value;
562 cp++;
563 }
564
565 if (endp)
566 *endp = cp;
567
568 return result;
569}
570
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000571static unsigned long prom_memparse(const char *ptr, const char **retptr)
Benjamin Krillcf687872009-07-27 22:02:39 +0000572{
573 unsigned long ret = prom_strtoul(ptr, retptr);
574 int shift = 0;
575
576 /*
577 * We can't use a switch here because GCC *may* generate a
578 * jump table which won't work, because we're not running at
579 * the address we're linked at.
580 */
581 if ('G' == **retptr || 'g' == **retptr)
582 shift = 30;
583
584 if ('M' == **retptr || 'm' == **retptr)
585 shift = 20;
586
587 if ('K' == **retptr || 'k' == **retptr)
588 shift = 10;
589
590 if (shift) {
591 ret <<= shift;
592 (*retptr)++;
593 }
594
595 return ret;
596}
597
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000598/*
599 * Early parsing of the command line passed to the kernel, used for
600 * "mem=x" and the options that affect the iommu
601 */
602static void __init early_cmdline_parse(void)
603{
Benjamin Herrenschmidtcc5d0182005-12-13 18:01:21 +1100604 const char *opt;
Benjamin Krillcf687872009-07-27 22:02:39 +0000605
Benjamin Herrenschmidtcc5d0182005-12-13 18:01:21 +1100606 char *p;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000607 int l = 0;
608
Anton Blanchard5827d412012-11-26 17:40:03 +0000609 prom_cmd_line[0] = 0;
610 p = prom_cmd_line;
611 if ((long)prom.chosen > 0)
612 l = prom_getprop(prom.chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000613#ifdef CONFIG_CMDLINE
Amos Waterland0e4aa9c2006-06-12 23:45:02 -0400614 if (l <= 0 || p[0] == '\0') /* dbl check */
Anton Blanchard5827d412012-11-26 17:40:03 +0000615 strlcpy(prom_cmd_line,
616 CONFIG_CMDLINE, sizeof(prom_cmd_line));
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000617#endif /* CONFIG_CMDLINE */
Anton Blanchard5827d412012-11-26 17:40:03 +0000618 prom_printf("command line: %s\n", prom_cmd_line);
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000619
620#ifdef CONFIG_PPC64
Anton Blanchard5827d412012-11-26 17:40:03 +0000621 opt = strstr(prom_cmd_line, "iommu=");
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000622 if (opt) {
623 prom_printf("iommu opt is: %s\n", opt);
624 opt += 6;
625 while (*opt && *opt == ' ')
626 opt++;
Anton Blanchard5827d412012-11-26 17:40:03 +0000627 if (!strncmp(opt, "off", 3))
628 prom_iommu_off = 1;
629 else if (!strncmp(opt, "force", 5))
630 prom_iommu_force_on = 1;
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000631 }
632#endif
Anton Blanchard5827d412012-11-26 17:40:03 +0000633 opt = strstr(prom_cmd_line, "mem=");
Benjamin Krillcf687872009-07-27 22:02:39 +0000634 if (opt) {
635 opt += 4;
Anton Blanchard5827d412012-11-26 17:40:03 +0000636 prom_memory_limit = prom_memparse(opt, (const char **)&opt);
Benjamin Krillcf687872009-07-27 22:02:39 +0000637#ifdef CONFIG_PPC64
638 /* Align to 16 MB == size of ppc64 large page */
Anton Blanchard5827d412012-11-26 17:40:03 +0000639 prom_memory_limit = ALIGN(prom_memory_limit, 0x1000000);
Benjamin Krillcf687872009-07-27 22:02:39 +0000640#endif
641 }
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +1100642
643 opt = strstr(prom_cmd_line, "disable_radix");
644 if (opt) {
645 prom_debug("Radix disabled from cmdline\n");
646 prom_radix_disable = true;
647 }
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000648}
649
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +0000650#if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000651/*
Nathan Fontenot530b5e12013-04-24 05:53:10 +0000652 * The architecture vector has an array of PVR mask/value pairs,
653 * followed by # option vectors - 1, followed by the option vectors.
654 *
655 * See prom.h for the definition of the bits specified in the
656 * architecture vector.
Paul Mackerrasf709bfa2006-04-28 16:28:35 +1000657 */
Paul Mackerrasf709bfa2006-04-28 16:28:35 +1000658
Michael Ellermane8a4fd02014-08-29 17:01:43 +1000659/* Firmware expects the value to be n - 1, where n is the # of vectors */
660#define NUM_VECTORS(n) ((n) - 1)
661
662/*
663 * Firmware expects 1 + n - 2, where n is the length of the option vector in
664 * bytes. The 1 accounts for the length byte itself, the - 2 .. ?
665 */
666#define VECTOR_LENGTH(n) (1 + (n) - 2)
667
Michael Ellermand03d1d62016-11-18 23:15:41 +1100668struct option_vector1 {
669 u8 byte1;
670 u8 arch_versions;
Paul Mackerrascc3d2942017-01-30 21:21:36 +1100671 u8 arch_versions3;
Michael Ellermand03d1d62016-11-18 23:15:41 +1100672} __packed;
673
674struct option_vector2 {
675 u8 byte1;
676 __be16 reserved;
677 __be32 real_base;
678 __be32 real_size;
679 __be32 virt_base;
680 __be32 virt_size;
681 __be32 load_base;
682 __be32 min_rma;
683 __be32 min_load;
684 u8 min_rma_percent;
685 u8 max_pft_size;
686} __packed;
687
688struct option_vector3 {
689 u8 byte1;
690 u8 byte2;
691} __packed;
692
693struct option_vector4 {
694 u8 byte1;
695 u8 min_vp_cap;
696} __packed;
697
698struct option_vector5 {
699 u8 byte1;
700 u8 byte2;
701 u8 byte3;
702 u8 cmo;
703 u8 associativity;
704 u8 bin_opts;
705 u8 micro_checkpoint;
706 u8 reserved0;
707 __be32 max_cpus;
708 __be16 papr_level;
709 __be16 reserved1;
710 u8 platform_facilities;
711 u8 reserved2;
712 __be16 reserved3;
713 u8 subprocessors;
Paul Mackerrascc3d2942017-01-30 21:21:36 +1100714 u8 byte22;
715 u8 intarch;
716 u8 mmu;
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +1100717 u8 hash_ext;
718 u8 radix_ext;
Michael Ellermand03d1d62016-11-18 23:15:41 +1100719} __packed;
720
721struct option_vector6 {
722 u8 reserved;
723 u8 secondary_pteg;
724 u8 os_name;
725} __packed;
726
Michael Ellerman76ffb572016-11-18 23:15:42 +1100727struct ibm_arch_vec {
Paul Mackerrascc3d2942017-01-30 21:21:36 +1100728 struct { u32 mask, val; } pvrs[12];
Michael Ellerman76ffb572016-11-18 23:15:42 +1100729
730 u8 num_vectors;
731
732 u8 vec1_len;
733 struct option_vector1 vec1;
734
735 u8 vec2_len;
736 struct option_vector2 vec2;
737
738 u8 vec3_len;
739 struct option_vector3 vec3;
740
741 u8 vec4_len;
742 struct option_vector4 vec4;
743
744 u8 vec5_len;
745 struct option_vector5 vec5;
746
747 u8 vec6_len;
748 struct option_vector6 vec6;
749} __packed;
750
751struct ibm_arch_vec __cacheline_aligned ibm_architecture_vec = {
752 .pvrs = {
753 {
754 .mask = cpu_to_be32(0xfffe0000), /* POWER5/POWER5+ */
755 .val = cpu_to_be32(0x003a0000),
756 },
757 {
758 .mask = cpu_to_be32(0xffff0000), /* POWER6 */
759 .val = cpu_to_be32(0x003e0000),
760 },
761 {
762 .mask = cpu_to_be32(0xffff0000), /* POWER7 */
763 .val = cpu_to_be32(0x003f0000),
764 },
765 {
766 .mask = cpu_to_be32(0xffff0000), /* POWER8E */
767 .val = cpu_to_be32(0x004b0000),
768 },
769 {
770 .mask = cpu_to_be32(0xffff0000), /* POWER8NVL */
771 .val = cpu_to_be32(0x004c0000),
772 },
773 {
774 .mask = cpu_to_be32(0xffff0000), /* POWER8 */
775 .val = cpu_to_be32(0x004d0000),
776 },
777 {
Paul Mackerrascc3d2942017-01-30 21:21:36 +1100778 .mask = cpu_to_be32(0xffff0000), /* POWER9 */
779 .val = cpu_to_be32(0x004e0000),
780 },
781 {
782 .mask = cpu_to_be32(0xffffffff), /* all 3.00-compliant */
783 .val = cpu_to_be32(0x0f000005),
784 },
785 {
Michael Ellerman76ffb572016-11-18 23:15:42 +1100786 .mask = cpu_to_be32(0xffffffff), /* all 2.07-compliant */
787 .val = cpu_to_be32(0x0f000004),
788 },
789 {
790 .mask = cpu_to_be32(0xffffffff), /* all 2.06-compliant */
791 .val = cpu_to_be32(0x0f000003),
792 },
793 {
794 .mask = cpu_to_be32(0xffffffff), /* all 2.05-compliant */
795 .val = cpu_to_be32(0x0f000002),
796 },
797 {
798 .mask = cpu_to_be32(0xfffffffe), /* all 2.04-compliant and earlier */
799 .val = cpu_to_be32(0x0f000001),
800 },
801 },
802
803 .num_vectors = NUM_VECTORS(6),
804
805 .vec1_len = VECTOR_LENGTH(sizeof(struct option_vector1)),
806 .vec1 = {
807 .byte1 = 0,
808 .arch_versions = OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
809 OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06 | OV1_PPC_2_07,
Paul Mackerrascc3d2942017-01-30 21:21:36 +1100810 .arch_versions3 = OV1_PPC_3_00,
Michael Ellerman76ffb572016-11-18 23:15:42 +1100811 },
812
813 .vec2_len = VECTOR_LENGTH(sizeof(struct option_vector2)),
814 /* option vector 2: Open Firmware options supported */
815 .vec2 = {
816 .byte1 = OV2_REAL_MODE,
817 .reserved = 0,
818 .real_base = cpu_to_be32(0xffffffff),
819 .real_size = cpu_to_be32(0xffffffff),
820 .virt_base = cpu_to_be32(0xffffffff),
821 .virt_size = cpu_to_be32(0xffffffff),
822 .load_base = cpu_to_be32(0xffffffff),
Sukadev Bhattiprolu687da8f2017-03-27 19:43:14 -0400823 .min_rma = cpu_to_be32(512), /* 512MB min RMA */
Michael Ellerman76ffb572016-11-18 23:15:42 +1100824 .min_load = cpu_to_be32(0xffffffff), /* full client load */
825 .min_rma_percent = 0, /* min RMA percentage of total RAM */
826 .max_pft_size = 48, /* max log_2(hash table size) */
827 },
828
829 .vec3_len = VECTOR_LENGTH(sizeof(struct option_vector3)),
830 /* option vector 3: processor options supported */
831 .vec3 = {
832 .byte1 = 0, /* don't ignore, don't halt */
833 .byte2 = OV3_FP | OV3_VMX | OV3_DFP,
834 },
835
836 .vec4_len = VECTOR_LENGTH(sizeof(struct option_vector4)),
837 /* option vector 4: IBM PAPR implementation */
838 .vec4 = {
839 .byte1 = 0, /* don't halt */
840 .min_vp_cap = OV4_MIN_ENT_CAP, /* minimum VP entitled capacity */
841 },
842
843 .vec5_len = VECTOR_LENGTH(sizeof(struct option_vector5)),
844 /* option vector 5: PAPR/OF options */
845 .vec5 = {
846 .byte1 = 0, /* don't ignore, don't halt */
847 .byte2 = OV5_FEAT(OV5_LPAR) | OV5_FEAT(OV5_SPLPAR) | OV5_FEAT(OV5_LARGE_PAGES) |
848 OV5_FEAT(OV5_DRCONF_MEMORY) | OV5_FEAT(OV5_DONATE_DEDICATE_CPU) |
849#ifdef CONFIG_PCI_MSI
850 /* PCIe/MSI support. Without MSI full PCIe is not supported */
851 OV5_FEAT(OV5_MSI),
852#else
853 0,
854#endif
855 .byte3 = 0,
856 .cmo =
857#ifdef CONFIG_PPC_SMLPAR
858 OV5_FEAT(OV5_CMO) | OV5_FEAT(OV5_XCMO),
859#else
860 0,
861#endif
862 .associativity = OV5_FEAT(OV5_TYPE1_AFFINITY) | OV5_FEAT(OV5_PRRN),
Michael Roth3dbbaf22017-02-20 19:12:18 -0600863 .bin_opts = OV5_FEAT(OV5_RESIZE_HPT) | OV5_FEAT(OV5_HP_EVT),
Michael Ellerman76ffb572016-11-18 23:15:42 +1100864 .micro_checkpoint = 0,
865 .reserved0 = 0,
866 .max_cpus = cpu_to_be32(NR_CPUS), /* number of cores supported */
867 .papr_level = 0,
868 .reserved1 = 0,
869 .platform_facilities = OV5_FEAT(OV5_PFO_HW_RNG) | OV5_FEAT(OV5_PFO_HW_ENCR) | OV5_FEAT(OV5_PFO_HW_842),
870 .reserved2 = 0,
871 .reserved3 = 0,
872 .subprocessors = 1,
Paul Mackerrascc3d2942017-01-30 21:21:36 +1100873 .intarch = 0,
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +1100874 .mmu = 0,
875 .hash_ext = 0,
876 .radix_ext = 0,
Michael Ellerman76ffb572016-11-18 23:15:42 +1100877 },
878
879 /* option vector 6: IBM PAPR hints */
880 .vec6_len = VECTOR_LENGTH(sizeof(struct option_vector6)),
881 .vec6 = {
882 .reserved = 0,
883 .secondary_pteg = 0,
884 .os_name = OV6_LINUX,
885 },
886};
887
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000888/* Old method - ELF header with PT_NOTE sections only works on BE */
889#ifdef __BIG_ENDIAN__
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000890static struct fake_elf {
891 Elf32_Ehdr elfhdr;
892 Elf32_Phdr phdr[2];
893 struct chrpnote {
894 u32 namesz;
895 u32 descsz;
896 u32 type;
897 char name[8]; /* "PowerPC" */
898 struct chrpdesc {
899 u32 real_mode;
900 u32 real_base;
901 u32 real_size;
902 u32 virt_base;
903 u32 virt_size;
904 u32 load_base;
905 } chrpdesc;
906 } chrpnote;
907 struct rpanote {
908 u32 namesz;
909 u32 descsz;
910 u32 type;
911 char name[24]; /* "IBM,RPA-Client-Config" */
912 struct rpadesc {
913 u32 lpar_affinity;
914 u32 min_rmo_size;
915 u32 min_rmo_percent;
916 u32 max_pft_size;
917 u32 splpar;
918 u32 min_load;
919 u32 new_mem_def;
920 u32 ignore_me;
921 } rpadesc;
922 } rpanote;
Paul Mackerras5663a122008-10-31 22:27:17 +1100923} fake_elf = {
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000924 .elfhdr = {
925 .e_ident = { 0x7f, 'E', 'L', 'F',
926 ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
927 .e_type = ET_EXEC, /* yeah right */
928 .e_machine = EM_PPC,
929 .e_version = EV_CURRENT,
930 .e_phoff = offsetof(struct fake_elf, phdr),
931 .e_phentsize = sizeof(Elf32_Phdr),
932 .e_phnum = 2
933 },
934 .phdr = {
935 [0] = {
936 .p_type = PT_NOTE,
937 .p_offset = offsetof(struct fake_elf, chrpnote),
938 .p_filesz = sizeof(struct chrpnote)
939 }, [1] = {
940 .p_type = PT_NOTE,
941 .p_offset = offsetof(struct fake_elf, rpanote),
942 .p_filesz = sizeof(struct rpanote)
943 }
944 },
945 .chrpnote = {
946 .namesz = sizeof("PowerPC"),
947 .descsz = sizeof(struct chrpdesc),
948 .type = 0x1275,
949 .name = "PowerPC",
950 .chrpdesc = {
951 .real_mode = ~0U, /* ~0 means "don't care" */
952 .real_base = ~0U,
953 .real_size = ~0U,
954 .virt_base = ~0U,
955 .virt_size = ~0U,
956 .load_base = ~0U
957 },
958 },
959 .rpanote = {
960 .namesz = sizeof("IBM,RPA-Client-Config"),
961 .descsz = sizeof(struct rpadesc),
962 .type = 0x12759999,
963 .name = "IBM,RPA-Client-Config",
964 .rpadesc = {
Paul Mackerras5663a122008-10-31 22:27:17 +1100965 .lpar_affinity = 0,
966 .min_rmo_size = 64, /* in megabytes */
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000967 .min_rmo_percent = 0,
Paul Mackerras5663a122008-10-31 22:27:17 +1100968 .max_pft_size = 48, /* 2^48 bytes max PFT size */
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000969 .splpar = 1,
970 .min_load = ~0U,
Paul Mackerras5663a122008-10-31 22:27:17 +1100971 .new_mem_def = 0
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000972 }
973 }
974};
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +1000975#endif /* __BIG_ENDIAN__ */
Paul Mackerras9b6b5632005-10-06 12:06:20 +1000976
Benjamin Herrenschmidtefec9592010-02-04 14:33:54 +1100977static int __init prom_count_smt_threads(void)
978{
979 phandle node;
980 char type[64];
981 unsigned int plen;
982
983 /* Pick up th first CPU node we can find */
984 for (node = 0; prom_next_node(&node); ) {
985 type[0] = 0;
986 prom_getprop(node, "device_type", type, sizeof(type));
987
Anton Blanchard5827d412012-11-26 17:40:03 +0000988 if (strcmp(type, "cpu"))
Benjamin Herrenschmidtefec9592010-02-04 14:33:54 +1100989 continue;
990 /*
991 * There is an entry for each smt thread, each entry being
992 * 4 bytes long. All cpus should have the same number of
993 * smt threads, so return after finding the first.
994 */
995 plen = prom_getproplen(node, "ibm,ppc-interrupt-server#s");
996 if (plen == PROM_ERROR)
997 break;
998 plen >>= 2;
Michael Neuling2c48a7d2010-07-27 18:26:21 +0000999 prom_debug("Found %lu smt threads per core\n", (unsigned long)plen);
Benjamin Herrenschmidtefec9592010-02-04 14:33:54 +11001000
1001 /* Sanity check */
1002 if (plen < 1 || plen > 64) {
Michael Neuling2c48a7d2010-07-27 18:26:21 +00001003 prom_printf("Threads per core %lu out of bounds, assuming 1\n",
Benjamin Herrenschmidtefec9592010-02-04 14:33:54 +11001004 (unsigned long)plen);
1005 return 1;
1006 }
1007 return plen;
1008 }
1009 prom_debug("No threads found, assuming 1 per core\n");
1010
1011 return 1;
1012
1013}
1014
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +11001015static void __init prom_parse_mmu_model(u8 val,
1016 struct platform_support *support)
1017{
1018 switch (val) {
1019 case OV5_FEAT(OV5_MMU_DYNAMIC):
1020 case OV5_FEAT(OV5_MMU_EITHER): /* Either Available */
1021 prom_debug("MMU - either supported\n");
1022 support->radix_mmu = !prom_radix_disable;
1023 support->hash_mmu = true;
1024 break;
1025 case OV5_FEAT(OV5_MMU_RADIX): /* Only Radix */
1026 prom_debug("MMU - radix only\n");
1027 if (prom_radix_disable) {
1028 /*
1029 * If we __have__ to do radix, we're better off ignoring
1030 * the command line rather than not booting.
1031 */
1032 prom_printf("WARNING: Ignoring cmdline option disable_radix\n");
1033 }
1034 support->radix_mmu = true;
1035 break;
1036 case OV5_FEAT(OV5_MMU_HASH):
1037 prom_debug("MMU - hash only\n");
1038 support->hash_mmu = true;
1039 break;
1040 default:
1041 prom_debug("Unknown mmu support option: 0x%x\n", val);
1042 break;
1043 }
1044}
1045
Cédric Le Goaterac5e5a52017-08-30 21:46:16 +02001046static void __init prom_parse_xive_model(u8 val,
1047 struct platform_support *support)
1048{
1049 switch (val) {
1050 case OV5_FEAT(OV5_XIVE_EITHER): /* Either Available */
1051 prom_debug("XIVE - either mode supported\n");
1052 support->xive = true;
1053 break;
1054 case OV5_FEAT(OV5_XIVE_EXPLOIT): /* Only Exploitation mode */
1055 prom_debug("XIVE - exploitation mode supported\n");
1056 support->xive = true;
1057 break;
1058 case OV5_FEAT(OV5_XIVE_LEGACY): /* Only Legacy mode */
1059 prom_debug("XIVE - legacy mode supported\n");
1060 break;
1061 default:
1062 prom_debug("Unknown xive support option: 0x%x\n", val);
1063 break;
1064 }
1065}
1066
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +11001067static void __init prom_parse_platform_support(u8 index, u8 val,
1068 struct platform_support *support)
1069{
1070 switch (index) {
1071 case OV5_INDX(OV5_MMU_SUPPORT): /* MMU Model */
1072 prom_parse_mmu_model(val & OV5_FEAT(OV5_MMU_SUPPORT), support);
1073 break;
1074 case OV5_INDX(OV5_RADIX_GTSE): /* Radix Extensions */
1075 if (val & OV5_FEAT(OV5_RADIX_GTSE)) {
1076 prom_debug("Radix - GTSE supported\n");
1077 support->radix_gtse = true;
1078 }
1079 break;
Cédric Le Goaterac5e5a52017-08-30 21:46:16 +02001080 case OV5_INDX(OV5_XIVE_SUPPORT): /* Interrupt mode */
1081 prom_parse_xive_model(val & OV5_FEAT(OV5_XIVE_SUPPORT),
1082 support);
1083 break;
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +11001084 }
1085}
1086
1087static void __init prom_check_platform_support(void)
1088{
1089 struct platform_support supported = {
1090 .hash_mmu = false,
1091 .radix_mmu = false,
Cédric Le Goaterac5e5a52017-08-30 21:46:16 +02001092 .radix_gtse = false,
1093 .xive = false
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +11001094 };
1095 int prop_len = prom_getproplen(prom.chosen,
1096 "ibm,arch-vec-5-platform-support");
1097 if (prop_len > 1) {
1098 int i;
1099 u8 vec[prop_len];
1100 prom_debug("Found ibm,arch-vec-5-platform-support, len: %d\n",
1101 prop_len);
1102 prom_getprop(prom.chosen, "ibm,arch-vec-5-platform-support",
1103 &vec, sizeof(vec));
1104 for (i = 0; i < prop_len; i += 2) {
1105 prom_debug("%d: index = 0x%x val = 0x%x\n", i / 2
1106 , vec[i]
1107 , vec[i + 1]);
1108 prom_parse_platform_support(vec[i], vec[i + 1],
1109 &supported);
1110 }
1111 }
1112
1113 if (supported.radix_mmu && supported.radix_gtse) {
1114 /* Radix preferred - but we require GTSE for now */
1115 prom_debug("Asking for radix with GTSE\n");
1116 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_RADIX);
1117 ibm_architecture_vec.vec5.radix_ext = OV5_FEAT(OV5_RADIX_GTSE);
1118 } else if (supported.hash_mmu) {
1119 /* Default to hash mmu (if we can) */
1120 prom_debug("Asking for hash\n");
1121 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_HASH);
1122 } else {
1123 /* We're probably on a legacy hypervisor */
1124 prom_debug("Assuming legacy hash support\n");
1125 }
Cédric Le Goaterac5e5a52017-08-30 21:46:16 +02001126
1127 if (supported.xive) {
1128 prom_debug("Asking for XIVE\n");
1129 ibm_architecture_vec.vec5.intarch = OV5_FEAT(OV5_XIVE_EXPLOIT);
1130 }
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +11001131}
Benjamin Herrenschmidtefec9592010-02-04 14:33:54 +11001132
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001133static void __init prom_send_capabilities(void)
1134{
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001135 ihandle root;
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001136 prom_arg_t ret;
Laurent Dufourdbd0c5d2013-09-17 11:52:48 +02001137 u32 cores;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001138
Suraj Jitindar Singh014d02c2017-02-28 17:03:48 +11001139 /* Check ibm,arch-vec-5-platform-support and fixup vec5 if required */
1140 prom_check_platform_support();
1141
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001142 root = call_prom("open", 1, 1, ADDR("/"));
1143 if (root != 0) {
Benjamin Herrenschmidtefec9592010-02-04 14:33:54 +11001144 /* We need to tell the FW about the number of cores we support.
1145 *
1146 * To do that, we count the number of threads on the first core
1147 * (we assume this is the same for all cores) and use it to
1148 * divide NR_CPUS.
1149 */
Laurent Dufourdbd0c5d2013-09-17 11:52:48 +02001150
Michael Ellerman76ffb572016-11-18 23:15:42 +11001151 cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads());
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001152 prom_printf("Max number of cores passed to firmware: %u (NR_CPUS = %d)\n",
Michael Ellerman76ffb572016-11-18 23:15:42 +11001153 cores, NR_CPUS);
1154
1155 ibm_architecture_vec.vec5.max_cpus = cpu_to_be32(cores);
Benjamin Herrenschmidtefec9592010-02-04 14:33:54 +11001156
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001157 /* try calling the ibm,client-architecture-support method */
Anton Blanchard049d0492009-09-21 20:47:39 +00001158 prom_printf("Calling ibm,client-architecture-support...");
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001159 if (call_prom_ret("call-method", 3, 2, &ret,
1160 ADDR("ibm,client-architecture-support"),
Benjamin Herrenschmidt33b74972006-06-07 12:01:32 +10001161 root,
Michael Ellerman76ffb572016-11-18 23:15:42 +11001162 ADDR(&ibm_architecture_vec)) == 0) {
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001163 /* the call exists... */
1164 if (ret)
Anton Blanchard4da727a2009-03-31 20:06:14 +00001165 prom_printf("\nWARNING: ibm,client-architecture"
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001166 "-support call FAILED!\n");
1167 call_prom("close", 1, 0, root);
Anton Blanchard4da727a2009-03-31 20:06:14 +00001168 prom_printf(" done\n");
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001169 return;
1170 }
1171 call_prom("close", 1, 0, root);
Anton Blanchard049d0492009-09-21 20:47:39 +00001172 prom_printf(" not implemented\n");
Paul Mackerrasf709bfa2006-04-28 16:28:35 +10001173 }
1174
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001175#ifdef __BIG_ENDIAN__
1176 {
1177 ihandle elfloader;
1178
1179 /* no ibm,client-architecture-support call, try the old way */
1180 elfloader = call_prom("open", 1, 1,
1181 ADDR("/packages/elf-loader"));
1182 if (elfloader == 0) {
1183 prom_printf("couldn't open /packages/elf-loader\n");
1184 return;
1185 }
1186 call_prom("call-method", 3, 1, ADDR("process-elf-header"),
1187 elfloader, ADDR(&fake_elf));
1188 call_prom("close", 1, 0, elfloader);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001189 }
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001190#endif /* __BIG_ENDIAN__ */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001191}
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001192#endif /* #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001193
1194/*
1195 * Memory allocation strategy... our layout is normally:
1196 *
1197 * at 14Mb or more we have vmlinux, then a gap and initrd. In some
1198 * rare cases, initrd might end up being before the kernel though.
1199 * We assume this won't override the final kernel at 0, we have no
1200 * provision to handle that in this version, but it should hopefully
1201 * never happen.
1202 *
1203 * alloc_top is set to the top of RMO, eventually shrink down if the
1204 * TCEs overlap
1205 *
1206 * alloc_bottom is set to the top of kernel/initrd
1207 *
1208 * from there, allocations are done this way : rtas is allocated
1209 * topmost, and the device-tree is allocated from the bottom. We try
1210 * to grow the device-tree allocation as we progress. If we can't,
1211 * then we fail, we don't currently have a facility to restart
1212 * elsewhere, but that shouldn't be necessary.
1213 *
1214 * Note that calls to reserve_mem have to be done explicitly, memory
1215 * allocated with either alloc_up or alloc_down isn't automatically
1216 * reserved.
1217 */
1218
1219
1220/*
1221 * Allocates memory in the RMO upward from the kernel/initrd
1222 *
1223 * When align is 0, this is a special case, it means to allocate in place
1224 * at the current location of alloc_bottom or fail (that is basically
1225 * extending the previous allocation). Used for the device-tree flattening
1226 */
1227static unsigned long __init alloc_up(unsigned long size, unsigned long align)
1228{
Anton Blanchard5827d412012-11-26 17:40:03 +00001229 unsigned long base = alloc_bottom;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001230 unsigned long addr = 0;
1231
Paul Mackerrasc49888202005-10-26 21:52:53 +10001232 if (align)
1233 base = _ALIGN_UP(base, align);
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001234 prom_debug("%s(%lx, %lx)\n", __func__, size, align);
Anton Blanchard5827d412012-11-26 17:40:03 +00001235 if (ram_top == 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001236 prom_panic("alloc_up() called with mem not initialized\n");
1237
1238 if (align)
Anton Blanchard5827d412012-11-26 17:40:03 +00001239 base = _ALIGN_UP(alloc_bottom, align);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001240 else
Anton Blanchard5827d412012-11-26 17:40:03 +00001241 base = alloc_bottom;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001242
Anton Blanchard5827d412012-11-26 17:40:03 +00001243 for(; (base + size) <= alloc_top;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001244 base = _ALIGN_UP(base + 0x100000, align)) {
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001245 prom_debug(" trying: 0x%lx\n\r", base);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001246 addr = (unsigned long)prom_claim(base, size, 0);
Paul Mackerrasc49888202005-10-26 21:52:53 +10001247 if (addr != PROM_ERROR && addr != 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001248 break;
1249 addr = 0;
1250 if (align == 0)
1251 break;
1252 }
1253 if (addr == 0)
1254 return 0;
Anton Blanchard5827d412012-11-26 17:40:03 +00001255 alloc_bottom = addr + size;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001256
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001257 prom_debug(" -> %lx\n", addr);
1258 prom_debug(" alloc_bottom : %lx\n", alloc_bottom);
1259 prom_debug(" alloc_top : %lx\n", alloc_top);
1260 prom_debug(" alloc_top_hi : %lx\n", alloc_top_high);
1261 prom_debug(" rmo_top : %lx\n", rmo_top);
1262 prom_debug(" ram_top : %lx\n", ram_top);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001263
1264 return addr;
1265}
1266
1267/*
1268 * Allocates memory downward, either from top of RMO, or if highmem
1269 * is set, from the top of RAM. Note that this one doesn't handle
1270 * failures. It does claim memory if highmem is not set.
1271 */
1272static unsigned long __init alloc_down(unsigned long size, unsigned long align,
1273 int highmem)
1274{
1275 unsigned long base, addr = 0;
1276
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001277 prom_debug("%s(%lx, %lx, %s)\n", __func__, size, align,
Anton Blanchard5827d412012-11-26 17:40:03 +00001278 highmem ? "(high)" : "(low)");
1279 if (ram_top == 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001280 prom_panic("alloc_down() called with mem not initialized\n");
1281
1282 if (highmem) {
1283 /* Carve out storage for the TCE table. */
Anton Blanchard5827d412012-11-26 17:40:03 +00001284 addr = _ALIGN_DOWN(alloc_top_high - size, align);
1285 if (addr <= alloc_bottom)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001286 return 0;
1287 /* Will we bump into the RMO ? If yes, check out that we
1288 * didn't overlap existing allocations there, if we did,
1289 * we are dead, we must be the first in town !
1290 */
Anton Blanchard5827d412012-11-26 17:40:03 +00001291 if (addr < rmo_top) {
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001292 /* Good, we are first */
Anton Blanchard5827d412012-11-26 17:40:03 +00001293 if (alloc_top == rmo_top)
1294 alloc_top = rmo_top = addr;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001295 else
1296 return 0;
1297 }
Anton Blanchard5827d412012-11-26 17:40:03 +00001298 alloc_top_high = addr;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001299 goto bail;
1300 }
1301
Anton Blanchard5827d412012-11-26 17:40:03 +00001302 base = _ALIGN_DOWN(alloc_top - size, align);
1303 for (; base > alloc_bottom;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001304 base = _ALIGN_DOWN(base - 0x100000, align)) {
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001305 prom_debug(" trying: 0x%lx\n\r", base);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001306 addr = (unsigned long)prom_claim(base, size, 0);
Paul Mackerrasc49888202005-10-26 21:52:53 +10001307 if (addr != PROM_ERROR && addr != 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001308 break;
1309 addr = 0;
1310 }
1311 if (addr == 0)
1312 return 0;
Anton Blanchard5827d412012-11-26 17:40:03 +00001313 alloc_top = addr;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001314
1315 bail:
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001316 prom_debug(" -> %lx\n", addr);
1317 prom_debug(" alloc_bottom : %lx\n", alloc_bottom);
1318 prom_debug(" alloc_top : %lx\n", alloc_top);
1319 prom_debug(" alloc_top_hi : %lx\n", alloc_top_high);
1320 prom_debug(" rmo_top : %lx\n", rmo_top);
1321 prom_debug(" ram_top : %lx\n", ram_top);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001322
1323 return addr;
1324}
1325
1326/*
1327 * Parse a "reg" cell
1328 */
1329static unsigned long __init prom_next_cell(int s, cell_t **cellp)
1330{
1331 cell_t *p = *cellp;
1332 unsigned long r = 0;
1333
1334 /* Ignore more than 2 cells */
1335 while (s > sizeof(unsigned long) / 4) {
1336 p++;
1337 s--;
1338 }
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001339 r = be32_to_cpu(*p++);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001340#ifdef CONFIG_PPC64
Paul Mackerras35499c02005-10-22 16:02:39 +10001341 if (s > 1) {
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001342 r <<= 32;
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001343 r |= be32_to_cpu(*(p++));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001344 }
1345#endif
1346 *cellp = p;
1347 return r;
1348}
1349
1350/*
1351 * Very dumb function for adding to the memory reserve list, but
1352 * we don't need anything smarter at this point
1353 *
1354 * XXX Eventually check for collisions. They should NEVER happen.
1355 * If problems seem to show up, it would be a good start to track
1356 * them down.
1357 */
Michael Ellerman0108d3f2007-05-07 15:58:28 +10001358static void __init reserve_mem(u64 base, u64 size)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001359{
Kumar Galacbbcf342006-01-11 17:57:13 -06001360 u64 top = base + size;
Anton Blanchard5827d412012-11-26 17:40:03 +00001361 unsigned long cnt = mem_reserve_cnt;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001362
1363 if (size == 0)
1364 return;
1365
1366 /* We need to always keep one empty entry so that we
1367 * have our terminator with "size" set to 0 since we are
1368 * dumb and just copy this entire array to the boot params
1369 */
1370 base = _ALIGN_DOWN(base, PAGE_SIZE);
1371 top = _ALIGN_UP(top, PAGE_SIZE);
1372 size = top - base;
1373
1374 if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
1375 prom_panic("Memory reserve map exhausted !\n");
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001376 mem_reserve_map[cnt].base = cpu_to_be64(base);
1377 mem_reserve_map[cnt].size = cpu_to_be64(size);
Anton Blanchard5827d412012-11-26 17:40:03 +00001378 mem_reserve_cnt = cnt + 1;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001379}
1380
1381/*
Adrian Bunkb3c2ffd2006-06-30 18:20:44 +02001382 * Initialize memory allocation mechanism, parse "memory" nodes and
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001383 * obtain that way the top of memory and RMO to setup out local allocator
1384 */
1385static void __init prom_init_mem(void)
1386{
1387 phandle node;
1388 char *path, type[64];
1389 unsigned int plen;
1390 cell_t *p, *endp;
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001391 __be32 val;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001392 u32 rac, rsc;
1393
1394 /*
1395 * We iterate the memory nodes to find
1396 * 1) top of RMO (first node)
1397 * 2) top of memory
1398 */
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001399 val = cpu_to_be32(2);
1400 prom_getprop(prom.root, "#address-cells", &val, sizeof(val));
1401 rac = be32_to_cpu(val);
1402 val = cpu_to_be32(1);
1403 prom_getprop(prom.root, "#size-cells", &val, sizeof(rsc));
1404 rsc = be32_to_cpu(val);
1405 prom_debug("root_addr_cells: %x\n", rac);
1406 prom_debug("root_size_cells: %x\n", rsc);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001407
1408 prom_debug("scanning memory:\n");
Anton Blanchard5827d412012-11-26 17:40:03 +00001409 path = prom_scratch;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001410
1411 for (node = 0; prom_next_node(&node); ) {
1412 type[0] = 0;
1413 prom_getprop(node, "device_type", type, sizeof(type));
1414
Paul Mackerrasc49888202005-10-26 21:52:53 +10001415 if (type[0] == 0) {
1416 /*
1417 * CHRP Longtrail machines have no device_type
1418 * on the memory node, so check the name instead...
1419 */
1420 prom_getprop(node, "name", type, sizeof(type));
1421 }
Anton Blanchard5827d412012-11-26 17:40:03 +00001422 if (strcmp(type, "memory"))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001423 continue;
Paul Mackerrasc49888202005-10-26 21:52:53 +10001424
Anton Blanchard5827d412012-11-26 17:40:03 +00001425 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001426 if (plen > sizeof(regbuf)) {
1427 prom_printf("memory node too large for buffer !\n");
1428 plen = sizeof(regbuf);
1429 }
Anton Blanchard5827d412012-11-26 17:40:03 +00001430 p = regbuf;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001431 endp = p + (plen / sizeof(cell_t));
1432
1433#ifdef DEBUG_PROM
1434 memset(path, 0, PROM_SCRATCH_SIZE);
1435 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1436 prom_debug(" node %s :\n", path);
1437#endif /* DEBUG_PROM */
1438
1439 while ((endp - p) >= (rac + rsc)) {
1440 unsigned long base, size;
1441
1442 base = prom_next_cell(rac, &p);
1443 size = prom_next_cell(rsc, &p);
1444
1445 if (size == 0)
1446 continue;
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001447 prom_debug(" %lx %lx\n", base, size);
Anton Blanchard5827d412012-11-26 17:40:03 +00001448 if (base == 0 && (of_platform & PLATFORM_LPAR))
1449 rmo_top = size;
1450 if ((base + size) > ram_top)
1451 ram_top = base + size;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001452 }
1453 }
1454
Anton Blanchard5827d412012-11-26 17:40:03 +00001455 alloc_bottom = PAGE_ALIGN((unsigned long)&_end + 0x4000);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001456
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001457 /*
Benjamin Krillcf687872009-07-27 22:02:39 +00001458 * If prom_memory_limit is set we reduce the upper limits *except* for
1459 * alloc_top_high. This must be the real top of RAM so we can put
1460 * TCE's up there.
1461 */
1462
Anton Blanchard5827d412012-11-26 17:40:03 +00001463 alloc_top_high = ram_top;
Benjamin Krillcf687872009-07-27 22:02:39 +00001464
Anton Blanchard5827d412012-11-26 17:40:03 +00001465 if (prom_memory_limit) {
1466 if (prom_memory_limit <= alloc_bottom) {
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001467 prom_printf("Ignoring mem=%lx <= alloc_bottom.\n",
1468 prom_memory_limit);
Anton Blanchard5827d412012-11-26 17:40:03 +00001469 prom_memory_limit = 0;
1470 } else if (prom_memory_limit >= ram_top) {
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001471 prom_printf("Ignoring mem=%lx >= ram_top.\n",
1472 prom_memory_limit);
Anton Blanchard5827d412012-11-26 17:40:03 +00001473 prom_memory_limit = 0;
Benjamin Krillcf687872009-07-27 22:02:39 +00001474 } else {
Anton Blanchard5827d412012-11-26 17:40:03 +00001475 ram_top = prom_memory_limit;
1476 rmo_top = min(rmo_top, prom_memory_limit);
Benjamin Krillcf687872009-07-27 22:02:39 +00001477 }
1478 }
1479
1480 /*
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001481 * Setup our top alloc point, that is top of RMO or top of
1482 * segment 0 when running non-LPAR.
1483 * Some RS64 machines have buggy firmware where claims up at
1484 * 1GB fail. Cap at 768MB as a workaround.
1485 * Since 768MB is plenty of room, and we need to cap to something
1486 * reasonable on 32-bit, cap at 768MB on all machines.
1487 */
Anton Blanchard5827d412012-11-26 17:40:03 +00001488 if (!rmo_top)
1489 rmo_top = ram_top;
1490 rmo_top = min(0x30000000ul, rmo_top);
1491 alloc_top = rmo_top;
1492 alloc_top_high = ram_top;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001493
Paul Mackerras64968f62011-12-13 17:54:13 +00001494 /*
1495 * Check if we have an initrd after the kernel but still inside
1496 * the RMO. If we do move our bottom point to after it.
1497 */
Anton Blanchard5827d412012-11-26 17:40:03 +00001498 if (prom_initrd_start &&
1499 prom_initrd_start < rmo_top &&
1500 prom_initrd_end > alloc_bottom)
1501 alloc_bottom = PAGE_ALIGN(prom_initrd_end);
Paul Mackerras64968f62011-12-13 17:54:13 +00001502
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001503 prom_printf("memory layout at init:\n");
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001504 prom_printf(" memory_limit : %lx (16 MB aligned)\n",
1505 prom_memory_limit);
1506 prom_printf(" alloc_bottom : %lx\n", alloc_bottom);
1507 prom_printf(" alloc_top : %lx\n", alloc_top);
1508 prom_printf(" alloc_top_hi : %lx\n", alloc_top_high);
1509 prom_printf(" rmo_top : %lx\n", rmo_top);
1510 prom_printf(" ram_top : %lx\n", ram_top);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001511}
1512
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00001513static void __init prom_close_stdin(void)
1514{
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001515 __be32 val;
1516 ihandle stdin;
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00001517
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001518 if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) {
1519 stdin = be32_to_cpu(val);
1520 call_prom("close", 1, 0, stdin);
1521 }
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00001522}
1523
1524#ifdef CONFIG_PPC_POWERNV
1525
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001526#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1527static u64 __initdata prom_opal_base;
1528static u64 __initdata prom_opal_entry;
1529#endif
1530
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001531/*
1532 * Allocate room for and instantiate OPAL
1533 */
1534static void __init prom_instantiate_opal(void)
1535{
1536 phandle opal_node;
1537 ihandle opal_inst;
1538 u64 base, entry;
1539 u64 size = 0, align = 0x10000;
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001540 __be64 val64;
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001541 u32 rets[2];
1542
1543 prom_debug("prom_instantiate_opal: start...\n");
1544
1545 opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1546 prom_debug("opal_node: %x\n", opal_node);
1547 if (!PHANDLE_VALID(opal_node))
1548 return;
1549
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001550 val64 = 0;
1551 prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64));
1552 size = be64_to_cpu(val64);
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001553 if (size == 0)
1554 return;
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001555 val64 = 0;
1556 prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64));
1557 align = be64_to_cpu(val64);
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001558
1559 base = alloc_down(size, align, 0);
1560 if (base == 0) {
1561 prom_printf("OPAL allocation failed !\n");
1562 return;
1563 }
1564
1565 opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1566 if (!IHANDLE_VALID(opal_inst)) {
1567 prom_printf("opening opal package failed (%x)\n", opal_inst);
1568 return;
1569 }
1570
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001571 prom_printf("instantiating opal at 0x%llx...", base);
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001572
1573 if (call_prom_ret("call-method", 4, 3, rets,
1574 ADDR("load-opal-runtime"),
1575 opal_inst,
1576 base >> 32, base & 0xffffffff) != 0
1577 || (rets[0] == 0 && rets[1] == 0)) {
1578 prom_printf(" failed\n");
1579 return;
1580 }
1581 entry = (((u64)rets[0]) << 32) | rets[1];
1582
1583 prom_printf(" done\n");
1584
1585 reserve_mem(base, size);
1586
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001587 prom_debug("opal base = 0x%llx\n", base);
1588 prom_debug("opal align = 0x%llx\n", align);
1589 prom_debug("opal entry = 0x%llx\n", entry);
1590 prom_debug("opal size = 0x%llx\n", size);
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001591
1592 prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1593 &base, sizeof(base));
1594 prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1595 &entry, sizeof(entry));
1596
1597#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
Anton Blanchard5827d412012-11-26 17:40:03 +00001598 prom_opal_base = base;
1599 prom_opal_entry = entry;
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00001600#endif
1601 prom_debug("prom_instantiate_opal: end...\n");
1602}
1603
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00001604#endif /* CONFIG_PPC_POWERNV */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001605
1606/*
1607 * Allocate room for and instantiate RTAS
1608 */
1609static void __init prom_instantiate_rtas(void)
1610{
1611 phandle rtas_node;
1612 ihandle rtas_inst;
1613 u32 base, entry = 0;
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001614 __be32 val;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001615 u32 size = 0;
1616
1617 prom_debug("prom_instantiate_rtas: start...\n");
1618
1619 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1620 prom_debug("rtas_node: %x\n", rtas_node);
1621 if (!PHANDLE_VALID(rtas_node))
1622 return;
1623
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001624 val = 0;
1625 prom_getprop(rtas_node, "rtas-size", &val, sizeof(size));
1626 size = be32_to_cpu(val);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001627 if (size == 0)
1628 return;
1629
1630 base = alloc_down(size, PAGE_SIZE, 0);
Anton Blanchard6d1e2c62011-11-14 12:55:47 +00001631 if (base == 0)
1632 prom_panic("Could not allocate memory for RTAS\n");
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001633
1634 rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1635 if (!IHANDLE_VALID(rtas_inst)) {
Paul Mackerrasa23414b2005-11-10 12:00:55 +11001636 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001637 return;
1638 }
1639
Anton Blanchard1f8737a2009-03-31 20:06:15 +00001640 prom_printf("instantiating rtas at 0x%x...", base);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001641
1642 if (call_prom_ret("call-method", 3, 2, &entry,
1643 ADDR("instantiate-rtas"),
Paul Mackerrasa23414b2005-11-10 12:00:55 +11001644 rtas_inst, base) != 0
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001645 || entry == 0) {
1646 prom_printf(" failed\n");
1647 return;
1648 }
1649 prom_printf(" done\n");
1650
1651 reserve_mem(base, size);
1652
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001653 val = cpu_to_be32(base);
Paul Mackerrasa23414b2005-11-10 12:00:55 +11001654 prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001655 &val, sizeof(val));
1656 val = cpu_to_be32(entry);
Paul Mackerrasa23414b2005-11-10 12:00:55 +11001657 prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001658 &val, sizeof(val));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001659
Benjamin Herrenschmidtdbe78b42013-09-25 14:02:50 +10001660 /* Check if it supports "query-cpu-stopped-state" */
1661 if (prom_getprop(rtas_node, "query-cpu-stopped-state",
1662 &val, sizeof(val)) != PROM_ERROR)
1663 rtas_has_query_cpu_stopped = true;
1664
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001665 prom_debug("rtas base = 0x%x\n", base);
1666 prom_debug("rtas entry = 0x%x\n", entry);
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001667 prom_debug("rtas size = 0x%x\n", size);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001668
1669 prom_debug("prom_instantiate_rtas: end...\n");
1670}
1671
1672#ifdef CONFIG_PPC64
1673/*
Ashley Lai4a727422012-08-14 18:34:57 -05001674 * Allocate room for and instantiate Stored Measurement Log (SML)
1675 */
1676static void __init prom_instantiate_sml(void)
1677{
1678 phandle ibmvtpm_node;
1679 ihandle ibmvtpm_inst;
Hon Ching \(Vicky\) Lob4ed0462015-10-07 20:11:53 -04001680 u32 entry = 0, size = 0, succ = 0;
Ashley Lai4a727422012-08-14 18:34:57 -05001681 u64 base;
Hon Ching \(Vicky\) Lob4ed0462015-10-07 20:11:53 -04001682 __be32 val;
Ashley Lai4a727422012-08-14 18:34:57 -05001683
1684 prom_debug("prom_instantiate_sml: start...\n");
1685
Hon Ching \(Vicky\) Lo2f82e982015-10-07 20:11:52 -04001686 ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/vdevice/vtpm"));
Ashley Lai4a727422012-08-14 18:34:57 -05001687 prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node);
1688 if (!PHANDLE_VALID(ibmvtpm_node))
1689 return;
1690
Hon Ching \(Vicky\) Lo2f82e982015-10-07 20:11:52 -04001691 ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/vdevice/vtpm"));
Ashley Lai4a727422012-08-14 18:34:57 -05001692 if (!IHANDLE_VALID(ibmvtpm_inst)) {
1693 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst);
1694 return;
1695 }
1696
Hon Ching \(Vicky\) Lob4ed0462015-10-07 20:11:53 -04001697 if (prom_getprop(ibmvtpm_node, "ibm,sml-efi-reformat-supported",
1698 &val, sizeof(val)) != PROM_ERROR) {
1699 if (call_prom_ret("call-method", 2, 2, &succ,
1700 ADDR("reformat-sml-to-efi-alignment"),
1701 ibmvtpm_inst) != 0 || succ == 0) {
1702 prom_printf("Reformat SML to EFI alignment failed\n");
1703 return;
1704 }
Hon Ching \(Vicky\) Lob4ed0462015-10-07 20:11:53 -04001705
Hon Ching \(Vicky\) Lo9e5d4af2015-10-07 20:11:54 -04001706 if (call_prom_ret("call-method", 2, 2, &size,
1707 ADDR("sml-get-allocated-size"),
1708 ibmvtpm_inst) != 0 || size == 0) {
1709 prom_printf("SML get allocated size failed\n");
1710 return;
1711 }
1712 } else {
1713 if (call_prom_ret("call-method", 2, 2, &size,
1714 ADDR("sml-get-handover-size"),
1715 ibmvtpm_inst) != 0 || size == 0) {
1716 prom_printf("SML get handover size failed\n");
1717 return;
1718 }
Ashley Lai4a727422012-08-14 18:34:57 -05001719 }
1720
1721 base = alloc_down(size, PAGE_SIZE, 0);
1722 if (base == 0)
1723 prom_panic("Could not allocate memory for sml\n");
1724
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001725 prom_printf("instantiating sml at 0x%llx...", base);
Ashley Lai4a727422012-08-14 18:34:57 -05001726
Hon Ching \(Vicky\) Lo9e5d4af2015-10-07 20:11:54 -04001727 memset((void *)base, 0, size);
1728
Ashley Lai4a727422012-08-14 18:34:57 -05001729 if (call_prom_ret("call-method", 4, 2, &entry,
1730 ADDR("sml-handover"),
1731 ibmvtpm_inst, size, base) != 0 || entry == 0) {
1732 prom_printf("SML handover failed\n");
1733 return;
1734 }
1735 prom_printf(" done\n");
1736
1737 reserve_mem(base, size);
1738
Hon Ching \(Vicky\) Lo2f82e982015-10-07 20:11:52 -04001739 prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-base",
Ashley Lai4a727422012-08-14 18:34:57 -05001740 &base, sizeof(base));
Hon Ching \(Vicky\) Lo2f82e982015-10-07 20:11:52 -04001741 prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-size",
Ashley Lai4a727422012-08-14 18:34:57 -05001742 &size, sizeof(size));
1743
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001744 prom_debug("sml base = 0x%llx\n", base);
1745 prom_debug("sml size = 0x%x\n", size);
Ashley Lai4a727422012-08-14 18:34:57 -05001746
1747 prom_debug("prom_instantiate_sml: end...\n");
1748}
1749
1750/*
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001751 * Allocate room for and initialize TCE tables
1752 */
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001753#ifdef __BIG_ENDIAN__
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001754static void __init prom_initialize_tce_table(void)
1755{
1756 phandle node;
1757 ihandle phb_node;
1758 char compatible[64], type[64], model[64];
Anton Blanchard5827d412012-11-26 17:40:03 +00001759 char *path = prom_scratch;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001760 u64 base, align;
1761 u32 minalign, minsize;
1762 u64 tce_entry, *tce_entryp;
1763 u64 local_alloc_top, local_alloc_bottom;
1764 u64 i;
1765
Anton Blanchard5827d412012-11-26 17:40:03 +00001766 if (prom_iommu_off)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001767 return;
1768
1769 prom_debug("starting prom_initialize_tce_table\n");
1770
1771 /* Cache current top of allocs so we reserve a single block */
Anton Blanchard5827d412012-11-26 17:40:03 +00001772 local_alloc_top = alloc_top_high;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001773 local_alloc_bottom = local_alloc_top;
1774
1775 /* Search all nodes looking for PHBs. */
1776 for (node = 0; prom_next_node(&node); ) {
1777 compatible[0] = 0;
1778 type[0] = 0;
1779 model[0] = 0;
1780 prom_getprop(node, "compatible",
1781 compatible, sizeof(compatible));
1782 prom_getprop(node, "device_type", type, sizeof(type));
1783 prom_getprop(node, "model", model, sizeof(model));
1784
Anton Blanchard5827d412012-11-26 17:40:03 +00001785 if ((type[0] == 0) || (strstr(type, "pci") == NULL))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001786 continue;
1787
Linas Vepstase788ff12007-09-07 03:45:21 +10001788 /* Keep the old logic intact to avoid regression. */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001789 if (compatible[0] != 0) {
Anton Blanchard5827d412012-11-26 17:40:03 +00001790 if ((strstr(compatible, "python") == NULL) &&
1791 (strstr(compatible, "Speedwagon") == NULL) &&
1792 (strstr(compatible, "Winnipeg") == NULL))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001793 continue;
1794 } else if (model[0] != 0) {
Anton Blanchard5827d412012-11-26 17:40:03 +00001795 if ((strstr(model, "ython") == NULL) &&
1796 (strstr(model, "peedwagon") == NULL) &&
1797 (strstr(model, "innipeg") == NULL))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001798 continue;
1799 }
1800
1801 if (prom_getprop(node, "tce-table-minalign", &minalign,
1802 sizeof(minalign)) == PROM_ERROR)
1803 minalign = 0;
1804 if (prom_getprop(node, "tce-table-minsize", &minsize,
1805 sizeof(minsize)) == PROM_ERROR)
1806 minsize = 4UL << 20;
1807
1808 /*
1809 * Even though we read what OF wants, we just set the table
1810 * size to 4 MB. This is enough to map 2GB of PCI DMA space.
1811 * By doing this, we avoid the pitfalls of trying to DMA to
1812 * MMIO space and the DMA alias hole.
1813 *
1814 * On POWER4, firmware sets the TCE region by assuming
1815 * each TCE table is 8MB. Using this memory for anything
1816 * else will impact performance, so we always allocate 8MB.
1817 * Anton
1818 */
Michael Ellermand3dbeef2012-08-19 21:44:01 +00001819 if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001820 minsize = 8UL << 20;
1821 else
1822 minsize = 4UL << 20;
1823
1824 /* Align to the greater of the align or size */
1825 align = max(minalign, minsize);
1826 base = alloc_down(minsize, align, 1);
1827 if (base == 0)
1828 prom_panic("ERROR, cannot find space for TCE table.\n");
1829 if (base < local_alloc_bottom)
1830 local_alloc_bottom = base;
1831
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001832 /* It seems OF doesn't null-terminate the path :-( */
Li Zefanaca71ef2007-11-05 13:21:56 +11001833 memset(path, 0, PROM_SCRATCH_SIZE);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001834 /* Call OF to setup the TCE hardware */
1835 if (call_prom("package-to-path", 3, 1, node,
1836 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1837 prom_printf("package-to-path failed\n");
1838 }
1839
Paul Mackerrasa23414b2005-11-10 12:00:55 +11001840 /* Save away the TCE table attributes for later use. */
1841 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1842 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1843
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001844 prom_debug("TCE table: %s\n", path);
1845 prom_debug("\tnode = 0x%x\n", node);
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001846 prom_debug("\tbase = 0x%llx\n", base);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001847 prom_debug("\tsize = 0x%x\n", minsize);
1848
1849 /* Initialize the table to have a one-to-one mapping
1850 * over the allocated size.
1851 */
Ingo Molnar2b931fb2009-01-06 13:56:52 +00001852 tce_entryp = (u64 *)base;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001853 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1854 tce_entry = (i << PAGE_SHIFT);
1855 tce_entry |= 0x3;
1856 *tce_entryp = tce_entry;
1857 }
1858
1859 prom_printf("opening PHB %s", path);
1860 phb_node = call_prom("open", 1, 1, path);
1861 if (phb_node == 0)
1862 prom_printf("... failed\n");
1863 else
1864 prom_printf("... done\n");
1865
1866 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1867 phb_node, -1, minsize,
1868 (u32) base, (u32) (base >> 32));
1869 call_prom("close", 1, 0, phb_node);
1870 }
1871
1872 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1873
Michael Ellerman2babf5c2006-05-17 18:00:46 +10001874 /* These are only really needed if there is a memory limit in
1875 * effect, but we don't know so export them always. */
Anton Blanchard5827d412012-11-26 17:40:03 +00001876 prom_tce_alloc_start = local_alloc_bottom;
1877 prom_tce_alloc_end = local_alloc_top;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001878
1879 /* Flag the first invalid entry */
1880 prom_debug("ending prom_initialize_tce_table\n");
1881}
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001882#endif /* __BIG_ENDIAN__ */
1883#endif /* CONFIG_PPC64 */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001884
1885/*
1886 * With CHRP SMP we need to use the OF to start the other processors.
1887 * We can't wait until smp_boot_cpus (the OF is trashed by then)
1888 * so we have to put the processors into a holding pattern controlled
1889 * by the kernel (not OF) before we destroy the OF.
1890 *
1891 * This uses a chunk of low memory, puts some holding pattern
1892 * code there and sends the other processors off to there until
1893 * smp_boot_cpus tells them to do something. The holding pattern
1894 * checks that address until its cpu # is there, when it is that
1895 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care
1896 * of setting those values.
1897 *
1898 * We also use physical address 0x4 here to tell when a cpu
1899 * is in its holding pattern code.
1900 *
1901 * -- Cort
1902 */
Paul Mackerrasbbd0abd2005-10-26 21:45:56 +10001903/*
1904 * We want to reference the copy of __secondary_hold_* in the
1905 * 0 - 0x100 address range
1906 */
1907#define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff)
1908
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001909static void __init prom_hold_cpus(void)
1910{
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001911 unsigned long i;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001912 phandle node;
1913 char type[64];
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001914 unsigned long *spinloop
Paul Mackerrasbbd0abd2005-10-26 21:45:56 +10001915 = (void *) LOW_ADDR(__secondary_hold_spinloop);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001916 unsigned long *acknowledge
Paul Mackerrasbbd0abd2005-10-26 21:45:56 +10001917 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
Paul Mackerrasbbd0abd2005-10-26 21:45:56 +10001918 unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001919
Benjamin Herrenschmidtdbe78b42013-09-25 14:02:50 +10001920 /*
1921 * On pseries, if RTAS supports "query-cpu-stopped-state",
1922 * we skip this stage, the CPUs will be started by the
1923 * kernel using RTAS.
1924 */
1925 if ((of_platform == PLATFORM_PSERIES ||
1926 of_platform == PLATFORM_PSERIES_LPAR) &&
1927 rtas_has_query_cpu_stopped) {
1928 prom_printf("prom_hold_cpus: skipped\n");
1929 return;
1930 }
1931
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001932 prom_debug("prom_hold_cpus: start...\n");
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001933 prom_debug(" 1) spinloop = 0x%lx\n", (unsigned long)spinloop);
1934 prom_debug(" 1) *spinloop = 0x%lx\n", *spinloop);
1935 prom_debug(" 1) acknowledge = 0x%lx\n",
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001936 (unsigned long)acknowledge);
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001937 prom_debug(" 1) *acknowledge = 0x%lx\n", *acknowledge);
1938 prom_debug(" 1) secondary_hold = 0x%lx\n", secondary_hold);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001939
1940 /* Set the common spinloop variable, so all of the secondary cpus
1941 * will block when they are awakened from their OF spinloop.
1942 * This must occur for both SMP and non SMP kernels, since OF will
1943 * be trashed when we move the kernel.
1944 */
1945 *spinloop = 0;
1946
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001947 /* look for cpus */
1948 for (node = 0; prom_next_node(&node); ) {
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001949 unsigned int cpu_no;
1950 __be32 reg;
1951
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001952 type[0] = 0;
1953 prom_getprop(node, "device_type", type, sizeof(type));
Anton Blanchard5827d412012-11-26 17:40:03 +00001954 if (strcmp(type, "cpu") != 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001955 continue;
1956
1957 /* Skip non-configured cpus. */
1958 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
Anton Blanchard5827d412012-11-26 17:40:03 +00001959 if (strcmp(type, "okay") != 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001960 continue;
1961
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001962 reg = cpu_to_be32(-1); /* make sparse happy */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001963 prom_getprop(node, "reg", &reg, sizeof(reg));
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001964 cpu_no = be32_to_cpu(reg);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001965
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001966 prom_debug("cpu hw idx = %u\n", cpu_no);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001967
1968 /* Init the acknowledge var which will be reset by
1969 * the secondary cpu when it awakens from its OF
1970 * spinloop.
1971 */
1972 *acknowledge = (unsigned long)-1;
1973
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001974 if (cpu_no != prom.cpu) {
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00001975 /* Primary Thread of non-boot cpu or any thread */
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001976 prom_printf("starting cpu hw idx %u... ", cpu_no);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001977 call_prom("start-cpu", 3, 0, node,
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001978 secondary_hold, cpu_no);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001979
Paul Mackerrasbbd0abd2005-10-26 21:45:56 +10001980 for (i = 0; (i < 100000000) &&
1981 (*acknowledge == ((unsigned long)-1)); i++ )
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001982 mb();
1983
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10001984 if (*acknowledge == cpu_no)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001985 prom_printf("done\n");
Paul Mackerrasbbd0abd2005-10-26 21:45:56 +10001986 else
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001987 prom_printf("failed: %lx\n", *acknowledge);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001988 }
1989#ifdef CONFIG_SMP
1990 else
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02001991 prom_printf("boot cpu hw idx %u\n", cpu_no);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001992#endif /* CONFIG_SMP */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001993 }
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001994
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001995 prom_debug("prom_hold_cpus: end...\n");
Paul Mackerras9b6b5632005-10-06 12:06:20 +10001996}
1997
1998
1999static void __init prom_init_client_services(unsigned long pp)
2000{
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002001 /* Get a handle to the prom entry point before anything else */
Anton Blanchard5827d412012-11-26 17:40:03 +00002002 prom_entry = pp;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002003
2004 /* get a handle for the stdout device */
Anton Blanchard5827d412012-11-26 17:40:03 +00002005 prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
2006 if (!PHANDLE_VALID(prom.chosen))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002007 prom_panic("cannot find chosen"); /* msg won't be printed :( */
2008
2009 /* get device tree root */
Anton Blanchard5827d412012-11-26 17:40:03 +00002010 prom.root = call_prom("finddevice", 1, 1, ADDR("/"));
2011 if (!PHANDLE_VALID(prom.root))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002012 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
Paul Mackerrasa575b802005-10-23 17:23:21 +10002013
Anton Blanchard5827d412012-11-26 17:40:03 +00002014 prom.mmumap = 0;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002015}
2016
Paul Mackerrasa575b802005-10-23 17:23:21 +10002017#ifdef CONFIG_PPC32
2018/*
2019 * For really old powermacs, we need to map things we claim.
2020 * For that, we need the ihandle of the mmu.
Paul Mackerrasa23414b2005-11-10 12:00:55 +11002021 * Also, on the longtrail, we need to work around other bugs.
Paul Mackerrasa575b802005-10-23 17:23:21 +10002022 */
2023static void __init prom_find_mmu(void)
2024{
Paul Mackerrasa575b802005-10-23 17:23:21 +10002025 phandle oprom;
2026 char version[64];
2027
2028 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
2029 if (!PHANDLE_VALID(oprom))
2030 return;
2031 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
2032 return;
2033 version[sizeof(version) - 1] = 0;
Paul Mackerrasa575b802005-10-23 17:23:21 +10002034 /* XXX might need to add other versions here */
Paul Mackerrasa23414b2005-11-10 12:00:55 +11002035 if (strcmp(version, "Open Firmware, 1.0.5") == 0)
2036 of_workarounds = OF_WA_CLAIM;
2037 else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
2038 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
2039 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
2040 } else
Paul Mackerrasa575b802005-10-23 17:23:21 +10002041 return;
Anton Blanchard5827d412012-11-26 17:40:03 +00002042 prom.memory = call_prom("open", 1, 1, ADDR("/memory"));
2043 prom_getprop(prom.chosen, "mmu", &prom.mmumap,
2044 sizeof(prom.mmumap));
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002045 prom.mmumap = be32_to_cpu(prom.mmumap);
Anton Blanchard5827d412012-11-26 17:40:03 +00002046 if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap))
Paul Mackerrasa23414b2005-11-10 12:00:55 +11002047 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */
Paul Mackerrasa575b802005-10-23 17:23:21 +10002048}
2049#else
2050#define prom_find_mmu()
2051#endif
2052
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002053static void __init prom_init_stdout(void)
2054{
Anton Blanchard5827d412012-11-26 17:40:03 +00002055 char *path = of_stdout_device;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002056 char type[16];
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002057 phandle stdout_node;
2058 __be32 val;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002059
Anton Blanchard5827d412012-11-26 17:40:03 +00002060 if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002061 prom_panic("cannot find stdout");
2062
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002063 prom.stdout = be32_to_cpu(val);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002064
2065 /* Get the full OF pathname of the stdout device */
2066 memset(path, 0, 256);
Anton Blanchard5827d412012-11-26 17:40:03 +00002067 call_prom("instance-to-path", 3, 1, prom.stdout, path, 255);
Anton Blanchard5827d412012-11-26 17:40:03 +00002068 prom_printf("OF stdout device is: %s\n", of_stdout_device);
2069 prom_setprop(prom.chosen, "/chosen", "linux,stdout-path",
Paul Mackerrasa23414b2005-11-10 12:00:55 +11002070 path, strlen(path) + 1);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002071
Benjamin Herrenschmidt10348f52014-01-13 09:49:17 +11002072 /* instance-to-package fails on PA-Semi */
2073 stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout);
2074 if (stdout_node != PROM_ERROR) {
2075 val = cpu_to_be32(stdout_node);
2076 prom_setprop(prom.chosen, "/chosen", "linux,stdout-package",
2077 &val, sizeof(val));
2078
2079 /* If it's a display, note it */
2080 memset(type, 0, sizeof(type));
2081 prom_getprop(stdout_node, "device_type", type, sizeof(type));
2082 if (strcmp(type, "display") == 0)
2083 prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0);
2084 }
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002085}
2086
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002087static int __init prom_find_machine_type(void)
2088{
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002089 char compat[256];
2090 int len, i = 0;
Benjamin Herrenschmidt21fe3302005-11-07 16:41:59 +11002091#ifdef CONFIG_PPC64
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002092 phandle rtas;
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002093 int x;
Benjamin Herrenschmidt21fe3302005-11-07 16:41:59 +11002094#endif
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002095
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002096 /* Look for a PowerMac or a Cell */
Anton Blanchard5827d412012-11-26 17:40:03 +00002097 len = prom_getprop(prom.root, "compatible",
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002098 compat, sizeof(compat)-1);
2099 if (len > 0) {
2100 compat[len] = 0;
2101 while (i < len) {
2102 char *p = &compat[i];
2103 int sl = strlen(p);
2104 if (sl == 0)
2105 break;
Anton Blanchard5827d412012-11-26 17:40:03 +00002106 if (strstr(p, "Power Macintosh") ||
2107 strstr(p, "MacRISC"))
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002108 return PLATFORM_POWERMAC;
Arnd Bergmann133dda12006-06-07 12:04:18 +10002109#ifdef CONFIG_PPC64
2110 /* We must make sure we don't detect the IBM Cell
2111 * blades as pSeries due to some firmware issues,
2112 * so we do it here.
2113 */
Anton Blanchard5827d412012-11-26 17:40:03 +00002114 if (strstr(p, "IBM,CBEA") ||
2115 strstr(p, "IBM,CPBW-1.0"))
Arnd Bergmann133dda12006-06-07 12:04:18 +10002116 return PLATFORM_GENERIC;
2117#endif /* CONFIG_PPC64 */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002118 i += sl + 1;
2119 }
2120 }
2121#ifdef CONFIG_PPC64
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002122 /* Try to detect OPAL */
2123 if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
2124 return PLATFORM_OPAL;
2125
2126 /* Try to figure out if it's an IBM pSeries or any other
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002127 * PAPR compliant platform. We assume it is if :
2128 * - /device_type is "chrp" (please, do NOT use that for future
2129 * non-IBM designs !
2130 * - it has /rtas
2131 */
Anton Blanchard5827d412012-11-26 17:40:03 +00002132 len = prom_getprop(prom.root, "device_type",
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002133 compat, sizeof(compat)-1);
2134 if (len <= 0)
2135 return PLATFORM_GENERIC;
Anton Blanchard5827d412012-11-26 17:40:03 +00002136 if (strcmp(compat, "chrp"))
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002137 return PLATFORM_GENERIC;
2138
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002139 /* Default to pSeries. We need to know if we are running LPAR */
2140 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002141 if (!PHANDLE_VALID(rtas))
2142 return PLATFORM_GENERIC;
2143 x = prom_getproplen(rtas, "ibm,hypertas-functions");
2144 if (x != PROM_ERROR) {
Anton Blanchard4da727a2009-03-31 20:06:14 +00002145 prom_debug("Hypertas detected, assuming LPAR !\n");
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002146 return PLATFORM_PSERIES_LPAR;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002147 }
2148 return PLATFORM_PSERIES;
2149#else
Benjamin Herrenschmidte8222502006-03-28 23:15:54 +11002150 return PLATFORM_GENERIC;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002151#endif
2152}
2153
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002154static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
2155{
2156 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
2157}
2158
2159/*
2160 * If we have a display that we don't know how to drive,
2161 * we will want to try to execute OF's open method for it
2162 * later. However, OF will probably fall over if we do that
2163 * we've taken over the MMU.
2164 * So we check whether we will need to open the display,
2165 * and if so, open it now.
2166 */
2167static void __init prom_check_displays(void)
2168{
2169 char type[16], *path;
2170 phandle node;
2171 ihandle ih;
2172 int i;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002173
2174 static unsigned char default_colors[] = {
2175 0x00, 0x00, 0x00,
2176 0x00, 0x00, 0xaa,
2177 0x00, 0xaa, 0x00,
2178 0x00, 0xaa, 0xaa,
2179 0xaa, 0x00, 0x00,
2180 0xaa, 0x00, 0xaa,
2181 0xaa, 0xaa, 0x00,
2182 0xaa, 0xaa, 0xaa,
2183 0x55, 0x55, 0x55,
2184 0x55, 0x55, 0xff,
2185 0x55, 0xff, 0x55,
2186 0x55, 0xff, 0xff,
2187 0xff, 0x55, 0x55,
2188 0xff, 0x55, 0xff,
2189 0xff, 0xff, 0x55,
2190 0xff, 0xff, 0xff
2191 };
2192 const unsigned char *clut;
2193
Anton Blanchard4da727a2009-03-31 20:06:14 +00002194 prom_debug("Looking for displays\n");
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002195 for (node = 0; prom_next_node(&node); ) {
2196 memset(type, 0, sizeof(type));
2197 prom_getprop(node, "device_type", type, sizeof(type));
Anton Blanchard5827d412012-11-26 17:40:03 +00002198 if (strcmp(type, "display") != 0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002199 continue;
2200
2201 /* It seems OF doesn't null-terminate the path :-( */
Anton Blanchard5827d412012-11-26 17:40:03 +00002202 path = prom_scratch;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002203 memset(path, 0, PROM_SCRATCH_SIZE);
2204
2205 /*
2206 * leave some room at the end of the path for appending extra
2207 * arguments
2208 */
2209 if (call_prom("package-to-path", 3, 1, node, path,
2210 PROM_SCRATCH_SIZE-10) == PROM_ERROR)
2211 continue;
Anton Blanchard1f8737a2009-03-31 20:06:15 +00002212 prom_printf("found display : %s, opening... ", path);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002213
2214 ih = call_prom("open", 1, 1, path);
2215 if (ih == 0) {
2216 prom_printf("failed\n");
2217 continue;
2218 }
2219
2220 /* Success */
2221 prom_printf("done\n");
Paul Mackerrasa23414b2005-11-10 12:00:55 +11002222 prom_setprop(node, path, "linux,opened", NULL, 0);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002223
2224 /* Setup a usable color table when the appropriate
2225 * method is available. Should update this to set-colors */
Anton Blanchard5827d412012-11-26 17:40:03 +00002226 clut = default_colors;
Benjamin Herrenschmidt3f536382011-12-14 13:55:11 +00002227 for (i = 0; i < 16; i++, clut += 3)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002228 if (prom_set_color(ih, i, clut[0], clut[1],
2229 clut[2]) != 0)
2230 break;
2231
2232#ifdef CONFIG_LOGO_LINUX_CLUT224
Anton Blanchard5827d412012-11-26 17:40:03 +00002233 clut = PTRRELOC(logo_linux_clut224.clut);
2234 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002235 if (prom_set_color(ih, i + 32, clut[0], clut[1],
2236 clut[2]) != 0)
2237 break;
2238#endif /* CONFIG_LOGO_LINUX_CLUT224 */
Benjamin Herrenschmidt7191b612013-07-25 12:12:32 +10002239
2240#ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX
2241 if (prom_getprop(node, "linux,boot-display", NULL, 0) !=
2242 PROM_ERROR) {
2243 u32 width, height, pitch, addr;
2244
2245 prom_printf("Setting btext !\n");
2246 prom_getprop(node, "width", &width, 4);
2247 prom_getprop(node, "height", &height, 4);
2248 prom_getprop(node, "linebytes", &pitch, 4);
2249 prom_getprop(node, "address", &addr, 4);
2250 prom_printf("W=%d H=%d LB=%d addr=0x%x\n",
2251 width, height, pitch, addr);
2252 btext_setup_display(width, height, 8, pitch, addr);
2253 }
2254#endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002255 }
2256}
2257
2258
2259/* Return (relocated) pointer to this much memory: moves initrd if reqd. */
2260static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
2261 unsigned long needed, unsigned long align)
2262{
2263 void *ret;
2264
2265 *mem_start = _ALIGN(*mem_start, align);
2266 while ((*mem_start + needed) > *mem_end) {
2267 unsigned long room, chunk;
2268
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02002269 prom_debug("Chunk exhausted, claiming more at %lx...\n",
Anton Blanchard5827d412012-11-26 17:40:03 +00002270 alloc_bottom);
2271 room = alloc_top - alloc_bottom;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002272 if (room > DEVTREE_CHUNK_SIZE)
2273 room = DEVTREE_CHUNK_SIZE;
2274 if (room < PAGE_SIZE)
Anton Blanchardfbafd722011-07-25 20:47:51 +00002275 prom_panic("No memory for flatten_device_tree "
2276 "(no room)\n");
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002277 chunk = alloc_up(room, 0);
2278 if (chunk == 0)
Anton Blanchardfbafd722011-07-25 20:47:51 +00002279 prom_panic("No memory for flatten_device_tree "
2280 "(claim failed)\n");
Anton Blanchard966728d2011-07-25 20:47:07 +00002281 *mem_end = chunk + room;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002282 }
2283
2284 ret = (void *)*mem_start;
2285 *mem_start += needed;
2286
2287 return ret;
2288}
2289
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002290#define dt_push_token(token, mem_start, mem_end) do { \
2291 void *room = make_room(mem_start, mem_end, 4, 4); \
2292 *(__be32 *)room = cpu_to_be32(token); \
2293 } while(0)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002294
2295static unsigned long __init dt_find_string(char *str)
2296{
2297 char *s, *os;
2298
Anton Blanchard5827d412012-11-26 17:40:03 +00002299 s = os = (char *)dt_string_start;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002300 s += 4;
Anton Blanchard5827d412012-11-26 17:40:03 +00002301 while (s < (char *)dt_string_end) {
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002302 if (strcmp(s, str) == 0)
2303 return s - os;
2304 s += strlen(s) + 1;
2305 }
2306 return 0;
2307}
2308
2309/*
2310 * The Open Firmware 1275 specification states properties must be 31 bytes or
2311 * less, however not all firmwares obey this. Make it 64 bytes to be safe.
2312 */
2313#define MAX_PROPERTY_NAME 64
2314
2315static void __init scan_dt_build_strings(phandle node,
2316 unsigned long *mem_start,
2317 unsigned long *mem_end)
2318{
2319 char *prev_name, *namep, *sstart;
2320 unsigned long soff;
2321 phandle child;
2322
Anton Blanchard5827d412012-11-26 17:40:03 +00002323 sstart = (char *)dt_string_start;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002324
2325 /* get and store all property names */
Anton Blanchard5827d412012-11-26 17:40:03 +00002326 prev_name = "";
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002327 for (;;) {
2328 /* 64 is max len of name including nul. */
2329 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
2330 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
2331 /* No more nodes: unwind alloc */
2332 *mem_start = (unsigned long)namep;
2333 break;
2334 }
2335
2336 /* skip "name" */
Anton Blanchard5827d412012-11-26 17:40:03 +00002337 if (strcmp(namep, "name") == 0) {
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002338 *mem_start = (unsigned long)namep;
Anton Blanchard5827d412012-11-26 17:40:03 +00002339 prev_name = "name";
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002340 continue;
2341 }
2342 /* get/create string entry */
2343 soff = dt_find_string(namep);
2344 if (soff != 0) {
2345 *mem_start = (unsigned long)namep;
2346 namep = sstart + soff;
2347 } else {
2348 /* Trim off some if we can */
2349 *mem_start = (unsigned long)namep + strlen(namep) + 1;
Anton Blanchard5827d412012-11-26 17:40:03 +00002350 dt_string_end = *mem_start;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002351 }
2352 prev_name = namep;
2353 }
2354
2355 /* do all our children */
2356 child = call_prom("child", 1, 1, node);
2357 while (child != 0) {
2358 scan_dt_build_strings(child, mem_start, mem_end);
2359 child = call_prom("peer", 1, 1, child);
2360 }
2361}
2362
2363static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
2364 unsigned long *mem_end)
2365{
2366 phandle child;
2367 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
2368 unsigned long soff;
2369 unsigned char *valp;
2370 static char pname[MAX_PROPERTY_NAME];
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002371 int l, room, has_phandle = 0;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002372
2373 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
2374
2375 /* get the node's full name */
2376 namep = (char *)*mem_start;
Paul Mackerrasc49888202005-10-26 21:52:53 +10002377 room = *mem_end - *mem_start;
2378 if (room > 255)
2379 room = 255;
2380 l = call_prom("package-to-path", 3, 1, node, namep, room);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002381 if (l >= 0) {
2382 /* Didn't fit? Get more room. */
Paul Mackerrasc49888202005-10-26 21:52:53 +10002383 if (l >= room) {
2384 if (l >= *mem_end - *mem_start)
2385 namep = make_room(mem_start, mem_end, l+1, 1);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002386 call_prom("package-to-path", 3, 1, node, namep, l);
2387 }
2388 namep[l] = '\0';
2389
2390 /* Fixup an Apple bug where they have bogus \0 chars in the
Paul Mackerrasa575b802005-10-23 17:23:21 +10002391 * middle of the path in some properties, and extract
2392 * the unit name (everything after the last '/').
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002393 */
Paul Mackerrasa575b802005-10-23 17:23:21 +10002394 for (lp = p = namep, ep = namep + l; p < ep; p++) {
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002395 if (*p == '/')
Paul Mackerrasa575b802005-10-23 17:23:21 +10002396 lp = namep;
2397 else if (*p != 0)
2398 *lp++ = *p;
2399 }
2400 *lp = 0;
2401 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002402 }
2403
2404 /* get it again for debugging */
Anton Blanchard5827d412012-11-26 17:40:03 +00002405 path = prom_scratch;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002406 memset(path, 0, PROM_SCRATCH_SIZE);
2407 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
2408
2409 /* get and store all properties */
Anton Blanchard5827d412012-11-26 17:40:03 +00002410 prev_name = "";
2411 sstart = (char *)dt_string_start;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002412 for (;;) {
2413 if (call_prom("nextprop", 3, 1, node, prev_name,
Anton Blanchard5827d412012-11-26 17:40:03 +00002414 pname) != 1)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002415 break;
2416
2417 /* skip "name" */
Anton Blanchard5827d412012-11-26 17:40:03 +00002418 if (strcmp(pname, "name") == 0) {
2419 prev_name = "name";
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002420 continue;
2421 }
2422
2423 /* find string offset */
Anton Blanchard5827d412012-11-26 17:40:03 +00002424 soff = dt_find_string(pname);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002425 if (soff == 0) {
2426 prom_printf("WARNING: Can't find string index for"
Anton Blanchard5827d412012-11-26 17:40:03 +00002427 " <%s>, node %s\n", pname, path);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002428 break;
2429 }
2430 prev_name = sstart + soff;
2431
2432 /* get length */
Anton Blanchard5827d412012-11-26 17:40:03 +00002433 l = call_prom("getproplen", 2, 1, node, pname);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002434
2435 /* sanity checks */
2436 if (l == PROM_ERROR)
2437 continue;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002438
2439 /* push property head */
2440 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2441 dt_push_token(l, mem_start, mem_end);
2442 dt_push_token(soff, mem_start, mem_end);
2443
2444 /* push property content */
2445 valp = make_room(mem_start, mem_end, l, 4);
Anton Blanchard5827d412012-11-26 17:40:03 +00002446 call_prom("getprop", 4, 1, node, pname, valp, l);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002447 *mem_start = _ALIGN(*mem_start, 4);
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002448
Anton Blanchard5827d412012-11-26 17:40:03 +00002449 if (!strcmp(pname, "phandle"))
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002450 has_phandle = 1;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002451 }
2452
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002453 /* Add a "linux,phandle" property if no "phandle" property already
2454 * existed (can happen with OPAL)
2455 */
2456 if (!has_phandle) {
Anton Blanchard5827d412012-11-26 17:40:03 +00002457 soff = dt_find_string("linux,phandle");
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002458 if (soff == 0)
2459 prom_printf("WARNING: Can't find string index for"
2460 " <linux-phandle> node %s\n", path);
2461 else {
2462 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2463 dt_push_token(4, mem_start, mem_end);
2464 dt_push_token(soff, mem_start, mem_end);
2465 valp = make_room(mem_start, mem_end, 4, 4);
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002466 *(__be32 *)valp = cpu_to_be32(node);
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00002467 }
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002468 }
2469
2470 /* do all our children */
2471 child = call_prom("child", 1, 1, node);
2472 while (child != 0) {
2473 scan_dt_build_struct(child, mem_start, mem_end);
2474 child = call_prom("peer", 1, 1, child);
2475 }
2476
2477 dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2478}
2479
2480static void __init flatten_device_tree(void)
2481{
2482 phandle root;
2483 unsigned long mem_start, mem_end, room;
2484 struct boot_param_header *hdr;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002485 char *namep;
2486 u64 *rsvmap;
2487
2488 /*
2489 * Check how much room we have between alloc top & bottom (+/- a
Anton Blanchardfbafd722011-07-25 20:47:51 +00002490 * few pages), crop to 1MB, as this is our "chunk" size
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002491 */
Anton Blanchard5827d412012-11-26 17:40:03 +00002492 room = alloc_top - alloc_bottom - 0x4000;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002493 if (room > DEVTREE_CHUNK_SIZE)
2494 room = DEVTREE_CHUNK_SIZE;
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02002495 prom_debug("starting device tree allocs at %lx\n", alloc_bottom);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002496
2497 /* Now try to claim that */
2498 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2499 if (mem_start == 0)
2500 prom_panic("Can't allocate initial device-tree chunk\n");
Anton Blanchard966728d2011-07-25 20:47:07 +00002501 mem_end = mem_start + room;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002502
2503 /* Get root of tree */
2504 root = call_prom("peer", 1, 1, (phandle)0);
2505 if (root == (phandle)0)
2506 prom_panic ("couldn't get device tree root\n");
2507
2508 /* Build header and make room for mem rsv map */
2509 mem_start = _ALIGN(mem_start, 4);
2510 hdr = make_room(&mem_start, &mem_end,
2511 sizeof(struct boot_param_header), 4);
Anton Blanchard5827d412012-11-26 17:40:03 +00002512 dt_header_start = (unsigned long)hdr;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002513 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2514
2515 /* Start of strings */
2516 mem_start = PAGE_ALIGN(mem_start);
Anton Blanchard5827d412012-11-26 17:40:03 +00002517 dt_string_start = mem_start;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002518 mem_start += 4; /* hole */
2519
2520 /* Add "linux,phandle" in there, we'll need it */
2521 namep = make_room(&mem_start, &mem_end, 16, 1);
Anton Blanchard5827d412012-11-26 17:40:03 +00002522 strcpy(namep, "linux,phandle");
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002523 mem_start = (unsigned long)namep + strlen(namep) + 1;
2524
2525 /* Build string array */
2526 prom_printf("Building dt strings...\n");
2527 scan_dt_build_strings(root, &mem_start, &mem_end);
Anton Blanchard5827d412012-11-26 17:40:03 +00002528 dt_string_end = mem_start;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002529
2530 /* Build structure */
2531 mem_start = PAGE_ALIGN(mem_start);
Anton Blanchard5827d412012-11-26 17:40:03 +00002532 dt_struct_start = mem_start;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002533 prom_printf("Building dt structure...\n");
2534 scan_dt_build_struct(root, &mem_start, &mem_end);
2535 dt_push_token(OF_DT_END, &mem_start, &mem_end);
Anton Blanchard5827d412012-11-26 17:40:03 +00002536 dt_struct_end = PAGE_ALIGN(mem_start);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002537
2538 /* Finish header */
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002539 hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu);
2540 hdr->magic = cpu_to_be32(OF_DT_HEADER);
2541 hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start);
2542 hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start);
2543 hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start);
2544 hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start);
2545 hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start);
2546 hdr->version = cpu_to_be32(OF_DT_VERSION);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002547 /* Version 16 is not backward compatible */
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002548 hdr->last_comp_version = cpu_to_be32(0x10);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002549
Jimi Xenidis4d1f3f22006-05-18 17:03:05 -05002550 /* Copy the reserve map in */
Anton Blanchard5827d412012-11-26 17:40:03 +00002551 memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002552
2553#ifdef DEBUG_PROM
2554 {
2555 int i;
2556 prom_printf("reserved memory map:\n");
Anton Blanchard5827d412012-11-26 17:40:03 +00002557 for (i = 0; i < mem_reserve_cnt; i++)
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02002558 prom_printf(" %llx - %llx\n",
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002559 be64_to_cpu(mem_reserve_map[i].base),
2560 be64_to_cpu(mem_reserve_map[i].size));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002561 }
2562#endif
Jimi Xenidis4d1f3f22006-05-18 17:03:05 -05002563 /* Bump mem_reserve_cnt to cause further reservations to fail
2564 * since it's too late.
2565 */
Anton Blanchard5827d412012-11-26 17:40:03 +00002566 mem_reserve_cnt = MEM_RESERVE_MAP_SIZE;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002567
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02002568 prom_printf("Device tree strings 0x%lx -> 0x%lx\n",
Anton Blanchard5827d412012-11-26 17:40:03 +00002569 dt_string_start, dt_string_end);
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02002570 prom_printf("Device tree struct 0x%lx -> 0x%lx\n",
Anton Blanchard5827d412012-11-26 17:40:03 +00002571 dt_struct_start, dt_struct_end);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002572}
2573
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002574#ifdef CONFIG_PPC_MAPLE
2575/* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2576 * The values are bad, and it doesn't even have the right number of cells. */
2577static void __init fixup_device_tree_maple(void)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002578{
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002579 phandle isa;
Benjamin Herrenschmidt980a6512006-07-03 17:22:05 +10002580 u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002581 u32 isa_ranges[6];
Benjamin Herrenschmidt980a6512006-07-03 17:22:05 +10002582 char *name;
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002583
Benjamin Herrenschmidt980a6512006-07-03 17:22:05 +10002584 name = "/ht@0/isa@4";
2585 isa = call_prom("finddevice", 1, 1, ADDR(name));
2586 if (!PHANDLE_VALID(isa)) {
2587 name = "/ht@0/isa@6";
2588 isa = call_prom("finddevice", 1, 1, ADDR(name));
2589 rloc = 0x01003000; /* IO space; PCI device = 6 */
2590 }
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002591 if (!PHANDLE_VALID(isa))
2592 return;
2593
Benjamin Herrenschmidt980a6512006-07-03 17:22:05 +10002594 if (prom_getproplen(isa, "ranges") != 12)
2595 return;
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002596 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2597 == PROM_ERROR)
2598 return;
2599
2600 if (isa_ranges[0] != 0x1 ||
2601 isa_ranges[1] != 0xf4000000 ||
2602 isa_ranges[2] != 0x00010000)
2603 return;
2604
Benjamin Herrenschmidt980a6512006-07-03 17:22:05 +10002605 prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002606
2607 isa_ranges[0] = 0x1;
2608 isa_ranges[1] = 0x0;
Benjamin Herrenschmidt980a6512006-07-03 17:22:05 +10002609 isa_ranges[2] = rloc;
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002610 isa_ranges[3] = 0x0;
2611 isa_ranges[4] = 0x0;
2612 isa_ranges[5] = 0x00010000;
Benjamin Herrenschmidt980a6512006-07-03 17:22:05 +10002613 prom_setprop(isa, name, "ranges",
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002614 isa_ranges, sizeof(isa_ranges));
2615}
Harry Ciao8f101a02009-06-17 16:28:00 -07002616
2617#define CPC925_MC_START 0xf8000000
2618#define CPC925_MC_LENGTH 0x1000000
2619/* The values for memory-controller don't have right number of cells */
2620static void __init fixup_device_tree_maple_memory_controller(void)
2621{
2622 phandle mc;
2623 u32 mc_reg[4];
2624 char *name = "/hostbridge@f8000000";
Harry Ciao8f101a02009-06-17 16:28:00 -07002625 u32 ac, sc;
2626
2627 mc = call_prom("finddevice", 1, 1, ADDR(name));
2628 if (!PHANDLE_VALID(mc))
2629 return;
2630
2631 if (prom_getproplen(mc, "reg") != 8)
2632 return;
2633
Anton Blanchard5827d412012-11-26 17:40:03 +00002634 prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac));
2635 prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc));
Harry Ciao8f101a02009-06-17 16:28:00 -07002636 if ((ac != 2) || (sc != 2))
2637 return;
2638
2639 if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2640 return;
2641
2642 if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2643 return;
2644
2645 prom_printf("Fixing up bogus hostbridge on Maple...\n");
2646
2647 mc_reg[0] = 0x0;
2648 mc_reg[1] = CPC925_MC_START;
2649 mc_reg[2] = 0x0;
2650 mc_reg[3] = CPC925_MC_LENGTH;
2651 prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2652}
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002653#else
2654#define fixup_device_tree_maple()
Harry Ciao8f101a02009-06-17 16:28:00 -07002655#define fixup_device_tree_maple_memory_controller()
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002656#endif
2657
Benjamin Herrenschmidte8c0acf2006-07-04 14:06:29 +10002658#ifdef CONFIG_PPC_CHRP
Olaf Heringe4805922007-04-04 18:20:04 +02002659/*
2660 * Pegasos and BriQ lacks the "ranges" property in the isa node
2661 * Pegasos needs decimal IRQ 14/15, not hexadecimal
Olaf Hering556ecf92007-08-18 04:27:17 +10002662 * Pegasos has the IDE configured in legacy mode, but advertised as native
Olaf Heringe4805922007-04-04 18:20:04 +02002663 */
Benjamin Herrenschmidte8c0acf2006-07-04 14:06:29 +10002664static void __init fixup_device_tree_chrp(void)
2665{
Olaf Heringe4805922007-04-04 18:20:04 +02002666 phandle ph;
2667 u32 prop[6];
Benjamin Herrenschmidt26c50322006-07-04 14:16:28 +10002668 u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
Benjamin Herrenschmidte8c0acf2006-07-04 14:06:29 +10002669 char *name;
2670 int rc;
2671
2672 name = "/pci@80000000/isa@c";
Olaf Heringe4805922007-04-04 18:20:04 +02002673 ph = call_prom("finddevice", 1, 1, ADDR(name));
2674 if (!PHANDLE_VALID(ph)) {
Benjamin Herrenschmidt26c50322006-07-04 14:16:28 +10002675 name = "/pci@ff500000/isa@6";
Olaf Heringe4805922007-04-04 18:20:04 +02002676 ph = call_prom("finddevice", 1, 1, ADDR(name));
Benjamin Herrenschmidt26c50322006-07-04 14:16:28 +10002677 rloc = 0x01003000; /* IO space; PCI device = 6 */
2678 }
Olaf Heringe4805922007-04-04 18:20:04 +02002679 if (PHANDLE_VALID(ph)) {
2680 rc = prom_getproplen(ph, "ranges");
2681 if (rc == 0 || rc == PROM_ERROR) {
2682 prom_printf("Fixing up missing ISA range on Pegasos...\n");
Benjamin Herrenschmidte8c0acf2006-07-04 14:06:29 +10002683
Olaf Heringe4805922007-04-04 18:20:04 +02002684 prop[0] = 0x1;
2685 prop[1] = 0x0;
2686 prop[2] = rloc;
2687 prop[3] = 0x0;
2688 prop[4] = 0x0;
2689 prop[5] = 0x00010000;
2690 prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2691 }
2692 }
Benjamin Herrenschmidte8c0acf2006-07-04 14:06:29 +10002693
Olaf Heringe4805922007-04-04 18:20:04 +02002694 name = "/pci@80000000/ide@C,1";
2695 ph = call_prom("finddevice", 1, 1, ADDR(name));
2696 if (PHANDLE_VALID(ph)) {
2697 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2698 prop[0] = 14;
2699 prop[1] = 0x0;
Olaf Hering556ecf92007-08-18 04:27:17 +10002700 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2701 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2702 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2703 if (rc == sizeof(u32)) {
2704 prop[0] &= ~0x5;
2705 prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2706 }
Olaf Heringe4805922007-04-04 18:20:04 +02002707 }
Benjamin Herrenschmidte8c0acf2006-07-04 14:06:29 +10002708}
2709#else
2710#define fixup_device_tree_chrp()
2711#endif
2712
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002713#if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002714static void __init fixup_device_tree_pmac(void)
2715{
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002716 phandle u3, i2c, mpic;
2717 u32 u3_rev;
2718 u32 interrupts[2];
2719 u32 parent;
2720
2721 /* Some G5s have a missing interrupt definition, fix it up here */
2722 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2723 if (!PHANDLE_VALID(u3))
2724 return;
2725 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2726 if (!PHANDLE_VALID(i2c))
2727 return;
2728 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2729 if (!PHANDLE_VALID(mpic))
2730 return;
2731
2732 /* check if proper rev of u3 */
2733 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2734 == PROM_ERROR)
2735 return;
Benjamin Herrenschmidt7d496972005-11-07 14:36:21 +11002736 if (u3_rev < 0x35 || u3_rev > 0x39)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002737 return;
2738 /* does it need fixup ? */
2739 if (prom_getproplen(i2c, "interrupts") > 0)
2740 return;
2741
2742 prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2743
2744 /* interrupt on this revision of u3 is number 0 and level */
2745 interrupts[0] = 0;
2746 interrupts[1] = 1;
Paul Mackerrasa23414b2005-11-10 12:00:55 +11002747 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2748 &interrupts, sizeof(interrupts));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002749 parent = (u32)mpic;
Paul Mackerrasa23414b2005-11-10 12:00:55 +11002750 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2751 &parent, sizeof(parent));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002752}
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002753#else
2754#define fixup_device_tree_pmac()
2755#endif
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002756
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002757#ifdef CONFIG_PPC_EFIKA
Grant Likely94d2dde2008-01-24 22:25:32 -07002758/*
2759 * The MPC5200 FEC driver requires an phy-handle property to tell it how
2760 * to talk to the phy. If the phy-handle property is missing, then this
2761 * function is called to add the appropriate nodes and link it to the
2762 * ethernet node.
2763 */
2764static void __init fixup_device_tree_efika_add_phy(void)
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002765{
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002766 u32 node;
2767 char prop[64];
Grant Likely94d2dde2008-01-24 22:25:32 -07002768 int rv;
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002769
Grant Likely94d2dde2008-01-24 22:25:32 -07002770 /* Check if /builtin/ethernet exists - bail if it doesn't */
2771 node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002772 if (!PHANDLE_VALID(node))
2773 return;
2774
Grant Likely94d2dde2008-01-24 22:25:32 -07002775 /* Check if the phy-handle property exists - bail if it does */
2776 rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2777 if (!rv)
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002778 return;
2779
Grant Likely94d2dde2008-01-24 22:25:32 -07002780 /*
2781 * At this point the ethernet device doesn't have a phy described.
2782 * Now we need to add the missing phy node and linkage
2783 */
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002784
Grant Likely94d2dde2008-01-24 22:25:32 -07002785 /* Check for an MDIO bus node - if missing then create one */
Olaf Hering6f4347c2008-01-10 01:06:08 +11002786 node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2787 if (!PHANDLE_VALID(node)) {
2788 prom_printf("Adding Ethernet MDIO node\n");
2789 call_prom("interpret", 1, 1,
2790 " s\" /builtin\" find-device"
2791 " new-device"
2792 " 1 encode-int s\" #address-cells\" property"
2793 " 0 encode-int s\" #size-cells\" property"
Grant Likely94d2dde2008-01-24 22:25:32 -07002794 " s\" mdio\" device-name"
2795 " s\" fsl,mpc5200b-mdio\" encode-string"
Olaf Hering6f4347c2008-01-10 01:06:08 +11002796 " s\" compatible\" property"
2797 " 0xf0003000 0x400 reg"
2798 " 0x2 encode-int"
2799 " 0x5 encode-int encode+"
2800 " 0x3 encode-int encode+"
2801 " s\" interrupts\" property"
2802 " finish-device");
2803 };
2804
Grant Likely94d2dde2008-01-24 22:25:32 -07002805 /* Check for a PHY device node - if missing then create one and
2806 * give it's phandle to the ethernet node */
2807 node = call_prom("finddevice", 1, 1,
2808 ADDR("/builtin/mdio/ethernet-phy"));
Olaf Hering6f4347c2008-01-10 01:06:08 +11002809 if (!PHANDLE_VALID(node)) {
2810 prom_printf("Adding Ethernet PHY node\n");
2811 call_prom("interpret", 1, 1,
2812 " s\" /builtin/mdio\" find-device"
2813 " new-device"
2814 " s\" ethernet-phy\" device-name"
2815 " 0x10 encode-int s\" reg\" property"
2816 " my-self"
2817 " ihandle>phandle"
2818 " finish-device"
2819 " s\" /builtin/ethernet\" find-device"
2820 " encode-int"
2821 " s\" phy-handle\" property"
2822 " device-end");
2823 }
Grant Likely94d2dde2008-01-24 22:25:32 -07002824}
Olaf Hering6f4347c2008-01-10 01:06:08 +11002825
Grant Likely94d2dde2008-01-24 22:25:32 -07002826static void __init fixup_device_tree_efika(void)
2827{
2828 int sound_irq[3] = { 2, 2, 0 };
2829 int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2830 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2831 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2832 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2833 u32 node;
2834 char prop[64];
2835 int rv, len;
2836
2837 /* Check if we're really running on a EFIKA */
2838 node = call_prom("finddevice", 1, 1, ADDR("/"));
2839 if (!PHANDLE_VALID(node))
2840 return;
2841
2842 rv = prom_getprop(node, "model", prop, sizeof(prop));
2843 if (rv == PROM_ERROR)
2844 return;
2845 if (strcmp(prop, "EFIKA5K2"))
2846 return;
2847
2848 prom_printf("Applying EFIKA device tree fixups\n");
2849
2850 /* Claiming to be 'chrp' is death */
2851 node = call_prom("finddevice", 1, 1, ADDR("/"));
2852 rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2853 if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2854 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2855
David Woodhouse7f4392c2008-04-14 02:52:38 +10002856 /* CODEGEN,description is exposed in /proc/cpuinfo so
2857 fix that too */
2858 rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2859 if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2860 prom_setprop(node, "/", "CODEGEN,description",
2861 "Efika 5200B PowerPC System",
2862 sizeof("Efika 5200B PowerPC System"));
2863
Grant Likely94d2dde2008-01-24 22:25:32 -07002864 /* Fixup bestcomm interrupts property */
2865 node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2866 if (PHANDLE_VALID(node)) {
2867 len = prom_getproplen(node, "interrupts");
2868 if (len == 12) {
2869 prom_printf("Fixing bestcomm interrupts property\n");
2870 prom_setprop(node, "/builtin/bestcom", "interrupts",
2871 bcomm_irq, sizeof(bcomm_irq));
2872 }
2873 }
2874
2875 /* Fixup sound interrupts property */
2876 node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2877 if (PHANDLE_VALID(node)) {
2878 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2879 if (rv == PROM_ERROR) {
2880 prom_printf("Adding sound interrupts property\n");
2881 prom_setprop(node, "/builtin/sound", "interrupts",
2882 sound_irq, sizeof(sound_irq));
2883 }
2884 }
2885
2886 /* Make sure ethernet phy-handle property exists */
2887 fixup_device_tree_efika_add_phy();
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002888}
2889#else
2890#define fixup_device_tree_efika()
2891#endif
2892
Darren Stevens50246782016-08-31 13:24:40 +01002893#ifdef CONFIG_PPC_PASEMI_NEMO
2894/*
2895 * CFE supplied on Nemo is broken in several ways, biggest
2896 * problem is that it reassigns ISA interrupts to unused mpic ints.
2897 * Add an interrupt-controller property for the io-bridge to use
2898 * and correct the ints so we can attach them to an irq_domain
2899 */
2900static void __init fixup_device_tree_pasemi(void)
2901{
2902 u32 interrupts[2], parent, rval, val = 0;
2903 char *name, *pci_name;
2904 phandle iob, node;
2905
2906 /* Find the root pci node */
2907 name = "/pxp@0,e0000000";
2908 iob = call_prom("finddevice", 1, 1, ADDR(name));
2909 if (!PHANDLE_VALID(iob))
2910 return;
2911
2912 /* check if interrupt-controller node set yet */
2913 if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR)
2914 return;
2915
2916 prom_printf("adding interrupt-controller property for SB600...\n");
2917
2918 prom_setprop(iob, name, "interrupt-controller", &val, 0);
2919
2920 pci_name = "/pxp@0,e0000000/pci@11";
2921 node = call_prom("finddevice", 1, 1, ADDR(pci_name));
2922 parent = ADDR(iob);
2923
2924 for( ; prom_next_node(&node); ) {
2925 /* scan each node for one with an interrupt */
2926 if (!PHANDLE_VALID(node))
2927 continue;
2928
2929 rval = prom_getproplen(node, "interrupts");
2930 if (rval == 0 || rval == PROM_ERROR)
2931 continue;
2932
2933 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts));
2934 if ((interrupts[0] < 212) || (interrupts[0] > 222))
2935 continue;
2936
2937 /* found a node, update both interrupts and interrupt-parent */
2938 if ((interrupts[0] >= 212) && (interrupts[0] <= 215))
2939 interrupts[0] -= 203;
2940 if ((interrupts[0] >= 216) && (interrupts[0] <= 220))
2941 interrupts[0] -= 213;
2942 if (interrupts[0] == 221)
2943 interrupts[0] = 14;
2944 if (interrupts[0] == 222)
2945 interrupts[0] = 8;
2946
2947 prom_setprop(node, pci_name, "interrupts", interrupts,
2948 sizeof(interrupts));
2949 prom_setprop(node, pci_name, "interrupt-parent", &parent,
2950 sizeof(parent));
2951 }
Darren Stevens687e16b2016-08-31 13:24:45 +01002952
2953 /*
2954 * The io-bridge has device_type set to 'io-bridge' change it to 'isa'
2955 * so that generic isa-bridge code can add the SB600 and its on-board
2956 * peripherals.
2957 */
2958 name = "/pxp@0,e0000000/io-bridge@0";
2959 iob = call_prom("finddevice", 1, 1, ADDR(name));
2960 if (!PHANDLE_VALID(iob))
2961 return;
2962
2963 /* device_type is already set, just change it. */
2964
2965 prom_printf("Changing device_type of SB600 node...\n");
2966
2967 prom_setprop(iob, name, "device_type", "isa", sizeof("isa"));
Darren Stevens50246782016-08-31 13:24:40 +01002968}
2969#else /* !CONFIG_PPC_PASEMI_NEMO */
2970static inline void fixup_device_tree_pasemi(void) { }
2971#endif
2972
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002973static void __init fixup_device_tree(void)
2974{
2975 fixup_device_tree_maple();
Harry Ciao8f101a02009-06-17 16:28:00 -07002976 fixup_device_tree_maple_memory_controller();
Benjamin Herrenschmidte8c0acf2006-07-04 14:06:29 +10002977 fixup_device_tree_chrp();
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002978 fixup_device_tree_pmac();
Sylvain Munaut88fd2a92007-02-12 23:13:20 +01002979 fixup_device_tree_efika();
Darren Stevens50246782016-08-31 13:24:40 +01002980 fixup_device_tree_pasemi();
Hollis Blanchard54f4ee12006-05-25 16:36:53 -05002981}
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002982
2983static void __init prom_find_boot_cpu(void)
2984{
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002985 __be32 rval;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002986 ihandle prom_cpu;
2987 phandle cpu_pkg;
2988
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002989 rval = 0;
2990 if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0)
Paul Mackerrasa575b802005-10-23 17:23:21 +10002991 return;
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002992 prom_cpu = be32_to_cpu(rval);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10002993
2994 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2995
Darren Stevensaf2b7fa2017-01-23 19:42:54 +00002996 if (!PHANDLE_VALID(cpu_pkg))
2997 return;
2998
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10002999 prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
3000 prom.cpu = be32_to_cpu(rval);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003001
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02003002 prom_debug("Booting CPU hw index = %d\n", prom.cpu);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003003}
3004
3005static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
3006{
3007#ifdef CONFIG_BLK_DEV_INITRD
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003008 if (r3 && r4 && r4 != 0xdeadbeef) {
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003009 __be64 val;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003010
Anton Blanchard5827d412012-11-26 17:40:03 +00003011 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3;
3012 prom_initrd_end = prom_initrd_start + r4;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003013
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003014 val = cpu_to_be64(prom_initrd_start);
Anton Blanchard5827d412012-11-26 17:40:03 +00003015 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start",
Paul Mackerrasa23414b2005-11-10 12:00:55 +11003016 &val, sizeof(val));
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003017 val = cpu_to_be64(prom_initrd_end);
Anton Blanchard5827d412012-11-26 17:40:03 +00003018 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end",
Paul Mackerrasa23414b2005-11-10 12:00:55 +11003019 &val, sizeof(val));
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003020
Anton Blanchard5827d412012-11-26 17:40:03 +00003021 reserve_mem(prom_initrd_start,
3022 prom_initrd_end - prom_initrd_start);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003023
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02003024 prom_debug("initrd_start=0x%lx\n", prom_initrd_start);
3025 prom_debug("initrd_end=0x%lx\n", prom_initrd_end);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003026 }
3027#endif /* CONFIG_BLK_DEV_INITRD */
3028}
3029
Anton Blanchard5ac47f72012-11-26 17:39:03 +00003030#ifdef CONFIG_PPC64
3031#ifdef CONFIG_RELOCATABLE
3032static void reloc_toc(void)
3033{
3034}
3035
3036static void unreloc_toc(void)
3037{
3038}
3039#else
Anton Blanchard16744002013-03-12 01:51:51 +00003040static void __reloc_toc(unsigned long offset, unsigned long nr_entries)
Anton Blanchard5ac47f72012-11-26 17:39:03 +00003041{
3042 unsigned long i;
Anton Blanchard16744002013-03-12 01:51:51 +00003043 unsigned long *toc_entry;
3044
3045 /* Get the start of the TOC by using r2 directly. */
3046 asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry));
Anton Blanchard5ac47f72012-11-26 17:39:03 +00003047
3048 for (i = 0; i < nr_entries; i++) {
3049 *toc_entry = *toc_entry + offset;
3050 toc_entry++;
3051 }
3052}
3053
3054static void reloc_toc(void)
3055{
3056 unsigned long offset = reloc_offset();
3057 unsigned long nr_entries =
3058 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3059
Anton Blanchard16744002013-03-12 01:51:51 +00003060 __reloc_toc(offset, nr_entries);
Anton Blanchard5ac47f72012-11-26 17:39:03 +00003061
3062 mb();
3063}
3064
3065static void unreloc_toc(void)
3066{
3067 unsigned long offset = reloc_offset();
3068 unsigned long nr_entries =
3069 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3070
3071 mb();
3072
Anton Blanchard16744002013-03-12 01:51:51 +00003073 __reloc_toc(-offset, nr_entries);
Anton Blanchard5ac47f72012-11-26 17:39:03 +00003074}
3075#endif
3076#endif
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003077
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003078/*
3079 * We enter here early on, when the Open Firmware prom is still
3080 * handling exceptions and the MMU hash table for us.
3081 */
3082
3083unsigned long __init prom_init(unsigned long r3, unsigned long r4,
3084 unsigned long pp,
Paul Mackerras549e8152008-08-30 11:43:47 +10003085 unsigned long r6, unsigned long r7,
3086 unsigned long kbase)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003087{
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003088 unsigned long hdr;
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003089
3090#ifdef CONFIG_PPC32
Paul Mackerras549e8152008-08-30 11:43:47 +10003091 unsigned long offset = reloc_offset();
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003092 reloc_got2(offset);
Anton Blanchard5ac47f72012-11-26 17:39:03 +00003093#else
3094 reloc_toc();
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003095#endif
3096
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003097 /*
3098 * First zero the BSS
3099 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003100 memset(&__bss_start, 0, __bss_stop - __bss_start);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003101
3102 /*
3103 * Init interface to Open Firmware, get some node references,
3104 * like /chosen
3105 */
3106 prom_init_client_services(pp);
3107
3108 /*
Paul Mackerrasa23414b2005-11-10 12:00:55 +11003109 * See if this OF is old enough that we need to do explicit maps
3110 * and other workarounds
3111 */
3112 prom_find_mmu();
3113
3114 /*
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003115 * Init prom stdout device
3116 */
3117 prom_init_stdout();
3118
Anton Blanchard5827d412012-11-26 17:40:03 +00003119 prom_printf("Preparing to boot %s", linux_banner);
Michael Ellermane7943fb2009-03-04 19:02:01 +00003120
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003121 /*
3122 * Get default machine type. At this point, we do not differentiate
3123 * between pSeries SMP and pSeries LPAR
3124 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003125 of_platform = prom_find_machine_type();
3126 prom_printf("Detected machine type: %x\n", of_platform);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003127
Suzuki Poulose0f890c82011-12-14 22:57:15 +00003128#ifndef CONFIG_NONSTATIC_KERNEL
Olaf Heringadd60ef2006-03-23 22:03:57 +01003129 /* Bail if this is a kdump kernel. */
3130 if (PHYSICAL_START > 0)
3131 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
Paul Mackerras549e8152008-08-30 11:43:47 +10003132#endif
Olaf Heringadd60ef2006-03-23 22:03:57 +01003133
3134 /*
3135 * Check for an initrd
3136 */
3137 prom_check_initrd(r3, r4);
3138
Suraj Jitindar Singh12cc9fd2017-02-28 17:03:47 +11003139 /*
3140 * Do early parsing of command line
3141 */
3142 early_cmdline_parse();
3143
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003144#if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003145 /*
3146 * On pSeries, inform the firmware about our capabilities
3147 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003148 if (of_platform == PLATFORM_PSERIES ||
3149 of_platform == PLATFORM_PSERIES_LPAR)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003150 prom_send_capabilities();
3151#endif
3152
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003153 /*
Arnd Bergmannf3f66f52005-10-31 20:08:37 -05003154 * Copy the CPU hold code
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003155 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003156 if (of_platform != PLATFORM_POWERMAC)
Paul Mackerras549e8152008-08-30 11:43:47 +10003157 copy_and_flush(0, kbase, 0x100, 0);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003158
3159 /*
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003160 * Initialize memory management within prom_init
3161 */
3162 prom_init_mem();
3163
3164 /*
3165 * Determine which cpu is actually running right _now_
3166 */
3167 prom_find_boot_cpu();
3168
3169 /*
3170 * Initialize display devices
3171 */
3172 prom_check_displays();
3173
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003174#if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003175 /*
3176 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
3177 * that uses the allocator, we need to make sure we get the top of memory
3178 * available for us here...
3179 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003180 if (of_platform == PLATFORM_PSERIES)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003181 prom_initialize_tce_table();
3182#endif
3183
3184 /*
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003185 * On non-powermacs, try to instantiate RTAS. PowerMacs don't
3186 * have a usable RTAS implementation.
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003187 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003188 if (of_platform != PLATFORM_POWERMAC &&
3189 of_platform != PLATFORM_OPAL)
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003190 prom_instantiate_rtas();
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003191
3192#ifdef CONFIG_PPC_POWERNV
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003193 if (of_platform == PLATFORM_OPAL)
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00003194 prom_instantiate_opal();
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003195#endif /* CONFIG_PPC_POWERNV */
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003196
Ashley Lai4a727422012-08-14 18:34:57 -05003197#ifdef CONFIG_PPC64
3198 /* instantiate sml */
3199 prom_instantiate_sml();
3200#endif
3201
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003202 /*
3203 * On non-powermacs, put all CPUs in spin-loops.
3204 *
3205 * PowerMacs use a different mechanism to spin CPUs
Benjamin Herrenschmidtdbe78b42013-09-25 14:02:50 +10003206 *
3207 * (This must be done after instanciating RTAS)
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003208 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003209 if (of_platform != PLATFORM_POWERMAC &&
3210 of_platform != PLATFORM_OPAL)
Benjamin Herrenschmidt27f44882011-09-19 18:27:58 +00003211 prom_hold_cpus();
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003212
3213 /*
3214 * Fill in some infos for use by the kernel later on
3215 */
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003216 if (prom_memory_limit) {
3217 __be64 val = cpu_to_be64(prom_memory_limit);
Anton Blanchard5827d412012-11-26 17:40:03 +00003218 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit",
Benjamin Herrenschmidt493adff2013-08-07 02:01:38 +10003219 &val, sizeof(val));
3220 }
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003221#ifdef CONFIG_PPC64
Anton Blanchard5827d412012-11-26 17:40:03 +00003222 if (prom_iommu_off)
3223 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off",
Paul Mackerrasa23414b2005-11-10 12:00:55 +11003224 NULL, 0);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003225
Anton Blanchard5827d412012-11-26 17:40:03 +00003226 if (prom_iommu_force_on)
3227 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on",
Paul Mackerrasa23414b2005-11-10 12:00:55 +11003228 NULL, 0);
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003229
Anton Blanchard5827d412012-11-26 17:40:03 +00003230 if (prom_tce_alloc_start) {
3231 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start",
3232 &prom_tce_alloc_start,
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003233 sizeof(prom_tce_alloc_start));
Anton Blanchard5827d412012-11-26 17:40:03 +00003234 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end",
3235 &prom_tce_alloc_end,
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003236 sizeof(prom_tce_alloc_end));
3237 }
3238#endif
3239
3240 /*
3241 * Fixup any known bugs in the device-tree
3242 */
3243 fixup_device_tree();
3244
3245 /*
3246 * Now finally create the flattened device-tree
3247 */
Anton Blanchard1f8737a2009-03-31 20:06:15 +00003248 prom_printf("copying OF device tree...\n");
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003249 flatten_device_tree();
3250
Paul Mackerras3825ac02005-11-08 22:48:08 +11003251 /*
3252 * in case stdin is USB and still active on IBM machines...
3253 * Unfortunately quiesce crashes on some powermacs if we have
Benjamin Herrenschmidt40dfef62011-11-29 18:22:56 +00003254 * closed stdin already (in particular the powerbook 101). It
3255 * appears that the OPAL version of OFW doesn't like it either.
Paul Mackerras3825ac02005-11-08 22:48:08 +11003256 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003257 if (of_platform != PLATFORM_POWERMAC &&
3258 of_platform != PLATFORM_OPAL)
Paul Mackerras3825ac02005-11-08 22:48:08 +11003259 prom_close_stdin();
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003260
3261 /*
3262 * Call OF "quiesce" method to shut down pending DMA's from
3263 * devices etc...
3264 */
Michael Ellerman7e862d72015-03-30 17:38:09 +11003265 prom_printf("Quiescing Open Firmware ...\n");
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003266 call_prom("quiesce", 0, 0);
3267
3268 /*
3269 * And finally, call the kernel passing it the flattened device
3270 * tree and NULL as r5, thus triggering the new entry point which
3271 * is common to us and kexec
3272 */
Anton Blanchard5827d412012-11-26 17:40:03 +00003273 hdr = dt_header_start;
Benjamin Herrenschmidt40dfef62011-11-29 18:22:56 +00003274
3275 /* Don't print anything after quiesce under OPAL, it crashes OFW */
Anton Blanchard5827d412012-11-26 17:40:03 +00003276 if (of_platform != PLATFORM_OPAL) {
Benjamin Herrenschmidt7d70c632016-08-10 17:29:29 +10003277 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase);
Mathieu Malaterre7eda3182018-04-06 22:12:19 +02003278 prom_debug("->dt_header_start=0x%lx\n", hdr);
Benjamin Herrenschmidt40dfef62011-11-29 18:22:56 +00003279 }
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003280
3281#ifdef CONFIG_PPC32
3282 reloc_got2(-offset);
Anton Blanchard5ac47f72012-11-26 17:39:03 +00003283#else
3284 unreloc_toc();
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003285#endif
3286
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00003287#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
3288 /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
3289 __start(hdr, kbase, 0, 0, 0,
Anton Blanchard5827d412012-11-26 17:40:03 +00003290 prom_opal_base, prom_opal_entry);
Benjamin Herrenschmidt6e35d5d2011-09-19 18:28:01 +00003291#else
3292 __start(hdr, kbase, 0, 0, 0, 0, 0);
3293#endif
Paul Mackerras9b6b5632005-10-06 12:06:20 +10003294
3295 return 0;
3296}