开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
setup.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：15k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

setup.c：源码内容
  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.  */
  13. /*
  14.  * This file handles the architecture-dependent parts of initialization
  15.  */
  17. #include <linux/errno.h>
  18. #include <linux/sched.h>
  19. #include <linux/kernel.h>
  20. #include <linux/mm.h>
  21. #include <linux/stddef.h>
  22. #include <linux/unistd.h>
  23. #include <linux/ptrace.h>
  24. #include <linux/slab.h>
  25. #include <linux/user.h>
  26. #include <linux/a.out.h>
  27. #include <linux/tty.h>
  28. #include <linux/ioport.h>
  29. #include <linux/delay.h>
  30. #include <linux/config.h>
  31. #include <linux/init.h>
  32. #ifdef CONFIG_BLK_DEV_RAM
  33. #include <linux/blk.h>
  34. #endif
  35. #include <linux/bootmem.h>
  36. #include <linux/console.h>
  37. #include <linux/seq_file.h>
  38. #include <asm/uaccess.h>
  39. #include <asm/system.h>
  40. #include <asm/smp.h>
  41. #include <asm/mmu_context.h>
  42. #include <asm/cpcmd.h>
  44. /*
  45.  * Machine setup..
  46.  */
  47. unsigned int console_mode = 0;
  48. unsigned int console_device = -1;
  49. unsigned long memory_size = 0;
  50. unsigned long machine_flags = 0;
  51. struct { unsigned long addr, size, type; } memory_chunk[16] = { { 0 } };
  52. #define CHUNK_READ_WRITE 0
  53. #define CHUNK_READ_ONLY 1
  54. __u16 boot_cpu_addr;
  55. int cpus_initialized = 0;
  56. unsigned long cpu_initialized = 0;
  57. volatile int __cpu_logical_map[NR_CPUS]; /* logical cpu to cpu address */
  59. /*
  60.  * Setup options
  61.  */
  62. extern int _text,_etext, _edata, _end;
  64. /*
  65.  * This is set up by the setup-routine at boot-time
  66.  * for S390 need to find out, what we have to setup
  67.  * using address 0x10400 ...
  68.  */
  70. #include <asm/setup.h>
  72. static char command_line[COMMAND_LINE_SIZE] = { 0, };
  73.        char saved_command_line[COMMAND_LINE_SIZE];
  75. static struct resource code_resource = { "Kernel code", 0x100000, 0 };
  76. static struct resource data_resource = { "Kernel data", 0, 0 };
  78. /*
  79.  * cpu_init() initializes state that is per-CPU.
  80.  */
  81. void __init cpu_init (void)
  82. {
  83.         int nr = smp_processor_id();
  84.         int addr = hard_smp_processor_id();
  86.         if (test_and_set_bit(nr,&cpu_initialized)) {
  87.                 printk("CPU#%d ALREADY INITIALIZED!!!!!!!!!n", nr);
  88.                 for (;;) __sti();
  89.         }
  90.         cpus_initialized++;
  92.         /*
  93.          * Store processor id in lowcore (used e.g. in timer_interrupt)
  94.          */
  95.         asm volatile ("stidp %0": "=m" (S390_lowcore.cpu_data.cpu_id));
  96.         S390_lowcore.cpu_data.cpu_addr = addr;
  97.         S390_lowcore.cpu_data.cpu_nr = nr;
  99.         /*
  100.          * Force FPU initialization:
  101.          */
  102.         current->flags &= ~PF_USEDFPU;
  103.         current->used_math = 0;
  105.         /* Setup active_mm for idle_task  */
  106.         atomic_inc(&init_mm.mm_count);
  107.         current->active_mm = &init_mm;
  108.         if (current->mm)
  109.                 BUG();
  110.         enter_lazy_tlb(&init_mm, current, nr);
  111. }
  113. /*
  114.  * VM halt and poweroff setup routines
  115.  */
  116. char vmhalt_cmd[128] = "";
  117. char vmpoff_cmd[128] = "";
  119. static inline void strncpy_skip_quote(char *dst, char *src, int n)
  120. {
  121.         int sx, dx;
  123.         dx = 0;
  124.         for (sx = 0; src[sx] != 0; sx++) {
  125.                 if (src[sx] == '"') continue;
  126.                 dst[dx++] = src[sx];
  127.                 if (dx >= n) break;
  128.         }
  129. }
  131. static int __init vmhalt_setup(char *str)
  132. {
  133.         strncpy_skip_quote(vmhalt_cmd, str, 127);
  134.         vmhalt_cmd[127] = 0;
  135.         return 1;
  136. }
  138. __setup("vmhalt=", vmhalt_setup);
  140. static int __init vmpoff_setup(char *str)
  141. {
  142.         strncpy_skip_quote(vmpoff_cmd, str, 127);
  143.         vmpoff_cmd[127] = 0;
  144.         return 1;
  145. }
  147. __setup("vmpoff=", vmpoff_setup);
  149. /*
  150.  * condev= and conmode= setup parameter.
  151.  */
  153. static int __init condev_setup(char *str)
  154. {
  155. int vdev;
  157. vdev = simple_strtoul(str, &str, 0);
  158. if (vdev >= 0 && vdev < 65536)
  159. console_device = vdev;
  160. return 1;
  161. }
  163. __setup("condev=", condev_setup);
  165. static int __init conmode_setup(char *str)
  166. {
  167. #if defined(CONFIG_HWC_CONSOLE)
  168. if (strncmp(str, "hwc", 4) == 0)
  169.                 SET_CONSOLE_HWC;
  170. #endif
  171. #if defined(CONFIG_TN3215_CONSOLE)
  172. if (strncmp(str, "3215", 5) == 0)
  173. SET_CONSOLE_3215;
  174. #endif
  175. #if defined(CONFIG_TN3270_CONSOLE)
  176. if (strncmp(str, "3270", 5) == 0)
  177. SET_CONSOLE_3270;
  178. #endif
  179.         return 1;
  180. }
  182. __setup("conmode=", conmode_setup);
  184. static void __init conmode_default(void)
  185. {
  186. char query_buffer[1024];
  187. char *ptr;
  189.         if (MACHINE_IS_VM) {
  190. cpcmd("QUERY TERM", query_buffer, 1024);
  191. ptr = strstr(query_buffer, "CONMODE");
  192. /*
  193.  * Set the conmode to 3215 so that the device recognition 
  194.  * will set the cu_type of the console to 3215. If the
  195.  * conmode is 3270 and we don't set it back then both
  196.  * 3215 and the 3270 driver will try to access the console
  197.  * device (3215 as console and 3270 as normal tty).
  198.  */
  199. cpcmd("TERM CONMODE 3215", NULL, 0);
  200. if (ptr == NULL) {
  201. #if defined(CONFIG_HWC_CONSOLE)
  202. SET_CONSOLE_HWC;
  203. #endif
  204. return;
  205. }
  206. if (strncmp(ptr + 8, "3270", 4) == 0) {
  207. #if defined(CONFIG_TN3270_CONSOLE)
  208. SET_CONSOLE_3270;
  209. #elif defined(CONFIG_TN3215_CONSOLE)
  210. SET_CONSOLE_3215;
  211. #elif defined(CONFIG_HWC_CONSOLE)
  212. SET_CONSOLE_HWC;
  213. #endif
  214. } else if (strncmp(ptr + 8, "3215", 4) == 0) {
  215. #if defined(CONFIG_TN3215_CONSOLE)
  216. SET_CONSOLE_3215;
  217. #elif defined(CONFIG_TN3270_CONSOLE)
  218. SET_CONSOLE_3270;
  219. #elif defined(CONFIG_HWC_CONSOLE)
  220. SET_CONSOLE_HWC;
  221. #endif
  222. }
  223.         } else if (MACHINE_IS_P390) {
  224. #if defined(CONFIG_TN3215_CONSOLE)
  225. SET_CONSOLE_3215;
  226. #elif defined(CONFIG_TN3270_CONSOLE)
  227. SET_CONSOLE_3270;
  228. #endif
  229. } else {
  230. #if defined(CONFIG_HWC_CONSOLE)
  231. SET_CONSOLE_HWC;
  232. #endif
  233. }
  234. }
  236. #ifdef CONFIG_SMP
  237. extern void machine_restart_smp(char *);
  238. extern void machine_halt_smp(void);
  239. extern void machine_power_off_smp(void);
  241. void (*_machine_restart)(char *command) = machine_restart_smp;
  242. void (*_machine_halt)(void) = machine_halt_smp;
  243. void (*_machine_power_off)(void) = machine_power_off_smp;
  244. #else
  245. /*
  246.  * Reboot, halt and power_off routines for non SMP.
  247.  */
  248. static void do_machine_restart_nonsmp(char * __unused)
  249. {
  250. reipl(S390_lowcore.ipl_device);
  251. }
  253. static void do_machine_halt_nonsmp(void)
  254. {
  255.         if (MACHINE_IS_VM && strlen(vmhalt_cmd) > 0)
  256.                 cpcmd(vmhalt_cmd, NULL, 0);
  257.         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
  258. }
  260. static void do_machine_power_off_nonsmp(void)
  261. {
  262.         if (MACHINE_IS_VM && strlen(vmpoff_cmd) > 0)
  263.                 cpcmd(vmpoff_cmd, NULL, 0);
  264.         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
  265. }
  267. void (*_machine_restart)(char *command) = do_machine_restart_nonsmp;
  268. void (*_machine_halt)(void) = do_machine_halt_nonsmp;
  269. void (*_machine_power_off)(void) = do_machine_power_off_nonsmp;
  270. #endif
  272. /*
  273.  * Reboot, halt and power_off stubs. They just call _machine_restart,
  274.  * _machine_halt or _machine_power_off. 
  275.  */
  277. void machine_restart(char *command)
  278. {
  279. _machine_restart(command);
  280. }
  282. void machine_halt(void)
  283. {
  284. _machine_halt();
  285. }
  287. void machine_power_off(void)
  288. {
  289. _machine_power_off();
  290. }
  292. /*
  293.  * Setup function called from init/main.c just after the banner
  294.  * was printed.
  295.  */
  296. extern char _pstart, _pend, _stext;
  298. void __init setup_arch(char **cmdline_p)
  299. {
  300.         unsigned long bootmap_size;
  301.         unsigned long memory_start, memory_end;
  302.         char c = ' ', cn, *to = command_line, *from = COMMAND_LINE;
  303. struct resource *res;
  304. unsigned long start_pfn, end_pfn;
  305.         static unsigned int smptrap=0;
  306.         unsigned long delay = 0;
  307. struct _lowcore *lowcore;
  308. int i;
  310.         if (smptrap)
  311.                 return;
  312.         smptrap=1;
  314.         /*
  315.          * print what head.S has found out about the machine 
  316.          */
  317. printk((MACHINE_IS_VM) ?
  318.        "We are running under VM (31 bit mode)n" :
  319.        "We are running native (31 bit mode)n");
  320. printk((MACHINE_HAS_IEEE) ?
  321.        "This machine has an IEEE fpun" :
  322.        "This machine has no IEEE fpun");
  324.         ROOT_DEV = to_kdev_t(0x0100);
  325.         memory_start = (unsigned long) &_end;    /* fixit if use $CODELO etc*/
  326. memory_end = memory_size & ~0x400000UL;  /* align memory end to 4MB */
  327.         /*
  328.          * We need some free virtual space to be able to do vmalloc.
  329.          * On a machine with 2GB memory we make sure that we have at
  330.          * least 128 MB free space for vmalloc.
  331.          */
  332.         if (memory_end > 1920*1024*1024)
  333.                 memory_end = 1920*1024*1024;
  334.         init_mm.start_code = PAGE_OFFSET;
  335.         init_mm.end_code = (unsigned long) &_etext;
  336.         init_mm.end_data = (unsigned long) &_edata;
  337.         init_mm.brk = (unsigned long) &_end;
  339. code_resource.start = (unsigned long) &_text;
  340. code_resource.end = (unsigned long) &_etext - 1;
  341. data_resource.start = (unsigned long) &_etext;
  342. data_resource.end = (unsigned long) &_edata - 1;
  344.         /* Save unparsed command line copy for /proc/cmdline */
  345.         memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
  346.         saved_command_line[COMMAND_LINE_SIZE-1] = '';
  348.         for (;;) {
  349.                 /*
  350.                  * "mem=XXX[kKmM]" sets memsize 
  351.                  */
  352.                 if (c == ' ' && strncmp(from, "mem=", 4) == 0) {
  353.                         memory_end = simple_strtoul(from+4, &from, 0);
  354.                         if ( *from == 'K' || *from == 'k' ) {
  355.                                 memory_end = memory_end << 10;
  356.                                 from++;
  357.                         } else if ( *from == 'M' || *from == 'm' ) {
  358.                                 memory_end = memory_end << 20;
  359.                                 from++;
  360.                         }
  361.                 }
  362.                 /*
  363.                  * "ipldelay=XXX[sm]" sets ipl delay in seconds or minutes
  364.                  */
  365.                 if (c == ' ' && strncmp(from, "ipldelay=", 9) == 0) {
  366.                         delay = simple_strtoul(from+9, &from, 0);
  367. if (*from == 's' || *from == 'S') {
  368. delay = delay*1000000;
  369. from++;
  370. } else if (*from == 'm' || *from == 'M') {
  371. delay = delay*60*1000000;
  372. from++;
  373. }
  374. /* now wait for the requested amount of time */
  375. udelay(delay);
  376.                 }
  377.                 cn = *(from++);
  378.                 if (!cn)
  379.                         break;
  380.                 if (cn == 'n')
  381.                         cn = ' ';  /* replace newlines with space */
  382. if (cn == 0x0d)
  383. cn = ' ';  /* replace 0x0d with space */
  384.                 if (cn == ' ' && c == ' ')
  385.                         continue;  /* remove additional spaces */
  386.                 c = cn;
  387.                 if (to - command_line >= COMMAND_LINE_SIZE)
  388.                         break;
  389.                 *(to++) = c;
  390.         }
  391.         if (c == ' ' && to > command_line) to--;
  392.         *to = '';
  393.         *cmdline_p = command_line;
  395. /*
  396.  * partially used pages are not usable - thus
  397.  * we are rounding upwards:
  398.  */
  399. start_pfn = (__pa(&_end) + PAGE_SIZE - 1) >> PAGE_SHIFT;
  400. end_pfn = memory_end >> PAGE_SHIFT;
  402. /*
  403.  * Initialize the boot-time allocator (with low memory only):
  404.  */
  405. bootmap_size = init_bootmem(start_pfn, end_pfn);
  407. /*
  408.  * Register RAM areas with the bootmem allocator.
  409.  */
  410. for (i = 0; i < 16 && memory_chunk[i].size > 0; i++) {
  411. unsigned long start_chunk, end_chunk;
  413. if (memory_chunk[i].type != CHUNK_READ_WRITE)
  414. continue;
  415. start_chunk = (memory_chunk[i].addr + PAGE_SIZE - 1);
  416. start_chunk >>= PAGE_SHIFT;
  417. end_chunk = (memory_chunk[i].addr + memory_chunk[i].size);
  418. end_chunk >>= PAGE_SHIFT;
  419. if (start_chunk < start_pfn)
  420. start_chunk = start_pfn;
  421. if (end_chunk > end_pfn)
  422. end_chunk = end_pfn;
  423. if (start_chunk < end_chunk)
  424. free_bootmem(start_chunk << PAGE_SHIFT,
  425.      (end_chunk - start_chunk) << PAGE_SHIFT);
  426. }
  428.         /*
  429.          * Reserve the bootmem bitmap itself as well. We do this in two
  430.          * steps (first step was init_bootmem()) because this catches
  431.          * the (very unlikely) case of us accidentally initializing the
  432.          * bootmem allocator with an invalid RAM area.
  433.          */
  434.         reserve_bootmem(start_pfn << PAGE_SHIFT, bootmap_size);
  436. #ifdef CONFIG_BLK_DEV_INITRD
  437.         if (INITRD_START) {
  438. if (INITRD_START + INITRD_SIZE <= memory_end) {
  439. reserve_bootmem(INITRD_START, INITRD_SIZE);
  440. initrd_start = INITRD_START;
  441. initrd_end = initrd_start + INITRD_SIZE;
  442. } else {
  443.                         printk("initrd extends beyond end of memory "
  444.                                "(0x%08lx > 0x%08lx)ndisabling initrdn",
  445.                                initrd_start + INITRD_SIZE, memory_end);
  446.                         initrd_start = initrd_end = 0;
  447. }
  448.         }
  449. #endif
  451.         /*
  452.          * Setup lowcore for boot cpu
  453.          */
  454. lowcore = (struct _lowcore *)
  455. __alloc_bootmem(PAGE_SIZE, PAGE_SIZE, 0);
  456. memset(lowcore, 0, PAGE_SIZE);
  457. lowcore->restart_psw.mask = _RESTART_PSW_MASK;
  458. lowcore->restart_psw.addr = _ADDR_31 + (addr_t) &restart_int_handler;
  459. lowcore->external_new_psw.mask = _EXT_PSW_MASK;
  460. lowcore->external_new_psw.addr = _ADDR_31 + (addr_t) &ext_int_handler;
  461. lowcore->svc_new_psw.mask = _SVC_PSW_MASK;
  462. lowcore->svc_new_psw.addr = _ADDR_31 + (addr_t) &system_call;
  463. lowcore->program_new_psw.mask = _PGM_PSW_MASK;
  464. lowcore->program_new_psw.addr = _ADDR_31 + (addr_t) &pgm_check_handler;
  465.         lowcore->mcck_new_psw.mask = _MCCK_PSW_MASK;
  466. lowcore->mcck_new_psw.addr = _ADDR_31 + (addr_t) &mcck_int_handler;
  467. lowcore->io_new_psw.mask = _IO_PSW_MASK;
  468. lowcore->io_new_psw.addr = _ADDR_31 + (addr_t) &io_int_handler;
  469. lowcore->ipl_device = S390_lowcore.ipl_device;
  470. lowcore->kernel_stack = ((__u32) &init_task_union) + 8192;
  471. lowcore->async_stack = (__u32)
  472. __alloc_bootmem(2*PAGE_SIZE, 2*PAGE_SIZE, 0) + 8192;
  473. lowcore->jiffy_timer = -1LL;
  474. set_prefix((__u32) lowcore);
  475.         cpu_init();
  476.         boot_cpu_addr = S390_lowcore.cpu_data.cpu_addr;
  477.         __cpu_logical_map[0] = boot_cpu_addr;
  479. /*
  480.  * Create kernel page tables and switch to virtual addressing.
  481.  */
  482.         paging_init();
  484. res = alloc_bootmem_low(sizeof(struct resource));
  485. res->start = 0;
  486. res->end = memory_end;
  487. res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  488. request_resource(&iomem_resource, res);
  489. request_resource(res, &code_resource);
  490. request_resource(res, &data_resource);
  492.         /* Setup default console */
  493. conmode_default();
  494. }
  496. void print_cpu_info(struct cpuinfo_S390 *cpuinfo)
  497. {
  498.    printk("cpu %d "
  499. #ifdef CONFIG_SMP
  500.            "phys_idx=%d "
  501. #endif
  502.            "vers=%02X ident=%06X machine=%04X unused=%04Xn",
  503.            cpuinfo->cpu_nr,
  504. #ifdef CONFIG_SMP
  505.            cpuinfo->cpu_addr,
  506. #endif
  507.            cpuinfo->cpu_id.version,
  508.            cpuinfo->cpu_id.ident,
  509.            cpuinfo->cpu_id.machine,
  510.            cpuinfo->cpu_id.unused);
  511. }
  513. /*
  514.  * show_cpuinfo - Get information on one CPU for use by procfs.
  515.  */
  517. static int show_cpuinfo(struct seq_file *m, void *v)
  518. {
  519.         struct cpuinfo_S390 *cpuinfo;
  520. unsigned long n = (unsigned long) v - 1;
  522. if (!n) {
  523. seq_printf(m, "vendor_id       : IBM/S390n"
  524.        "# processors    : %in"
  525.        "bogomips per cpu: %lu.%02lun",
  526.        smp_num_cpus, loops_per_jiffy/(500000/HZ),
  527.        (loops_per_jiffy/(5000/HZ))%100);
  528. }
  529. if (cpu_online_map & (1 << n)) {
  530. cpuinfo = &safe_get_cpu_lowcore(n)->cpu_data;
  531. seq_printf(m, "processor %li: "
  532.        "version = %02X,  "
  533.        "identification = %06X,  "
  534.        "machine = %04Xn",
  535.        n, cpuinfo->cpu_id.version,
  536.        cpuinfo->cpu_id.ident,
  537.        cpuinfo->cpu_id.machine);
  538. }
  539.         return 0;
  540. }
  542. static void *c_start(struct seq_file *m, loff_t *pos)
  543. {
  544. return *pos <= NR_CPUS ? (void *)((unsigned long) *pos + 1) : NULL;
  545. }
  546. static void *c_next(struct seq_file *m, void *v, loff_t *pos)
  547. {
  548. ++*pos;
  549. return c_start(m, pos);
  550. }
  551. static void c_stop(struct seq_file *m, void *v)
  552. {
  553. }
  554. struct seq_operations cpuinfo_op = {
  555. start: c_start,
  556. next: c_next,
  557. stop: c_stop,
  558. show: show_cpuinfo,
  559. };