projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[S390] Remove crept in whitespace from head*.S again.
[deliverable/linux.git] / arch / s390 / kernel / setup.c
CommitLineData
1da177e4
LT		 1/*
2 * arch/s390/kernel/setup.c
3 *
4 * S390 version
5 * Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
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#include <linux/errno.h>
18#include <linux/module.h>
19#include <linux/sched.h>
20#include <linux/kernel.h>
21#include <linux/mm.h>
22#include <linux/stddef.h>
23#include <linux/unistd.h>
24#include <linux/ptrace.h>
25#include <linux/slab.h>
26#include <linux/user.h>
27#include <linux/a.out.h>
28#include <linux/tty.h>
29#include <linux/ioport.h>
30#include <linux/delay.h>
1da177e4
LT		 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/seq_file.h>
37#include <linux/kernel_stat.h>
1e8e3383 38#include <linux/device.h>
585c3047 39#include <linux/notifier.h>
65912a84 40#include <linux/pfn.h>
1da177e4
LT		 41
42#include <asm/uaccess.h>
43#include <asm/system.h>
44#include <asm/smp.h>
45#include <asm/mmu_context.h>
46#include <asm/cpcmd.h>
47#include <asm/lowcore.h>
48#include <asm/irq.h>
0b642ede
PO		 49#include <asm/page.h>
50#include <asm/ptrace.h>
cc13ad62 51#include <asm/sections.h>
1da177e4 52
d02765d1
GS		 53/*
54 * User copy operations.
55 */
56struct uaccess_ops uaccess;
57EXPORT_SYMBOL_GPL(uaccess);
58
1da177e4
LT		 59/*
60 * Machine setup..
61 */
62unsigned int console_mode = 0;
63unsigned int console_devno = -1;
64unsigned int console_irq = -1;
65unsigned long memory_size = 0;
66unsigned long machine_flags = 0;
1da177e4
LT		 67struct {
68 unsigned long addr, size, type;
69} memory_chunk[MEMORY_CHUNKS] = { { 0 } };
70#define CHUNK_READ_WRITE 0
71#define CHUNK_READ_ONLY 1
72volatile int __cpu_logical_map[NR_CPUS]; /* logical cpu to cpu address */
c9e37353
HC		 73unsigned long __initdata zholes_size[MAX_NR_ZONES];
74static unsigned long __initdata memory_end;
1da177e4 75
1da177e4
LT		 76/*
77 * This is set up by the setup-routine at boot-time
78 * for S390 need to find out, what we have to setup
79 * using address 0x10400 ...
80 */
81
82#include <asm/setup.h>
83
1da177e4
LT		 84static struct resource code_resource = {
85 .name = "Kernel code",
86 .flags = IORESOURCE_BUSY | IORESOURCE_MEM,
87};
88
89static struct resource data_resource = {
90 .name = "Kernel data",
91 .flags = IORESOURCE_BUSY | IORESOURCE_MEM,
92};
93
94/*
95 * cpu_init() initializes state that is per-CPU.
96 */
97void __devinit cpu_init (void)
98{
99 int addr = hard_smp_processor_id();
100
101 /*
102 * Store processor id in lowcore (used e.g. in timer_interrupt)
103 */
94c12cc7 104 asm volatile("stidp %0": "=m" (S390_lowcore.cpu_data.cpu_id));
1da177e4
LT		 105 S390_lowcore.cpu_data.cpu_addr = addr;
106
107 /*
108 * Force FPU initialization:
109 */
110 clear_thread_flag(TIF_USEDFPU);
111 clear_used_math();
112
113 atomic_inc(&init_mm.mm_count);
114 current->active_mm = &init_mm;
115 if (current->mm)
116 BUG();
117 enter_lazy_tlb(&init_mm, current);
118}
119
120/*
121 * VM halt and poweroff setup routines
122 */
123char vmhalt_cmd[128] = "";
124char vmpoff_cmd[128] = "";
585c3047 125char vmpanic_cmd[128] = "";
1da177e4
LT		 126
127static inline void strncpy_skip_quote(char *dst, char *src, int n)
128{
129 int sx, dx;
130
131 dx = 0;
132 for (sx = 0; src[sx] != 0; sx++) {
133 if (src[sx] == '"') continue;
134 dst[dx++] = src[sx];
135 if (dx >= n) break;
136 }
137}
138
139static int __init vmhalt_setup(char *str)
140{
141 strncpy_skip_quote(vmhalt_cmd, str, 127);
142 vmhalt_cmd[127] = 0;
143 return 1;
144}
145
146__setup("vmhalt=", vmhalt_setup);
147
148static int __init vmpoff_setup(char *str)
149{
150 strncpy_skip_quote(vmpoff_cmd, str, 127);
151 vmpoff_cmd[127] = 0;
152 return 1;
153}
154
155__setup("vmpoff=", vmpoff_setup);
156
585c3047
PO		 157static int vmpanic_notify(struct notifier_block *self, unsigned long event,
158 void *data)
159{
160 if (MACHINE_IS_VM && strlen(vmpanic_cmd) > 0)
161 cpcmd(vmpanic_cmd, NULL, 0, NULL);
162
163 return NOTIFY_OK;
164}
165
166#define PANIC_PRI_VMPANIC 0
167
168static struct notifier_block vmpanic_nb = {
169 .notifier_call = vmpanic_notify,
170 .priority = PANIC_PRI_VMPANIC
171};
172
173static int __init vmpanic_setup(char *str)
174{
175 static int register_done __initdata = 0;
176
177 strncpy_skip_quote(vmpanic_cmd, str, 127);
178 vmpanic_cmd[127] = 0;
179 if (!register_done) {
180 register_done = 1;
181 atomic_notifier_chain_register(&panic_notifier_list,
182 &vmpanic_nb);
183 }
184 return 1;
185}
186
187__setup("vmpanic=", vmpanic_setup);
188
1da177e4
LT		 189/*
190 * condev= and conmode= setup parameter.
191 */
192
193static int __init condev_setup(char *str)
194{
195 int vdev;
196
197 vdev = simple_strtoul(str, &str, 0);
198 if (vdev >= 0 && vdev < 65536) {
199 console_devno = vdev;
200 console_irq = -1;
201 }
202 return 1;
203}
204
205__setup("condev=", condev_setup);
206
207static int __init conmode_setup(char *str)
208{
209#if defined(CONFIG_SCLP_CONSOLE)
210 if (strncmp(str, "hwc", 4) == 0 || strncmp(str, "sclp", 5) == 0)
211 SET_CONSOLE_SCLP;
212#endif
213#if defined(CONFIG_TN3215_CONSOLE)
214 if (strncmp(str, "3215", 5) == 0)
215 SET_CONSOLE_3215;
216#endif
217#if defined(CONFIG_TN3270_CONSOLE)
218 if (strncmp(str, "3270", 5) == 0)
219 SET_CONSOLE_3270;
220#endif
221 return 1;
222}
223
224__setup("conmode=", conmode_setup);
225
226static void __init conmode_default(void)
227{
228 char query_buffer[1024];
229 char *ptr;
230
231 if (MACHINE_IS_VM) {
6b979de3 232 __cpcmd("QUERY CONSOLE", query_buffer, 1024, NULL);
1da177e4
LT		 233 console_devno = simple_strtoul(query_buffer + 5, NULL, 16);
234 ptr = strstr(query_buffer, "SUBCHANNEL =");
235 console_irq = simple_strtoul(ptr + 13, NULL, 16);
6b979de3 236 __cpcmd("QUERY TERM", query_buffer, 1024, NULL);
1da177e4
LT		 237 ptr = strstr(query_buffer, "CONMODE");
238 /*
239 * Set the conmode to 3215 so that the device recognition
240 * will set the cu_type of the console to 3215. If the
241 * conmode is 3270 and we don't set it back then both
242 * 3215 and the 3270 driver will try to access the console
243 * device (3215 as console and 3270 as normal tty).
244 */
6b979de3 245 __cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
1da177e4
LT		 246 if (ptr == NULL) {
247#if defined(CONFIG_SCLP_CONSOLE)
248 SET_CONSOLE_SCLP;
249#endif
250 return;
251 }
252 if (strncmp(ptr + 8, "3270", 4) == 0) {
253#if defined(CONFIG_TN3270_CONSOLE)
254 SET_CONSOLE_3270;
255#elif defined(CONFIG_TN3215_CONSOLE)
256 SET_CONSOLE_3215;
257#elif defined(CONFIG_SCLP_CONSOLE)
258 SET_CONSOLE_SCLP;
259#endif
260 } else if (strncmp(ptr + 8, "3215", 4) == 0) {
261#if defined(CONFIG_TN3215_CONSOLE)
262 SET_CONSOLE_3215;
263#elif defined(CONFIG_TN3270_CONSOLE)
264 SET_CONSOLE_3270;
265#elif defined(CONFIG_SCLP_CONSOLE)
266 SET_CONSOLE_SCLP;
267#endif
268 }
269 } else if (MACHINE_IS_P390) {
270#if defined(CONFIG_TN3215_CONSOLE)
271 SET_CONSOLE_3215;
272#elif defined(CONFIG_TN3270_CONSOLE)
273 SET_CONSOLE_3270;
274#endif
275 } else {
276#if defined(CONFIG_SCLP_CONSOLE)
277 SET_CONSOLE_SCLP;
278#endif
279 }
280}
281
282#ifdef CONFIG_SMP
283extern void machine_restart_smp(char *);
284extern void machine_halt_smp(void);
285extern void machine_power_off_smp(void);
286
287void (*_machine_restart)(char *command) = machine_restart_smp;
288void (*_machine_halt)(void) = machine_halt_smp;
289void (*_machine_power_off)(void) = machine_power_off_smp;
290#else
291/*
292 * Reboot, halt and power_off routines for non SMP.
293 */
1da177e4
LT		 294static void do_machine_restart_nonsmp(char * __unused)
295{
ff6b8ea6 296 do_reipl();
1da177e4
LT		 297}
298
299static void do_machine_halt_nonsmp(void)
300{
301 if (MACHINE_IS_VM && strlen(vmhalt_cmd) > 0)
68c11917 302 cpcmd(vmhalt_cmd, NULL, 0, NULL);
1da177e4
LT		 303 signal_processor(smp_processor_id(), sigp_stop_and_store_status);
304}
305
306static void do_machine_power_off_nonsmp(void)
307{
308 if (MACHINE_IS_VM && strlen(vmpoff_cmd) > 0)
68c11917 309 cpcmd(vmpoff_cmd, NULL, 0, NULL);
1da177e4
LT		 310 signal_processor(smp_processor_id(), sigp_stop_and_store_status);
311}
312
313void (*_machine_restart)(char *command) = do_machine_restart_nonsmp;
314void (*_machine_halt)(void) = do_machine_halt_nonsmp;
315void (*_machine_power_off)(void) = do_machine_power_off_nonsmp;
316#endif
317
318 /*
319 * Reboot, halt and power_off stubs. They just call _machine_restart,
320 * _machine_halt or _machine_power_off.
321 */
322
323void machine_restart(char *command)
324{
06fa46a2
MS		 325 if (!in_interrupt() || oops_in_progress)
326 /*
327 * Only unblank the console if we are called in enabled
328 * context or a bust_spinlocks cleared the way for us.
329 */
330 console_unblank();
1da177e4
LT		 331 _machine_restart(command);
332}
333
1da177e4
LT		 334void machine_halt(void)
335{
06fa46a2
MS		 336 if (!in_interrupt() || oops_in_progress)
337 /*
338 * Only unblank the console if we are called in enabled
339 * context or a bust_spinlocks cleared the way for us.
340 */
341 console_unblank();
1da177e4
LT		 342 _machine_halt();
343}
344
1da177e4
LT		 345void machine_power_off(void)
346{
06fa46a2
MS		 347 if (!in_interrupt() || oops_in_progress)
348 /*
349 * Only unblank the console if we are called in enabled
350 * context or a bust_spinlocks cleared the way for us.
351 */
352 console_unblank();
1da177e4
LT		 353 _machine_power_off();
354}
355
53df751c
MS		 356/*
357 * Dummy power off function.
358 */
359void (*pm_power_off)(void) = machine_power_off;
360
c9e37353
HC		 361static void __init
362add_memory_hole(unsigned long start, unsigned long end)
1da177e4 363{
c9e37353
HC		 364 unsigned long dma_pfn = MAX_DMA_ADDRESS >> PAGE_SHIFT;
365
366 if (end <= dma_pfn)
367 zholes_size[ZONE_DMA] += end - start + 1;
368 else if (start > dma_pfn)
369 zholes_size[ZONE_NORMAL] += end - start + 1;
370 else {
371 zholes_size[ZONE_DMA] += dma_pfn - start + 1;
372 zholes_size[ZONE_NORMAL] += end - dma_pfn;
373 }
374}
1da177e4 375
59685296
HC		 376static int __init early_parse_mem(char *p)
377{
378 memory_end = memparse(p, &p);
379 return 0;
380}
381early_param("mem", early_parse_mem);
382
383/*
384 * "ipldelay=XXX[sm]" sets ipl delay in seconds or minutes
385 */
386static int __init early_parse_ipldelay(char *p)
c9e37353 387{
c9e37353 388 unsigned long delay = 0;
1da177e4 389
59685296 390 delay = simple_strtoul(p, &p, 0);
1da177e4 391
59685296
HC		 392 switch (*p) {
393 case 's':
394 case 'S':
395 delay *= 1000000;
396 break;
397 case 'm':
398 case 'M':
399 delay *= 60 * 1000000;
c9e37353 400 }
59685296
HC		 401
402 /* now wait for the requested amount of time */
403 udelay(delay);
404
405 return 0;
c9e37353 406}
59685296 407early_param("ipldelay", early_parse_ipldelay);
c9e37353
HC		 408
409static void __init
410setup_lowcore(void)
411{
412 struct _lowcore *lc;
413 int lc_pages;
414
415 /*
416 * Setup lowcore for boot cpu
417 */
418 lc_pages = sizeof(void *) == 8 ? 2 : 1;
419 lc = (struct _lowcore *)
420 __alloc_bootmem(lc_pages * PAGE_SIZE, lc_pages * PAGE_SIZE, 0);
421 memset(lc, 0, lc_pages * PAGE_SIZE);
0b642ede 422 lc->restart_psw.mask = PSW_BASE_BITS | PSW_DEFAULT_KEY;
c9e37353
HC		 423 lc->restart_psw.addr =
424 PSW_ADDR_AMODE | (unsigned long) restart_int_handler;
425 lc->external_new_psw.mask = PSW_KERNEL_BITS;
426 lc->external_new_psw.addr =
427 PSW_ADDR_AMODE | (unsigned long) ext_int_handler;
428 lc->svc_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_IO | PSW_MASK_EXT;
429 lc->svc_new_psw.addr = PSW_ADDR_AMODE | (unsigned long) system_call;
430 lc->program_new_psw.mask = PSW_KERNEL_BITS;
431 lc->program_new_psw.addr =
432 PSW_ADDR_AMODE | (unsigned long)pgm_check_handler;
77fa2245
HC		 433 lc->mcck_new_psw.mask =
434 PSW_KERNEL_BITS & ~PSW_MASK_MCHECK & ~PSW_MASK_DAT;
c9e37353
HC		 435 lc->mcck_new_psw.addr =
436 PSW_ADDR_AMODE | (unsigned long) mcck_int_handler;
437 lc->io_new_psw.mask = PSW_KERNEL_BITS;
438 lc->io_new_psw.addr = PSW_ADDR_AMODE | (unsigned long) io_int_handler;
439 lc->ipl_device = S390_lowcore.ipl_device;
440 lc->jiffy_timer = -1LL;
441 lc->kernel_stack = ((unsigned long) &init_thread_union) + THREAD_SIZE;
442 lc->async_stack = (unsigned long)
443 __alloc_bootmem(ASYNC_SIZE, ASYNC_SIZE, 0) + ASYNC_SIZE;
c9e37353
HC		 444 lc->panic_stack = (unsigned long)
445 __alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0) + PAGE_SIZE;
c9e37353
HC		 446 lc->current_task = (unsigned long) init_thread_union.thread_info.task;
447 lc->thread_info = (unsigned long) &init_thread_union;
347a8dc3 448#ifndef CONFIG_64BIT
77fa2245
HC		 449 if (MACHINE_HAS_IEEE) {
450 lc->extended_save_area_addr = (__u32)
451 __alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0);
452 /* enable extended save area */
453 ctl_set_bit(14, 29);
454 }
455#endif
c9e37353
HC		 456 set_prefix((u32)(unsigned long) lc);
457}
458
459static void __init
460setup_resources(void)
461{
462 struct resource *res;
463 int i;
464
cc13ad62
HC		 465 code_resource.start = (unsigned long) &_text;
466 code_resource.end = (unsigned long) &_etext - 1;
467 data_resource.start = (unsigned long) &_etext;
468 data_resource.end = (unsigned long) &_edata - 1;
469
c9e37353
HC		 470 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
471 res = alloc_bootmem_low(sizeof(struct resource));
472 res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
473 switch (memory_chunk[i].type) {
474 case CHUNK_READ_WRITE:
475 res->name = "System RAM";
476 break;
477 case CHUNK_READ_ONLY:
478 res->name = "System ROM";
479 res->flags |= IORESOURCE_READONLY;
480 break;
481 default:
482 res->name = "reserved";
483 }
484 res->start = memory_chunk[i].addr;
485 res->end = memory_chunk[i].addr + memory_chunk[i].size - 1;
486 request_resource(&iomem_resource, res);
487 request_resource(res, &code_resource);
488 request_resource(res, &data_resource);
489 }
490}
491
492static void __init
493setup_memory(void)
494{
495 unsigned long bootmap_size;
0b642ede 496 unsigned long start_pfn, end_pfn, init_pfn;
c9e37353
HC		 497 unsigned long last_rw_end;
498 int i;
1da177e4
LT		 499
500 /*
501 * partially used pages are not usable - thus
502 * we are rounding upwards:
503 */
65912a84
HC		 504 start_pfn = PFN_UP(__pa(&_end));
505 end_pfn = max_pfn = PFN_DOWN(memory_end);
1da177e4 506
0b642ede
PO		 507 /* Initialize storage key for kernel pages */
508 for (init_pfn = 0 ; init_pfn < start_pfn; init_pfn++)
509 page_set_storage_key(init_pfn << PAGE_SHIFT, PAGE_DEFAULT_KEY);
510
65912a84
HC		 511#ifdef CONFIG_BLK_DEV_INITRD
512 /*
513 * Move the initrd in case the bitmap of the bootmem allocater
514 * would overwrite it.
515 */
516
517 if (INITRD_START && INITRD_SIZE) {
518 unsigned long bmap_size;
519 unsigned long start;
520
521 bmap_size = bootmem_bootmap_pages(end_pfn - start_pfn + 1);
522 bmap_size = PFN_PHYS(bmap_size);
523
524 if (PFN_PHYS(start_pfn) + bmap_size > INITRD_START) {
525 start = PFN_PHYS(start_pfn) + bmap_size + PAGE_SIZE;
526
527 if (start + INITRD_SIZE > memory_end) {
528 printk("initrd extends beyond end of memory "
529 "(0x%08lx > 0x%08lx)\n"
530 "disabling initrd\n",
531 start + INITRD_SIZE, memory_end);
532 INITRD_START = INITRD_SIZE = 0;
533 } else {
534 printk("Moving initrd (0x%08lx -> 0x%08lx, "
535 "size: %ld)\n",
536 INITRD_START, start, INITRD_SIZE);
537 memmove((void *) start, (void *) INITRD_START,
538 INITRD_SIZE);
539 INITRD_START = start;
540 }
541 }
542 }
543#endif
544
1da177e4
LT		 545 /*
546 * Initialize the boot-time allocator (with low memory only):
547 */
548 bootmap_size = init_bootmem(start_pfn, end_pfn);
549
550 /*
551 * Register RAM areas with the bootmem allocator.
552 */
c9e37353
HC		 553 last_rw_end = start_pfn;
554
0b642ede 555 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
1da177e4
LT		 556 unsigned long start_chunk, end_chunk;
557
558 if (memory_chunk[i].type != CHUNK_READ_WRITE)
559 continue;
560 start_chunk = (memory_chunk[i].addr + PAGE_SIZE - 1);
561 start_chunk >>= PAGE_SHIFT;
562 end_chunk = (memory_chunk[i].addr + memory_chunk[i].size);
563 end_chunk >>= PAGE_SHIFT;
564 if (start_chunk < start_pfn)
565 start_chunk = start_pfn;
566 if (end_chunk > end_pfn)
567 end_chunk = end_pfn;
c9e37353 568 if (start_chunk < end_chunk) {
0b642ede
PO		 569 /* Initialize storage key for RAM pages */
570 for (init_pfn = start_chunk ; init_pfn < end_chunk;
571 init_pfn++)
572 page_set_storage_key(init_pfn << PAGE_SHIFT,
573 PAGE_DEFAULT_KEY);
1da177e4
LT		 574 free_bootmem(start_chunk << PAGE_SHIFT,
575 (end_chunk - start_chunk) << PAGE_SHIFT);
c9e37353
HC		 576 if (last_rw_end < start_chunk)
577 add_memory_hole(last_rw_end, start_chunk - 1);
578 last_rw_end = end_chunk;
579 }
1da177e4
LT		 580 }
581
0b642ede
PO		 582 psw_set_key(PAGE_DEFAULT_KEY);
583
c9e37353
HC		 584 if (last_rw_end < end_pfn - 1)
585 add_memory_hole(last_rw_end, end_pfn - 1);
586
587 /*
588 * Reserve the bootmem bitmap itself as well. We do this in two
589 * steps (first step was init_bootmem()) because this catches
590 * the (very unlikely) case of us accidentally initializing the
591 * bootmem allocator with an invalid RAM area.
592 */
593 reserve_bootmem(start_pfn << PAGE_SHIFT, bootmap_size);
1da177e4
LT		 594
595#ifdef CONFIG_BLK_DEV_INITRD
65912a84 596 if (INITRD_START && INITRD_SIZE) {
1da177e4
LT		 597 if (INITRD_START + INITRD_SIZE <= memory_end) {
598 reserve_bootmem(INITRD_START, INITRD_SIZE);
599 initrd_start = INITRD_START;
600 initrd_end = initrd_start + INITRD_SIZE;
601 } else {
c9e37353
HC		 602 printk("initrd extends beyond end of memory "
603 "(0x%08lx > 0x%08lx)\ndisabling initrd\n",
604 initrd_start + INITRD_SIZE, memory_end);
605 initrd_start = initrd_end = 0;
1da177e4 606 }
c9e37353 607 }
1da177e4 608#endif
c9e37353 609}
1da177e4 610
c9e37353
HC		 611/*
612 * Setup function called from init/main.c just after the banner
613 * was printed.
614 */
1da177e4 615
c9e37353
HC		 616void __init
617setup_arch(char **cmdline_p)
618{
1da177e4 619 /*
c9e37353 620 * print what head.S has found out about the machine
1da177e4 621 */
347a8dc3 622#ifndef CONFIG_64BIT
c9e37353
HC		 623 printk((MACHINE_IS_VM) ?
624 "We are running under VM (31 bit mode)\n" :
625 "We are running native (31 bit mode)\n");
626 printk((MACHINE_HAS_IEEE) ?
627 "This machine has an IEEE fpu\n" :
628 "This machine has no IEEE fpu\n");
347a8dc3 629#else /* CONFIG_64BIT */
c9e37353
HC		 630 printk((MACHINE_IS_VM) ?
631 "We are running under VM (64 bit mode)\n" :
632 "We are running native (64 bit mode)\n");
347a8dc3 633#endif /* CONFIG_64BIT */
c9e37353 634
59685296
HC		 635 /* Save unparsed command line copy for /proc/cmdline */
636 strlcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
637
638 *cmdline_p = COMMAND_LINE;
639 *(*cmdline_p + COMMAND_LINE_SIZE - 1) = '\0';
640
c9e37353 641 ROOT_DEV = Root_RAM0;
59685296
HC		 642
643 init_mm.start_code = PAGE_OFFSET;
644 init_mm.end_code = (unsigned long) &_etext;
645 init_mm.end_data = (unsigned long) &_edata;
646 init_mm.brk = (unsigned long) &_end;
647
648 memory_end = memory_size;
649
6c2a9e6d
GS		 650 if (MACHINE_HAS_MVCOS)
651 memcpy(&uaccess, &uaccess_mvcos, sizeof(uaccess));
652 else
653 memcpy(&uaccess, &uaccess_std, sizeof(uaccess));
654
59685296
HC		 655 parse_early_param();
656
347a8dc3 657#ifndef CONFIG_64BIT
59685296
HC		 658 memory_end &= ~0x400000UL;
659
c9e37353
HC		 660 /*
661 * We need some free virtual space to be able to do vmalloc.
662 * On a machine with 2GB memory we make sure that we have at
663 * least 128 MB free space for vmalloc.
664 */
665 if (memory_end > 1920*1024*1024)
666 memory_end = 1920*1024*1024;
347a8dc3 667#else /* CONFIG_64BIT */
59685296 668 memory_end &= ~0x200000UL;
347a8dc3 669#endif /* CONFIG_64BIT */
c9e37353 670
c9e37353
HC		 671 setup_memory();
672 setup_resources();
673 setup_lowcore();
674
1da177e4
LT		 675 cpu_init();
676 __cpu_logical_map[0] = S390_lowcore.cpu_data.cpu_addr;
255acee7 677 smp_setup_cpu_possible_map();
1da177e4
LT		 678
679 /*
680 * Create kernel page tables and switch to virtual addressing.
681 */
682 paging_init();
683
684 /* Setup default console */
685 conmode_default();
686}
687
688void print_cpu_info(struct cpuinfo_S390 *cpuinfo)
689{
690 printk("cpu %d "
691#ifdef CONFIG_SMP
692 "phys_idx=%d "
693#endif
694 "vers=%02X ident=%06X machine=%04X unused=%04X\n",
695 cpuinfo->cpu_nr,
696#ifdef CONFIG_SMP
697 cpuinfo->cpu_addr,
698#endif
699 cpuinfo->cpu_id.version,
700 cpuinfo->cpu_id.ident,
701 cpuinfo->cpu_id.machine,
702 cpuinfo->cpu_id.unused);
703}
704
705/*
706 * show_cpuinfo - Get information on one CPU for use by procfs.
707 */
708
709static int show_cpuinfo(struct seq_file *m, void *v)
710{
711 struct cpuinfo_S390 *cpuinfo;
712 unsigned long n = (unsigned long) v - 1;
713
b7ae9dd8 714 preempt_disable();
1da177e4
LT		 715 if (!n) {
716 seq_printf(m, "vendor_id : IBM/S390\n"
717 "# processors : %i\n"
718 "bogomips per cpu: %lu.%02lu\n",
719 num_online_cpus(), loops_per_jiffy/(500000/HZ),
720 (loops_per_jiffy/(5000/HZ))%100);
721 }
722 if (cpu_online(n)) {
723#ifdef CONFIG_SMP
724 if (smp_processor_id() == n)
725 cpuinfo = &S390_lowcore.cpu_data;
726 else
727 cpuinfo = &lowcore_ptr[n]->cpu_data;
728#else
729 cpuinfo = &S390_lowcore.cpu_data;
730#endif
731 seq_printf(m, "processor %li: "
732 "version = %02X, "
733 "identification = %06X, "
734 "machine = %04X\n",
735 n, cpuinfo->cpu_id.version,
736 cpuinfo->cpu_id.ident,
737 cpuinfo->cpu_id.machine);
738 }
b7ae9dd8 739 preempt_enable();
1da177e4
LT		 740 return 0;
741}
742
743static void *c_start(struct seq_file *m, loff_t *pos)
744{
745 return *pos < NR_CPUS ? (void *)((unsigned long) *pos + 1) : NULL;
746}
747static void *c_next(struct seq_file *m, void *v, loff_t *pos)
748{
749 ++*pos;
750 return c_start(m, pos);
751}
752static void c_stop(struct seq_file *m, void *v)
753{
754}
755struct seq_operations cpuinfo_op = {
756 .start = c_start,
757 .next = c_next,
758 .stop = c_stop,
759 .show = show_cpuinfo,
760};
761
Linux kernel - Deliverables
This page took 0.297273 seconds and 5 git commands to generate.