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

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

Linux/Unix编程

开发平台：

Unix_Linux

setup.c：源码内容
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 1995  Linus Torvalds
  7.  * Copyright (C) 1995  Waldorf Electronics
  8.  * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001  Ralf Baechle
  9.  * Copyright (C) 1996  Stoned Elipot
  10.  * Copyright (C) 2000, 2001  Maciej W. Rozycki
  11.  */
  12. #include <linux/config.h>
  13. #include <linux/errno.h>
  14. #include <linux/hdreg.h>
  15. #include <linux/init.h>
  16. #include <linux/ioport.h>
  17. #include <linux/sched.h>
  18. #include <linux/kernel.h>
  19. #include <linux/mm.h>
  20. #include <linux/module.h>
  21. #include <linux/stddef.h>
  22. #include <linux/string.h>
  23. #include <linux/unistd.h>
  24. #include <linux/slab.h>
  25. #include <linux/user.h>
  26. #include <linux/utsname.h>
  27. #include <linux/a.out.h>
  28. #include <linux/tty.h>
  29. #include <linux/bootmem.h>
  30. #include <linux/blk.h>
  31. #include <linux/ide.h>
  32. #include <linux/timex.h>
  34. #include <asm/asm.h>
  35. #include <asm/bootinfo.h>
  36. #include <asm/cachectl.h>
  37. #include <asm/cpu.h>
  38. #include <asm/io.h>
  39. #include <asm/ptrace.h>
  40. #include <asm/system.h>
  42. #ifndef CONFIG_SMP
  43. struct cpuinfo_mips cpu_data[1];
  44. #endif
  46. /*
  47.  * There are several bus types available for MIPS machines.  "RISC PC"
  48.  * type machines have ISA, EISA, VLB or PCI available, DECstations
  49.  * have Turbochannel or Q-Bus, SGI has GIO, there are lots of VME
  50.  * boxes ...
  51.  * This flag is set if a EISA slots are available.
  52.  */
  53. #ifdef CONFIG_EISA
  54. int EISA_bus = 0;
  55. #endif
  57. struct screen_info screen_info;
  59. extern struct fd_ops no_fd_ops;
  60. struct fd_ops *fd_ops;
  62. #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
  63. extern struct ide_ops no_ide_ops;
  64. struct ide_ops *ide_ops;
  65. #endif
  67. extern void * __rd_start, * __rd_end;
  69. extern struct rtc_ops no_rtc_ops;
  70. struct rtc_ops *rtc_ops;
  72. #ifdef CONFIG_PC_KEYB
  73. extern struct kbd_ops no_kbd_ops;
  74. struct kbd_ops *kbd_ops;
  75. #endif
  77. /*
  78.  * Setup information
  79.  *
  80.  * These are initialized so they are in the .data section
  81.  */
  82. unsigned long mips_machtype = MACH_UNKNOWN;
  83. unsigned long mips_machgroup = MACH_GROUP_UNKNOWN;
  85. struct boot_mem_map boot_mem_map;
  87. unsigned char aux_device_present;
  88. extern char _ftext, _etext, _fdata, _edata, _end;
  90. static char command_line[CL_SIZE];
  91.        char saved_command_line[CL_SIZE];
  92. extern char arcs_cmdline[CL_SIZE];
  94. /*
  95.  * mips_io_port_base is the begin of the address space to which x86 style
  96.  * I/O ports are mapped.
  97.  */
  98. const unsigned long mips_io_port_base = -1;
  99. EXPORT_SYMBOL(mips_io_port_base);
  102. /*
  103.  * isa_slot_offset is the address where E(ISA) busaddress 0 is is mapped
  104.  * for the processor.
  105.  */
  106. unsigned long isa_slot_offset;
  107. EXPORT_SYMBOL(isa_slot_offset);
  109. extern void sgi_sysinit(void);
  110. extern void SetUpBootInfo(void);
  111. extern void loadmmu(void);
  112. extern asmlinkage void start_kernel(void);
  113. extern void prom_init(int, char **, char **, int *);
  115. static struct resource code_resource = { "Kernel code" };
  116. static struct resource data_resource = { "Kernel data" };
  118. asmlinkage void __init
  119. init_arch(int argc, char **argv, char **envp, int *prom_vec)
  120. {
  121. /* Determine which MIPS variant we are running on. */
  122. cpu_probe();
  124. prom_init(argc, argv, envp, prom_vec);
  126. #ifdef CONFIG_SGI_IP22
  127. sgi_sysinit();
  128. #endif
  130. cpu_report();
  132. /*
  133.  * Determine the mmu/cache attached to this machine,
  134.  * then flush the tlb and caches.  On the r4xx0
  135.  * variants this also sets CP0_WIRED to zero.
  136.  */
  137. loadmmu();
  139. /* Disable coprocessors and set FPU for 16/32 FPR register model */
  140. clear_cp0_status(ST0_CU1|ST0_CU2|ST0_CU3|ST0_KX|ST0_SX|ST0_FR);
  141. set_cp0_status(ST0_CU0);
  143. start_kernel();
  144. }
  146. void __init add_memory_region(phys_t start, phys_t size,
  147.       long type)
  148. {
  149. int x = boot_mem_map.nr_map;
  151. if (x == BOOT_MEM_MAP_MAX) {
  152. printk("Ooops! Too many entries in the memory map!n");
  153. return;
  154. }
  156. boot_mem_map.map[x].addr = start;
  157. boot_mem_map.map[x].size = size;
  158. boot_mem_map.map[x].type = type;
  159. boot_mem_map.nr_map++;
  160. }
  162. static void __init print_memory_map(void)
  163. {
  164. int i;
  166. for (i = 0; i < boot_mem_map.nr_map; i++) {
  167. printk(" memory: %08Lx @ %08Lx ",
  168. (u64) boot_mem_map.map[i].size,
  169.         (u64) boot_mem_map.map[i].addr);
  171. switch (boot_mem_map.map[i].type) {
  172. case BOOT_MEM_RAM:
  173. printk("(usable)n");
  174. break;
  175. case BOOT_MEM_ROM_DATA:
  176. printk("(ROM data)n");
  177. break;
  178. case BOOT_MEM_RESERVED:
  179. printk("(reserved)n");
  180. break;
  181. default:
  182. printk("type %lun", boot_mem_map.map[i].type);
  183. break;
  184. }
  185. }
  186. }
  188. static inline void parse_mem_cmdline(void)
  189. {
  190. char c = ' ', *to = command_line, *from = saved_command_line;
  191. unsigned long start_at, mem_size;
  192. int len = 0;
  193. int usermem = 0;
  195. printk("Determined physical RAM map:n");
  196. print_memory_map();
  198. for (;;) {
  199. /*
  200.  * "mem=XXX[kKmM]" defines a memory region from
  201.  * 0 to <XXX>, overriding the determined size.
  202.  * "mem=XXX[KkmM]@YYY[KkmM]" defines a memory region from
  203.  * <YYY> to <YYY>+<XXX>, overriding the determined size.
  204.  */
  205. if (c == ' ' && !memcmp(from, "mem=", 4)) {
  206. if (to != command_line)
  207. to--;
  208. /*
  209.  * If a user specifies memory size, we
  210.  * blow away any automatically generated
  211.  * size.
  212.  */
  213. if (usermem == 0) {
  214. boot_mem_map.nr_map = 0;
  215. usermem = 1;
  216. }
  217. mem_size = memparse(from + 4, &from);
  218. if (*from == '@')
  219. start_at = memparse(from + 1, &from);
  220. else
  221. start_at = 0;
  222. add_memory_region(start_at, mem_size, BOOT_MEM_RAM);
  223. }
  224. c = *(from++);
  225. if (!c)
  226. break;
  227. if (CL_SIZE <= ++len)
  228. break;
  229. *(to++) = c;
  230. }
  231. *to = '';
  233. if (usermem) {
  234. printk("User-defined physical RAM map:n");
  235. print_memory_map();
  236. }
  237. }
  239. void __init setup_arch(char **cmdline_p)
  240. {
  241. void atlas_setup(void);
  242. void baget_setup(void);
  243. void cobalt_setup(void);
  244. void ddb_setup(void);
  245. void decstation_setup(void);
  246. void deskstation_setup(void);
  247. void jazz_setup(void);
  248. void sni_rm200_pci_setup(void);
  249. void ip22_setup(void);
  250.         void ev96100_setup(void);
  251. void malta_setup(void);
  252. void sead_setup(void);
  253. void ikos_setup(void);
  254. void momenco_ocelot_setup(void);
  255. void momenco_ocelot_g_setup(void);
  256. void nino_setup(void);
  257. void nec_osprey_setup(void);
  258. void nec_eagle_setup(void);
  259. void zao_capcella_setup(void);
  260. void jmr3927_setup(void);
  261.   void it8172_setup(void);
  262. void swarm_setup(void);
  263. void hp_setup(void);
  265. unsigned long bootmap_size;
  266. unsigned long start_pfn, max_pfn, max_low_pfn, first_usable_pfn;
  267. #ifdef CONFIG_BLK_DEV_INITRD
  268. unsigned long tmp;
  269. unsigned long* initrd_header;
  270. #endif
  272. int i;
  274. #ifdef CONFIG_BLK_DEV_FD
  275. fd_ops = &no_fd_ops;
  276. #endif
  278. #ifdef CONFIG_BLK_DEV_IDE
  279. ide_ops = &no_ide_ops;
  280. #endif
  282. #ifdef CONFIG_PC_KEYB
  283. kbd_ops = &no_kbd_ops;
  284. #endif
  286. rtc_ops = &no_rtc_ops;
  288. switch(mips_machgroup)
  289. {
  290. #ifdef CONFIG_BAGET_MIPS
  291. case MACH_GROUP_BAGET:
  292. baget_setup();
  293. break;
  294. #endif
  295. #ifdef CONFIG_MIPS_COBALT
  296.         case MACH_GROUP_COBALT:
  297.                 cobalt_setup();
  298.                 break;
  299. #endif
  300. #ifdef CONFIG_DECSTATION
  301. case MACH_GROUP_DEC:
  302. decstation_setup();
  303. break;
  304. #endif
  305. #ifdef CONFIG_MIPS_ATLAS
  306. case MACH_GROUP_UNKNOWN:
  307. atlas_setup();
  308. break;
  309. #endif
  310. #ifdef CONFIG_MIPS_JAZZ
  311. case MACH_GROUP_JAZZ:
  312. jazz_setup();
  313. break;
  314. #endif
  315. #ifdef CONFIG_MIPS_MALTA
  316. case MACH_GROUP_UNKNOWN:
  317. malta_setup();
  318. break;
  319. #endif
  320. #ifdef CONFIG_MOMENCO_OCELOT
  321. case MACH_GROUP_MOMENCO:
  322. momenco_ocelot_setup();
  323. break;
  324. #endif
  325. #ifdef CONFIG_MOMENCO_OCELOT_G
  326. case MACH_GROUP_MOMENCO:
  327. momenco_ocelot_g_setup();
  328. break;
  329. #endif
  330. #ifdef CONFIG_MIPS_SEAD
  331. case MACH_GROUP_UNKNOWN:
  332. sead_setup();
  333. break;
  334. #endif
  335. #ifdef CONFIG_SGI_IP22
  336. /* As of now this is only IP22.  */
  337. case MACH_GROUP_SGI:
  338. ip22_setup();
  339. break;
  340. #endif
  341. #ifdef CONFIG_SNI_RM200_PCI
  342. case MACH_GROUP_SNI_RM:
  343. sni_rm200_pci_setup();
  344. break;
  345. #endif
  346. #ifdef CONFIG_DDB5074
  347. case MACH_GROUP_NEC_DDB:
  348. ddb_setup();
  349. break;
  350. #endif
  351. #ifdef CONFIG_DDB5476
  352.        case MACH_GROUP_NEC_DDB:
  353.                ddb_setup();
  354.                break;
  355. #endif
  356. #ifdef CONFIG_DDB5477
  357.        case MACH_GROUP_NEC_DDB:
  358.                ddb_setup();
  359.                break;
  360. #endif
  361. #ifdef CONFIG_CPU_VR41XX
  362. case MACH_GROUP_NEC_VR41XX:
  363. switch (mips_machtype) {
  364. #ifdef CONFIG_NEC_OSPREY
  365. case MACH_NEC_OSPREY:
  366. nec_osprey_setup();
  367. break;
  368. #endif
  369. #ifdef CONFIG_NEC_EAGLE
  370. case MACH_NEC_EAGLE:
  371. nec_eagle_setup();
  372. break;
  373. #endif
  374. #ifdef CONFIG_ZAO_CAPCELLA
  375. case MACH_ZAO_CAPCELLA:
  376. zao_capcella_setup();
  377. break;
  378. #endif
  379. }
  380. break;
  381. #endif
  382. #ifdef CONFIG_MIPS_EV96100
  383. case MACH_GROUP_GALILEO:
  384. ev96100_setup();
  385. break;
  386. #endif
  387. #ifdef CONFIG_MIPS_EV64120
  388. case MACH_GROUP_GALILEO:
  389. ev64120_setup();
  390. break;
  391. #endif
  392. #if defined(CONFIG_MIPS_IVR) || defined(CONFIG_MIPS_ITE8172)
  393. case  MACH_GROUP_ITE:
  394. case  MACH_GROUP_GLOBESPAN:
  395. it8172_setup();
  396. break;
  397. #endif
  398. #ifdef CONFIG_NINO
  399. case MACH_GROUP_PHILIPS:
  400. nino_setup();
  401. break;
  402. #endif
  403. #ifdef CONFIG_MIPS_PB1000
  404. case MACH_GROUP_ALCHEMY:
  405. au1000_setup();
  406. break;
  407. #endif
  408. #ifdef CONFIG_MIPS_PB1100
  409. case MACH_GROUP_ALCHEMY:
  410. au1100_setup();
  411. break;
  412. #endif
  413. #ifdef CONFIG_MIPS_PB1500
  414. case MACH_GROUP_ALCHEMY:
  415. au1500_setup();
  416. break;
  417. #endif
  418. #ifdef CONFIG_TOSHIBA_JMR3927
  419. case MACH_GROUP_TOSHIBA:
  420. jmr3927_setup();
  421. break;
  422. #endif
  423. #ifdef CONFIG_SIBYTE_SWARM
  424. case MACH_GROUP_SIBYTE:
  425. swarm_setup();
  426. break;
  427. #endif
  428. #ifdef CONFIG_HP_LASERJET
  429.         case MACH_GROUP_HP_LJ:
  430.                 hp_setup();
  431.                 break;
  432. #endif
  433. default:
  434. panic("Unsupported architecture");
  435. }
  437. strncpy(command_line, arcs_cmdline, sizeof command_line);
  438. command_line[sizeof command_line - 1] = 0;
  439. strcpy(saved_command_line, command_line);
  440. *cmdline_p = command_line;
  442. parse_mem_cmdline();
  444. #define PFN_UP(x) (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)
  445. #define PFN_DOWN(x) ((x) >> PAGE_SHIFT)
  446. #define PFN_PHYS(x) ((x) << PAGE_SHIFT)
  448. #define MAXMEM HIGHMEM_START
  449. #define MAXMEM_PFN PFN_DOWN(MAXMEM)
  451. #ifdef CONFIG_BLK_DEV_INITRD
  452. tmp = (((unsigned long)&_end + PAGE_SIZE-1) & PAGE_MASK) - 8;
  453. if (tmp < (unsigned long)&_end)
  454. tmp += PAGE_SIZE;
  455. initrd_header = (unsigned long *)tmp;
  456. if (initrd_header[0] == 0x494E5244) {
  457. initrd_start = (unsigned long)&initrd_header[2];
  458. initrd_end = initrd_start + initrd_header[1];
  459. }
  460. start_pfn = PFN_UP(__pa((&_end)+(initrd_end - initrd_start) + PAGE_SIZE));
  461. #else
  462. /*
  463.  * Partially used pages are not usable - thus
  464.  * we are rounding upwards.
  465.  */
  466. start_pfn = PFN_UP(__pa(&_end));
  467. #endif /* CONFIG_BLK_DEV_INITRD */
  469. /* Find the highest page frame number we have available.  */
  470. max_pfn = 0;
  471. first_usable_pfn = -1UL;
  472. for (i = 0; i < boot_mem_map.nr_map; i++) {
  473. unsigned long start, end;
  475. if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
  476. continue;
  478. start = PFN_UP(boot_mem_map.map[i].addr);
  479. end = PFN_DOWN(boot_mem_map.map[i].addr
  480.       + boot_mem_map.map[i].size);
  482. if (start >= end)
  483. continue;
  484. if (end > max_pfn)
  485. max_pfn = end;
  486. if (start < first_usable_pfn) {
  487. if (start > start_pfn) {
  488. first_usable_pfn = start;
  489. } else if (end > start_pfn) {
  490. first_usable_pfn = start_pfn;
  491. }
  492. }
  493. }
  495. /*
  496.  * Determine low and high memory ranges
  497.  */
  498. max_low_pfn = max_pfn;
  499. if (max_low_pfn > MAXMEM_PFN) {
  500. max_low_pfn = MAXMEM_PFN;
  501. #ifndef CONFIG_HIGHMEM
  502. /* Maximum memory usable is what is directly addressable */
  503. printk(KERN_WARNING "Warning only %ldMB will be used.n",
  504.        MAXMEM>>20);
  505. printk(KERN_WARNING "Use a HIGHMEM enabled kernel.n");
  506. #endif
  507. }
  509. #ifdef CONFIG_HIGHMEM
  510. /*
  511.  * Crude, we really should make a better attempt at detecting
  512.  * highstart_pfn
  513.  */
  514. highstart_pfn = highend_pfn = max_pfn;
  515. if (max_pfn > MAXMEM_PFN) {
  516. highstart_pfn = MAXMEM_PFN;
  517. printk(KERN_NOTICE "%ldMB HIGHMEM available.n",
  518.        (highend_pfn - highstart_pfn) >> (20 - PAGE_SHIFT));
  519. }
  520. #endif
  522. /* Initialize the boot-time allocator with low memory only.  */
  523. bootmap_size = init_bootmem(first_usable_pfn, max_low_pfn);
  525. /*
  526.  * Register fully available low RAM pages with the bootmem allocator.
  527.  */
  528. for (i = 0; i < boot_mem_map.nr_map; i++) {
  529. unsigned long curr_pfn, last_pfn, size;
  531. /*
  532.  * Reserve usable memory.
  533.  */
  534. if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
  535. continue;
  537. /*
  538.  * We are rounding up the start address of usable memory:
  539.  */
  540. curr_pfn = PFN_UP(boot_mem_map.map[i].addr);
  541. if (curr_pfn >= max_low_pfn)
  542. continue;
  543. if (curr_pfn < start_pfn)
  544. curr_pfn = start_pfn;
  546. /*
  547.  * ... and at the end of the usable range downwards:
  548.  */
  549. last_pfn = PFN_DOWN(boot_mem_map.map[i].addr
  550.     + boot_mem_map.map[i].size);
  552. if (last_pfn > max_low_pfn)
  553. last_pfn = max_low_pfn;
  555. /*
  556.  * Only register lowmem part of lowmem segment with bootmem.
  557.  */
  558. size = last_pfn - curr_pfn;
  559. if (curr_pfn > PFN_DOWN(HIGHMEM_START))
  560. continue;
  561. if (curr_pfn + size - 1 > PFN_DOWN(HIGHMEM_START))
  562. size = PFN_DOWN(HIGHMEM_START) - curr_pfn;
  563. if (!size)
  564. continue;
  566. /*
  567.  * ... finally, did all the rounding and playing
  568.  * around just make the area go away?
  569.  */
  570. if (last_pfn <= curr_pfn)
  571. continue;
  573. /* Register lowmem ranges */
  574. free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
  575. }
  577. /* Reserve the bootmap memory.  */
  578. reserve_bootmem(PFN_PHYS(first_usable_pfn), bootmap_size);
  580. #ifdef CONFIG_BLK_DEV_INITRD
  581. /* Board specific code should have set up initrd_start and initrd_end */
  582. ROOT_DEV = MKDEV(RAMDISK_MAJOR, 0);
  583. if (&__rd_start != &__rd_end) {
  584. initrd_start = (unsigned long)&__rd_start;
  585. initrd_end = (unsigned long)&__rd_end;
  586. }
  587. initrd_below_start_ok = 1;
  588. if (initrd_start) {
  589. unsigned long initrd_size = ((unsigned char *)initrd_end) - ((unsigned char *)initrd_start);
  590. printk("Initial ramdisk at: 0x%p (%lu bytes)n",
  591.        (void *)initrd_start,
  592.        initrd_size);
  593. if (PHYSADDR(initrd_end) > PFN_PHYS(max_low_pfn)) {
  594. printk("initrd extends beyond end of memory "
  595.        "(0x%lx > 0x%p)ndisabling initrdn",
  596.        PHYSADDR(initrd_end),
  597.        PFN_PHYS(max_low_pfn));
  598. initrd_start = initrd_end = 0;
  599. }
  600. }
  601. #endif /* CONFIG_BLK_DEV_INITRD  */
  603. paging_init();
  605. code_resource.start = virt_to_bus(&_ftext);
  606. code_resource.end = virt_to_bus(&_etext) - 1;
  607. data_resource.start = virt_to_bus(&_fdata);
  608. data_resource.end = virt_to_bus(&_edata) - 1;
  610. /*
  611.  * Request address space for all standard RAM.
  612.  */
  613. for (i = 0; i < boot_mem_map.nr_map; i++) {
  614. struct resource *res;
  615. unsigned long addr_pfn, end_pfn;
  617. res = alloc_bootmem(sizeof(struct resource));
  618. switch (boot_mem_map.map[i].type) {
  619. case BOOT_MEM_RAM:
  620. case BOOT_MEM_ROM_DATA:
  621. res->name = "System RAM";
  622. break;
  623. case BOOT_MEM_RESERVED:
  624. default:
  625. res->name = "reserved";
  626. }
  627. addr_pfn = PFN_UP(boot_mem_map.map[i].addr);
  628. end_pfn = PFN_UP(boot_mem_map.map[i].addr+boot_mem_map.map[i].size);
  629. if (addr_pfn > max_low_pfn)
  630. continue;
  631. res->start = boot_mem_map.map[i].addr;
  632. if (end_pfn < max_low_pfn) {
  633. res->end = res->start + boot_mem_map.map[i].size - 1;
  634. } else {
  635. res->end = max_low_pfn - 1;
  636. }
  637. res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  638. request_resource(&iomem_resource, res);
  640. /*
  641.  *  We dont't know which RAM region contains kernel data,
  642.  *  so we try it repeatedly and let the resource manager
  643.  *  test it.
  644.  */
  645. request_resource(res, &code_resource);
  646. request_resource(res, &data_resource);
  647. }
  648. }
  650. static int __init fpu_disable(char *s)
  651. {
  652. mips_cpu.options &= ~MIPS_CPU_FPU;
  653. return 1;
  654. }
  655. __setup("nofpu", fpu_disable);