start_pfn = memblock_region_memory_base_pfn(reg);
                end_pfn = memblock_region_memory_end_pfn(reg);
                memblock_set_node(PFN_PHYS(start_pfn),
-                                 PFN_PHYS(end_pfn - start_pfn), 0);
+                                 PFN_PHYS(end_pfn - start_pfn),
+                                 &memblock.memory, 0);
        }
 
        /* All of system RAM sits in node 0 for the non-NUMA case */
 
        memblock_add(start, end - start);
 
        memblock_set_node(PFN_PHYS(start_pfn),
-                         PFN_PHYS(end_pfn - start_pfn), nid);
+                         PFN_PHYS(end_pfn - start_pfn),
+                         &memblock.memory, nid);
 
        /* Node-local pgdat */
        pgdat_paddr = memblock_alloc_base(sizeof(struct pglist_data),
 
                start_pfn = memblock_region_memory_base_pfn(reg);
                end_pfn = memblock_region_memory_end_pfn(reg);
                memblock_set_node(start_pfn << PAGE_SHIFT,
-                                       (end_pfn - start_pfn) << PAGE_SHIFT, 0);
+                                 (end_pfn - start_pfn) << PAGE_SHIFT,
+                                 &memblock.memory, 0);
        }
 
        /* free bootmem is whole main memory */
 
        /* Place all memblock_regions in the same node and merge contiguous
         * memblock_regions
         */
-       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, 0);
+       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, &memblock.memory, 0);
 
        /* Add all physical memory to the bootmem map, mark each area
         * present.
 
                        node_set_online(nid);
                        sz = numa_enforce_memory_limit(base, size);
                        if (sz)
-                               memblock_set_node(base, sz, nid);
+                               memblock_set_node(base, sz,
+                                                 &memblock.memory, nid);
                } while (--ranges);
        }
 }
                                continue;
                }
 
-               memblock_set_node(start, size, nid);
+               memblock_set_node(start, size, &memblock.memory, nid);
 
                if (--ranges)
                        goto new_range;
 
                fake_numa_create_new_node(end_pfn, &nid);
                memblock_set_node(PFN_PHYS(start_pfn),
-                                 PFN_PHYS(end_pfn - start_pfn), nid);
+                                 PFN_PHYS(end_pfn - start_pfn),
+                                 &memblock.memory, nid);
                node_set_online(nid);
        }
 }
 
        pmb_bolt_mapping((unsigned long)__va(start), start, end - start,
                         PAGE_KERNEL);
 
-       memblock_set_node(PFN_PHYS(start_pfn),
-                         PFN_PHYS(end_pfn - start_pfn), nid);
+       memblock_set_node(PFN_PHYS(start_pfn), PFN_PHYS(end_pfn - start_pfn),
+                         &memblock.memory, nid);
 }
 
 void __init __weak plat_early_device_setup(void)
 
                                "start[%lx] end[%lx]\n",
                                nid, start, this_end);
 
-                       memblock_set_node(start, this_end - start, nid);
+                       memblock_set_node(start, this_end - start,
+                                         &memblock.memory, nid);
                        start = this_end;
                }
        }
               (top_of_ram - total_ram) >> 20);
 
        init_node_masks_nonnuma();
-       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, 0);
+       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, &memblock.memory, 0);
        allocate_node_data(0);
        node_set_online(0);
 }
 
        high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
 #endif
 
-       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, 0);
+       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, &memblock.memory, 0);
        sparse_memory_present_with_active_regions(0);
 
 #ifdef CONFIG_FLATMEM
 
 #ifndef CONFIG_NUMA
 void __init initmem_init(void)
 {
-       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, 0);
+       memblock_set_node(0, (phys_addr_t)ULLONG_MAX, &memblock.memory, 0);
 }
 #endif
 
 
 
        for (i = 0; i < mi->nr_blks; i++) {
                struct numa_memblk *mb = &mi->blk[i];
-               memblock_set_node(mb->start, mb->end - mb->start, mb->nid);
+               memblock_set_node(mb->start, mb->end - mb->start,
+                                 &memblock.memory, mb->nid);
        }
 
        /*
        nodes_clear(node_possible_map);
        nodes_clear(node_online_map);
        memset(&numa_meminfo, 0, sizeof(numa_meminfo));
-       WARN_ON(memblock_set_node(0, ULLONG_MAX, MAX_NUMNODES));
+       WARN_ON(memblock_set_node(0, ULLONG_MAX, &memblock.memory,
+                                 MAX_NUMNODES));
        numa_reset_distance();
 
        ret = init_func();
 
 }
 
 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
-int memblock_set_node(phys_addr_t base, phys_addr_t size, int nid);
+int memblock_set_node(phys_addr_t base, phys_addr_t size,
+                     struct memblock_type *type, int nid);
 
 static inline void memblock_set_region_node(struct memblock_region *r, int nid)
 {
 
  * memblock_set_node - set node ID on memblock regions
  * @base: base of area to set node ID for
  * @size: size of area to set node ID for
+ * @type: memblock type to set node ID for
  * @nid: node ID to set
  *
- * Set the nid of memblock memory regions in [@base,@base+@size) to @nid.
+ * Set the nid of memblock @type regions in [@base,@base+@size) to @nid.
  * Regions which cross the area boundaries are split as necessary.
  *
  * RETURNS:
  * 0 on success, -errno on failure.
  */
 int __init_memblock memblock_set_node(phys_addr_t base, phys_addr_t size,
-                                     int nid)
+                                     struct memblock_type *type, int nid)
 {
-       struct memblock_type *type = &memblock.memory;
        int start_rgn, end_rgn;
        int i, ret;