This option enables hardware multithreading on RS64 cpus.
          pSeries systems p620 and p660 have such a cpu type.
 
+config ARCH_SELECT_MEMORY_MODEL
+       def_bool y
+
+config ARCH_FLATMEM_ENABLE
+       def_bool y
+       depends on !NUMA
+
 config ARCH_DISCONTIGMEM_ENABLE
        def_bool y
        depends on SMP && PPC_PSERIES
 config ARCH_FLATMEM_ENABLE
        def_bool y
 
+config ARCH_SPARSEMEM_ENABLE
+       def_bool y
+       depends on ARCH_DISCONTIGMEM_ENABLE
+
 source "mm/Kconfig"
 
 config HAVE_ARCH_EARLY_PFN_TO_NID
 
 config NUMA
        bool "NUMA support"
-       depends on DISCONTIGMEM
+       default y if DISCONTIGMEM || SPARSEMEM
 
 config SCHED_SMT
        bool "SMT (Hyperthreading) scheduler support"
 
 
        /* set up the bootmem stuff with available memory */
        do_init_bootmem();
+       sparse_init();
 
        /* initialize the syscall map in systemcfg */
        setup_syscall_map();
 
 
 obj-y := fault.o init.o imalloc.o hash_utils.o hash_low.o tlb.o \
        slb_low.o slb.o stab.o mmap.o
-obj-$(CONFIG_DISCONTIGMEM) += numa.o
+obj-$(CONFIG_NEED_MULTIPLE_NODES) += numa.o
 obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o
 obj-$(CONFIG_PPC_MULTIPLATFORM) += hash_native.o
 
  * Initialize the bootmem system and give it all the memory we
  * have available.
  */
-#ifndef CONFIG_DISCONTIGMEM
+#ifndef CONFIG_NEED_MULTIPLE_NODES
 void __init do_init_bootmem(void)
 {
        unsigned long i;
 
        max_pfn = max_low_pfn;
 
-       /* add all physical memory to the bootmem map. Also find the first */
+       /* Add all physical memory to the bootmem map, mark each area
+        * present.
+        */
        for (i=0; i < lmb.memory.cnt; i++) {
                unsigned long physbase, size;
+               unsigned long start_pfn, end_pfn;
 
                physbase = lmb.memory.region[i].physbase;
                size = lmb.memory.region[i].size;
+
+               start_pfn = physbase >> PAGE_SHIFT;
+               end_pfn = start_pfn + (size >> PAGE_SHIFT);
+               memory_present(0, start_pfn, end_pfn);
+
                free_bootmem(physbase, size);
        }
 
        free_area_init_node(0, NODE_DATA(0), zones_size,
                            __pa(PAGE_OFFSET) >> PAGE_SHIFT, zholes_size);
 }
-#endif /* CONFIG_DISCONTIGMEM */
+#endif /* ! CONFIG_NEED_MULTIPLE_NODES */
 
 static struct kcore_list kcore_vmem;
 
 
 void __init mem_init(void)
 {
-#ifdef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_NEED_MULTIPLE_NODES
        int nid;
 #endif
        pg_data_t *pgdat;
        num_physpages = max_low_pfn;    /* RAM is assumed contiguous */
        high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
 
-#ifdef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_NEED_MULTIPLE_NODES
         for_each_online_node(nid) {
                if (NODE_DATA(nid)->node_spanned_pages != 0) {
                        printk("freeing bootmem node %x\n", nid);
 
 #include <linux/config.h>
 #include <asm/smp.h>
 
-#ifdef CONFIG_DISCONTIGMEM
+/* generic non-linear memory support:
+ *
+ * 1) we will not split memory into more chunks than will fit into the
+ *    flags field of the struct page
+ */
+
+
+#ifdef CONFIG_NEED_MULTIPLE_NODES
 
 extern struct pglist_data *node_data[];
+/*
+ * Return a pointer to the node data for node n.
+ */
+#define NODE_DATA(nid)         (node_data[nid])
 
 /*
  * Following are specific to this numa platform.
        return nid;
 }
 
-#define pfn_to_nid(pfn)                pa_to_nid((pfn) << PAGE_SHIFT)
-
-/*
- * Return a pointer to the node data for node n.
- */
-#define NODE_DATA(nid)         (node_data[nid])
-
 #define node_localnr(pfn, nid) ((pfn) - NODE_DATA(nid)->node_start_pfn)
 
 /*
  * Following are macros that each numa implmentation must define.
  */
 
-/*
- * Given a kernel address, find the home node of the underlying memory.
- */
-#define kvaddr_to_nid(kaddr)   pa_to_nid(__pa(kaddr))
-
 #define node_start_pfn(nid)    (NODE_DATA(nid)->node_start_pfn)
 #define node_end_pfn(nid)      (NODE_DATA(nid)->node_end_pfn)
 
 #define local_mapnr(kvaddr) \
        ( (__pa(kvaddr) >> PAGE_SHIFT) - node_start_pfn(kvaddr_to_nid(kvaddr)) 
 
+#ifdef CONFIG_DISCONTIGMEM
+
+/*
+ * Given a kernel address, find the home node of the underlying memory.
+ */
+#define kvaddr_to_nid(kaddr)   pa_to_nid(__pa(kaddr))
+
+#define pfn_to_nid(pfn)                pa_to_nid((unsigned long)(pfn) << PAGE_SHIFT)
+
 /* Written this way to avoid evaluating arguments twice */
 #define discontigmem_pfn_to_page(pfn) \
 ({ \
 
 #endif /* CONFIG_DISCONTIGMEM */
 
+#endif /* CONFIG_NEED_MULTIPLE_NODES */
+
 #ifdef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
 #define early_pfn_to_nid(pfn)  pa_to_nid(((unsigned long)pfn) << PAGE_SHIFT)
 #endif
 
 #define page_to_pfn(page)      discontigmem_page_to_pfn(page)
 #define pfn_to_page(pfn)       discontigmem_pfn_to_page(pfn)
 #define pfn_valid(pfn)         discontigmem_pfn_valid(pfn)
-#else
+#endif
+#ifdef CONFIG_FLATMEM
 #define pfn_to_page(pfn)       (mem_map + (pfn))
 #define page_to_pfn(page)      ((unsigned long)((page) - mem_map))
 #define pfn_valid(pfn)         ((pfn) < max_mapnr)
 
--- /dev/null
+#ifndef _ASM_PPC64_SPARSEMEM_H
+#define _ASM_PPC64_SPARSEMEM_H 1
+
+#ifdef CONFIG_SPARSEMEM
+/*
+ * SECTION_SIZE_BITS           2^N: how big each section will be
+ * MAX_PHYSADDR_BITS           2^N: how much physical address space we have
+ * MAX_PHYSMEM_BITS            2^N: how much memory we can have in that space
+ */
+#define SECTION_SIZE_BITS       24
+#define MAX_PHYSADDR_BITS       38
+#define MAX_PHYSMEM_BITS        36
+
+#endif /* CONFIG_SPARSEMEM */
+
+#endif /* _ASM_PPC64_SPARSEMEM_H */