setup.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895
  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) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 03 Ralf Baechle
  9. * Copyright (C) 1996 Stoned Elipot
  10. * Copyright (C) 1999 Silicon Graphics, Inc.
  11. * Copyright (C) 2000, 2001, 2002, 2007 Maciej W. Rozycki
  12. */
  13. #include <linux/init.h>
  14. #include <linux/ioport.h>
  15. #include <linux/export.h>
  16. #include <linux/screen_info.h>
  17. #include <linux/memblock.h>
  18. #include <linux/bootmem.h>
  19. #include <linux/initrd.h>
  20. #include <linux/root_dev.h>
  21. #include <linux/highmem.h>
  22. #include <linux/console.h>
  23. #include <linux/pfn.h>
  24. #include <linux/debugfs.h>
  25. #include <linux/kexec.h>
  26. #include <linux/sizes.h>
  27. #include <linux/device.h>
  28. #include <linux/dma-contiguous.h>
  29. #include <linux/decompress/generic.h>
  30. #include <asm/addrspace.h>
  31. #include <asm/bootinfo.h>
  32. #include <asm/bugs.h>
  33. #include <asm/cache.h>
  34. #include <asm/cdmm.h>
  35. #include <asm/cpu.h>
  36. #include <asm/debug.h>
  37. #include <asm/sections.h>
  38. #include <asm/setup.h>
  39. #include <asm/smp-ops.h>
  40. #include <asm/prom.h>
  41. #ifdef CONFIG_MIPS_ELF_APPENDED_DTB
  42. const char __section(.appended_dtb) __appended_dtb[0x100000];
  43. #endif /* CONFIG_MIPS_ELF_APPENDED_DTB */
  44. struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly;
  45. EXPORT_SYMBOL(cpu_data);
  46. #ifdef CONFIG_VT
  47. struct screen_info screen_info;
  48. #endif
  49. /*
  50. * Setup information
  51. *
  52. * These are initialized so they are in the .data section
  53. */
  54. unsigned long mips_machtype __read_mostly = MACH_UNKNOWN;
  55. EXPORT_SYMBOL(mips_machtype);
  56. struct boot_mem_map boot_mem_map;
  57. static char __initdata command_line[COMMAND_LINE_SIZE];
  58. char __initdata arcs_cmdline[COMMAND_LINE_SIZE];
  59. #ifdef CONFIG_CMDLINE_BOOL
  60. static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
  61. #endif
  62. /*
  63. * mips_io_port_base is the begin of the address space to which x86 style
  64. * I/O ports are mapped.
  65. */
  66. const unsigned long mips_io_port_base = -1;
  67. EXPORT_SYMBOL(mips_io_port_base);
  68. static struct resource code_resource = { .name = "Kernel code", };
  69. static struct resource data_resource = { .name = "Kernel data", };
  70. static void *detect_magic __initdata = detect_memory_region;
  71. void __init add_memory_region(phys_addr_t start, phys_addr_t size, long type)
  72. {
  73. int x = boot_mem_map.nr_map;
  74. int i;
  75. /* Sanity check */
  76. if (start + size < start) {
  77. pr_warn("Trying to add an invalid memory region, skipped\n");
  78. return;
  79. }
  80. /*
  81. * Try to merge with existing entry, if any.
  82. */
  83. for (i = 0; i < boot_mem_map.nr_map; i++) {
  84. struct boot_mem_map_entry *entry = boot_mem_map.map + i;
  85. unsigned long top;
  86. if (entry->type != type)
  87. continue;
  88. if (start + size < entry->addr)
  89. continue; /* no overlap */
  90. if (entry->addr + entry->size < start)
  91. continue; /* no overlap */
  92. top = max(entry->addr + entry->size, start + size);
  93. entry->addr = min(entry->addr, start);
  94. entry->size = top - entry->addr;
  95. return;
  96. }
  97. if (boot_mem_map.nr_map == BOOT_MEM_MAP_MAX) {
  98. pr_err("Ooops! Too many entries in the memory map!\n");
  99. return;
  100. }
  101. boot_mem_map.map[x].addr = start;
  102. boot_mem_map.map[x].size = size;
  103. boot_mem_map.map[x].type = type;
  104. boot_mem_map.nr_map++;
  105. }
  106. void __init detect_memory_region(phys_addr_t start, phys_addr_t sz_min, phys_addr_t sz_max)
  107. {
  108. void *dm = &detect_magic;
  109. phys_addr_t size;
  110. for (size = sz_min; size < sz_max; size <<= 1) {
  111. if (!memcmp(dm, dm + size, sizeof(detect_magic)))
  112. break;
  113. }
  114. pr_debug("Memory: %lluMB of RAM detected at 0x%llx (min: %lluMB, max: %lluMB)\n",
  115. ((unsigned long long) size) / SZ_1M,
  116. (unsigned long long) start,
  117. ((unsigned long long) sz_min) / SZ_1M,
  118. ((unsigned long long) sz_max) / SZ_1M);
  119. add_memory_region(start, size, BOOT_MEM_RAM);
  120. }
  121. static void __init print_memory_map(void)
  122. {
  123. int i;
  124. const int field = 2 * sizeof(unsigned long);
  125. for (i = 0; i < boot_mem_map.nr_map; i++) {
  126. printk(KERN_INFO " memory: %0*Lx @ %0*Lx ",
  127. field, (unsigned long long) boot_mem_map.map[i].size,
  128. field, (unsigned long long) boot_mem_map.map[i].addr);
  129. switch (boot_mem_map.map[i].type) {
  130. case BOOT_MEM_RAM:
  131. printk(KERN_CONT "(usable)\n");
  132. break;
  133. case BOOT_MEM_INIT_RAM:
  134. printk(KERN_CONT "(usable after init)\n");
  135. break;
  136. case BOOT_MEM_ROM_DATA:
  137. printk(KERN_CONT "(ROM data)\n");
  138. break;
  139. case BOOT_MEM_RESERVED:
  140. printk(KERN_CONT "(reserved)\n");
  141. break;
  142. default:
  143. printk(KERN_CONT "type %lu\n", boot_mem_map.map[i].type);
  144. break;
  145. }
  146. }
  147. }
  148. /*
  149. * Manage initrd
  150. */
  151. #ifdef CONFIG_BLK_DEV_INITRD
  152. static int __init rd_start_early(char *p)
  153. {
  154. unsigned long start = memparse(p, &p);
  155. #ifdef CONFIG_64BIT
  156. /* Guess if the sign extension was forgotten by bootloader */
  157. if (start < XKPHYS)
  158. start = (int)start;
  159. #endif
  160. initrd_start = start;
  161. initrd_end += start;
  162. return 0;
  163. }
  164. early_param("rd_start", rd_start_early);
  165. static int __init rd_size_early(char *p)
  166. {
  167. initrd_end += memparse(p, &p);
  168. return 0;
  169. }
  170. early_param("rd_size", rd_size_early);
  171. /* it returns the next free pfn after initrd */
  172. static unsigned long __init init_initrd(void)
  173. {
  174. unsigned long end;
  175. /*
  176. * Board specific code or command line parser should have
  177. * already set up initrd_start and initrd_end. In these cases
  178. * perfom sanity checks and use them if all looks good.
  179. */
  180. if (!initrd_start || initrd_end <= initrd_start)
  181. goto disable;
  182. if (initrd_start & ~PAGE_MASK) {
  183. pr_err("initrd start must be page aligned\n");
  184. goto disable;
  185. }
  186. if (initrd_start < PAGE_OFFSET) {
  187. pr_err("initrd start < PAGE_OFFSET\n");
  188. goto disable;
  189. }
  190. /*
  191. * Sanitize initrd addresses. For example firmware
  192. * can't guess if they need to pass them through
  193. * 64-bits values if the kernel has been built in pure
  194. * 32-bit. We need also to switch from KSEG0 to XKPHYS
  195. * addresses now, so the code can now safely use __pa().
  196. */
  197. end = __pa(initrd_end);
  198. initrd_end = (unsigned long)__va(end);
  199. initrd_start = (unsigned long)__va(__pa(initrd_start));
  200. ROOT_DEV = Root_RAM0;
  201. return PFN_UP(end);
  202. disable:
  203. initrd_start = 0;
  204. initrd_end = 0;
  205. return 0;
  206. }
  207. /* In some conditions (e.g. big endian bootloader with a little endian
  208. kernel), the initrd might appear byte swapped. Try to detect this and
  209. byte swap it if needed. */
  210. static void __init maybe_bswap_initrd(void)
  211. {
  212. #if defined(CONFIG_CPU_CAVIUM_OCTEON)
  213. u64 buf;
  214. /* Check for CPIO signature */
  215. if (!memcmp((void *)initrd_start, "070701", 6))
  216. return;
  217. /* Check for compressed initrd */
  218. if (decompress_method((unsigned char *)initrd_start, 8, NULL))
  219. return;
  220. /* Try again with a byte swapped header */
  221. buf = swab64p((u64 *)initrd_start);
  222. if (!memcmp(&buf, "070701", 6) ||
  223. decompress_method((unsigned char *)(&buf), 8, NULL)) {
  224. unsigned long i;
  225. pr_info("Byteswapped initrd detected\n");
  226. for (i = initrd_start; i < ALIGN(initrd_end, 8); i += 8)
  227. swab64s((u64 *)i);
  228. }
  229. #endif
  230. }
  231. static void __init finalize_initrd(void)
  232. {
  233. unsigned long size = initrd_end - initrd_start;
  234. if (size == 0) {
  235. printk(KERN_INFO "Initrd not found or empty");
  236. goto disable;
  237. }
  238. if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) {
  239. printk(KERN_ERR "Initrd extends beyond end of memory");
  240. goto disable;
  241. }
  242. maybe_bswap_initrd();
  243. reserve_bootmem(__pa(initrd_start), size, BOOTMEM_DEFAULT);
  244. initrd_below_start_ok = 1;
  245. pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n",
  246. initrd_start, size);
  247. return;
  248. disable:
  249. printk(KERN_CONT " - disabling initrd\n");
  250. initrd_start = 0;
  251. initrd_end = 0;
  252. }
  253. #else /* !CONFIG_BLK_DEV_INITRD */
  254. static unsigned long __init init_initrd(void)
  255. {
  256. return 0;
  257. }
  258. #define finalize_initrd() do {} while (0)
  259. #endif
  260. /*
  261. * Initialize the bootmem allocator. It also setup initrd related data
  262. * if needed.
  263. */
  264. #if defined(CONFIG_SGI_IP27) || (defined(CONFIG_CPU_LOONGSON3) && defined(CONFIG_NUMA))
  265. static void __init bootmem_init(void)
  266. {
  267. init_initrd();
  268. finalize_initrd();
  269. }
  270. #else /* !CONFIG_SGI_IP27 */
  271. static void __init bootmem_init(void)
  272. {
  273. unsigned long reserved_end;
  274. unsigned long mapstart = ~0UL;
  275. unsigned long bootmap_size;
  276. int i;
  277. /*
  278. * Sanity check any INITRD first. We don't take it into account
  279. * for bootmem setup initially, rely on the end-of-kernel-code
  280. * as our memory range starting point. Once bootmem is inited we
  281. * will reserve the area used for the initrd.
  282. */
  283. init_initrd();
  284. reserved_end = (unsigned long) PFN_UP(__pa_symbol(&_end));
  285. /*
  286. * max_low_pfn is not a number of pages. The number of pages
  287. * of the system is given by 'max_low_pfn - min_low_pfn'.
  288. */
  289. min_low_pfn = ~0UL;
  290. max_low_pfn = 0;
  291. /*
  292. * Find the highest page frame number we have available.
  293. */
  294. for (i = 0; i < boot_mem_map.nr_map; i++) {
  295. unsigned long start, end;
  296. if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
  297. continue;
  298. start = PFN_UP(boot_mem_map.map[i].addr);
  299. end = PFN_DOWN(boot_mem_map.map[i].addr
  300. + boot_mem_map.map[i].size);
  301. if (end > max_low_pfn)
  302. max_low_pfn = end;
  303. if (start < min_low_pfn)
  304. min_low_pfn = start;
  305. if (end <= reserved_end)
  306. continue;
  307. #ifdef CONFIG_BLK_DEV_INITRD
  308. /* Skip zones before initrd and initrd itself */
  309. if (initrd_end && end <= (unsigned long)PFN_UP(__pa(initrd_end)))
  310. continue;
  311. #endif
  312. if (start >= mapstart)
  313. continue;
  314. mapstart = max(reserved_end, start);
  315. }
  316. if (min_low_pfn >= max_low_pfn)
  317. panic("Incorrect memory mapping !!!");
  318. if (min_low_pfn > ARCH_PFN_OFFSET) {
  319. pr_info("Wasting %lu bytes for tracking %lu unused pages\n",
  320. (min_low_pfn - ARCH_PFN_OFFSET) * sizeof(struct page),
  321. min_low_pfn - ARCH_PFN_OFFSET);
  322. } else if (min_low_pfn < ARCH_PFN_OFFSET) {
  323. pr_info("%lu free pages won't be used\n",
  324. ARCH_PFN_OFFSET - min_low_pfn);
  325. }
  326. min_low_pfn = ARCH_PFN_OFFSET;
  327. /*
  328. * Determine low and high memory ranges
  329. */
  330. max_pfn = max_low_pfn;
  331. if (max_low_pfn > PFN_DOWN(HIGHMEM_START)) {
  332. #ifdef CONFIG_HIGHMEM
  333. highstart_pfn = PFN_DOWN(HIGHMEM_START);
  334. highend_pfn = max_low_pfn;
  335. #endif
  336. max_low_pfn = PFN_DOWN(HIGHMEM_START);
  337. }
  338. #ifdef CONFIG_BLK_DEV_INITRD
  339. /*
  340. * mapstart should be after initrd_end
  341. */
  342. if (initrd_end)
  343. mapstart = max(mapstart, (unsigned long)PFN_UP(__pa(initrd_end)));
  344. #endif
  345. /*
  346. * Initialize the boot-time allocator with low memory only.
  347. */
  348. bootmap_size = init_bootmem_node(NODE_DATA(0), mapstart,
  349. min_low_pfn, max_low_pfn);
  350. for (i = 0; i < boot_mem_map.nr_map; i++) {
  351. unsigned long start, end;
  352. start = PFN_UP(boot_mem_map.map[i].addr);
  353. end = PFN_DOWN(boot_mem_map.map[i].addr
  354. + boot_mem_map.map[i].size);
  355. if (start <= min_low_pfn)
  356. start = min_low_pfn;
  357. if (start >= end)
  358. continue;
  359. #ifndef CONFIG_HIGHMEM
  360. if (end > max_low_pfn)
  361. end = max_low_pfn;
  362. /*
  363. * ... finally, is the area going away?
  364. */
  365. if (end <= start)
  366. continue;
  367. #endif
  368. memblock_add_node(PFN_PHYS(start), PFN_PHYS(end - start), 0);
  369. }
  370. /*
  371. * Register fully available low RAM pages with the bootmem allocator.
  372. */
  373. for (i = 0; i < boot_mem_map.nr_map; i++) {
  374. unsigned long start, end, size;
  375. start = PFN_UP(boot_mem_map.map[i].addr);
  376. end = PFN_DOWN(boot_mem_map.map[i].addr
  377. + boot_mem_map.map[i].size);
  378. /*
  379. * Reserve usable memory.
  380. */
  381. switch (boot_mem_map.map[i].type) {
  382. case BOOT_MEM_RAM:
  383. break;
  384. case BOOT_MEM_INIT_RAM:
  385. memory_present(0, start, end);
  386. continue;
  387. default:
  388. /* Not usable memory */
  389. continue;
  390. }
  391. /*
  392. * We are rounding up the start address of usable memory
  393. * and at the end of the usable range downwards.
  394. */
  395. if (start >= max_low_pfn)
  396. continue;
  397. if (start < reserved_end)
  398. start = reserved_end;
  399. if (end > max_low_pfn)
  400. end = max_low_pfn;
  401. /*
  402. * ... finally, is the area going away?
  403. */
  404. if (end <= start)
  405. continue;
  406. size = end - start;
  407. /* Register lowmem ranges */
  408. free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT);
  409. memory_present(0, start, end);
  410. }
  411. /*
  412. * Reserve the bootmap memory.
  413. */
  414. reserve_bootmem(PFN_PHYS(mapstart), bootmap_size, BOOTMEM_DEFAULT);
  415. #ifdef CONFIG_RELOCATABLE
  416. /*
  417. * The kernel reserves all memory below its _end symbol as bootmem,
  418. * but the kernel may now be at a much higher address. The memory
  419. * between the original and new locations may be returned to the system.
  420. */
  421. if (__pa_symbol(_text) > __pa_symbol(VMLINUX_LOAD_ADDRESS)) {
  422. unsigned long offset;
  423. extern void show_kernel_relocation(const char *level);
  424. offset = __pa_symbol(_text) - __pa_symbol(VMLINUX_LOAD_ADDRESS);
  425. free_bootmem(__pa_symbol(VMLINUX_LOAD_ADDRESS), offset);
  426. #if defined(CONFIG_DEBUG_KERNEL) && defined(CONFIG_DEBUG_INFO)
  427. /*
  428. * This information is necessary when debugging the kernel
  429. * But is a security vulnerability otherwise!
  430. */
  431. show_kernel_relocation(KERN_INFO);
  432. #endif
  433. }
  434. #endif
  435. /*
  436. * Reserve initrd memory if needed.
  437. */
  438. finalize_initrd();
  439. }
  440. #endif /* CONFIG_SGI_IP27 */
  441. /*
  442. * arch_mem_init - initialize memory management subsystem
  443. *
  444. * o plat_mem_setup() detects the memory configuration and will record detected
  445. * memory areas using add_memory_region.
  446. *
  447. * At this stage the memory configuration of the system is known to the
  448. * kernel but generic memory management system is still entirely uninitialized.
  449. *
  450. * o bootmem_init()
  451. * o sparse_init()
  452. * o paging_init()
  453. * o dma_contiguous_reserve()
  454. *
  455. * At this stage the bootmem allocator is ready to use.
  456. *
  457. * NOTE: historically plat_mem_setup did the entire platform initialization.
  458. * This was rather impractical because it meant plat_mem_setup had to
  459. * get away without any kind of memory allocator. To keep old code from
  460. * breaking plat_setup was just renamed to plat_mem_setup and a second platform
  461. * initialization hook for anything else was introduced.
  462. */
  463. static int usermem __initdata;
  464. static int __init early_parse_mem(char *p)
  465. {
  466. phys_addr_t start, size;
  467. /*
  468. * If a user specifies memory size, we
  469. * blow away any automatically generated
  470. * size.
  471. */
  472. if (usermem == 0) {
  473. boot_mem_map.nr_map = 0;
  474. usermem = 1;
  475. }
  476. start = 0;
  477. size = memparse(p, &p);
  478. if (*p == '@')
  479. start = memparse(p + 1, &p);
  480. add_memory_region(start, size, BOOT_MEM_RAM);
  481. return 0;
  482. }
  483. early_param("mem", early_parse_mem);
  484. #ifdef CONFIG_PROC_VMCORE
  485. unsigned long setup_elfcorehdr, setup_elfcorehdr_size;
  486. static int __init early_parse_elfcorehdr(char *p)
  487. {
  488. int i;
  489. setup_elfcorehdr = memparse(p, &p);
  490. for (i = 0; i < boot_mem_map.nr_map; i++) {
  491. unsigned long start = boot_mem_map.map[i].addr;
  492. unsigned long end = (boot_mem_map.map[i].addr +
  493. boot_mem_map.map[i].size);
  494. if (setup_elfcorehdr >= start && setup_elfcorehdr < end) {
  495. /*
  496. * Reserve from the elf core header to the end of
  497. * the memory segment, that should all be kdump
  498. * reserved memory.
  499. */
  500. setup_elfcorehdr_size = end - setup_elfcorehdr;
  501. break;
  502. }
  503. }
  504. /*
  505. * If we don't find it in the memory map, then we shouldn't
  506. * have to worry about it, as the new kernel won't use it.
  507. */
  508. return 0;
  509. }
  510. early_param("elfcorehdr", early_parse_elfcorehdr);
  511. #endif
  512. static void __init arch_mem_addpart(phys_addr_t mem, phys_addr_t end, int type)
  513. {
  514. phys_addr_t size;
  515. int i;
  516. size = end - mem;
  517. if (!size)
  518. return;
  519. /* Make sure it is in the boot_mem_map */
  520. for (i = 0; i < boot_mem_map.nr_map; i++) {
  521. if (mem >= boot_mem_map.map[i].addr &&
  522. mem < (boot_mem_map.map[i].addr +
  523. boot_mem_map.map[i].size))
  524. return;
  525. }
  526. add_memory_region(mem, size, type);
  527. }
  528. #ifdef CONFIG_KEXEC
  529. static inline unsigned long long get_total_mem(void)
  530. {
  531. unsigned long long total;
  532. total = max_pfn - min_low_pfn;
  533. return total << PAGE_SHIFT;
  534. }
  535. static void __init mips_parse_crashkernel(void)
  536. {
  537. unsigned long long total_mem;
  538. unsigned long long crash_size, crash_base;
  539. int ret;
  540. total_mem = get_total_mem();
  541. ret = parse_crashkernel(boot_command_line, total_mem,
  542. &crash_size, &crash_base);
  543. if (ret != 0 || crash_size <= 0)
  544. return;
  545. crashk_res.start = crash_base;
  546. crashk_res.end = crash_base + crash_size - 1;
  547. }
  548. static void __init request_crashkernel(struct resource *res)
  549. {
  550. int ret;
  551. ret = request_resource(res, &crashk_res);
  552. if (!ret)
  553. pr_info("Reserving %ldMB of memory at %ldMB for crashkernel\n",
  554. (unsigned long)((crashk_res.end -
  555. crashk_res.start + 1) >> 20),
  556. (unsigned long)(crashk_res.start >> 20));
  557. }
  558. #else /* !defined(CONFIG_KEXEC) */
  559. static void __init mips_parse_crashkernel(void)
  560. {
  561. }
  562. static void __init request_crashkernel(struct resource *res)
  563. {
  564. }
  565. #endif /* !defined(CONFIG_KEXEC) */
  566. #define USE_PROM_CMDLINE IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_BOOTLOADER)
  567. #define USE_DTB_CMDLINE IS_ENABLED(CONFIG_MIPS_CMDLINE_FROM_DTB)
  568. #define EXTEND_WITH_PROM IS_ENABLED(CONFIG_MIPS_CMDLINE_DTB_EXTEND)
  569. #define BUILTIN_EXTEND_WITH_PROM \
  570. IS_ENABLED(CONFIG_MIPS_CMDLINE_BUILTIN_EXTEND)
  571. static void __init arch_mem_init(char **cmdline_p)
  572. {
  573. struct memblock_region *reg;
  574. extern void plat_mem_setup(void);
  575. /* call board setup routine */
  576. plat_mem_setup();
  577. /*
  578. * Make sure all kernel memory is in the maps. The "UP" and
  579. * "DOWN" are opposite for initdata since if it crosses over
  580. * into another memory section you don't want that to be
  581. * freed when the initdata is freed.
  582. */
  583. arch_mem_addpart(PFN_DOWN(__pa_symbol(&_text)) << PAGE_SHIFT,
  584. PFN_UP(__pa_symbol(&_edata)) << PAGE_SHIFT,
  585. BOOT_MEM_RAM);
  586. arch_mem_addpart(PFN_UP(__pa_symbol(&__init_begin)) << PAGE_SHIFT,
  587. PFN_DOWN(__pa_symbol(&__init_end)) << PAGE_SHIFT,
  588. BOOT_MEM_INIT_RAM);
  589. pr_info("Determined physical RAM map:\n");
  590. print_memory_map();
  591. #if defined(CONFIG_CMDLINE_BOOL) && defined(CONFIG_CMDLINE_OVERRIDE)
  592. strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
  593. #else
  594. if ((USE_PROM_CMDLINE && arcs_cmdline[0]) ||
  595. (USE_DTB_CMDLINE && !boot_command_line[0]))
  596. strlcpy(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE);
  597. if (EXTEND_WITH_PROM && arcs_cmdline[0]) {
  598. if (boot_command_line[0])
  599. strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
  600. strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE);
  601. }
  602. #if defined(CONFIG_CMDLINE_BOOL)
  603. if (builtin_cmdline[0]) {
  604. if (boot_command_line[0])
  605. strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
  606. strlcat(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
  607. }
  608. if (BUILTIN_EXTEND_WITH_PROM && arcs_cmdline[0]) {
  609. if (boot_command_line[0])
  610. strlcat(boot_command_line, " ", COMMAND_LINE_SIZE);
  611. strlcat(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE);
  612. }
  613. #endif
  614. #endif
  615. strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
  616. *cmdline_p = command_line;
  617. parse_early_param();
  618. if (usermem) {
  619. pr_info("User-defined physical RAM map:\n");
  620. print_memory_map();
  621. }
  622. bootmem_init();
  623. #ifdef CONFIG_PROC_VMCORE
  624. if (setup_elfcorehdr && setup_elfcorehdr_size) {
  625. printk(KERN_INFO "kdump reserved memory at %lx-%lx\n",
  626. setup_elfcorehdr, setup_elfcorehdr_size);
  627. reserve_bootmem(setup_elfcorehdr, setup_elfcorehdr_size,
  628. BOOTMEM_DEFAULT);
  629. }
  630. #endif
  631. mips_parse_crashkernel();
  632. #ifdef CONFIG_KEXEC
  633. if (crashk_res.start != crashk_res.end)
  634. reserve_bootmem(crashk_res.start,
  635. crashk_res.end - crashk_res.start + 1,
  636. BOOTMEM_DEFAULT);
  637. #endif
  638. device_tree_init();
  639. sparse_init();
  640. plat_swiotlb_setup();
  641. paging_init();
  642. dma_contiguous_reserve(PFN_PHYS(max_low_pfn));
  643. /* Tell bootmem about cma reserved memblock section */
  644. for_each_memblock(reserved, reg)
  645. if (reg->size != 0)
  646. reserve_bootmem(reg->base, reg->size, BOOTMEM_DEFAULT);
  647. reserve_bootmem_region(__pa_symbol(&__nosave_begin),
  648. __pa_symbol(&__nosave_end)); /* Reserve for hibernation */
  649. }
  650. static void __init resource_init(void)
  651. {
  652. int i;
  653. if (UNCAC_BASE != IO_BASE)
  654. return;
  655. code_resource.start = __pa_symbol(&_text);
  656. code_resource.end = __pa_symbol(&_etext) - 1;
  657. data_resource.start = __pa_symbol(&_etext);
  658. data_resource.end = __pa_symbol(&_edata) - 1;
  659. for (i = 0; i < boot_mem_map.nr_map; i++) {
  660. struct resource *res;
  661. unsigned long start, end;
  662. start = boot_mem_map.map[i].addr;
  663. end = boot_mem_map.map[i].addr + boot_mem_map.map[i].size - 1;
  664. if (start >= HIGHMEM_START)
  665. continue;
  666. if (end >= HIGHMEM_START)
  667. end = HIGHMEM_START - 1;
  668. res = alloc_bootmem(sizeof(struct resource));
  669. res->start = start;
  670. res->end = end;
  671. res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  672. switch (boot_mem_map.map[i].type) {
  673. case BOOT_MEM_RAM:
  674. case BOOT_MEM_INIT_RAM:
  675. case BOOT_MEM_ROM_DATA:
  676. res->name = "System RAM";
  677. res->flags |= IORESOURCE_SYSRAM;
  678. break;
  679. case BOOT_MEM_RESERVED:
  680. default:
  681. res->name = "reserved";
  682. }
  683. request_resource(&iomem_resource, res);
  684. /*
  685. * We don't know which RAM region contains kernel data,
  686. * so we try it repeatedly and let the resource manager
  687. * test it.
  688. */
  689. request_resource(res, &code_resource);
  690. request_resource(res, &data_resource);
  691. request_crashkernel(res);
  692. }
  693. }
  694. #ifdef CONFIG_SMP
  695. static void __init prefill_possible_map(void)
  696. {
  697. int i, possible = num_possible_cpus();
  698. if (possible > nr_cpu_ids)
  699. possible = nr_cpu_ids;
  700. for (i = 0; i < possible; i++)
  701. set_cpu_possible(i, true);
  702. for (; i < NR_CPUS; i++)
  703. set_cpu_possible(i, false);
  704. nr_cpu_ids = possible;
  705. }
  706. #else
  707. static inline void prefill_possible_map(void) {}
  708. #endif
  709. void __init setup_arch(char **cmdline_p)
  710. {
  711. cpu_probe();
  712. mips_cm_probe();
  713. prom_init();
  714. setup_early_fdc_console();
  715. #ifdef CONFIG_EARLY_PRINTK
  716. setup_early_printk();
  717. #endif
  718. cpu_report();
  719. check_bugs_early();
  720. #if defined(CONFIG_VT)
  721. #if defined(CONFIG_VGA_CONSOLE)
  722. conswitchp = &vga_con;
  723. #elif defined(CONFIG_DUMMY_CONSOLE)
  724. conswitchp = &dummy_con;
  725. #endif
  726. #endif
  727. arch_mem_init(cmdline_p);
  728. resource_init();
  729. plat_smp_setup();
  730. prefill_possible_map();
  731. cpu_cache_init();
  732. }
  733. unsigned long kernelsp[NR_CPUS];
  734. unsigned long fw_arg0, fw_arg1, fw_arg2, fw_arg3;
  735. #ifdef CONFIG_USE_OF
  736. unsigned long fw_passed_dtb;
  737. #endif
  738. #ifdef CONFIG_DEBUG_FS
  739. struct dentry *mips_debugfs_dir;
  740. static int __init debugfs_mips(void)
  741. {
  742. struct dentry *d;
  743. d = debugfs_create_dir("mips", NULL);
  744. if (!d)
  745. return -ENOMEM;
  746. mips_debugfs_dir = d;
  747. return 0;
  748. }
  749. arch_initcall(debugfs_mips);
  750. #endif