`mem_section` objects and the number of rows is calculated to fit
   all the memory sections.
 
-The architecture setup code should call :c:func:`memory_present` for
-each active memory range or use :c:func:`memblocks_present` or
-:c:func:`sparse_memory_present_with_active_regions` wrappers to
-initialize the memory sections. Next, the actual memory maps should be
-set up using :c:func:`sparse_init`.
+The architecture setup code should call sparse_init() to
+initialize the memory sections and the memory maps.
 
 With SPARSEMEM there are two possible ways to convert a PFN to the
 corresponding `struct page` - a "classic sparse" and "sparse
 
                      (phys_addr_t)max_low_pfn << PAGE_SHIFT);
 
        /*
-        * Sparsemem tries to allocate bootmem in memory_present(),
-        * so must be done after the fixed reservations
-        */
-       memblocks_present();
-
-       /*
-        * sparse_init() needs the bootmem allocator up and running.
+        * sparse_init() tries to allocate memory from memblock, so must be
+        * done after the fixed reservations
         */
        sparse_init();
 
 
 #endif
 
        /*
-        * Sparsemem tries to allocate bootmem in memory_present(), so must be
-        * done after the fixed reservations.
+        * sparse_init() tries to allocate memory from memblock, so must be
+        * done after the fixed reservations
         */
-       memblocks_present();
-
        sparse_init();
        zone_sizes_init(min, max);
 
 
 
        max_dma = virt_to_phys((void *) MAX_DMA_ADDRESS) >> PAGE_SHIFT;
 
-       sparse_memory_present_with_active_regions(MAX_NUMNODES);
        sparse_init();
 
 #ifdef CONFIG_VIRTUAL_MEM_MAP
 
                                  &memblock.memory, 0);
        }
 
-       /* XXX need to clip this if using highmem? */
-       sparse_memory_present_with_active_regions(0);
-
        paging_init();
 }
 
 
 #endif
        }
 
-
-       /*
-        * In any case the added to the memblock memory regions
-        * (highmem/lowmem, available/reserved, etc) are considered
-        * as present, so inform sparsemem about them.
-        */
-       memblocks_present();
-
        /*
         * Reserve initrd memory if needed.
         */
 
                        cpumask_clear(&__node_cpumask[node]);
                }
        }
-       memblocks_present();
        max_low_pfn = PHYS_PFN(memblock_end_of_DRAM());
 
        for (cpu = 0; cpu < loongson_sysconf.nr_cpus; cpu++) {
 
                }
                __node_data[node] = &null_node;
        }
-
-       memblocks_present();
 }
 
 void __init prom_free_prom_memory(void)
 
        flush_cache_all_local(); /* start with known state */
        flush_tlb_all_local(NULL);
 
-       /*
-        * Mark all memblocks as present for sparsemem using
-        * memory_present() and then initialize sparsemem.
-        */
-       memblocks_present();
        sparse_init();
        parisc_bootmem_free();
 }
 
 
 void __init initmem_init(void)
 {
-       /* XXX need to clip this if using highmem? */
-       sparse_memory_present_with_active_regions(0);
        sparse_init();
 }
 
 
 
                get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
                setup_node_data(nid, start_pfn, end_pfn);
-               sparse_memory_present_with_active_regions(nid);
        }
 
        sparse_init();
 
 void __init paging_init(void)
 {
        setup_vm_final();
-       memblocks_present();
        sparse_init();
        setup_zero_page();
        zone_sizes_init();
 
        __load_psw_mask(psw.mask);
        kasan_free_early_identity();
 
-       sparse_memory_present_with_active_regions(MAX_NUMNODES);
        sparse_init();
        zone_dma_bits = 31;
        memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
 
 
        plat_mem_setup();
 
-       for_each_memblock(memory, reg) {
-               int nid = memblock_get_region_node(reg);
-
-               memory_present(nid, memblock_region_memory_base_pfn(reg),
-                       memblock_region_memory_end_pfn(reg));
-       }
        sparse_init();
 }
 
 
 
        /* It's up */
        node_set_online(nid);
-
-       /* Kick sparsemem */
-       sparse_memory_present_with_active_regions(nid);
 }
 
 
        /* XXX cpu notifier XXX */
 
-       sparse_memory_present_with_active_regions(MAX_NUMNODES);
        sparse_init();
 
        return end_pfn;
 
 #endif
 
        memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0);
-       sparse_memory_present_with_active_regions(0);
 
 #ifdef CONFIG_FLATMEM
        max_mapnr = IS_ENABLED(CONFIG_HIGHMEM) ? highend_pfn : max_low_pfn;
         * NOTE: at this point the bootmem allocator is fully available.
         */
        olpc_dt_build_devicetree();
