xref: /openbmc/linux/arch/s390/kernel/setup.c (revision 31b90347)
1 /*
2  *  S390 version
3  *    Copyright IBM Corp. 1999, 2012
4  *    Author(s): Hartmut Penner (hp@de.ibm.com),
5  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
6  *
7  *  Derived from "arch/i386/kernel/setup.c"
8  *    Copyright (C) 1995, Linus Torvalds
9  */
10 
11 /*
12  * This file handles the architecture-dependent parts of initialization
13  */
14 
15 #define KMSG_COMPONENT "setup"
16 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
17 
18 #include <linux/errno.h>
19 #include <linux/export.h>
20 #include <linux/sched.h>
21 #include <linux/kernel.h>
22 #include <linux/memblock.h>
23 #include <linux/mm.h>
24 #include <linux/stddef.h>
25 #include <linux/unistd.h>
26 #include <linux/ptrace.h>
27 #include <linux/user.h>
28 #include <linux/tty.h>
29 #include <linux/ioport.h>
30 #include <linux/delay.h>
31 #include <linux/init.h>
32 #include <linux/initrd.h>
33 #include <linux/bootmem.h>
34 #include <linux/root_dev.h>
35 #include <linux/console.h>
36 #include <linux/kernel_stat.h>
37 #include <linux/device.h>
38 #include <linux/notifier.h>
39 #include <linux/pfn.h>
40 #include <linux/ctype.h>
41 #include <linux/reboot.h>
42 #include <linux/topology.h>
43 #include <linux/ftrace.h>
44 #include <linux/kexec.h>
45 #include <linux/crash_dump.h>
46 #include <linux/memory.h>
47 #include <linux/compat.h>
48 
49 #include <asm/ipl.h>
50 #include <asm/uaccess.h>
51 #include <asm/facility.h>
52 #include <asm/smp.h>
53 #include <asm/mmu_context.h>
54 #include <asm/cpcmd.h>
55 #include <asm/lowcore.h>
56 #include <asm/irq.h>
57 #include <asm/page.h>
58 #include <asm/ptrace.h>
59 #include <asm/sections.h>
60 #include <asm/ebcdic.h>
61 #include <asm/kvm_virtio.h>
62 #include <asm/diag.h>
63 #include <asm/os_info.h>
64 #include <asm/sclp.h>
65 #include "entry.h"
66 
67 /*
68  * User copy operations.
69  */
70 struct uaccess_ops uaccess;
71 EXPORT_SYMBOL(uaccess);
72 
73 /*
74  * Machine setup..
75  */
76 unsigned int console_mode = 0;
77 EXPORT_SYMBOL(console_mode);
78 
79 unsigned int console_devno = -1;
80 EXPORT_SYMBOL(console_devno);
81 
82 unsigned int console_irq = -1;
83 EXPORT_SYMBOL(console_irq);
84 
85 unsigned long elf_hwcap = 0;
86 char elf_platform[ELF_PLATFORM_SIZE];
87 
88 struct mem_chunk __initdata memory_chunk[MEMORY_CHUNKS];
89 
90 int __initdata memory_end_set;
91 unsigned long __initdata memory_end;
92 
93 unsigned long VMALLOC_START;
94 EXPORT_SYMBOL(VMALLOC_START);
95 
96 unsigned long VMALLOC_END;
97 EXPORT_SYMBOL(VMALLOC_END);
98 
99 struct page *vmemmap;
100 EXPORT_SYMBOL(vmemmap);
101 
102 #ifdef CONFIG_64BIT
103 unsigned long MODULES_VADDR;
104 unsigned long MODULES_END;
105 #endif
106 
107 /* An array with a pointer to the lowcore of every CPU. */
108 struct _lowcore *lowcore_ptr[NR_CPUS];
109 EXPORT_SYMBOL(lowcore_ptr);
110 
111 /*
112  * This is set up by the setup-routine at boot-time
113  * for S390 need to find out, what we have to setup
114  * using address 0x10400 ...
115  */
116 
117 #include <asm/setup.h>
118 
119 /*
120  * condev= and conmode= setup parameter.
121  */
122 
123 static int __init condev_setup(char *str)
124 {
125 	int vdev;
126 
127 	vdev = simple_strtoul(str, &str, 0);
128 	if (vdev >= 0 && vdev < 65536) {
129 		console_devno = vdev;
130 		console_irq = -1;
131 	}
132 	return 1;
133 }
134 
135 __setup("condev=", condev_setup);
136 
137 static void __init set_preferred_console(void)
138 {
139 	if (MACHINE_IS_KVM) {
140 		if (sclp_has_vt220())
141 			add_preferred_console("ttyS", 1, NULL);
142 		else if (sclp_has_linemode())
143 			add_preferred_console("ttyS", 0, NULL);
144 		else
145 			add_preferred_console("hvc", 0, NULL);
146 	} else if (CONSOLE_IS_3215 || CONSOLE_IS_SCLP)
147 		add_preferred_console("ttyS", 0, NULL);
148 	else if (CONSOLE_IS_3270)
149 		add_preferred_console("tty3270", 0, NULL);
150 }
151 
152 static int __init conmode_setup(char *str)
153 {
154 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
155 	if (strncmp(str, "hwc", 4) == 0 || strncmp(str, "sclp", 5) == 0)
156                 SET_CONSOLE_SCLP;
157 #endif
158 #if defined(CONFIG_TN3215_CONSOLE)
159 	if (strncmp(str, "3215", 5) == 0)
160 		SET_CONSOLE_3215;
161 #endif
162 #if defined(CONFIG_TN3270_CONSOLE)
163 	if (strncmp(str, "3270", 5) == 0)
164 		SET_CONSOLE_3270;
165 #endif
166 	set_preferred_console();
167         return 1;
168 }
169 
170 __setup("conmode=", conmode_setup);
171 
172 static void __init conmode_default(void)
173 {
174 	char query_buffer[1024];
175 	char *ptr;
176 
177         if (MACHINE_IS_VM) {
178 		cpcmd("QUERY CONSOLE", query_buffer, 1024, NULL);
179 		console_devno = simple_strtoul(query_buffer + 5, NULL, 16);
180 		ptr = strstr(query_buffer, "SUBCHANNEL =");
181 		console_irq = simple_strtoul(ptr + 13, NULL, 16);
182 		cpcmd("QUERY TERM", query_buffer, 1024, NULL);
183 		ptr = strstr(query_buffer, "CONMODE");
184 		/*
185 		 * Set the conmode to 3215 so that the device recognition
186 		 * will set the cu_type of the console to 3215. If the
187 		 * conmode is 3270 and we don't set it back then both
188 		 * 3215 and the 3270 driver will try to access the console
189 		 * device (3215 as console and 3270 as normal tty).
190 		 */
191 		cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
192 		if (ptr == NULL) {
193 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
194 			SET_CONSOLE_SCLP;
195 #endif
196 			return;
197 		}
198 		if (strncmp(ptr + 8, "3270", 4) == 0) {
199 #if defined(CONFIG_TN3270_CONSOLE)
200 			SET_CONSOLE_3270;
201 #elif defined(CONFIG_TN3215_CONSOLE)
202 			SET_CONSOLE_3215;
203 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
204 			SET_CONSOLE_SCLP;
205 #endif
206 		} else if (strncmp(ptr + 8, "3215", 4) == 0) {
207 #if defined(CONFIG_TN3215_CONSOLE)
208 			SET_CONSOLE_3215;
209 #elif defined(CONFIG_TN3270_CONSOLE)
210 			SET_CONSOLE_3270;
211 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
212 			SET_CONSOLE_SCLP;
213 #endif
214 		}
215 	} else {
216 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
217 		SET_CONSOLE_SCLP;
218 #endif
219 	}
220 }
221 
222 #ifdef CONFIG_ZFCPDUMP
223 static void __init setup_zfcpdump(void)
224 {
225 	if (ipl_info.type != IPL_TYPE_FCP_DUMP)
226 		return;
227 	if (OLDMEM_BASE)
228 		return;
229 	strcat(boot_command_line, " cio_ignore=all,!ipldev,!condev");
230 	console_loglevel = 2;
231 }
232 #else
233 static inline void setup_zfcpdump(void) {}
234 #endif /* CONFIG_ZFCPDUMP */
235 
236  /*
237  * Reboot, halt and power_off stubs. They just call _machine_restart,
238  * _machine_halt or _machine_power_off.
239  */
240 
241 void machine_restart(char *command)
242 {
243 	if ((!in_interrupt() && !in_atomic()) || oops_in_progress)
244 		/*
245 		 * Only unblank the console if we are called in enabled
246 		 * context or a bust_spinlocks cleared the way for us.
247 		 */
248 		console_unblank();
249 	_machine_restart(command);
250 }
251 
252 void machine_halt(void)
253 {
254 	if (!in_interrupt() || oops_in_progress)
255 		/*
256 		 * Only unblank the console if we are called in enabled
257 		 * context or a bust_spinlocks cleared the way for us.
258 		 */
259 		console_unblank();
260 	_machine_halt();
261 }
262 
263 void machine_power_off(void)
264 {
265 	if (!in_interrupt() || oops_in_progress)
266 		/*
267 		 * Only unblank the console if we are called in enabled
268 		 * context or a bust_spinlocks cleared the way for us.
269 		 */
270 		console_unblank();
271 	_machine_power_off();
272 }
273 
274 /*
275  * Dummy power off function.
276  */
277 void (*pm_power_off)(void) = machine_power_off;
278 EXPORT_SYMBOL_GPL(pm_power_off);
279 
280 static int __init early_parse_mem(char *p)
281 {
282 	memory_end = memparse(p, &p);
283 	memory_end_set = 1;
284 	return 0;
285 }
286 early_param("mem", early_parse_mem);
287 
288 static int __init parse_vmalloc(char *arg)
289 {
290 	if (!arg)
291 		return -EINVAL;
292 	VMALLOC_END = (memparse(arg, &arg) + PAGE_SIZE - 1) & PAGE_MASK;
293 	return 0;
294 }
295 early_param("vmalloc", parse_vmalloc);
296 
297 static int __init early_parse_user_mode(char *p)
298 {
299 	if (!p || strcmp(p, "primary") == 0)
300 		return 0;
301 	return 1;
302 }
303 early_param("user_mode", early_parse_user_mode);
304 
305 void *restart_stack __attribute__((__section__(".data")));
306 
307 static void __init setup_lowcore(void)
308 {
309 	struct _lowcore *lc;
310 
311 	/*
312 	 * Setup lowcore for boot cpu
313 	 */
314 	BUILD_BUG_ON(sizeof(struct _lowcore) != LC_PAGES * 4096);
315 	lc = __alloc_bootmem_low(LC_PAGES * PAGE_SIZE, LC_PAGES * PAGE_SIZE, 0);
316 	lc->restart_psw.mask = PSW_KERNEL_BITS;
317 	lc->restart_psw.addr =
318 		PSW_ADDR_AMODE | (unsigned long) restart_int_handler;
319 	lc->external_new_psw.mask = PSW_KERNEL_BITS |
320 		PSW_MASK_DAT | PSW_MASK_MCHECK;
321 	lc->external_new_psw.addr =
322 		PSW_ADDR_AMODE | (unsigned long) ext_int_handler;
323 	lc->svc_new_psw.mask = PSW_KERNEL_BITS |
324 		PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
325 	lc->svc_new_psw.addr = PSW_ADDR_AMODE | (unsigned long) system_call;
326 	lc->program_new_psw.mask = PSW_KERNEL_BITS |
327 		PSW_MASK_DAT | PSW_MASK_MCHECK;
328 	lc->program_new_psw.addr =
329 		PSW_ADDR_AMODE | (unsigned long) pgm_check_handler;
330 	lc->mcck_new_psw.mask = PSW_KERNEL_BITS;
331 	lc->mcck_new_psw.addr =
332 		PSW_ADDR_AMODE | (unsigned long) mcck_int_handler;
333 	lc->io_new_psw.mask = PSW_KERNEL_BITS |
334 		PSW_MASK_DAT | PSW_MASK_MCHECK;
335 	lc->io_new_psw.addr = PSW_ADDR_AMODE | (unsigned long) io_int_handler;
336 	lc->clock_comparator = -1ULL;
337 	lc->kernel_stack = ((unsigned long) &init_thread_union)
338 		+ THREAD_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);
339 	lc->async_stack = (unsigned long)
340 		__alloc_bootmem(ASYNC_SIZE, ASYNC_SIZE, 0)
341 		+ ASYNC_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);
342 	lc->panic_stack = (unsigned long)
343 		__alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0)
344 		+ PAGE_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);
345 	lc->current_task = (unsigned long) init_thread_union.thread_info.task;
346 	lc->thread_info = (unsigned long) &init_thread_union;
347 	lc->machine_flags = S390_lowcore.machine_flags;
348 	lc->stfl_fac_list = S390_lowcore.stfl_fac_list;
349 	memcpy(lc->stfle_fac_list, S390_lowcore.stfle_fac_list,
350 	       MAX_FACILITY_BIT/8);
351 #ifndef CONFIG_64BIT
352 	if (MACHINE_HAS_IEEE) {
353 		lc->extended_save_area_addr = (__u32)
354 			__alloc_bootmem_low(PAGE_SIZE, PAGE_SIZE, 0);
355 		/* enable extended save area */
356 		__ctl_set_bit(14, 29);
357 	}
358 #else
359 	lc->vdso_per_cpu_data = (unsigned long) &lc->paste[0];
360 #endif
361 	lc->sync_enter_timer = S390_lowcore.sync_enter_timer;
362 	lc->async_enter_timer = S390_lowcore.async_enter_timer;
363 	lc->exit_timer = S390_lowcore.exit_timer;
364 	lc->user_timer = S390_lowcore.user_timer;
365 	lc->system_timer = S390_lowcore.system_timer;
366 	lc->steal_timer = S390_lowcore.steal_timer;
367 	lc->last_update_timer = S390_lowcore.last_update_timer;
368 	lc->last_update_clock = S390_lowcore.last_update_clock;
369 	lc->ftrace_func = S390_lowcore.ftrace_func;
370 
371 	restart_stack = __alloc_bootmem(ASYNC_SIZE, ASYNC_SIZE, 0);
372 	restart_stack += ASYNC_SIZE;
373 
374 	/*
375 	 * Set up PSW restart to call ipl.c:do_restart(). Copy the relevant
376 	 * restart data to the absolute zero lowcore. This is necesary if
377 	 * PSW restart is done on an offline CPU that has lowcore zero.
378 	 */
379 	lc->restart_stack = (unsigned long) restart_stack;
380 	lc->restart_fn = (unsigned long) do_restart;
381 	lc->restart_data = 0;
382 	lc->restart_source = -1UL;
383 
384 	/* Setup absolute zero lowcore */
385 	mem_assign_absolute(S390_lowcore.restart_stack, lc->restart_stack);
386 	mem_assign_absolute(S390_lowcore.restart_fn, lc->restart_fn);
387 	mem_assign_absolute(S390_lowcore.restart_data, lc->restart_data);
388 	mem_assign_absolute(S390_lowcore.restart_source, lc->restart_source);
389 	mem_assign_absolute(S390_lowcore.restart_psw, lc->restart_psw);
390 
391 	set_prefix((u32)(unsigned long) lc);
392 	lowcore_ptr[0] = lc;
393 }
394 
395 static struct resource code_resource = {
396 	.name  = "Kernel code",
397 	.flags = IORESOURCE_BUSY | IORESOURCE_MEM,
398 };
399 
400 static struct resource data_resource = {
401 	.name = "Kernel data",
402 	.flags = IORESOURCE_BUSY | IORESOURCE_MEM,
403 };
404 
405 static struct resource bss_resource = {
406 	.name = "Kernel bss",
407 	.flags = IORESOURCE_BUSY | IORESOURCE_MEM,
408 };
409 
410 static struct resource __initdata *standard_resources[] = {
411 	&code_resource,
412 	&data_resource,
413 	&bss_resource,
414 };
415 
416 static void __init setup_resources(void)
417 {
418 	struct resource *res, *std_res, *sub_res;
419 	int i, j;
420 
421 	code_resource.start = (unsigned long) &_text;
422 	code_resource.end = (unsigned long) &_etext - 1;
423 	data_resource.start = (unsigned long) &_etext;
424 	data_resource.end = (unsigned long) &_edata - 1;
425 	bss_resource.start = (unsigned long) &__bss_start;
426 	bss_resource.end = (unsigned long) &__bss_stop - 1;
427 
428 	for (i = 0; i < MEMORY_CHUNKS; i++) {
429 		if (!memory_chunk[i].size)
430 			continue;
431 		res = alloc_bootmem_low(sizeof(*res));
432 		res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
433 		switch (memory_chunk[i].type) {
434 		case CHUNK_READ_WRITE:
435 			res->name = "System RAM";
436 			break;
437 		case CHUNK_READ_ONLY:
438 			res->name = "System ROM";
439 			res->flags |= IORESOURCE_READONLY;
440 			break;
441 		default:
442 			res->name = "reserved";
443 		}
444 		res->start = memory_chunk[i].addr;
445 		res->end = res->start + memory_chunk[i].size - 1;
446 		request_resource(&iomem_resource, res);
447 
448 		for (j = 0; j < ARRAY_SIZE(standard_resources); j++) {
449 			std_res = standard_resources[j];
450 			if (std_res->start < res->start ||
451 			    std_res->start > res->end)
452 				continue;
453 			if (std_res->end > res->end) {
454 				sub_res = alloc_bootmem_low(sizeof(*sub_res));
455 				*sub_res = *std_res;
456 				sub_res->end = res->end;
457 				std_res->start = res->end + 1;
458 				request_resource(res, sub_res);
459 			} else {
460 				request_resource(res, std_res);
461 			}
462 		}
463 	}
464 }
465 
466 static void __init setup_memory_end(void)
467 {
468 	unsigned long vmax, vmalloc_size, tmp;
469 	unsigned long real_memory_size = 0;
470 	int i;
471 
472 
473 #ifdef CONFIG_ZFCPDUMP
474 	if (ipl_info.type == IPL_TYPE_FCP_DUMP &&
475 	    !OLDMEM_BASE && sclp_get_hsa_size()) {
476 		memory_end = sclp_get_hsa_size();
477 		memory_end_set = 1;
478 	}
479 #endif
480 	memory_end &= PAGE_MASK;
481 
482 	/*
483 	 * Make sure all chunks are MAX_ORDER aligned so we don't need the
484 	 * extra checks that HOLES_IN_ZONE would require.
485 	 */
486 	for (i = 0; i < MEMORY_CHUNKS; i++) {
487 		unsigned long start, end;
488 		struct mem_chunk *chunk;
489 		unsigned long align;
490 
491 		chunk = &memory_chunk[i];
492 		if (!chunk->size)
493 			continue;
494 		align = 1UL << (MAX_ORDER + PAGE_SHIFT - 1);
495 		start = (chunk->addr + align - 1) & ~(align - 1);
496 		end = (chunk->addr + chunk->size) & ~(align - 1);
497 		if (start >= end)
498 			memset(chunk, 0, sizeof(*chunk));
499 		else {
500 			chunk->addr = start;
501 			chunk->size = end - start;
502 		}
503 		real_memory_size = max(real_memory_size,
504 				       chunk->addr + chunk->size);
505 	}
506 
507 	/* Choose kernel address space layout: 2, 3, or 4 levels. */
508 #ifdef CONFIG_64BIT
509 	vmalloc_size = VMALLOC_END ?: (128UL << 30) - MODULES_LEN;
510 	tmp = (memory_end ?: real_memory_size) / PAGE_SIZE;
511 	tmp = tmp * (sizeof(struct page) + PAGE_SIZE) + vmalloc_size;
512 	if (tmp <= (1UL << 42))
513 		vmax = 1UL << 42;	/* 3-level kernel page table */
514 	else
515 		vmax = 1UL << 53;	/* 4-level kernel page table */
516 	/* module area is at the end of the kernel address space. */
517 	MODULES_END = vmax;
518 	MODULES_VADDR = MODULES_END - MODULES_LEN;
519 	VMALLOC_END = MODULES_VADDR;
520 #else
521 	vmalloc_size = VMALLOC_END ?: 96UL << 20;
522 	vmax = 1UL << 31;		/* 2-level kernel page table */
523 	/* vmalloc area is at the end of the kernel address space. */
524 	VMALLOC_END = vmax;
525 #endif
526 	VMALLOC_START = vmax - vmalloc_size;
527 
528 	/* Split remaining virtual space between 1:1 mapping & vmemmap array */
529 	tmp = VMALLOC_START / (PAGE_SIZE + sizeof(struct page));
530 	/* vmemmap contains a multiple of PAGES_PER_SECTION struct pages */
531 	tmp = SECTION_ALIGN_UP(tmp);
532 	tmp = VMALLOC_START - tmp * sizeof(struct page);
533 	tmp &= ~((vmax >> 11) - 1);	/* align to page table level */
534 	tmp = min(tmp, 1UL << MAX_PHYSMEM_BITS);
535 	vmemmap = (struct page *) tmp;
536 
537 	/* Take care that memory_end is set and <= vmemmap */
538 	memory_end = min(memory_end ?: real_memory_size, tmp);
539 
540 	/* Fixup memory chunk array to fit into 0..memory_end */
541 	for (i = 0; i < MEMORY_CHUNKS; i++) {
542 		struct mem_chunk *chunk = &memory_chunk[i];
543 
544 		if (!chunk->size)
545 			continue;
546 		if (chunk->addr >= memory_end) {
547 			memset(chunk, 0, sizeof(*chunk));
548 			continue;
549 		}
550 		if (chunk->addr + chunk->size > memory_end)
551 			chunk->size = memory_end - chunk->addr;
552 	}
553 }
554 
555 static void __init setup_vmcoreinfo(void)
556 {
557 	mem_assign_absolute(S390_lowcore.vmcore_info, paddr_vmcoreinfo_note());
558 }
559 
560 #ifdef CONFIG_CRASH_DUMP
561 
562 /*
563  * Find suitable location for crashkernel memory
564  */
565 static unsigned long __init find_crash_base(unsigned long crash_size,
566 					    char **msg)
567 {
568 	unsigned long crash_base;
569 	struct mem_chunk *chunk;
570 	int i;
571 
572 	if (memory_chunk[0].size < crash_size) {
573 		*msg = "first memory chunk must be at least crashkernel size";
574 		return 0;
575 	}
576 	if (OLDMEM_BASE && crash_size == OLDMEM_SIZE)
577 		return OLDMEM_BASE;
578 
579 	for (i = MEMORY_CHUNKS - 1; i >= 0; i--) {
580 		chunk = &memory_chunk[i];
581 		if (chunk->size == 0)
582 			continue;
583 		if (chunk->type != CHUNK_READ_WRITE)
584 			continue;
585 		if (chunk->size < crash_size)
586 			continue;
587 		crash_base = (chunk->addr + chunk->size) - crash_size;
588 		if (crash_base < crash_size)
589 			continue;
590 		if (crash_base < sclp_get_hsa_size())
591 			continue;
592 		if (crash_base < (unsigned long) INITRD_START + INITRD_SIZE)
593 			continue;
594 		return crash_base;
595 	}
596 	*msg = "no suitable area found";
597 	return 0;
598 }
599 
600 /*
601  * Check if crash_base and crash_size is valid
602  */
603 static int __init verify_crash_base(unsigned long crash_base,
604 				    unsigned long crash_size,
605 				    char **msg)
606 {
607 	struct mem_chunk *chunk;
608 	int i;
609 
610 	/*
611 	 * Because we do the swap to zero, we must have at least 'crash_size'
612 	 * bytes free space before crash_base
613 	 */
614 	if (crash_size > crash_base) {
615 		*msg = "crashkernel offset must be greater than size";
616 		return -EINVAL;
617 	}
618 
619 	/* First memory chunk must be at least crash_size */
620 	if (memory_chunk[0].size < crash_size) {
621 		*msg = "first memory chunk must be at least crashkernel size";
622 		return -EINVAL;
623 	}
624 	/* Check if we fit into the respective memory chunk */
625 	for (i = 0; i < MEMORY_CHUNKS; i++) {
626 		chunk = &memory_chunk[i];
627 		if (chunk->size == 0)
628 			continue;
629 		if (crash_base < chunk->addr)
630 			continue;
631 		if (crash_base >= chunk->addr + chunk->size)
632 			continue;
633 		/* we have found the memory chunk */
634 		if (crash_base + crash_size > chunk->addr + chunk->size) {
635 			*msg = "selected memory chunk is too small for "
636 				"crashkernel memory";
637 			return -EINVAL;
638 		}
639 		return 0;
640 	}
641 	*msg = "invalid memory range specified";
642 	return -EINVAL;
643 }
644 
645 /*
646  * When kdump is enabled, we have to ensure that no memory from
647  * the area [0 - crashkernel memory size] and
648  * [crashk_res.start - crashk_res.end] is set offline.
649  */
650 static int kdump_mem_notifier(struct notifier_block *nb,
651 			      unsigned long action, void *data)
652 {
653 	struct memory_notify *arg = data;
654 
655 	if (arg->start_pfn < PFN_DOWN(resource_size(&crashk_res)))
656 		return NOTIFY_BAD;
657 	if (arg->start_pfn > PFN_DOWN(crashk_res.end))
658 		return NOTIFY_OK;
659 	if (arg->start_pfn + arg->nr_pages - 1 < PFN_DOWN(crashk_res.start))
660 		return NOTIFY_OK;
661 	return NOTIFY_BAD;
662 }
663 
664 static struct notifier_block kdump_mem_nb = {
665 	.notifier_call = kdump_mem_notifier,
666 };
667 
668 #endif
669 
670 /*
671  * Make sure that oldmem, where the dump is stored, is protected
672  */
673 static void reserve_oldmem(void)
674 {
675 #ifdef CONFIG_CRASH_DUMP
676 	unsigned long real_size = 0;
677 	int i;
678 
679 	if (!OLDMEM_BASE)
680 		return;
681 	for (i = 0; i < MEMORY_CHUNKS; i++) {
682 		struct mem_chunk *chunk = &memory_chunk[i];
683 
684 		real_size = max(real_size, chunk->addr + chunk->size);
685 	}
686 	create_mem_hole(memory_chunk, OLDMEM_BASE, OLDMEM_SIZE);
687 	create_mem_hole(memory_chunk, OLDMEM_SIZE, real_size - OLDMEM_SIZE);
688 #endif
689 }
690 
691 /*
692  * Reserve memory for kdump kernel to be loaded with kexec
693  */
694 static void __init reserve_crashkernel(void)
695 {
696 #ifdef CONFIG_CRASH_DUMP
697 	unsigned long long crash_base, crash_size;
698 	char *msg = NULL;
699 	int rc;
700 
701 	rc = parse_crashkernel(boot_command_line, memory_end, &crash_size,
702 			       &crash_base);
703 	if (rc || crash_size == 0)
704 		return;
705 	crash_base = ALIGN(crash_base, KEXEC_CRASH_MEM_ALIGN);
706 	crash_size = ALIGN(crash_size, KEXEC_CRASH_MEM_ALIGN);
707 	if (register_memory_notifier(&kdump_mem_nb))
708 		return;
709 	if (!crash_base)
710 		crash_base = find_crash_base(crash_size, &msg);
711 	if (!crash_base) {
712 		pr_info("crashkernel reservation failed: %s\n", msg);
713 		unregister_memory_notifier(&kdump_mem_nb);
714 		return;
715 	}
716 	if (verify_crash_base(crash_base, crash_size, &msg)) {
717 		pr_info("crashkernel reservation failed: %s\n", msg);
718 		unregister_memory_notifier(&kdump_mem_nb);
719 		return;
720 	}
721 	if (!OLDMEM_BASE && MACHINE_IS_VM)
722 		diag10_range(PFN_DOWN(crash_base), PFN_DOWN(crash_size));
723 	crashk_res.start = crash_base;
724 	crashk_res.end = crash_base + crash_size - 1;
725 	insert_resource(&iomem_resource, &crashk_res);
726 	create_mem_hole(memory_chunk, crash_base, crash_size);
727 	pr_info("Reserving %lluMB of memory at %lluMB "
728 		"for crashkernel (System RAM: %luMB)\n",
729 		crash_size >> 20, crash_base >> 20, memory_end >> 20);
730 	os_info_crashkernel_add(crash_base, crash_size);
731 #endif
732 }
733 
734 static void __init setup_memory(void)
735 {
736         unsigned long bootmap_size;
737 	unsigned long start_pfn, end_pfn;
738 	int i;
739 
740 	/*
741 	 * partially used pages are not usable - thus
742 	 * we are rounding upwards:
743 	 */
744 	start_pfn = PFN_UP(__pa(&_end));
745 	end_pfn = max_pfn = PFN_DOWN(memory_end);
746 
747 #ifdef CONFIG_BLK_DEV_INITRD
748 	/*
749 	 * Move the initrd in case the bitmap of the bootmem allocater
750 	 * would overwrite it.
751 	 */
752 
753 	if (INITRD_START && INITRD_SIZE) {
754 		unsigned long bmap_size;
755 		unsigned long start;
756 
757 		bmap_size = bootmem_bootmap_pages(end_pfn - start_pfn + 1);
758 		bmap_size = PFN_PHYS(bmap_size);
759 
760 		if (PFN_PHYS(start_pfn) + bmap_size > INITRD_START) {
761 			start = PFN_PHYS(start_pfn) + bmap_size + PAGE_SIZE;
762 
763 #ifdef CONFIG_CRASH_DUMP
764 			if (OLDMEM_BASE) {
765 				/* Move initrd behind kdump oldmem */
766 				if (start + INITRD_SIZE > OLDMEM_BASE &&
767 				    start < OLDMEM_BASE + OLDMEM_SIZE)
768 					start = OLDMEM_BASE + OLDMEM_SIZE;
769 			}
770 #endif
771 			if (start + INITRD_SIZE > memory_end) {
772 				pr_err("initrd extends beyond end of "
773 				       "memory (0x%08lx > 0x%08lx) "
774 				       "disabling initrd\n",
775 				       start + INITRD_SIZE, memory_end);
776 				INITRD_START = INITRD_SIZE = 0;
777 			} else {
778 				pr_info("Moving initrd (0x%08lx -> "
779 					"0x%08lx, size: %ld)\n",
780 					INITRD_START, start, INITRD_SIZE);
781 				memmove((void *) start, (void *) INITRD_START,
782 					INITRD_SIZE);
783 				INITRD_START = start;
784 			}
785 		}
786 	}
787 #endif
788 
789 	/*
790 	 * Initialize the boot-time allocator
791 	 */
792 	bootmap_size = init_bootmem(start_pfn, end_pfn);
793 
794 	/*
795 	 * Register RAM areas with the bootmem allocator.
796 	 */
797 
798 	for (i = 0; i < MEMORY_CHUNKS; i++) {
799 		unsigned long start_chunk, end_chunk, pfn;
800 
801 		if (!memory_chunk[i].size)
802 			continue;
803 		start_chunk = PFN_DOWN(memory_chunk[i].addr);
804 		end_chunk = start_chunk + PFN_DOWN(memory_chunk[i].size);
805 		end_chunk = min(end_chunk, end_pfn);
806 		if (start_chunk >= end_chunk)
807 			continue;
808 		memblock_add_node(PFN_PHYS(start_chunk),
809 				  PFN_PHYS(end_chunk - start_chunk), 0);
810 		pfn = max(start_chunk, start_pfn);
811 		storage_key_init_range(PFN_PHYS(pfn), PFN_PHYS(end_chunk));
812 	}
813 
814 	psw_set_key(PAGE_DEFAULT_KEY);
815 
816 	free_bootmem_with_active_regions(0, max_pfn);
817 
818 	/*
819 	 * Reserve memory used for lowcore/command line/kernel image.
820 	 */
821 	reserve_bootmem(0, (unsigned long)_ehead, BOOTMEM_DEFAULT);
822 	reserve_bootmem((unsigned long)_stext,
823 			PFN_PHYS(start_pfn) - (unsigned long)_stext,
824 			BOOTMEM_DEFAULT);
825 	/*
826 	 * Reserve the bootmem bitmap itself as well. We do this in two
827 	 * steps (first step was init_bootmem()) because this catches
828 	 * the (very unlikely) case of us accidentally initializing the
829 	 * bootmem allocator with an invalid RAM area.
830 	 */
831 	reserve_bootmem(start_pfn << PAGE_SHIFT, bootmap_size,
832 			BOOTMEM_DEFAULT);
833 
834 #ifdef CONFIG_CRASH_DUMP
835 	if (crashk_res.start)
836 		reserve_bootmem(crashk_res.start,
837 				crashk_res.end - crashk_res.start + 1,
838 				BOOTMEM_DEFAULT);
839 	if (is_kdump_kernel())
840 		reserve_bootmem(elfcorehdr_addr - OLDMEM_BASE,
841 				PAGE_ALIGN(elfcorehdr_size), BOOTMEM_DEFAULT);
842 #endif
843 #ifdef CONFIG_BLK_DEV_INITRD
844 	if (INITRD_START && INITRD_SIZE) {
845 		if (INITRD_START + INITRD_SIZE <= memory_end) {
846 			reserve_bootmem(INITRD_START, INITRD_SIZE,
847 					BOOTMEM_DEFAULT);
848 			initrd_start = INITRD_START;
849 			initrd_end = initrd_start + INITRD_SIZE;
850 		} else {
851 			pr_err("initrd extends beyond end of "
852 			       "memory (0x%08lx > 0x%08lx) "
853 			       "disabling initrd\n",
854 			       initrd_start + INITRD_SIZE, memory_end);
855 			initrd_start = initrd_end = 0;
856 		}
857 	}
858 #endif
859 }
860 
861 /*
862  * Setup hardware capabilities.
863  */
864 static void __init setup_hwcaps(void)
865 {
866 	static const int stfl_bits[6] = { 0, 2, 7, 17, 19, 21 };
867 	struct cpuid cpu_id;
868 	int i;
869 
870 	/*
871 	 * The store facility list bits numbers as found in the principles
872 	 * of operation are numbered with bit 1UL<<31 as number 0 to
873 	 * bit 1UL<<0 as number 31.
874 	 *   Bit 0: instructions named N3, "backported" to esa-mode
875 	 *   Bit 2: z/Architecture mode is active
876 	 *   Bit 7: the store-facility-list-extended facility is installed
877 	 *   Bit 17: the message-security assist is installed
878 	 *   Bit 19: the long-displacement facility is installed
879 	 *   Bit 21: the extended-immediate facility is installed
880 	 *   Bit 22: extended-translation facility 3 is installed
881 	 *   Bit 30: extended-translation facility 3 enhancement facility
882 	 * These get translated to:
883 	 *   HWCAP_S390_ESAN3 bit 0, HWCAP_S390_ZARCH bit 1,
884 	 *   HWCAP_S390_STFLE bit 2, HWCAP_S390_MSA bit 3,
885 	 *   HWCAP_S390_LDISP bit 4, HWCAP_S390_EIMM bit 5 and
886 	 *   HWCAP_S390_ETF3EH bit 8 (22 && 30).
887 	 */
888 	for (i = 0; i < 6; i++)
889 		if (test_facility(stfl_bits[i]))
890 			elf_hwcap |= 1UL << i;
891 
892 	if (test_facility(22) && test_facility(30))
893 		elf_hwcap |= HWCAP_S390_ETF3EH;
894 
895 	/*
896 	 * Check for additional facilities with store-facility-list-extended.
897 	 * stfle stores doublewords (8 byte) with bit 1ULL<<63 as bit 0
898 	 * and 1ULL<<0 as bit 63. Bits 0-31 contain the same information
899 	 * as stored by stfl, bits 32-xxx contain additional facilities.
900 	 * How many facility words are stored depends on the number of
901 	 * doublewords passed to the instruction. The additional facilities
902 	 * are:
903 	 *   Bit 42: decimal floating point facility is installed
904 	 *   Bit 44: perform floating point operation facility is installed
905 	 * translated to:
906 	 *   HWCAP_S390_DFP bit 6 (42 && 44).
907 	 */
908 	if ((elf_hwcap & (1UL << 2)) && test_facility(42) && test_facility(44))
909 		elf_hwcap |= HWCAP_S390_DFP;
910 
911 	/*
912 	 * Huge page support HWCAP_S390_HPAGE is bit 7.
913 	 */
914 	if (MACHINE_HAS_HPAGE)
915 		elf_hwcap |= HWCAP_S390_HPAGE;
916 
917 #if defined(CONFIG_64BIT)
918 	/*
919 	 * 64-bit register support for 31-bit processes
920 	 * HWCAP_S390_HIGH_GPRS is bit 9.
921 	 */
922 	elf_hwcap |= HWCAP_S390_HIGH_GPRS;
923 
924 	/*
925 	 * Transactional execution support HWCAP_S390_TE is bit 10.
926 	 */
927 	if (test_facility(50) && test_facility(73))
928 		elf_hwcap |= HWCAP_S390_TE;
929 #endif
930 
931 	get_cpu_id(&cpu_id);
932 	switch (cpu_id.machine) {
933 	case 0x9672:
934 #if !defined(CONFIG_64BIT)
935 	default:	/* Use "g5" as default for 31 bit kernels. */
936 #endif
937 		strcpy(elf_platform, "g5");
938 		break;
939 	case 0x2064:
940 	case 0x2066:
941 #if defined(CONFIG_64BIT)
942 	default:	/* Use "z900" as default for 64 bit kernels. */
943 #endif
944 		strcpy(elf_platform, "z900");
945 		break;
946 	case 0x2084:
947 	case 0x2086:
948 		strcpy(elf_platform, "z990");
949 		break;
950 	case 0x2094:
951 	case 0x2096:
952 		strcpy(elf_platform, "z9-109");
953 		break;
954 	case 0x2097:
955 	case 0x2098:
956 		strcpy(elf_platform, "z10");
957 		break;
958 	case 0x2817:
959 	case 0x2818:
960 		strcpy(elf_platform, "z196");
961 		break;
962 	case 0x2827:
963 	case 0x2828:
964 		strcpy(elf_platform, "zEC12");
965 		break;
966 	}
967 }
968 
969 /*
970  * Setup function called from init/main.c just after the banner
971  * was printed.
972  */
973 
974 void __init setup_arch(char **cmdline_p)
975 {
976         /*
977          * print what head.S has found out about the machine
978          */
979 #ifndef CONFIG_64BIT
980 	if (MACHINE_IS_VM)
981 		pr_info("Linux is running as a z/VM "
982 			"guest operating system in 31-bit mode\n");
983 	else if (MACHINE_IS_LPAR)
984 		pr_info("Linux is running natively in 31-bit mode\n");
985 	if (MACHINE_HAS_IEEE)
986 		pr_info("The hardware system has IEEE compatible "
987 			"floating point units\n");
988 	else
989 		pr_info("The hardware system has no IEEE compatible "
990 			"floating point units\n");
991 #else /* CONFIG_64BIT */
992 	if (MACHINE_IS_VM)
993 		pr_info("Linux is running as a z/VM "
994 			"guest operating system in 64-bit mode\n");
995 	else if (MACHINE_IS_KVM)
996 		pr_info("Linux is running under KVM in 64-bit mode\n");
997 	else if (MACHINE_IS_LPAR)
998 		pr_info("Linux is running natively in 64-bit mode\n");
999 #endif /* CONFIG_64BIT */
1000 
1001 	/* Have one command line that is parsed and saved in /proc/cmdline */
1002 	/* boot_command_line has been already set up in early.c */
1003 	*cmdline_p = boot_command_line;
1004 
1005         ROOT_DEV = Root_RAM0;
1006 
1007 	init_mm.start_code = PAGE_OFFSET;
1008 	init_mm.end_code = (unsigned long) &_etext;
1009 	init_mm.end_data = (unsigned long) &_edata;
1010 	init_mm.brk = (unsigned long) &_end;
1011 
1012 	uaccess = MACHINE_HAS_MVCOS ? uaccess_mvcos : uaccess_pt;
1013 
1014 	parse_early_param();
1015 	detect_memory_layout(memory_chunk, memory_end);
1016 	os_info_init();
1017 	setup_ipl();
1018 	reserve_oldmem();
1019 	setup_memory_end();
1020 	reserve_crashkernel();
1021 	setup_memory();
1022 	setup_resources();
1023 	setup_vmcoreinfo();
1024 	setup_lowcore();
1025 
1026 	smp_fill_possible_mask();
1027         cpu_init();
1028 	s390_init_cpu_topology();
1029 
1030 	/*
1031 	 * Setup capabilities (ELF_HWCAP & ELF_PLATFORM).
1032 	 */
1033 	setup_hwcaps();
1034 
1035 	/*
1036 	 * Create kernel page tables and switch to virtual addressing.
1037 	 */
1038         paging_init();
1039 
1040         /* Setup default console */
1041 	conmode_default();
1042 	set_preferred_console();
1043 
1044 	/* Setup zfcpdump support */
1045 	setup_zfcpdump();
1046 }
1047