m68k: discontinuous memory support

Fix support for discontinuous memory Signed-off-by: Roman Zippel <zippel@linux-m68k.org> Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

m68k: discontinuous memory support
Fix support for discontinuous memory Signed-off-by: Roman Zippel <zippel@linux-m68k.org> Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Roman Zippel · Linus Torvalds
1 parent 00c541eae7
Showing 16 changed files with 247 additions and 248 deletions Side-by-side Diff
arch/m68k/Kconfig
arch/m68k/kernel/module.c
arch/m68k/kernel/setup.c
arch/m68k/mm/init.c
arch/m68k/mm/memory.c
arch/m68k/mm/motorola.c
arch/m68k/sun3/config.c
include/asm-m68k/mmzone.h
include/asm-m68k/module.h
include/asm-m68k/motorola_pgtable.h
include/asm-m68k/page.h
include/asm-m68k/pgalloc.h
include/asm-m68k/pgtable.h
include/asm-m68k/sun3_pgtable.h
include/asm-m68k/virtconvert.h
mm/page_alloc.c
@@ -355,8 +355,9 @@
 	  adventurous.
  
 config SINGLE_MEMORY_CHUNK
-	bool "Use one physical chunk of memory only"
-	depends on ADVANCED && !SUN3
+	bool "Use one physical chunk of memory only" if ADVANCED && !SUN3
+	default y if SUN3
+	select NEED_MULTIPLE_NODES
 	help
 	  Ignore all but the first contiguous chunk of physical memory for VM
 	  purposes.  This will save a few bytes kernel size and may speed up
@@ -376,6 +377,14 @@
 	  drivers on 68060 based systems where the 68060 bus snooping signal
 	  is hardwired on.  The 53c710 SCSI driver is known to suffer from
 	  this problem.
+
+config ARCH_DISCONTIGMEM_ENABLE
+	def_bool !SINGLE_MEMORY_CHUNK
+
+config NODES_SHIFT
+	int
+	default "3"
+	depends on !SINGLE_MEMORY_CHUNK
  
 source "mm/Kconfig"
  
@@ -149,6 +149,9 @@
 		case m68k_fixup_memoffset:
 			*(u32 *)fixup->addr = m68k_memoffset;
 			break;
+		case m68k_fixup_vnode_shift:
+			*(u16 *)fixup->addr += m68k_virt_to_node_shift;
+			break;
 		}
 	}
 }
@@ -60,14 +60,12 @@
 int m68k_num_memory;
 int m68k_realnum_memory;
 EXPORT_SYMBOL(m68k_realnum_memory);
-#ifdef CONFIG_SINGLE_MEMORY_CHUNK
 unsigned long m68k_memoffset;
 EXPORT_SYMBOL(m68k_memoffset);
-#endif
 struct mem_info m68k_memory[NUM_MEMINFO];
 EXPORT_SYMBOL(m68k_memory);
  
-static struct mem_info m68k_ramdisk;
+struct mem_info m68k_ramdisk;
  
 static char m68k_command_line[CL_SIZE];
  
@@ -208,9 +206,6 @@
 void __init setup_arch(char **cmdline_p)
 {
 	extern int _etext, _edata, _end;
-#ifndef CONFIG_SUN3
-	unsigned long endmem, startmem;
-#endif
 	int i;
  
 	/* The bootinfo is located right after the kernel bss */
  
  
@@ -320,30 +315,16 @@
 		panic("No configuration setup");
 	}
  
-#ifndef CONFIG_SUN3
-	startmem= m68k_memory[0].addr;
-	endmem = startmem + m68k_memory[0].size;
-	high_memory = (void *)PAGE_OFFSET;
-	for (i = 0; i < m68k_num_memory; i++) {
-		m68k_memory[i].size &= MASK_256K;
-		if (m68k_memory[i].addr < startmem)
-			startmem = m68k_memory[i].addr;
-		if (m68k_memory[i].addr+m68k_memory[i].size > endmem)
-			endmem = m68k_memory[i].addr+m68k_memory[i].size;
-		high_memory += m68k_memory[i].size;
-	}
+	paging_init();
  