-       sparse_memory_present_with_active_regions(MAX_NUMNODES);
        sparse_init();
        zone_sizes_init();
 }
 
 
 void __init paging_init(void)
 {
-       sparse_memory_present_with_active_regions(MAX_NUMNODES);
        sparse_init();
 
        /*
 
  * for_each_valid_physical_page_range()
  *     memblock_add_node(base, size, nid)
  * free_area_init(max_zone_pfns);
- *
- * sparse_memory_present_with_active_regions() calls memory_present() for
- * each range when SPARSEMEM is enabled.
  */
 void free_area_init(unsigned long *max_zone_pfn);
 unsigned long node_map_pfn_alignment(void);
 extern void get_pfn_range_for_nid(unsigned int nid,
                        unsigned long *start_pfn, unsigned long *end_pfn);
 extern unsigned long find_min_pfn_with_active_regions(void);
-extern void sparse_memory_present_with_active_regions(int nid);
 
 #ifndef CONFIG_NEED_MULTIPLE_NODES
 static inline int early_pfn_to_nid(unsigned long pfn)
 
 
 extern unsigned long lruvec_lru_size(struct lruvec *lruvec, enum lru_list lru, int zone_idx);
 
-#ifdef CONFIG_HAVE_MEMORY_PRESENT
-void memory_present(int nid, unsigned long start, unsigned long end);
-#else
-static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
-#endif
-
-#if defined(CONFIG_SPARSEMEM)
-void memblocks_present(void);
-#else
-static inline void memblocks_present(void) {}
-#endif
-
 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
 int local_memory_node(int node_id);
 #else
 #define early_pfn_valid(pfn)   (1)
 #endif
 
-void memory_present(int nid, unsigned long start, unsigned long end);
-
 /*
  * If it is possible to have holes within a MAX_ORDER_NR_PAGES, then we
  * need to check pfn validity within that MAX_ORDER_NR_PAGES block.
 
        def_bool y
        depends on DISCONTIGMEM || NUMA
 
-config HAVE_MEMORY_PRESENT
-       def_bool y
-       depends on ARCH_HAVE_MEMORY_PRESENT || SPARSEMEM
-
 #
 # SPARSEMEM_EXTREME (which is the default) does some bootmem
-# allocations when memory_present() is called.  If this cannot
+# allocations when sparse_init() is called.  If this cannot
 # be done on your architecture, select this option.  However,
 # statically allocating the mem_section[] array can potentially
 # consume vast quantities of .bss, so be careful.
 
        zone->initialized = 1;
 }
 
-/**
- * sparse_memory_present_with_active_regions - Call memory_present for each active range
- * @nid: The node to call memory_present for. If MAX_NUMNODES, all nodes will be used.
- *
- * If an architecture guarantees that all ranges registered contain no holes and may
- * be freed, this function may be used instead of calling memory_present() manually.
- */
-void __init sparse_memory_present_with_active_regions(int nid)
-{
-       unsigned long start_pfn, end_pfn;
-       int i, this_nid;
-
-       for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, &this_nid)
-               memory_present(this_nid, start_pfn, end_pfn);
-}
-
 /**
  * get_pfn_range_for_nid - Return the start and end page frames for a node
  * @nid: The nid to return the range for. If MAX_NUMNODES, the min and max PFN are returned.
 
 #endif
 
 /* Record a memory area against a node. */
-void __init memory_present(int nid, unsigned long start, unsigned long end)
+static void __init memory_present(int nid, unsigned long start, unsigned long end)
 {
        unsigned long pfn;
 
 }
 
 /*
- * Mark all memblocks as present using memory_present(). This is a
- * convenience function that is useful for a number of arches
- * to mark all of the systems memory as present during initialization.
+ * Mark all memblocks as present using memory_present().
+ * This is a convenience function that is useful to mark all of the systems
+ * memory as present during initialization.
  */
-void __init memblocks_present(void)
+static void __init memblocks_present(void)
 {
        struct memblock_region *reg;
 
  */
 void __init sparse_init(void)
 {
-       unsigned long pnum_begin = first_present_section_nr();
-       int nid_begin = sparse_early_nid(__nr_to_section(pnum_begin));
-       unsigned long pnum_end, map_count = 1;
+       unsigned long pnum_end, pnum_begin, map_count = 1;
+       int nid_begin;
+
+       memblocks_present();
+
+       pnum_begin = first_present_section_nr();
+       nid_begin = sparse_early_nid(__nr_to_section(pnum_begin));
 
        /* Setup pageblock_order for HUGETLB_PAGE_SIZE_VARIABLE */
        set_pageblock_order();