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