-	availmem += init_bootmem_node(NODE_DATA(0), availmem >> PAGE_SHIFT,
-				      startmem >> PAGE_SHIFT, endmem >> PAGE_SHIFT);
-
-	for (i = 0; i < m68k_num_memory; i++)
-		free_bootmem(m68k_memory[i].addr, m68k_memory[i].size);
-
-	reserve_bootmem(m68k_memory[0].addr, availmem - m68k_memory[0].addr);
-
+#ifndef CONFIG_SUN3
+	for (i = 1; i < m68k_num_memory; i++)
+		free_bootmem_node(NODE_DATA(i), m68k_memory[i].addr,
+				  m68k_memory[i].size);
 #ifdef CONFIG_BLK_DEV_INITRD
 	if (m68k_ramdisk.size) {
-		reserve_bootmem(m68k_ramdisk.addr, m68k_ramdisk.size);
+		reserve_bootmem_node(__virt_to_node(phys_to_virt(m68k_ramdisk.addr)),
+				     m68k_ramdisk.addr, m68k_ramdisk.size);
 		initrd_start = (unsigned long)phys_to_virt(m68k_ramdisk.addr);
 		initrd_end = initrd_start + m68k_ramdisk.size;
 		printk("initrd: %08lx - %08lx\n", initrd_start, initrd_end);
@@ -361,8 +342,6 @@
 #endif
  
 #endif /* !CONFIG_SUN3 */
-
-	paging_init();
  
 /* set ISA defs early as possible */
 #if defined(CONFIG_ISA) && defined(MULTI_ISA)
@@ -7,6 +7,7 @@
  *  to motorola.c and sun3mmu.c
  */
  
+#include <linux/module.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
@@ -31,6 +32,37 @@
  
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
  
+static bootmem_data_t __initdata bootmem_data[MAX_NUMNODES];
+
+pg_data_t pg_data_map[MAX_NUMNODES];
+EXPORT_SYMBOL(pg_data_map);
+
+int m68k_virt_to_node_shift;
+
+#ifndef CONFIG_SINGLE_MEMORY_CHUNK
+pg_data_t *pg_data_table[65];
+EXPORT_SYMBOL(pg_data_table);
+#endif
+
+void m68k_setup_node(int node)
+{
+#ifndef CONFIG_SINGLE_MEMORY_CHUNK
+	struct mem_info *info = m68k_memory + node;
+	int i, end;
+
+	i = (unsigned long)phys_to_virt(info->addr) >> __virt_to_node_shift();
+	end = (unsigned long)phys_to_virt(info->addr + info->size - 1) >> __virt_to_node_shift();
+	for (; i <= end; i++) {
+		if (pg_data_table[i])
+			printk("overlap at %u for chunk %u\n", i, node);
+		pg_data_table[i] = pg_data_map + node;
+	}
+#endif
+	pg_data_map[node].bdata = bootmem_data + node;
+	node_set_online(node);
+}
+
+
 /*
  * ZERO_PAGE is a special page that is used for zero-initialized
  * data and COW.
  
  
  
  
  
  
  
  
  
  
@@ -40,72 +72,77 @@
  
 void show_mem(void)
 {
-    unsigned long i;
-    int free = 0, total = 0, reserved = 0, shared = 0;
-    int cached = 0;
+	pg_data_t *pgdat;
+	int free = 0, total = 0, reserved = 0, shared = 0;
+	int cached = 0;
+	int i;
  
-    printk("\nMem-info:\n");
-    show_free_areas();
-    printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
-    i = max_mapnr;
-    while (i-- > 0) {
-	total++;
-	if (PageReserved(mem_map+i))
-	    reserved++;
-	else if (PageSwapCache(mem_map+i))
-	    cached++;
-	else if (!page_count(mem_map+i))
-	    free++;
-	else
-	    shared += page_count(mem_map+i) - 1;
-    }
-    printk("%d pages of RAM\n",total);
-    printk("%d free pages\n",free);
-    printk("%d reserved pages\n",reserved);
-    printk("%d pages shared\n",shared);
-    printk("%d pages swap cached\n",cached);
+	printk("\nMem-info:\n");
+	show_free_areas();
+	printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
+	for_each_online_pgdat(pgdat) {
+		for (i = 0; i < pgdat->node_spanned_pages; i++) {
+			struct page *page = pgdat->node_mem_map + i;
+			total++;
+			if (PageReserved(page))
+				reserved++;
+			else if (PageSwapCache(page))
+				cached++;
+			else if (!page_count(page))
+				free++;
+			else
+				shared += page_count(page) - 1;
+		}
+	}
+	printk("%d pages of RAM\n",total);
+	printk("%d free pages\n",free);
+	printk("%d reserved pages\n",reserved);
+	printk("%d pages shared\n",shared);
+	printk("%d pages swap cached\n",cached);
 }
  
 extern void init_pointer_table(unsigned long ptable);
  
 /* References to section boundaries */
  
-extern char _text, _etext, _edata, __bss_start, _end;
-extern char __init_begin, __init_end;
+extern char _text[], _etext[];
+extern char __init_begin[], __init_end[];
  
 extern pmd_t *zero_pgtable;
  
 void __init mem_init(void)
 {
+	pg_data_t *pgdat;
 	int codepages = 0;
 	int datapages = 0;
 	int initpages = 0;
-	unsigned long tmp;
-#ifndef CONFIG_SUN3
 	int i;
-#endif
  
-	max_mapnr = num_physpages = (((unsigned long)high_memory - PAGE_OFFSET) >> PAGE_SHIFT);
-
 #ifdef CONFIG_ATARI
 	if (MACH_IS_ATARI)
 		atari_stram_mem_init_hook();
 #endif
  
 	/* this will put all memory onto the freelists */
-	totalram_pages = free_all_bootmem();
+	totalram_pages = num_physpages = 0;
+	for_each_online_pgdat(pgdat) {
+		num_physpages += pgdat->node_present_pages;
  
-	for (tmp = PAGE_OFFSET ; tmp < (unsigned long)high_memory; tmp += PAGE_SIZE) {
-		if (PageReserved(virt_to_page(tmp))) {
-			if (tmp >= (unsigned long)&_text
-			    && tmp < (unsigned long)&_etext)
+		totalram_pages += free_all_bootmem_node(pgdat);
+		for (i = 0; i < pgdat->node_spanned_pages; i++) {
+			struct page *page = pgdat->node_mem_map + i;
+			char *addr = page_to_virt(page);
+
+			if (!PageReserved(page))
+				continue;
+			if (addr >= _text &&
+			    addr < _etext)
 				codepages++;
-			else if (tmp >= (unsigned long) &__init_begin
-				 && tmp < (unsigned long) &__init_end)
+			else if (addr >= __init_begin &&
+				 addr < __init_end)
 				initpages++;
 			else
 				datapages++;
-			continue;
 		}
 	}
  
@@ -124,7 +161,7 @@
  
 	printk("Memory: %luk/%luk available (%dk kernel code, %dk data, %dk init)\n",
 	       (unsigned long)nr_free_pages() << (PAGE_SHIFT-10),
-	       max_mapnr << (PAGE_SHIFT-10),
+	       totalram_pages << (PAGE_SHIFT-10),
 	       codepages << (PAGE_SHIFT-10),
 	       datapages << (PAGE_SHIFT-10),
 	       initpages << (PAGE_SHIFT-10));
@@ -127,67 +127,6 @@
 	return 0;
 }
  
-#ifdef DEBUG_INVALID_PTOV
-int mm_inv_cnt = 5;
-#endif
-
-#ifndef CONFIG_SINGLE_MEMORY_CHUNK
-/*
- * The following two routines map from a physical address to a kernel
- * virtual address and vice versa.
- */
-unsigned long mm_vtop(unsigned long vaddr)
-{
-	int i=0;
-	unsigned long voff = (unsigned long)vaddr - PAGE_OFFSET;
-
-	do {
-		if (voff < m68k_memory[i].size) {
-#ifdef DEBUGPV
-			printk ("VTOP(%p)=%lx\n", vaddr,
-				m68k_memory[i].addr + voff);
-#endif
-			return m68k_memory[i].addr + voff;
-		}
-		voff -= m68k_memory[i].size;
-	} while (++i < m68k_num_memory);
-
-	/* As a special case allow `__pa(high_memory)'.  */
-	if (voff == 0)
-		return m68k_memory[i-1].addr + m68k_memory[i-1].size;
-
-	return -1;
-}
-EXPORT_SYMBOL(mm_vtop);
-
-unsigned long mm_ptov (unsigned long paddr)
-{
-	int i = 0;
-	unsigned long poff, voff = PAGE_OFFSET;
-
-	do {
-		poff = paddr - m68k_memory[i].addr;
-		if (poff < m68k_memory[i].size) {
-#ifdef DEBUGPV
-			printk ("PTOV(%lx)=%lx\n", paddr, poff + voff);
-#endif
-			return poff + voff;
-		}
-		voff += m68k_memory[i].size;
-	} while (++i < m68k_num_memory);
-
-#ifdef DEBUG_INVALID_PTOV
-	if (mm_inv_cnt > 0) {
-		mm_inv_cnt--;
-		printk("Invalid use of phys_to_virt(0x%lx) at 0x%p!\n",
-			paddr, __builtin_return_address(0));
-	}
-#endif
-	return -1;
-}
-EXPORT_SYMBOL(mm_ptov);
-#endif
-
 /* invalidate page in both caches */
 static inline void clear040(unsigned long paddr)
 {
@@ -353,17 +292,4 @@
 #endif
 }
 EXPORT_SYMBOL(cache_push);
-
-#ifndef CONFIG_SINGLE_MEMORY_CHUNK
-int mm_end_of_chunk (unsigned long addr, int len)
-{
-	int i;
-
-	for (i = 0; i < m68k_num_memory; i++)
-		if (m68k_memory[i].addr + m68k_memory[i].size == addr + len)
-			return 1;
-	return 0;
-}
-EXPORT_SYMBOL(mm_end_of_chunk);
-#endif
@@ -43,6 +43,11 @@
 EXPORT_SYMBOL(mm_cachebits);
 #endif
  
+/* size of memory already mapped in head.S */
+#define INIT_MAPPED_SIZE	(4UL<<20)
+
+extern unsigned long availmem;
+
 static pte_t * __init kernel_page_table(void)
 {
 	pte_t *ptablep;
  
  
@@ -98,19 +103,20 @@
 	return last_pgtable;
 }
  
-static unsigned long __init
-map_chunk (unsigned long addr, long size)
+static void __init map_node(int node)
 {
 #define PTRTREESIZE (256*1024)
 #define ROOTTREESIZE (32*1024*1024)
-	static unsigned long virtaddr = PAGE_OFFSET;
-	unsigned long physaddr;
+	unsigned long physaddr, virtaddr, size;
 	pgd_t *pgd_dir;
 	pmd_t *pmd_dir;
 	pte_t *pte_dir;
  
-	physaddr = (addr | m68k_supervisor_cachemode |
-		    _PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_DIRTY);
+	size = m68k_memory[node].size;
+	physaddr = m68k_memory[node].addr;
+	virtaddr = (unsigned long)phys_to_virt(physaddr);
+	physaddr |= m68k_supervisor_cachemode |
+		    _PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_DIRTY;
 	if (CPU_IS_040_OR_060)
 		physaddr |= _PAGE_GLOBAL040;
  
@@ -190,8 +196,6 @@
 #ifdef DEBUG
 	printk("\n");
 #endif
-
-	return virtaddr;
 }
  
 /*
  
  
@@ -200,15 +204,16 @@
  */
 void __init paging_init(void)
 {
-	int chunk;
-	unsigned long mem_avail = 0;
 	unsigned long zones_size[MAX_NR_ZONES] = { 0, };
+	unsigned long min_addr, max_addr;
+	unsigned long addr, size, end;
+	int i;
  
 #ifdef DEBUG
 	{
 		extern unsigned long availmem;
-		printk ("start of paging_init (%p, %lx, %lx, %lx)\n",
-			kernel_pg_dir, availmem, start_mem, end_mem);
+		printk ("start of paging_init (%p, %lx)\n",
+			kernel_pg_dir, availmem);
 	}
 #endif
  
  
  
  
  
  
  
@@ -222,27 +227,62 @@
 			pgprot_val(protection_map[i]) |= _PAGE_CACHE040;
 	}
  
+	min_addr = m68k_memory[0].addr;
+	max_addr = min_addr + m68k_memory[0].size;
+	for (i = 1; i < m68k_num_memory;) {
+		if (m68k_memory[i].addr < min_addr) {
+			printk("Ignoring memory chunk at 0x%lx:0x%lx before the first chunk\n",
+				m68k_memory[i].addr, m68k_memory[i].size);
+			printk("Fix your bootloader or use a memfile to make use of this area!\n");
+			m68k_num_memory--;
+			memmove(m68k_memory + i, m68k_memory + i + 1,
+				(m68k_num_memory - i) * sizeof(struct mem_info));
+			continue;
+		}
+		addr = m68k_memory[i].addr + m68k_memory[i].size;
+		if (addr > max_addr)
+			max_addr = addr;
+		i++;
+	}
+	m68k_memoffset = min_addr - PAGE_OFFSET;
+	m68k_virt_to_node_shift = fls(max_addr - min_addr - 1) - 6;
+
 	module_fixup(NULL, __start_fixup, __stop_fixup);
 	flush_icache();
  
+	high_memory = phys_to_virt(max_addr);
+
+	min_low_pfn = availmem >> PAGE_SHIFT;
+	max_low_pfn = max_addr >> PAGE_SHIFT;
+
+	for (i = 0; i < m68k_num_memory; i++) {
+		addr = m68k_memory[i].addr;
+		end = addr + m68k_memory[i].size;
+		m68k_setup_node(i);
+		availmem = PAGE_ALIGN(availmem);
+		availmem += init_bootmem_node(NODE_DATA(i),
+					      availmem >> PAGE_SHIFT,
+					      addr >> PAGE_SHIFT,
+					      end >> PAGE_SHIFT);
+	}
+
 	/*
 	 * Map the physical memory available into the kernel virtual
-	 * address space.  It may allocate some memory for page
-	 * tables and thus modify availmem.
+	 * address space. First initialize the bootmem allocator with
+	 * the memory we already mapped, so map_node() has something
+	 * to allocate.
 	 */
+	addr = m68k_memory[0].addr;
+	size = m68k_memory[0].size;
+	free_bootmem_node(NODE_DATA(0), availmem, min(INIT_MAPPED_SIZE, size) - (availmem - addr));
+	map_node(0);
+	if (size > INIT_MAPPED_SIZE)
+		free_bootmem_node(NODE_DATA(0), addr + INIT_MAPPED_SIZE, size - INIT_MAPPED_SIZE);
  
-	for (chunk = 0; chunk < m68k_num_memory; chunk++) {
-		mem_avail = map_chunk (m68k_memory[chunk].addr,
-				       m68k_memory[chunk].size);
+	for (i = 1; i < m68k_num_memory; i++)
+		map_node(i);
  
-	}
-
 	flush_tlb_all();
-#ifdef DEBUG
-	printk ("memory available is %ldKB\n", mem_avail >> 10);
-	printk ("start_mem is %#lx\nvirtual_end is %#lx\n",
-		start_mem, end_mem);
-#endif
  
 	/*
 	 * initialize the bad page table and bad page to point
@@ -259,14 +299,11 @@
 #ifdef DEBUG
 	printk ("before free_area_init\n");
 #endif
-	zones_size[ZONE_DMA] = (mach_max_dma_address < (unsigned long)high_memory ?
-				(mach_max_dma_address+1) : (unsigned long)high_memory);
-	zones_size[ZONE_NORMAL] = (unsigned long)high_memory - zones_size[0];
-
-	zones_size[ZONE_DMA] = (zones_size[ZONE_DMA] - PAGE_OFFSET) >> PAGE_SHIFT;
-	zones_size[ZONE_NORMAL] >>= PAGE_SHIFT;
-
-	free_area_init(zones_size);
+	for (i = 0; i < m68k_num_memory; i++) {
+		zones_size[ZONE_DMA] = m68k_memory[i].size >> PAGE_SHIFT;
+		free_area_init_node(i, pg_data_map + i, zones_size,
+				    m68k_memory[i].addr >> PAGE_SHIFT, NULL);
+	}
 }
  
 extern char __init_begin, __init_end;
@@ -21,6 +21,7 @@
 #include <asm/contregs.h>
 #include <asm/movs.h>
 #include <asm/pgtable.h>
+#include <asm/pgalloc.h>
 #include <asm/sun3-head.h>
 #include <asm/sun3mmu.h>
 #include <asm/rtc.h>
@@ -127,6 +128,7 @@
 	high_memory = (void *)memory_end;
 	availmem = memory_start;
  
+	m68k_setup_node(0);
 	availmem += init_bootmem_node(NODE_DATA(0), start_page, 0, num_pages);
 	availmem = (availmem + (PAGE_SIZE-1)) & PAGE_MASK;
  
+#ifndef _ASM_M68K_MMZONE_H_
+#define _ASM_M68K_MMZONE_H_
+
+extern pg_data_t pg_data_map[];
+
+#define NODE_DATA(nid)		(&pg_data_map[nid])
+#define NODE_MEM_MAP(nid)	(NODE_DATA(nid)->node_mem_map)
+
+#endif /* _ASM_M68K_MMZONE_H_ */
@@ -17,6 +17,7 @@
  
 enum m68k_fixup_type {
 	m68k_fixup_memoffset,
+	m68k_fixup_vnode_shift,
 };
  
 struct m68k_fixup_info {
@@ -130,7 +130,7 @@
 #define pte_present(pte)	(pte_val(pte) & (_PAGE_PRESENT | _PAGE_PROTNONE))
 #define pte_clear(mm,addr,ptep)		({ pte_val(*(ptep)) = 0; })
  
-#define pte_page(pte)		(mem_map + ((unsigned long)(__va(pte_val(pte)) - PAGE_OFFSET) >> PAGE_SHIFT))
+#define pte_page(pte)		virt_to_page(__va(pte_val(pte)))
 #define pte_pfn(pte)		(pte_val(pte) >> PAGE_SHIFT)
 #define pfn_pte(pfn, prot)	__pte(((pfn) << PAGE_SHIFT) | pgprot_val(prot))
  
@@ -143,7 +143,7 @@
 	while (--__i >= 0)			\
 		*__ptr++ = 0;			\
 })
-#define pmd_page(pmd)		(mem_map + ((unsigned long)(__va(pmd_val(pmd)) - PAGE_OFFSET) >> PAGE_SHIFT))
+#define pmd_page(pmd)		virt_to_page(__va(pmd_val(pmd)))
  
  
 #define pgd_none(pgd)		(!pgd_val(pgd))
  
@@ -223,10 +223,10 @@
 	return (pte_t *)__pmd_page(*pmdp) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
 }
  
-#define pte_offset_map(pmdp,address) ((pte_t *)kmap(pmd_page(*pmdp)) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))
+#define pte_offset_map(pmdp,address) ((pte_t *)__pmd_page(*pmdp) + (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))
 #define pte_offset_map_nested(pmdp, address) pte_offset_map(pmdp, address)
-#define pte_unmap(pte) kunmap(pte)
-#define pte_unmap_nested(pte) kunmap(pte)
+#define pte_unmap(pte)		((void)0)
+#define pte_unmap_nested(pte)	((void)0)
  
 /*
  * Allocate and free page tables. The xxx_kernel() versions are
@@ -121,7 +121,6 @@
 #ifndef CONFIG_SUN3
  
 #define WANT_PAGE_VIRTUAL
-#ifdef CONFIG_SINGLE_MEMORY_CHUNK
  
 static inline unsigned long ___pa(void *vaddr)
 {
@@ -133,7 +132,7 @@
 		: "0" (vaddr), "i" (m68k_fixup_memoffset));
 	return paddr;
 }
-#define __pa(vaddr)    ___pa((void *)(vaddr))
+#define __pa(vaddr)	___pa((void *)(vaddr))
 static inline void *__va(unsigned long paddr)
 {
 	void *vaddr;
@@ -145,11 +144,6 @@
 	return vaddr;
 }
  
-#else
-#define __pa(vaddr)		virt_to_phys((void *)(vaddr))
-#define __va(paddr)		phys_to_virt((unsigned long)(paddr))
-#endif
-
 #else	/* !CONFIG_SUN3 */
 /* This #define is a horrible hack to suppress lots of warnings. --m */
 #define __pa(x) ___pa((unsigned long)(x))
  
@@ -184,11 +178,47 @@
 #define virt_to_pfn(kaddr)	(__pa(kaddr) >> PAGE_SHIFT)
 #define pfn_to_virt(pfn)	__va((pfn) << PAGE_SHIFT)
  
-#define virt_to_page(kaddr)	(mem_map + (((unsigned long)(kaddr)-PAGE_OFFSET) >> PAGE_SHIFT))
-#define page_to_virt(page)	((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
+extern int m68k_virt_to_node_shift;
  
-#define pfn_to_page(pfn)	virt_to_page(pfn_to_virt(pfn))
-#define page_to_pfn(page)	virt_to_pfn(page_to_virt(page))
+#ifdef CONFIG_SINGLE_MEMORY_CHUNK
+#define __virt_to_node(addr)	(&pg_data_map[0])
+#else
+extern struct pglist_data *pg_data_table[];
+
+static inline __attribute_const__ int __virt_to_node_shift(void)
+{
+	int shift;
+
+	asm (
+		"1:	moveq	#0,%0\n"
+		m68k_fixup(%c1, 1b)
+		: "=d" (shift)
+		: "i" (m68k_fixup_vnode_shift));
+	return shift;
+}
+
+#define __virt_to_node(addr)	(pg_data_table[(unsigned long)(addr) >> __virt_to_node_shift()])
+#endif
+
+#define virt_to_page(addr) ({						\
+	pfn_to_page(virt_to_pfn(addr));					\
+})
+#define page_to_virt(page) ({						\
+	pfn_to_virt(page_to_pfn(page));					\
+})
+
+#define pfn_to_page(pfn) ({						\
+	unsigned long __pfn = (pfn);					\
+	struct pglist_data *pgdat;					\
+	pgdat = __virt_to_node((unsigned long)pfn_to_virt(__pfn));	\
+	pgdat->node_mem_map + (__pfn - pgdat->node_start_pfn);		\
+})
+#define page_to_pfn(_page) ({						\
+	struct page *__p = (_page);					\
+	struct pglist_data *pgdat;					\
+	pgdat = &pg_data_map[page_to_nid(__p)];				\
+	((__p) - pgdat->node_mem_map) + pgdat->node_start_pfn;		\
+})
  
 #define virt_addr_valid(kaddr)	((void *)(kaddr) >= (void *)PAGE_OFFSET && (void *)(kaddr) < high_memory)
 #define pfn_valid(pfn)		virt_addr_valid(pfn_to_virt(pfn))
