1 /* 2 * pseries Memory Hotplug infrastructure. 3 * 4 * Copyright (C) 2008 Badari Pulavarty, IBM Corporation 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 12 #include <linux/of.h> 13 #include <linux/memblock.h> 14 #include <linux/vmalloc.h> 15 #include <linux/memory.h> 16 17 #include <asm/firmware.h> 18 #include <asm/machdep.h> 19 #include <asm/pSeries_reconfig.h> 20 #include <asm/sparsemem.h> 21 22 static unsigned long get_memblock_size(void) 23 { 24 struct device_node *np; 25 unsigned int memblock_size = MIN_MEMORY_BLOCK_SIZE; 26 struct resource r; 27 28 np = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory"); 29 if (np) { 30 const __be64 *size; 31 32 size = of_get_property(np, "ibm,lmb-size", NULL); 33 if (size) 34 memblock_size = be64_to_cpup(size); 35 of_node_put(np); 36 } else if (machine_is(pseries)) { 37 /* This fallback really only applies to pseries */ 38 unsigned int memzero_size = 0; 39 40 np = of_find_node_by_path("/memory@0"); 41 if (np) { 42 if (!of_address_to_resource(np, 0, &r)) 43 memzero_size = resource_size(&r); 44 of_node_put(np); 45 } 46 47 if (memzero_size) { 48 /* We now know the size of memory@0, use this to find 49 * the first memoryblock and get its size. 50 */ 51 char buf[64]; 52 53 sprintf(buf, "/memory@%x", memzero_size); 54 np = of_find_node_by_path(buf); 55 if (np) { 56 if (!of_address_to_resource(np, 0, &r)) 57 memblock_size = resource_size(&r); 58 of_node_put(np); 59 } 60 } 61 } 62 return memblock_size; 63 } 64 65 /* WARNING: This is going to override the generic definition whenever 66 * pseries is built-in regardless of what platform is active at boot 67 * time. This is fine for now as this is the only "option" and it 68 * should work everywhere. If not, we'll have to turn this into a 69 * ppc_md. callback 70 */ 71 unsigned long memory_block_size_bytes(void) 72 { 73 return get_memblock_size(); 74 } 75 76 static int pseries_remove_memblock(unsigned long base, unsigned int memblock_size) 77 { 78 unsigned long start, start_pfn; 79 struct zone *zone; 80 int ret; 81 unsigned long section; 82 unsigned long sections_to_remove; 83 84 start_pfn = base >> PAGE_SHIFT; 85 86 if (!pfn_valid(start_pfn)) { 87 memblock_remove(base, memblock_size); 88 return 0; 89 } 90 91 zone = page_zone(pfn_to_page(start_pfn)); 92 93 /* 94 * Remove section mappings and sysfs entries for the 95 * section of the memory we are removing. 96 * 97 * NOTE: Ideally, this should be done in generic code like 98 * remove_memory(). But remove_memory() gets called by writing 99 * to sysfs "state" file and we can't remove sysfs entries 100 * while writing to it. So we have to defer it to here. 101 */ 102 sections_to_remove = (memblock_size >> PAGE_SHIFT) / PAGES_PER_SECTION; 103 for (section = 0; section < sections_to_remove; section++) { 104 unsigned long pfn = start_pfn + section * PAGES_PER_SECTION; 105 ret = __remove_pages(zone, pfn, PAGES_PER_SECTION); 106 if (ret) 107 return ret; 108 } 109 110 /* 111 * Update memory regions for memory remove 112 */ 113 memblock_remove(base, memblock_size); 114 115 /* 116 * Remove htab bolted mappings for this section of memory 117 */ 118 start = (unsigned long)__va(base); 119 ret = remove_section_mapping(start, start + memblock_size); 120 121 /* Ensure all vmalloc mappings are flushed in case they also 122 * hit that section of memory 123 */ 124 vm_unmap_aliases(); 125 126 return ret; 127 } 128 129 static int pseries_remove_memory(struct device_node *np) 130 { 131 const char *type; 132 const unsigned int *regs; 133 unsigned long base; 134 unsigned int lmb_size; 135 int ret = -EINVAL; 136 137 /* 138 * Check to see if we are actually removing memory 139 */ 140 type = of_get_property(np, "device_type", NULL); 141 if (type == NULL || strcmp(type, "memory") != 0) 142 return 0; 143 144 /* 145 * Find the bae address and size of the memblock 146 */ 147 regs = of_get_property(np, "reg", NULL); 148 if (!regs) 149 return ret; 150 151 base = *(unsigned long *)regs; 152 lmb_size = regs[3]; 153 154 ret = pseries_remove_memblock(base, lmb_size); 155 return ret; 156 } 157 158 static int pseries_add_memory(struct device_node *np) 159 { 160 const char *type; 161 const unsigned int *regs; 162 unsigned long base; 163 unsigned int lmb_size; 164 int ret = -EINVAL; 165 166 /* 167 * Check to see if we are actually adding memory 168 */ 169 type = of_get_property(np, "device_type", NULL); 170 if (type == NULL || strcmp(type, "memory") != 0) 171 return 0; 172 173 /* 174 * Find the base and size of the memblock 175 */ 176 regs = of_get_property(np, "reg", NULL); 177 if (!regs) 178 return ret; 179 180 base = *(unsigned long *)regs; 181 lmb_size = regs[3]; 182 183 /* 184 * Update memory region to represent the memory add 185 */ 186 ret = memblock_add(base, lmb_size); 187 return (ret < 0) ? -EINVAL : 0; 188 } 189 190 static int pseries_drconf_memory(unsigned long *base, unsigned int action) 191 { 192 unsigned long memblock_size; 193 int rc; 194 195 memblock_size = get_memblock_size(); 196 if (!memblock_size) 197 return -EINVAL; 198 199 if (action == PSERIES_DRCONF_MEM_ADD) { 200 rc = memblock_add(*base, memblock_size); 201 rc = (rc < 0) ? -EINVAL : 0; 202 } else if (action == PSERIES_DRCONF_MEM_REMOVE) { 203 rc = pseries_remove_memblock(*base, memblock_size); 204 } else { 205 rc = -EINVAL; 206 } 207 208 return rc; 209 } 210 211 static int pseries_memory_notifier(struct notifier_block *nb, 212 unsigned long action, void *node) 213 { 214 int err = 0; 215 216 switch (action) { 217 case PSERIES_RECONFIG_ADD: 218 err = pseries_add_memory(node); 219 break; 220 case PSERIES_RECONFIG_REMOVE: 221 err = pseries_remove_memory(node); 222 break; 223 case PSERIES_DRCONF_MEM_ADD: 224 case PSERIES_DRCONF_MEM_REMOVE: 225 err = pseries_drconf_memory(node, action); 226 break; 227 } 228 return notifier_from_errno(err); 229 } 230 231 static struct notifier_block pseries_mem_nb = { 232 .notifier_call = pseries_memory_notifier, 233 }; 234 235 static int __init pseries_memory_hotplug_init(void) 236 { 237 if (firmware_has_feature(FW_FEATURE_LPAR)) 238 pSeries_reconfig_notifier_register(&pseries_mem_nb); 239 240 return 0; 241 } 242 machine_device_initcall(pseries, pseries_memory_hotplug_init); 243