init.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681
  1. /*
  2. * linux/arch/arm/mm/init.c
  3. *
  4. * Copyright (C) 1995-2005 Russell King
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. */
  10. #include <linux/kernel.h>
  11. #include <linux/errno.h>
  12. #include <linux/swap.h>
  13. #include <linux/init.h>
  14. #include <linux/bootmem.h>
  15. #include <linux/mman.h>
  16. #include <linux/nodemask.h>
  17. #include <linux/initrd.h>
  18. #include <linux/highmem.h>
  19. #include <linux/gfp.h>
  20. #include <linux/memblock.h>
  21. #include <linux/sort.h>
  22. #include <asm/mach-types.h>
  23. #include <asm/sections.h>
  24. #include <asm/setup.h>
  25. #include <asm/sizes.h>
  26. #include <asm/tlb.h>
  27. #include <asm/fixmap.h>
  28. #include <asm/mach/arch.h>
  29. #include <asm/mach/map.h>
  30. #include "mm.h"
  31. static unsigned long phys_initrd_start __initdata = 0;
  32. static unsigned long phys_initrd_size __initdata = 0;
  33. static int __init early_initrd(char *p)
  34. {
  35. unsigned long start, size;
  36. char *endp;
  37. start = memparse(p, &endp);
  38. if (*endp == ',') {
  39. size = memparse(endp + 1, NULL);
  40. phys_initrd_start = start;
  41. phys_initrd_size = size;
  42. }
  43. return 0;
  44. }
  45. early_param("initrd", early_initrd);
  46. static int __init parse_tag_initrd(const struct tag *tag)
  47. {
  48. printk(KERN_WARNING "ATAG_INITRD is deprecated; "
  49. "please update your bootloader.\n");
  50. phys_initrd_start = __virt_to_phys(tag->u.initrd.start);
  51. phys_initrd_size = tag->u.initrd.size;
  52. return 0;
  53. }
  54. __tagtable(ATAG_INITRD, parse_tag_initrd);
  55. static int __init parse_tag_initrd2(const struct tag *tag)
  56. {
  57. phys_initrd_start = tag->u.initrd.start;
  58. phys_initrd_size = tag->u.initrd.size;
  59. return 0;
  60. }
  61. __tagtable(ATAG_INITRD2, parse_tag_initrd2);
  62. /*
  63. * This keeps memory configuration data used by a couple memory
  64. * initialization functions, as well as show_mem() for the skipping
  65. * of holes in the memory map. It is populated by arm_add_memory().
  66. */
  67. struct meminfo meminfo;
  68. void show_mem(unsigned int filter)
  69. {
  70. int free = 0, total = 0, reserved = 0;
  71. int shared = 0, cached = 0, slab = 0, i;
  72. struct meminfo * mi = &meminfo;
  73. printk("Mem-info:\n");
  74. show_free_areas();
  75. for_each_bank (i, mi) {
  76. struct membank *bank = &mi->bank[i];
  77. unsigned int pfn1, pfn2;
  78. struct page *page, *end;
  79. pfn1 = bank_pfn_start(bank);
  80. pfn2 = bank_pfn_end(bank);
  81. page = pfn_to_page(pfn1);
  82. end = pfn_to_page(pfn2 - 1) + 1;
  83. do {
  84. total++;
  85. if (PageReserved(page))
  86. reserved++;
  87. else if (PageSwapCache(page))
  88. cached++;
  89. else if (PageSlab(page))
  90. slab++;
  91. else if (!page_count(page))
  92. free++;
  93. else
  94. shared += page_count(page) - 1;
  95. page++;
  96. } while (page < end);
  97. }
  98. printk("%d pages of RAM\n", total);
  99. printk("%d free pages\n", free);
  100. printk("%d reserved pages\n", reserved);
  101. printk("%d slab pages\n", slab);
  102. printk("%d pages shared\n", shared);
  103. printk("%d pages swap cached\n", cached);
  104. }
  105. static void __init find_limits(unsigned long *min, unsigned long *max_low,
  106. unsigned long *max_high)
  107. {
  108. struct meminfo *mi = &meminfo;
  109. int i;
  110. *min = -1UL;
  111. *max_low = *max_high = 0;
  112. for_each_bank (i, mi) {
  113. struct membank *bank = &mi->bank[i];
  114. unsigned long start, end;
  115. start = bank_pfn_start(bank);
  116. end = bank_pfn_end(bank);
  117. if (*min > start)
  118. *min = start;
  119. if (*max_high < end)
  120. *max_high = end;
  121. if (bank->highmem)
  122. continue;
  123. if (*max_low < end)
  124. *max_low = end;
  125. }
  126. }
  127. static void __init arm_bootmem_init(unsigned long start_pfn,
  128. unsigned long end_pfn)
  129. {
  130. struct memblock_region *reg;
  131. unsigned int boot_pages;
  132. phys_addr_t bitmap;
  133. pg_data_t *pgdat;
  134. /*
  135. * Allocate the bootmem bitmap page. This must be in a region
  136. * of memory which has already been mapped.
  137. */
  138. boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
  139. bitmap = memblock_alloc_base(boot_pages << PAGE_SHIFT, L1_CACHE_BYTES,
  140. __pfn_to_phys(end_pfn));
  141. /*
  142. * Initialise the bootmem allocator, handing the
  143. * memory banks over to bootmem.
  144. */
  145. node_set_online(0);
  146. pgdat = NODE_DATA(0);
  147. init_bootmem_node(pgdat, __phys_to_pfn(bitmap), start_pfn, end_pfn);
  148. /* Free the lowmem regions from memblock into bootmem. */
  149. for_each_memblock(memory, reg) {
  150. unsigned long start = memblock_region_memory_base_pfn(reg);
  151. unsigned long end = memblock_region_memory_end_pfn(reg);
  152. if (end >= end_pfn)
  153. end = end_pfn;
  154. if (start >= end)
  155. break;
  156. free_bootmem(__pfn_to_phys(start), (end - start) << PAGE_SHIFT);
  157. }
  158. /* Reserve the lowmem memblock reserved regions in bootmem. */
  159. for_each_memblock(reserved, reg) {
  160. unsigned long start = memblock_region_reserved_base_pfn(reg);
  161. unsigned long end = memblock_region_reserved_end_pfn(reg);
  162. if (end >= end_pfn)
  163. end = end_pfn;
  164. if (start >= end)
  165. break;
  166. reserve_bootmem(__pfn_to_phys(start),
  167. (end - start) << PAGE_SHIFT, BOOTMEM_DEFAULT);
  168. }
  169. }
  170. static void __init arm_bootmem_free(unsigned long min, unsigned long max_low,
  171. unsigned long max_high)
  172. {
  173. unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
  174. struct memblock_region *reg;
  175. /*
  176. * initialise the zones.
  177. */
  178. memset(zone_size, 0, sizeof(zone_size));
  179. /*
  180. * The memory size has already been determined. If we need
  181. * to do anything fancy with the allocation of this memory
  182. * to the zones, now is the time to do it.
  183. */
  184. zone_size[0] = max_low - min;
  185. #ifdef CONFIG_HIGHMEM
  186. zone_size[ZONE_HIGHMEM] = max_high - max_low;
  187. #endif
  188. /*
  189. * Calculate the size of the holes.
  190. * holes = node_size - sum(bank_sizes)
  191. */
  192. memcpy(zhole_size, zone_size, sizeof(zhole_size));
  193. for_each_memblock(memory, reg) {
  194. unsigned long start = memblock_region_memory_base_pfn(reg);
  195. unsigned long end = memblock_region_memory_end_pfn(reg);
  196. if (start < max_low) {
  197. unsigned long low_end = min(end, max_low);
  198. zhole_size[0] -= low_end - start;
  199. }
  200. #ifdef CONFIG_HIGHMEM
  201. if (end > max_low) {
  202. unsigned long high_start = max(start, max_low);
  203. zhole_size[ZONE_HIGHMEM] -= end - high_start;
  204. }
  205. #endif
  206. }
  207. /*
  208. * Adjust the sizes according to any special requirements for
  209. * this machine type.
  210. */
  211. arch_adjust_zones(zone_size, zhole_size);
  212. free_area_init_node(0, zone_size, min, zhole_size);
  213. }
  214. #ifndef CONFIG_SPARSEMEM
  215. int pfn_valid(unsigned long pfn)
  216. {
  217. return memblock_is_memory(pfn << PAGE_SHIFT);
  218. }
  219. EXPORT_SYMBOL(pfn_valid);
  220. static void arm_memory_present(void)
  221. {
  222. }
  223. #else
  224. static void arm_memory_present(void)
  225. {
  226. struct memblock_region *reg;
  227. for_each_memblock(memory, reg)
  228. memory_present(0, memblock_region_memory_base_pfn(reg),
  229. memblock_region_memory_end_pfn(reg));
  230. }
  231. #endif
  232. static int __init meminfo_cmp(const void *_a, const void *_b)
  233. {
  234. const struct membank *a = _a, *b = _b;
  235. long cmp = bank_pfn_start(a) - bank_pfn_start(b);
  236. return cmp < 0 ? -1 : cmp > 0 ? 1 : 0;
  237. }
  238. void __init arm_memblock_init(struct meminfo *mi, struct machine_desc *mdesc)
  239. {
  240. int i;
  241. sort(&meminfo.bank, meminfo.nr_banks, sizeof(meminfo.bank[0]), meminfo_cmp, NULL);
  242. memblock_init();
  243. for (i = 0; i < mi->nr_banks; i++)
  244. memblock_add(mi->bank[i].start, mi->bank[i].size);
  245. /* Register the kernel text, kernel data and initrd with memblock. */
  246. #ifdef CONFIG_XIP_KERNEL
  247. memblock_reserve(__pa(_sdata), _end - _sdata);
  248. #else
  249. memblock_reserve(__pa(_stext), _end - _stext);
  250. #endif
  251. #ifdef CONFIG_BLK_DEV_INITRD
  252. if (phys_initrd_size &&
  253. memblock_is_region_reserved(phys_initrd_start, phys_initrd_size)) {
  254. pr_err("INITRD: 0x%08lx+0x%08lx overlaps in-use memory region - disabling initrd\n",
  255. phys_initrd_start, phys_initrd_size);
  256. phys_initrd_start = phys_initrd_size = 0;
  257. }
  258. if (phys_initrd_size) {
  259. memblock_reserve(phys_initrd_start, phys_initrd_size);
  260. /* Now convert initrd to virtual addresses */
  261. initrd_start = __phys_to_virt(phys_initrd_start);
  262. initrd_end = initrd_start + phys_initrd_size;
  263. }
  264. #endif
  265. arm_mm_memblock_reserve();
  266. /* reserve any platform specific memblock areas */
  267. if (mdesc->reserve)
  268. mdesc->reserve();
  269. memblock_analyze();
  270. memblock_dump_all();
  271. }
  272. void __init bootmem_init(void)
  273. {
  274. unsigned long min, max_low, max_high;
  275. max_low = max_high = 0;
  276. find_limits(&min, &max_low, &max_high);
  277. arm_bootmem_init(min, max_low);
  278. /*
  279. * Sparsemem tries to allocate bootmem in memory_present(),
  280. * so must be done after the fixed reservations
  281. */
  282. arm_memory_present();
  283. /*
  284. * sparse_init() needs the bootmem allocator up and running.
  285. */
  286. sparse_init();
  287. /*
  288. * Now free the memory - free_area_init_node needs
  289. * the sparse mem_map arrays initialized by sparse_init()
  290. * for memmap_init_zone(), otherwise all PFNs are invalid.
  291. */
  292. arm_bootmem_free(min, max_low, max_high);
  293. high_memory = __va(((phys_addr_t)max_low << PAGE_SHIFT) - 1) + 1;
  294. /*
  295. * This doesn't seem to be used by the Linux memory manager any
  296. * more, but is used by ll_rw_block. If we can get rid of it, we
  297. * also get rid of some of the stuff above as well.
  298. *
  299. * Note: max_low_pfn and max_pfn reflect the number of _pages_ in
  300. * the system, not the maximum PFN.
  301. */
  302. max_low_pfn = max_low - PHYS_PFN_OFFSET;
  303. max_pfn = max_high - PHYS_PFN_OFFSET;
  304. }
  305. static inline int free_area(unsigned long pfn, unsigned long end, char *s)
  306. {
  307. unsigned int pages = 0, size = (end - pfn) << (PAGE_SHIFT - 10);
  308. for (; pfn < end; pfn++) {
  309. struct page *page = pfn_to_page(pfn);
  310. ClearPageReserved(page);
  311. init_page_count(page);
  312. __free_page(page);
  313. pages++;
  314. }
  315. if (size && s)
  316. printk(KERN_INFO "Freeing %s memory: %dK\n", s, size);
  317. return pages;
  318. }
  319. static inline void
  320. free_memmap(unsigned long start_pfn, unsigned long end_pfn)
  321. {
  322. struct page *start_pg, *end_pg;
  323. unsigned long pg, pgend;
  324. /*
  325. * Convert start_pfn/end_pfn to a struct page pointer.
  326. */
  327. start_pg = pfn_to_page(start_pfn - 1) + 1;
  328. end_pg = pfn_to_page(end_pfn);
  329. /*
  330. * Convert to physical addresses, and
  331. * round start upwards and end downwards.
  332. */
  333. pg = (unsigned long)PAGE_ALIGN(__pa(start_pg));
  334. pgend = (unsigned long)__pa(end_pg) & PAGE_MASK;
  335. /*
  336. * If there are free pages between these,
  337. * free the section of the memmap array.
  338. */
  339. if (pg < pgend)
  340. free_bootmem(pg, pgend - pg);
  341. }
  342. /*
  343. * The mem_map array can get very big. Free the unused area of the memory map.
  344. */
  345. static void __init free_unused_memmap(struct meminfo *mi)
  346. {
  347. unsigned long bank_start, prev_bank_end = 0;
  348. unsigned int i;
  349. /*
  350. * This relies on each bank being in address order.
  351. * The banks are sorted previously in bootmem_init().
  352. */
  353. for_each_bank(i, mi) {
  354. struct membank *bank = &mi->bank[i];
  355. bank_start = bank_pfn_start(bank);
  356. /*
  357. * If we had a previous bank, and there is a space
  358. * between the current bank and the previous, free it.
  359. */
  360. if (prev_bank_end && prev_bank_end < bank_start)
  361. free_memmap(prev_bank_end, bank_start);
  362. /*
  363. * Align up here since the VM subsystem insists that the
  364. * memmap entries are valid from the bank end aligned to
  365. * MAX_ORDER_NR_PAGES.
  366. */
  367. prev_bank_end = ALIGN(bank_pfn_end(bank), MAX_ORDER_NR_PAGES);
  368. }
  369. }
  370. static void __init free_highpages(void)
  371. {
  372. #ifdef CONFIG_HIGHMEM
  373. unsigned long max_low = max_low_pfn + PHYS_PFN_OFFSET;
  374. struct memblock_region *mem, *res;
  375. /* set highmem page free */
  376. for_each_memblock(memory, mem) {
  377. unsigned long start = memblock_region_memory_base_pfn(mem);
  378. unsigned long end = memblock_region_memory_end_pfn(mem);
  379. /* Ignore complete lowmem entries */
  380. if (end <= max_low)
  381. continue;
  382. /* Truncate partial highmem entries */
  383. if (start < max_low)
  384. start = max_low;
  385. /* Find and exclude any reserved regions */
  386. for_each_memblock(reserved, res) {
  387. unsigned long res_start, res_end;
  388. res_start = memblock_region_reserved_base_pfn(res);
  389. res_end = memblock_region_reserved_end_pfn(res);
  390. if (res_end < start)
  391. continue;
  392. if (res_start < start)
  393. res_start = start;
  394. if (res_start > end)
  395. res_start = end;
  396. if (res_end > end)
  397. res_end = end;
  398. if (res_start != start)
  399. totalhigh_pages += free_area(start, res_start,
  400. NULL);
  401. start = res_end;
  402. if (start == end)
  403. break;
  404. }
  405. /* And now free anything which remains */
  406. if (start < end)
  407. totalhigh_pages += free_area(start, end, NULL);
  408. }
  409. totalram_pages += totalhigh_pages;
  410. #endif
  411. }
  412. /*
  413. * mem_init() marks the free areas in the mem_map and tells us how much
  414. * memory is free. This is done after various parts of the system have
  415. * claimed their memory after the kernel image.
  416. */
  417. void __init mem_init(void)
  418. {
  419. unsigned long reserved_pages, free_pages;
  420. struct memblock_region *reg;
  421. int i;
  422. #ifdef CONFIG_HAVE_TCM
  423. /* These pointers are filled in on TCM detection */
  424. extern u32 dtcm_end;
  425. extern u32 itcm_end;
  426. #endif
  427. max_mapnr = pfn_to_page(max_pfn + PHYS_PFN_OFFSET) - mem_map;
  428. /* this will put all unused low memory onto the freelists */
  429. free_unused_memmap(&meminfo);
  430. totalram_pages += free_all_bootmem();
  431. #ifdef CONFIG_SA1111
  432. /* now that our DMA memory is actually so designated, we can free it */
  433. totalram_pages += free_area(PHYS_PFN_OFFSET,
  434. __phys_to_pfn(__pa(swapper_pg_dir)), NULL);
  435. #endif
  436. free_highpages();
  437. reserved_pages = free_pages = 0;
  438. for_each_bank(i, &meminfo) {
  439. struct membank *bank = &meminfo.bank[i];
  440. unsigned int pfn1, pfn2;
  441. struct page *page, *end;
  442. pfn1 = bank_pfn_start(bank);
  443. pfn2 = bank_pfn_end(bank);
  444. page = pfn_to_page(pfn1);
  445. end = pfn_to_page(pfn2 - 1) + 1;
  446. do {
  447. if (PageReserved(page))
  448. reserved_pages++;
  449. else if (!page_count(page))
  450. free_pages++;
  451. page++;
  452. } while (page < end);
  453. }
  454. /*
  455. * Since our memory may not be contiguous, calculate the
  456. * real number of pages we have in this system
  457. */
  458. printk(KERN_INFO "Memory:");
  459. num_physpages = 0;
  460. for_each_memblock(memory, reg) {
  461. unsigned long pages = memblock_region_memory_end_pfn(reg) -
  462. memblock_region_memory_base_pfn(reg);
  463. num_physpages += pages;
  464. printk(" %ldMB", pages >> (20 - PAGE_SHIFT));
  465. }
  466. printk(" = %luMB total\n", num_physpages >> (20 - PAGE_SHIFT));
  467. printk(KERN_NOTICE "Memory: %luk/%luk available, %luk reserved, %luK highmem\n",
  468. nr_free_pages() << (PAGE_SHIFT-10),
  469. free_pages << (PAGE_SHIFT-10),
  470. reserved_pages << (PAGE_SHIFT-10),
  471. totalhigh_pages << (PAGE_SHIFT-10));
  472. #define MLK(b, t) b, t, ((t) - (b)) >> 10
  473. #define MLM(b, t) b, t, ((t) - (b)) >> 20
  474. #define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K)
  475. printk(KERN_NOTICE "Virtual kernel memory layout:\n"
  476. " vector : 0x%08lx - 0x%08lx (%4ld kB)\n"
  477. #ifdef CONFIG_HAVE_TCM
  478. " DTCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
  479. " ITCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
  480. #endif
  481. " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
  482. #ifdef CONFIG_MMU
  483. " DMA : 0x%08lx - 0x%08lx (%4ld MB)\n"
  484. #endif
  485. " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
  486. " lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n"
  487. #ifdef CONFIG_HIGHMEM
  488. " pkmap : 0x%08lx - 0x%08lx (%4ld MB)\n"
  489. #endif
  490. " modules : 0x%08lx - 0x%08lx (%4ld MB)\n"
  491. " .init : 0x%p" " - 0x%p" " (%4d kB)\n"
  492. " .text : 0x%p" " - 0x%p" " (%4d kB)\n"
  493. " .data : 0x%p" " - 0x%p" " (%4d kB)\n",
  494. MLK(UL(CONFIG_VECTORS_BASE), UL(CONFIG_VECTORS_BASE) +
  495. (PAGE_SIZE)),
  496. #ifdef CONFIG_HAVE_TCM
  497. MLK(DTCM_OFFSET, (unsigned long) dtcm_end),
  498. MLK(ITCM_OFFSET, (unsigned long) itcm_end),
  499. #endif
  500. MLK(FIXADDR_START, FIXADDR_TOP),
  501. #ifdef CONFIG_MMU
  502. MLM(CONSISTENT_BASE, CONSISTENT_END),
  503. #endif
  504. MLM(VMALLOC_START, VMALLOC_END),
  505. MLM(PAGE_OFFSET, (unsigned long)high_memory),
  506. #ifdef CONFIG_HIGHMEM
  507. MLM(PKMAP_BASE, (PKMAP_BASE) + (LAST_PKMAP) *
  508. (PAGE_SIZE)),
  509. #endif
  510. MLM(MODULES_VADDR, MODULES_END),
  511. MLK_ROUNDUP(__init_begin, __init_end),
  512. MLK_ROUNDUP(_text, _etext),
  513. MLK_ROUNDUP(_sdata, _edata));
  514. #undef MLK
  515. #undef MLM
  516. #undef MLK_ROUNDUP
  517. /*
  518. * Check boundaries twice: Some fundamental inconsistencies can
  519. * be detected at build time already.
  520. */
  521. #ifdef CONFIG_MMU
  522. BUILD_BUG_ON(VMALLOC_END > CONSISTENT_BASE);
  523. BUG_ON(VMALLOC_END > CONSISTENT_BASE);
  524. BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR);
  525. BUG_ON(TASK_SIZE > MODULES_VADDR);
  526. #endif
  527. #ifdef CONFIG_HIGHMEM
  528. BUILD_BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
  529. BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
  530. #endif
  531. if (PAGE_SIZE >= 16384 && num_physpages <= 128) {
  532. extern int sysctl_overcommit_memory;
  533. /*
  534. * On a machine this small we won't get
  535. * anywhere without overcommit, so turn
  536. * it on by default.
  537. */
  538. sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
  539. }
  540. }
  541. void free_initmem(void)
  542. {
  543. #ifdef CONFIG_HAVE_TCM
  544. extern char __tcm_start, __tcm_end;
  545. totalram_pages += free_area(__phys_to_pfn(__pa(&__tcm_start)),
  546. __phys_to_pfn(__pa(&__tcm_end)),
  547. "TCM link");
  548. #endif
  549. if (!machine_is_integrator() && !machine_is_cintegrator())
  550. totalram_pages += free_area(__phys_to_pfn(__pa(__init_begin)),
  551. __phys_to_pfn(__pa(__init_end)),
  552. "init");
  553. }
  554. #ifdef CONFIG_BLK_DEV_INITRD
  555. static int keep_initrd;
  556. void free_initrd_mem(unsigned long start, unsigned long end)
  557. {
  558. if (!keep_initrd)
  559. totalram_pages += free_area(__phys_to_pfn(__pa(start)),
  560. __phys_to_pfn(__pa(end)),
  561. "initrd");
  562. }
  563. static int __init keepinitrd_setup(char *__unused)
  564. {
  565. keep_initrd = 1;
  566. return 1;
  567. }
  568. __setup("keepinitrd", keepinitrd_setup);
  569. #endif