@@ -8,12 +8,13 @@
 #include <asm/virtconvert.h>
  
  
-
 #ifdef CONFIG_SUN3
 #include <asm/sun3_pgalloc.h>
 #else
 #include <asm/motorola_pgalloc.h>
 #endif
+
+extern void m68k_setup_node(int node);
  
 #endif /* M68K_PGALLOC_H */
@@ -107,22 +107,7 @@
 /* 64-bit machines, beware!  SRB. */
 #define SIZEOF_PTR_LOG2			       2
  
-/*
- * Check if the addr/len goes up to the end of a physical
- * memory chunk.  Used for DMA functions.
- */
-#ifdef CONFIG_SINGLE_MEMORY_CHUNK
-/*
- * It makes no sense to consider whether we cross a memory boundary if
- * we support just one physical chunk of memory.
- */
-static inline int mm_end_of_chunk(unsigned long addr, int len)
-{
-	return 0;
-}
-#else
-int mm_end_of_chunk (unsigned long addr, int len);
-#endif
+#define mm_end_of_chunk(addr, len)	0
  
 extern void kernel_set_cachemode(void *addr, unsigned long size, int cmode);
  
@@ -132,8 +132,8 @@
 #define pfn_pte(pfn, pgprot) \
 ({ pte_t __pte; pte_val(__pte) = pfn | pgprot_val(pgprot); __pte; })
  
