init_32.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/arch/sparc/mm/init.c
  4. *
  5. * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  6. * Copyright (C) 1995 Eddie C. Dost (ecd@skynet.be)
  7. * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  8. * Copyright (C) 2000 Anton Blanchard (anton@samba.org)
  9. */
  10. #include <linux/module.h>
  11. #include <linux/signal.h>
  12. #include <linux/sched.h>
  13. #include <linux/kernel.h>
  14. #include <linux/errno.h>
  15. #include <linux/string.h>
  16. #include <linux/types.h>
  17. #include <linux/ptrace.h>
  18. #include <linux/mman.h>
  19. #include <linux/mm.h>
  20. #include <linux/swap.h>
  21. #include <linux/initrd.h>
  22. #include <linux/init.h>
  23. #include <linux/highmem.h>
  24. #include <linux/memblock.h>
  25. #include <linux/pagemap.h>
  26. #include <linux/poison.h>
  27. #include <linux/gfp.h>
  28. #include <asm/sections.h>
  29. #include <asm/page.h>
  30. #include <asm/vaddrs.h>
  31. #include <asm/setup.h>
  32. #include <asm/tlb.h>
  33. #include <asm/prom.h>
  34. #include <asm/leon.h>
  35. #include "mm_32.h"
  36. unsigned long *sparc_valid_addr_bitmap;
  37. EXPORT_SYMBOL(sparc_valid_addr_bitmap);
  38. unsigned long phys_base;
  39. EXPORT_SYMBOL(phys_base);
  40. unsigned long pfn_base;
  41. EXPORT_SYMBOL(pfn_base);
  42. struct sparc_phys_banks sp_banks[SPARC_PHYS_BANKS+1];
  43. /* Initial ramdisk setup */
  44. extern unsigned int sparc_ramdisk_image;
  45. extern unsigned int sparc_ramdisk_size;
  46. unsigned long highstart_pfn, highend_pfn;
  47. unsigned long last_valid_pfn;
  48. unsigned long calc_highpages(void)
  49. {
  50. int i;
  51. int nr = 0;
  52. for (i = 0; sp_banks[i].num_bytes != 0; i++) {
  53. unsigned long start_pfn = sp_banks[i].base_addr >> PAGE_SHIFT;
  54. unsigned long end_pfn = (sp_banks[i].base_addr + sp_banks[i].num_bytes) >> PAGE_SHIFT;
  55. if (end_pfn <= max_low_pfn)
  56. continue;
  57. if (start_pfn < max_low_pfn)
  58. start_pfn = max_low_pfn;
  59. nr += end_pfn - start_pfn;
  60. }
  61. return nr;
  62. }
  63. static unsigned long calc_max_low_pfn(void)
  64. {
  65. int i;
  66. unsigned long tmp = pfn_base + (SRMMU_MAXMEM >> PAGE_SHIFT);
  67. unsigned long curr_pfn, last_pfn;
  68. last_pfn = (sp_banks[0].base_addr + sp_banks[0].num_bytes) >> PAGE_SHIFT;
  69. for (i = 1; sp_banks[i].num_bytes != 0; i++) {
  70. curr_pfn = sp_banks[i].base_addr >> PAGE_SHIFT;
  71. if (curr_pfn >= tmp) {
  72. if (last_pfn < tmp)
  73. tmp = last_pfn;
  74. break;
  75. }
  76. last_pfn = (sp_banks[i].base_addr + sp_banks[i].num_bytes) >> PAGE_SHIFT;
  77. }
  78. return tmp;
  79. }
  80. static void __init find_ramdisk(unsigned long end_of_phys_memory)
  81. {
  82. #ifdef CONFIG_BLK_DEV_INITRD
  83. unsigned long size;
  84. /* Now have to check initial ramdisk, so that it won't pass
  85. * the end of memory
  86. */
  87. if (sparc_ramdisk_image) {
  88. if (sparc_ramdisk_image >= (unsigned long)&_end - 2 * PAGE_SIZE)
  89. sparc_ramdisk_image -= KERNBASE;
  90. initrd_start = sparc_ramdisk_image + phys_base;
  91. initrd_end = initrd_start + sparc_ramdisk_size;
  92. if (initrd_end > end_of_phys_memory) {
  93. printk(KERN_CRIT "initrd extends beyond end of memory "
  94. "(0x%016lx > 0x%016lx)\ndisabling initrd\n",
  95. initrd_end, end_of_phys_memory);
  96. initrd_start = 0;
  97. } else {
  98. /* Reserve the initrd image area. */
  99. size = initrd_end - initrd_start;
  100. memblock_reserve(initrd_start, size);
  101. initrd_start = (initrd_start - phys_base) + PAGE_OFFSET;
  102. initrd_end = (initrd_end - phys_base) + PAGE_OFFSET;
  103. }
  104. }
  105. #endif
  106. }
  107. unsigned long __init bootmem_init(unsigned long *pages_avail)
  108. {
  109. unsigned long start_pfn, bytes_avail, size;
  110. unsigned long end_of_phys_memory = 0;
  111. unsigned long high_pages = 0;
  112. int i;
  113. memblock_set_bottom_up(true);
  114. memblock_allow_resize();
  115. bytes_avail = 0UL;
  116. for (i = 0; sp_banks[i].num_bytes != 0; i++) {
  117. end_of_phys_memory = sp_banks[i].base_addr +
  118. sp_banks[i].num_bytes;
  119. bytes_avail += sp_banks[i].num_bytes;
  120. if (cmdline_memory_size) {
  121. if (bytes_avail > cmdline_memory_size) {
  122. unsigned long slack = bytes_avail - cmdline_memory_size;
  123. bytes_avail -= slack;
  124. end_of_phys_memory -= slack;
  125. sp_banks[i].num_bytes -= slack;
  126. if (sp_banks[i].num_bytes == 0) {
  127. sp_banks[i].base_addr = 0xdeadbeef;
  128. } else {
  129. memblock_add(sp_banks[i].base_addr,
  130. sp_banks[i].num_bytes);
  131. sp_banks[i+1].num_bytes = 0;
  132. sp_banks[i+1].base_addr = 0xdeadbeef;
  133. }
  134. break;
  135. }
  136. }
  137. memblock_add(sp_banks[i].base_addr, sp_banks[i].num_bytes);
  138. }
  139. /* Start with page aligned address of last symbol in kernel
  140. * image.
  141. */
  142. start_pfn = (unsigned long)__pa(PAGE_ALIGN((unsigned long) &_end));
  143. /* Now shift down to get the real physical page frame number. */
  144. start_pfn >>= PAGE_SHIFT;
  145. max_pfn = end_of_phys_memory >> PAGE_SHIFT;
  146. max_low_pfn = max_pfn;
  147. highstart_pfn = highend_pfn = max_pfn;
  148. if (max_low_pfn > pfn_base + (SRMMU_MAXMEM >> PAGE_SHIFT)) {
  149. highstart_pfn = pfn_base + (SRMMU_MAXMEM >> PAGE_SHIFT);
  150. max_low_pfn = calc_max_low_pfn();
  151. high_pages = calc_highpages();
  152. printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
  153. high_pages >> (20 - PAGE_SHIFT));
  154. }
  155. find_ramdisk(end_of_phys_memory);
  156. /* Reserve the kernel text/data/bss. */
  157. size = (start_pfn << PAGE_SHIFT) - phys_base;
  158. memblock_reserve(phys_base, size);
  159. memblock_add(phys_base, size);
  160. size = memblock_phys_mem_size() - memblock_reserved_size();
  161. *pages_avail = (size >> PAGE_SHIFT) - high_pages;
  162. /* Only allow low memory to be allocated via memblock allocation */
  163. memblock_set_current_limit(max_low_pfn << PAGE_SHIFT);
  164. return max_pfn;
  165. }
  166. /*
  167. * paging_init() sets up the page tables: We call the MMU specific
  168. * init routine based upon the Sun model type on the Sparc.
  169. *
  170. */
  171. void __init paging_init(void)
  172. {
  173. srmmu_paging_init();
  174. prom_build_devicetree();
  175. of_fill_in_cpu_data();
  176. device_scan();
  177. }
  178. static void __init taint_real_pages(void)
  179. {
  180. int i;
  181. for (i = 0; sp_banks[i].num_bytes; i++) {
  182. unsigned long start, end;
  183. start = sp_banks[i].base_addr;
  184. end = start + sp_banks[i].num_bytes;
  185. while (start < end) {
  186. set_bit(start >> 20, sparc_valid_addr_bitmap);
  187. start += PAGE_SIZE;
  188. }
  189. }
  190. }
  191. static void map_high_region(unsigned long start_pfn, unsigned long end_pfn)
  192. {
  193. unsigned long tmp;
  194. #ifdef CONFIG_DEBUG_HIGHMEM
  195. printk("mapping high region %08lx - %08lx\n", start_pfn, end_pfn);
  196. #endif
  197. for (tmp = start_pfn; tmp < end_pfn; tmp++)
  198. free_highmem_page(pfn_to_page(tmp));
  199. }
  200. void __init mem_init(void)
  201. {
  202. int i;
  203. if (PKMAP_BASE+LAST_PKMAP*PAGE_SIZE >= FIXADDR_START) {
  204. prom_printf("BUG: fixmap and pkmap areas overlap\n");
  205. prom_printf("pkbase: 0x%lx pkend: 0x%lx fixstart 0x%lx\n",
  206. PKMAP_BASE,
  207. (unsigned long)PKMAP_BASE+LAST_PKMAP*PAGE_SIZE,
  208. FIXADDR_START);
  209. prom_printf("Please mail sparclinux@vger.kernel.org.\n");
  210. prom_halt();
  211. }
  212. /* Saves us work later. */
  213. memset((void *)empty_zero_page, 0, PAGE_SIZE);
  214. i = last_valid_pfn >> ((20 - PAGE_SHIFT) + 5);
  215. i += 1;
  216. sparc_valid_addr_bitmap = (unsigned long *)
  217. memblock_alloc(i << 2, SMP_CACHE_BYTES);
  218. if (sparc_valid_addr_bitmap == NULL) {
  219. prom_printf("mem_init: Cannot alloc valid_addr_bitmap.\n");
  220. prom_halt();
  221. }
  222. memset(sparc_valid_addr_bitmap, 0, i << 2);
  223. taint_real_pages();
  224. max_mapnr = last_valid_pfn - pfn_base;
  225. high_memory = __va(max_low_pfn << PAGE_SHIFT);
  226. memblock_free_all();
  227. for (i = 0; sp_banks[i].num_bytes != 0; i++) {
  228. unsigned long start_pfn = sp_banks[i].base_addr >> PAGE_SHIFT;
  229. unsigned long end_pfn = (sp_banks[i].base_addr + sp_banks[i].num_bytes) >> PAGE_SHIFT;
  230. if (end_pfn <= highstart_pfn)
  231. continue;
  232. if (start_pfn < highstart_pfn)
  233. start_pfn = highstart_pfn;
  234. map_high_region(start_pfn, end_pfn);
  235. }
  236. mem_init_print_info(NULL);
  237. }
  238. void sparc_flush_page_to_ram(struct page *page)
  239. {
  240. unsigned long vaddr = (unsigned long)page_address(page);
  241. if (vaddr)
  242. __flush_page_to_ram(vaddr);
  243. }
  244. EXPORT_SYMBOL(sparc_flush_page_to_ram);