-#define pte_page(pte)		(mem_map+((__pte_page(pte) - PAGE_OFFSET) >> PAGE_SHIFT))
-#define pmd_page(pmd)		(mem_map+((__pmd_page(pmd) - PAGE_OFFSET) >> PAGE_SHIFT))
+#define pte_page(pte)		virt_to_page(__pte_page(pte))
+#define pmd_page(pmd)		virt_to_page(__pmd_page(pmd))
  
  
 static inline int pmd_none2 (pmd_t *pmd) { return !pmd_val (*pmd); }
@@ -8,56 +8,35 @@
 #ifdef __KERNEL__
  
 #include <linux/compiler.h>
+#include <linux/mmzone.h>
 #include <asm/setup.h>
 #include <asm/page.h>
  
-#ifdef CONFIG_AMIGA
-#include <asm/amigahw.h>
-#endif
-
 /*
  * Change virtual addresses to physical addresses and vv.
  */
-#ifndef CONFIG_SUN3
-extern unsigned long mm_vtop(unsigned long addr) __attribute_const__;
-extern unsigned long mm_ptov(unsigned long addr) __attribute_const__;
-#else
-static inline unsigned long mm_vtop(unsigned long vaddr)
-{
-	return __pa(vaddr);
-}
-
-static inline unsigned long mm_ptov(unsigned long paddr)
-{
-	return (unsigned long)__va(paddr);
-}
-#endif
-
-#ifdef CONFIG_SINGLE_MEMORY_CHUNK
-static inline unsigned long virt_to_phys(void *vaddr)
-{
-	return (unsigned long)vaddr - PAGE_OFFSET + m68k_memory[0].addr;
-}
-
-static inline void * phys_to_virt(unsigned long paddr)
-{
-	return (void *)(paddr - m68k_memory[0].addr + PAGE_OFFSET);
-}
-#else
 static inline unsigned long virt_to_phys(void *address)
 {
-	return mm_vtop((unsigned long)address);
+	return __pa(address);
 }
  
 static inline void *phys_to_virt(unsigned long address)
 {
-	return (void *) mm_ptov(address);
+	return __va(address);
 }
-#endif
  
 /* Permanent address of a page. */
-#define __page_address(page)	(PAGE_OFFSET + (((page) - mem_map) << PAGE_SHIFT))
-#define page_to_phys(page)	virt_to_phys((void *)__page_address(page))
+#ifdef CONFIG_SINGLE_MEMORY_CHUNK
+#define page_to_phys(page) \
+	__pa(PAGE_OFFSET + (((page) - pg_data_map[0].node_mem_map) << PAGE_SHIFT))
+#else
+#define page_to_phys(_page) ({						\
+	struct page *__page = _page;					\
+	struct pglist_data *pgdat;					\
+	pgdat = pg_data_table[page_to_nid(__page)];			\
+	page_to_pfn(__page) << PAGE_SHIFT;				\
+})
+#endif
  
 /*
  * IO bus memory addresses are 1:1 with the physical address,
@@ -2689,7 +2689,7 @@
 			map = alloc_bootmem_node(pgdat, size);
 		pgdat->node_mem_map = map + (pgdat->node_start_pfn - start);
 	}
-#ifdef CONFIG_FLATMEM
+#ifndef CONFIG_NEED_MULTIPLE_NODES
 	/*
 	 * With no DISCONTIG, the global mem_map is just set as node 0's
 	 */
...	...	@@ -355,8 +355,9 @@
355	355	adventurous.
356	356
357	357	config SINGLE_MEMORY_CHUNK
358		- bool "Use one physical chunk of memory only"
359		- depends on ADVANCED && !SUN3
	358	+ bool "Use one physical chunk of memory only" if ADVANCED && !SUN3
	359	+ default y if SUN3
	360	+ select NEED_MULTIPLE_NODES
360	361	help
361	362	Ignore all but the first contiguous chunk of physical memory for VM
362	363	purposes. This will save a few bytes kernel size and may speed up
...	...	@@ -376,6 +377,14 @@
376	377	drivers on 68060 based systems where the 68060 bus snooping signal
377	378	is hardwired on. The 53c710 SCSI driver is known to suffer from
378	379	this problem.
	380	+
	381	+config ARCH_DISCONTIGMEM_ENABLE
	382	+ def_bool !SINGLE_MEMORY_CHUNK
	383	+
	384	+config NODES_SHIFT
	385	+ int
	386	+ default "3"
	387	+ depends on !SINGLE_MEMORY_CHUNK
379	388
380	389	source "mm/Kconfig"
381	390
...	...	@@ -149,6 +149,9 @@
149	149	case m68k_fixup_memoffset:
150	150	(u32 )fixup->addr = m68k_memoffset;
151	151	break;
	152	+ case m68k_fixup_vnode_shift:
	153	+ (u16 )fixup->addr += m68k_virt_to_node_shift;
	154	+ break;
152	155	}
153	156	}
154	157	}
...	...	@@ -60,14 +60,12 @@
60	60	int m68k_num_memory;
61	61	int m68k_realnum_memory;
62	62	EXPORT_SYMBOL(m68k_realnum_memory);
63		-#ifdef CONFIG_SINGLE_MEMORY_CHUNK
64	63	unsigned long m68k_memoffset;
65	64	EXPORT_SYMBOL(m68k_memoffset);
66		-#endif
67	65	struct mem_info m68k_memory[NUM_MEMINFO];
68	66	EXPORT_SYMBOL(m68k_memory);
69	67
70		-static struct mem_info m68k_ramdisk;
	68	+struct mem_info m68k_ramdisk;
71	69
72	70	static char m68k_command_line[CL_SIZE];
73	71
...	...	@@ -208,9 +206,6 @@
208	206	void __init setup_arch(char **cmdline_p)
209	207	{
210	208	extern int _etext, _edata, _end;
211		-#ifndef CONFIG_SUN3
212		- unsigned long endmem, startmem;
213		-#endif
214	209	int i;
215	210
216	211	/* The bootinfo is located right after the kernel bss */
217	212
218	213
...	...	@@ -320,30 +315,16 @@
320	315	panic("No configuration setup");
321	316	}
322	317
323		-#ifndef CONFIG_SUN3
324		- startmem= m68k_memory[0].addr;
325		- endmem = startmem + m68k_memory[0].size;
326		- high_memory = (void *)PAGE_OFFSET;
327		- for (i = 0; i < m68k_num_memory; i++) {
328		- m68k_memory[i].size &= MASK_256K;
329		- if (m68k_memory[i].addr < startmem)
330		- startmem = m68k_memory[i].addr;
331		- if (m68k_memory[i].addr+m68k_memory[i].size > endmem)
332		- endmem = m68k_memory[i].addr+m68k_memory[i].size;
333		- high_memory += m68k_memory[i].size;
334		- }
	318	+ paging_init();
335	319
336		- availmem += init_bootmem_node(NODE_DATA(0), availmem >> PAGE_SHIFT,
337		- startmem >> PAGE_SHIFT, endmem >> PAGE_SHIFT);
338		-
339		- for (i = 0; i < m68k_num_memory; i++)
340		- free_bootmem(m68k_memory[i].addr, m68k_memory[i].size);
341		-
342		- reserve_bootmem(m68k_memory[0].addr, availmem - m68k_memory[0].addr);
343		-
	320	+#ifndef CONFIG_SUN3
	321	+ for (i = 1; i < m68k_num_memory; i++)
	322	+ free_bootmem_node(NODE_DATA(i), m68k_memory[i].addr,
	323	+ m68k_memory[i].size);
344	324	#ifdef CONFIG_BLK_DEV_INITRD
345	325	if (m68k_ramdisk.size) {
346		- reserve_bootmem(m68k_ramdisk.addr, m68k_ramdisk.size);
	326	+ reserve_bootmem_node(__virt_to_node(phys_to_virt(m68k_ramdisk.addr)),
	327	+ m68k_ramdisk.addr, m68k_ramdisk.size);
347	328	initrd_start = (unsigned long)phys_to_virt(m68k_ramdisk.addr);
348	329	initrd_end = initrd_start + m68k_ramdisk.size;
349	330	printk("initrd: %08lx - %08lx\n", initrd_start, initrd_end);
...	...	@@ -361,8 +342,6 @@
361	342	#endif
362	343
363	344	#endif /* !CONFIG_SUN3 */
364		-
365		- paging_init();
366	345
367	346	/* set ISA defs early as possible */
368	347	#if defined(CONFIG_ISA) && defined(MULTI_ISA)
...	...	@@ -7,6 +7,7 @@
7	7	* to motorola.c and sun3mmu.c
8	8	*/
9	9
	10	+#include <linux/module.h>
10	11	#include <linux/signal.h>
11	12	#include <linux/sched.h>
12	13	#include <linux/mm.h>
...	...	@@ -31,6 +32,37 @@
31	32
32	33	DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
33	34
	35	+static bootmem_data_t __initdata bootmem_data[MAX_NUMNODES];
	36	+
	37	+pg_data_t pg_data_map[MAX_NUMNODES];
	38	+EXPORT_SYMBOL(pg_data_map);
	39	+
	40	+int m68k_virt_to_node_shift;
	41	+
	42	+#ifndef CONFIG_SINGLE_MEMORY_CHUNK
	43	+pg_data_t *pg_data_table[65];
	44	+EXPORT_SYMBOL(pg_data_table);
	45	+#endif
	46	+
	47	+void m68k_setup_node(int node)
	48	+{
	49	+#ifndef CONFIG_SINGLE_MEMORY_CHUNK
	50	+ struct mem_info *info = m68k_memory + node;
	51	+ int i, end;
	52	+
	53	+ i = (unsigned long)phys_to_virt(info->addr) >> __virt_to_node_shift();
	54	+ end = (unsigned long)phys_to_virt(info->addr + info->size - 1) >> __virt_to_node_shift();
	55	+ for (; i <= end; i++) {
	56	+ if (pg_data_table[i])
	57	+ printk("overlap at %u for chunk %u\n", i, node);
	58	+ pg_data_table[i] = pg_data_map + node;
	59	+ }
	60	+#endif
	61	+ pg_data_map[node].bdata = bootmem_data + node;
	62	+ node_set_online(node);
	63	+}
	64	+
	65	+
34	66	/*
35	67	* ZERO_PAGE is a special page that is used for zero-initialized
36	68	* data and COW.
37	69
38	70
39	71
40	72
41	73
42	74
43	75
44	76
45	77
46	78
...	...	@@ -40,72 +72,77 @@
40	72
41	73	void show_mem(void)
42	74	{
43		- unsigned long i;
44		- int free = 0, total = 0, reserved = 0, shared = 0;
45		- int cached = 0;
	75	+ pg_data_t *pgdat;
	76	+ int free = 0, total = 0, reserved = 0, shared = 0;
	77	+ int cached = 0;
	78	+ int i;
46	79
47		- printk("\nMem-info:\n");
48		- show_free_areas();
49		- printk("Free swap: %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
50		- i = max_mapnr;
51		- while (i-- > 0) {
52		- total++;
53		- if (PageReserved(mem_map+i))
54		- reserved++;
55		- else if (PageSwapCache(mem_map+i))
56		- cached++;
57		- else if (!page_count(mem_map+i))
58		- free++;
59		- else
60		- shared += page_count(mem_map+i) - 1;
61		- }
62		- printk("%d pages of RAM\n",total);
63		- printk("%d free pages\n",free);
64		- printk("%d reserved pages\n",reserved);
65		- printk("%d pages shared\n",shared);
66		- printk("%d pages swap cached\n",cached);
	80	+ printk("\nMem-info:\n");
	81	+ show_free_areas();
	82	+ printk("Free swap: %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
	83	+ for_each_online_pgdat(pgdat) {
	84	+ for (i = 0; i < pgdat->node_spanned_pages; i++) {
	85	+ struct page *page = pgdat->node_mem_map + i;
	86	+ total++;
	87	+ if (PageReserved(page))
	88	+ reserved++;
	89	+ else if (PageSwapCache(page))
	90	+ cached++;
	91	+ else if (!page_count(page))
	92	+ free++;
	93	+ else
	94	+ shared += page_count(page) - 1;
	95	+ }
	96	+ }
	97	+ printk("%d pages of RAM\n",total);
	98	+ printk("%d free pages\n",free);
	99	+ printk("%d reserved pages\n",reserved);
	100	+ printk("%d pages shared\n",shared);
	101	+ printk("%d pages swap cached\n",cached);
67	102	}
68	103
69	104	extern void init_pointer_table(unsigned long ptable);
70	105
71	106	/* References to section boundaries */
72	107
73		-extern char _text, _etext, _edata, __bss_start, _end;
74		-extern char __init_begin, __init_end;
	108	+extern char _text[], _etext[];
	109	+extern char __init_begin[], __init_end[];
75	110
76	111	extern pmd_t *zero_pgtable;
77	112
78	113	void __init mem_init(void)
79	114	{
	115	+ pg_data_t *pgdat;
80	116	int codepages = 0;
81	117	int datapages = 0;
82	118	int initpages = 0;
83		- unsigned long tmp;
84		-#ifndef CONFIG_SUN3
85	119	int i;
86		-#endif
87	120
88		- max_mapnr = num_physpages = (((unsigned long)high_memory - PAGE_OFFSET) >> PAGE_SHIFT);
89		-
90	121	#ifdef CONFIG_ATARI
91	122	if (MACH_IS_ATARI)
92	123	atari_stram_mem_init_hook();
93	124	#endif
94	125
95	126	/* this will put all memory onto the freelists */
96		- totalram_pages = free_all_bootmem();
	127	+ totalram_pages = num_physpages = 0;
	128	+ for_each_online_pgdat(pgdat) {
	129	+ num_physpages += pgdat->node_present_pages;
97	130
98		- for (tmp = PAGE_OFFSET ; tmp < (unsigned long)high_memory; tmp += PAGE_SIZE) {
99		- if (PageReserved(virt_to_page(tmp))) {
100		- if (tmp >= (unsigned long)&_text
101		- && tmp < (unsigned long)&_etext)
	131	+ totalram_pages += free_all_bootmem_node(pgdat);
	132	+ for (i = 0; i < pgdat->node_spanned_pages; i++) {
	133	+ struct page *page = pgdat->node_mem_map + i;
	134	+ char *addr = page_to_virt(page);
	135	+
	136	+ if (!PageReserved(page))
	137	+ continue;
	138	+ if (addr >= _text &&
	139	+ addr < _etext)
102	140	codepages++;
103		- else if (tmp >= (unsigned long) &__init_begin
104		- && tmp < (unsigned long) &__init_end)
	141	+ else if (addr >= __init_begin &&
	142	+ addr < __init_end)
105	143	initpages++;
106	144	else
107	145	datapages++;
108		- continue;
109	146	}
110	147	}
111	148
...	...	@@ -124,7 +161,7 @@
124	161
125	162	printk("Memory: %luk/%luk available (%dk kernel code, %dk data, %dk init)\n",
126	163	(unsigned long)nr_free_pages() << (PAGE_SHIFT-10),
127		- max_mapnr << (PAGE_SHIFT-10),
	164	+ totalram_pages << (PAGE_SHIFT-10),
128	165	codepages << (PAGE_SHIFT-10),
129	166	datapages << (PAGE_SHIFT-10),
130	167	initpages << (PAGE_SHIFT-10));
...	...	@@ -127,67 +127,6 @@
127	127	return 0;
128	128	}
129	129
130		-#ifdef DEBUG_INVALID_PTOV
131		-int mm_inv_cnt = 5;
132		-#endif
133		-
134		-#ifndef CONFIG_SINGLE_MEMORY_CHUNK
135		-/*
136		- * The following two routines map from a physical address to a kernel
137		- * virtual address and vice versa.
138		- */
139		-unsigned long mm_vtop(unsigned long vaddr)
140		-{
141		- int i=0;
142		- unsigned long voff = (unsigned long)vaddr - PAGE_OFFSET;
143		-
144		- do {
145		- if (voff < m68k_memory[i].size) {
146		-#ifdef DEBUGPV
147		- printk ("VTOP(%p)=%lx\n", vaddr,
148		- m68k_memory[i].addr + voff);
149		-#endif
150		- return m68k_memory[i].addr + voff;
151		- }
152		- voff -= m68k_memory[i].size;
153		- } while (++i < m68k_num_memory);
154		-
155		- /* As a special case allow `__pa(high_memory)'. */
156		- if (voff == 0)
157		- return m68k_memory[i-1].addr + m68k_memory[i-1].size;
158		-
159		- return -1;
160		-}
161		-EXPORT_SYMBOL(mm_vtop);
162		-
163		-unsigned long mm_ptov (unsigned long paddr)
164		-{
165		- int i = 0;
166		- unsigned long poff, voff = PAGE_OFFSET;
167		-
168		- do {
169		- poff = paddr - m68k_memory[i].addr;
170		- if (poff < m68k_memory[i].size) {
171		-#ifdef DEBUGPV
172		- printk ("PTOV(%lx)=%lx\n", paddr, poff + voff);
173		-#endif
174		- return poff + voff;
175		- }
176		- voff += m68k_memory[i].size;
177		- } while (++i < m68k_num_memory);
178		-
179		-#ifdef DEBUG_INVALID_PTOV
180		- if (mm_inv_cnt > 0) {
181		- mm_inv_cnt--;
182		- printk("Invalid use of phys_to_virt(0x%lx) at 0x%p!\n",
183		- paddr, __builtin_return_address(0));
184		- }
185		-#endif
186		- return -1;
187		-}
188		-EXPORT_SYMBOL(mm_ptov);
189		-#endif
190		-
191	130	/* invalidate page in both caches */
192	131	static inline void clear040(unsigned long paddr)
193	132	{
...	...	@@ -353,17 +292,4 @@
353	292	#endif
354	293	}
355	294	EXPORT_SYMBOL(cache_push);
356		-
357		-#ifndef CONFIG_SINGLE_MEMORY_CHUNK
358		-int mm_end_of_chunk (unsigned long addr, int len)
359		-{
360		- int i;
361		-
362		- for (i = 0; i < m68k_num_memory; i++)
363		- if (m68k_memory[i].addr + m68k_memory[i].size == addr + len)
364		- return 1;
365		- return 0;
366		-}
367		-EXPORT_SYMBOL(mm_end_of_chunk);
368		-#endif
...	...	@@ -43,6 +43,11 @@
43	43	EXPORT_SYMBOL(mm_cachebits);
44	44	#endif
45	45
	46	+/* size of memory already mapped in head.S */
	47	+#define INIT_MAPPED_SIZE (4UL<<20)
	48	+
	49	+extern unsigned long availmem;
	50	+
46	51	static pte_t * __init kernel_page_table(void)
47	52	{
48	53	pte_t *ptablep;
49	54
50	55
...	...	@@ -98,19 +103,20 @@
98	103	return last_pgtable;
99	104	}
100	105
101		-static unsigned long __init
102		-map_chunk (unsigned long addr, long size)
	106	+static void __init map_node(int node)
103	107	{
104	108	#define PTRTREESIZE (256*1024)
105	109	#define ROOTTREESIZE (3210241024)
106		- static unsigned long virtaddr = PAGE_OFFSET;
107		- unsigned long physaddr;
	110	+ unsigned long physaddr, virtaddr, size;
108	111	pgd_t *pgd_dir;
109	112	pmd_t *pmd_dir;
110	113	pte_t *pte_dir;
111	114
112		- physaddr = (addr \| m68k_supervisor_cachemode \|
113		- _PAGE_PRESENT \| _PAGE_ACCESSED \| _PAGE_DIRTY);
	115	+ size = m68k_memory[node].size;
	116	+ physaddr = m68k_memory[node].addr;
	117	+ virtaddr = (unsigned long)phys_to_virt(physaddr);
	118	+ physaddr \|= m68k_supervisor_cachemode \|
	119	+ _PAGE_PRESENT \| _PAGE_ACCESSED \| _PAGE_DIRTY;
114	120	if (CPU_IS_040_OR_060)
115	121	physaddr \|= _PAGE_GLOBAL040;
116	122
...	...	@@ -190,8 +196,6 @@
190	196	#ifdef DEBUG
191	197	printk("\n");
192	198	#endif
193		-
194		- return virtaddr;
195	199	}
196	200
197	201	/*
198	202
199	203
...	...	@@ -200,15 +204,16 @@
200	204	*/
201	205	void __init paging_init(void)
202	206	{
203		- int chunk;
204		- unsigned long mem_avail = 0;
205	207	unsigned long zones_size[MAX_NR_ZONES] = { 0, };
	208	+ unsigned long min_addr, max_addr;
	209	+ unsigned long addr, size, end;
	210	+ int i;
206	211
207	212	#ifdef DEBUG
208	213	{
209	214	extern unsigned long availmem;
210		- printk ("start of paging_init (%p, %lx, %lx, %lx)\n",
211		- kernel_pg_dir, availmem, start_mem, end_mem);
	215	+ printk ("start of paging_init (%p, %lx)\n",
	216	+ kernel_pg_dir, availmem);
212	217	}
213	218	#endif
214	219
215	220
216	221
217	222
218	223
219	224
220	225
...	...	@@ -222,27 +227,62 @@
222	227	pgprot_val(protection_map[i]) \|= _PAGE_CACHE040;
223	228	}
224	229
	230	+ min_addr = m68k_memory[0].addr;
	231	+ max_addr = min_addr + m68k_memory[0].size;
	232	+ for (i = 1; i < m68k_num_memory;) {
	233	+ if (m68k_memory[i].addr < min_addr) {
	234	+ printk("Ignoring memory chunk at 0x%lx:0x%lx before the first chunk\n",
	235	+ m68k_memory[i].addr, m68k_memory[i].size);
	236	+ printk("Fix your bootloader or use a memfile to make use of this area!\n");
	237	+ m68k_num_memory--;
	238	+ memmove(m68k_memory + i, m68k_memory + i + 1,
	239	+ (m68k_num_memory - i) * sizeof(struct mem_info));
	240	+ continue;
	241	+ }
	242	+ addr = m68k_memory[i].addr + m68k_memory[i].size;
	243	+ if (addr > max_addr)
	244	+ max_addr = addr;
	245	+ i++;
	246	+ }
	247	+ m68k_memoffset = min_addr - PAGE_OFFSET;
	248	+ m68k_virt_to_node_shift = fls(max_addr - min_addr - 1) - 6;
	249	+
225	250	module_fixup(NULL, __start_fixup, __stop_fixup);
226	251	flush_icache();
227	252
	253	+ high_memory = phys_to_virt(max_addr);
	254	+
	255	+ min_low_pfn = availmem >> PAGE_SHIFT;
	256	+ max_low_pfn = max_addr >> PAGE_SHIFT;
	257	+
	258	+ for (i = 0; i < m68k_num_memory; i++) {
	259	+ addr = m68k_memory[i].addr;
	260	+ end = addr + m68k_memory[i].size;
	261	+ m68k_setup_node(i);
	262	+ availmem = PAGE_ALIGN(availmem);
	263	+ availmem += init_bootmem_node(NODE_DATA(i),
	264	+ availmem >> PAGE_SHIFT,
	265	+ addr >> PAGE_SHIFT,
	266	+ end >> PAGE_SHIFT);
	267	+ }
	268	+
228	269	/*
229	270	* Map the physical memory available into the kernel virtual
230		- * address space. It may allocate some memory for page
231		- * tables and thus modify availmem.
	271	+ * address space. First initialize the bootmem allocator with
	272	+ * the memory we already mapped, so map_node() has something
	273	+ * to allocate.
232	274	*/
	275	+ addr = m68k_memory[0].addr;
	276	+ size = m68k_memory[0].size;
	277	+ free_bootmem_node(NODE_DATA(0), availmem, min(INIT_MAPPED_SIZE, size) - (availmem - addr));
	278	+ map_node(0);
	279	+ if (size > INIT_MAPPED_SIZE)
	280	+ free_bootmem_node(NODE_DATA(0), addr + INIT_MAPPED_SIZE, size - INIT_MAPPED_SIZE);
233	281
234		- for (chunk = 0; chunk < m68k_num_memory; chunk++) {
235		- mem_avail = map_chunk (m68k_memory[chunk].addr,
236		- m68k_memory[chunk].size);
	282	+ for (i = 1; i < m68k_num_memory; i++)
	283	+ map_node(i);
237	284
238		- }
239		-
240	285	flush_tlb_all();
241		-#ifdef DEBUG
242		- printk ("memory available is %ldKB\n", mem_avail >> 10);
243		- printk ("start_mem is %#lx\nvirtual_end is %#lx\n",
244		- start_mem, end_mem);
245		-#endif
246	286
247	287	/*
248	288	* initialize the bad page table and bad page to point
...	...	@@ -259,14 +299,11 @@
259	299	#ifdef DEBUG
260	300	printk ("before free_area_init\n");
261	301	#endif
262		- zones_size[ZONE_DMA] = (mach_max_dma_address < (unsigned long)high_memory ?
263		- (mach_max_dma_address+1) : (unsigned long)high_memory);
264		- zones_size[ZONE_NORMAL] = (unsigned long)high_memory - zones_size[0];
265		-
266		- zones_size[ZONE_DMA] = (zones_size[ZONE_DMA] - PAGE_OFFSET) >> PAGE_SHIFT;
267		- zones_size[ZONE_NORMAL] >>= PAGE_SHIFT;
268		-
269		- free_area_init(zones_size);
	302	+ for (i = 0; i < m68k_num_memory; i++) {
	303	+ zones_size[ZONE_DMA] = m68k_memory[i].size >> PAGE_SHIFT;
	304	+ free_area_init_node(i, pg_data_map + i, zones_size,
	305	+ m68k_memory[i].addr >> PAGE_SHIFT, NULL);
	306	+ }
270	307	}
271	308
272	309	extern char __init_begin, __init_end;
...	...	@@ -21,6 +21,7 @@
21	21	#include <asm/contregs.h>
22	22	#include <asm/movs.h>
23	23	#include <asm/pgtable.h>
	24	+#include <asm/pgalloc.h>
24	25	#include <asm/sun3-head.h>
25	26	#include <asm/sun3mmu.h>
26	27	#include <asm/rtc.h>
...	...	@@ -127,6 +128,7 @@
127	128	high_memory = (void *)memory_end;
128	129	availmem = memory_start;
129	130
	131	+ m68k_setup_node(0);
130	132	availmem += init_bootmem_node(NODE_DATA(0), start_page, 0, num_pages);
131	133	availmem = (availmem + (PAGE_SIZE-1)) & PAGE_MASK;
132	134
	1	+#ifndef _ASM_M68K_MMZONE_H_
	2	+#define _ASM_M68K_MMZONE_H_
	3	+
	4	+extern pg_data_t pg_data_map[];
	5	+
	6	+#define NODE_DATA(nid) (&pg_data_map[nid])
	7	+#define NODE_MEM_MAP(nid) (NODE_DATA(nid)->node_mem_map)
	8	+
	9	+#endif /* _ASM_M68K_MMZONE_H_ */
...	...	@@ -17,6 +17,7 @@
17	17
18	18	enum m68k_fixup_type {
19	19	m68k_fixup_memoffset,
	20	+ m68k_fixup_vnode_shift,
20	21	};
21	22
22	23	struct m68k_fixup_info {
...	...	@@ -130,7 +130,7 @@
130	130	#define pte_present(pte) (pte_val(pte) & (_PAGE_PRESENT \| _PAGE_PROTNONE))
131	131	#define pte_clear(mm,addr,ptep) ({ pte_val(*(ptep)) = 0; })
132	132
133		-#define pte_page(pte) (mem_map + ((unsigned long)(__va(pte_val(pte)) - PAGE_OFFSET) >> PAGE_SHIFT))
	133	+#define pte_page(pte) virt_to_page(__va(pte_val(pte)))
134	134	#define pte_pfn(pte) (pte_val(pte) >> PAGE_SHIFT)
135	135	#define pfn_pte(pfn, prot) __pte(((pfn) << PAGE_SHIFT) \| pgprot_val(prot))
136	136
...	...	@@ -143,7 +143,7 @@
143	143	while (--__i >= 0) \
144	144	*__ptr++ = 0; \
145	145	})
146		-#define pmd_page(pmd) (mem_map + ((unsigned long)(__va(pmd_val(pmd)) - PAGE_OFFSET) >> PAGE_SHIFT))
	146	+#define pmd_page(pmd) virt_to_page(__va(pmd_val(pmd)))
147	147
148	148
149	149	#define pgd_none(pgd) (!pgd_val(pgd))
150	150
...	...	@@ -223,10 +223,10 @@
223	223	return (pte_t )__pmd_page(pmdp) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
224	224	}
225	225
226		-#define pte_offset_map(pmdp,address) ((pte_t )kmap(pmd_page(pmdp)) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))
	226	+#define pte_offset_map(pmdp,address) ((pte_t )__pmd_page(pmdp) + (((address) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))
227	227	#define pte_offset_map_nested(pmdp, address) pte_offset_map(pmdp, address)
228		-#define pte_unmap(pte) kunmap(pte)
229		-#define pte_unmap_nested(pte) kunmap(pte)
	228	+#define pte_unmap(pte) ((void)0)
	229	+#define pte_unmap_nested(pte) ((void)0)
230	230
231	231	/*
232	232	* Allocate and free page tables. The xxx_kernel() versions are