1 /* 2 * Copyright (C) 2004, 2013 Intel Corporation 3 * Author: Naveen B S <naveen.b.s@intel.com> 4 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 5 * 6 * All rights reserved. 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or (at 11 * your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 16 * NON INFRINGEMENT. See the GNU General Public License for more 17 * details. 18 * 19 * ACPI based HotPlug driver that supports Memory Hotplug 20 * This driver fields notifications from firmware for memory add 21 * and remove operations and alerts the VM of the affected memory 22 * ranges. 23 */ 24 25 #include <linux/acpi.h> 26 #include <linux/memory.h> 27 #include <linux/memory_hotplug.h> 28 29 #include "internal.h" 30 31 #define ACPI_MEMORY_DEVICE_CLASS "memory" 32 #define ACPI_MEMORY_DEVICE_HID "PNP0C80" 33 #define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device" 34 35 #define _COMPONENT ACPI_MEMORY_DEVICE_COMPONENT 36 37 #undef PREFIX 38 #define PREFIX "ACPI:memory_hp:" 39 40 ACPI_MODULE_NAME("acpi_memhotplug"); 41 42 static const struct acpi_device_id memory_device_ids[] = { 43 {ACPI_MEMORY_DEVICE_HID, 0}, 44 {"", 0}, 45 }; 46 47 #ifdef CONFIG_ACPI_HOTPLUG_MEMORY 48 49 /* Memory Device States */ 50 #define MEMORY_INVALID_STATE 0 51 #define MEMORY_POWER_ON_STATE 1 52 #define MEMORY_POWER_OFF_STATE 2 53 54 static int acpi_memory_device_add(struct acpi_device *device, 55 const struct acpi_device_id *not_used); 56 static void acpi_memory_device_remove(struct acpi_device *device); 57 58 static struct acpi_scan_handler memory_device_handler = { 59 .ids = memory_device_ids, 60 .attach = acpi_memory_device_add, 61 .detach = acpi_memory_device_remove, 62 .hotplug = { 63 .enabled = true, 64 }, 65 }; 66 67 struct acpi_memory_info { 68 struct list_head list; 69 u64 start_addr; /* Memory Range start physical addr */ 70 u64 length; /* Memory Range length */ 71 unsigned short caching; /* memory cache attribute */ 72 unsigned short write_protect; /* memory read/write attribute */ 73 unsigned int enabled:1; 74 }; 75 76 struct acpi_memory_device { 77 struct acpi_device * device; 78 unsigned int state; /* State of the memory device */ 79 struct list_head res_list; 80 }; 81 82 static acpi_status 83 acpi_memory_get_resource(struct acpi_resource *resource, void *context) 84 { 85 struct acpi_memory_device *mem_device = context; 86 struct acpi_resource_address64 address64; 87 struct acpi_memory_info *info, *new; 88 acpi_status status; 89 90 status = acpi_resource_to_address64(resource, &address64); 91 if (ACPI_FAILURE(status) || 92 (address64.resource_type != ACPI_MEMORY_RANGE)) 93 return AE_OK; 94 95 list_for_each_entry(info, &mem_device->res_list, list) { 96 /* Can we combine the resource range information? */ 97 if ((info->caching == address64.info.mem.caching) && 98 (info->write_protect == address64.info.mem.write_protect) && 99 (info->start_addr + info->length == address64.address.minimum)) { 100 info->length += address64.address.address_length; 101 return AE_OK; 102 } 103 } 104 105 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL); 106 if (!new) 107 return AE_ERROR; 108 109 INIT_LIST_HEAD(&new->list); 110 new->caching = address64.info.mem.caching; 111 new->write_protect = address64.info.mem.write_protect; 112 new->start_addr = address64.address.minimum; 113 new->length = address64.address.address_length; 114 list_add_tail(&new->list, &mem_device->res_list); 115 116 return AE_OK; 117 } 118 119 static void 120 acpi_memory_free_device_resources(struct acpi_memory_device *mem_device) 121 { 122 struct acpi_memory_info *info, *n; 123 124 list_for_each_entry_safe(info, n, &mem_device->res_list, list) 125 kfree(info); 126 INIT_LIST_HEAD(&mem_device->res_list); 127 } 128 129 static int 130 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device) 131 { 132 acpi_status status; 133 134 if (!list_empty(&mem_device->res_list)) 135 return 0; 136 137 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS, 138 acpi_memory_get_resource, mem_device); 139 if (ACPI_FAILURE(status)) { 140 acpi_memory_free_device_resources(mem_device); 141 return -EINVAL; 142 } 143 144 return 0; 145 } 146 147 static int acpi_memory_check_device(struct acpi_memory_device *mem_device) 148 { 149 unsigned long long current_status; 150 151 /* Get device present/absent information from the _STA */ 152 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, 153 METHOD_NAME__STA, NULL, 154 ¤t_status))) 155 return -ENODEV; 156 /* 157 * Check for device status. Device should be 158 * present/enabled/functioning. 159 */ 160 if (!((current_status & ACPI_STA_DEVICE_PRESENT) 161 && (current_status & ACPI_STA_DEVICE_ENABLED) 162 && (current_status & ACPI_STA_DEVICE_FUNCTIONING))) 163 return -ENODEV; 164 165 return 0; 166 } 167 168 static unsigned long acpi_meminfo_start_pfn(struct acpi_memory_info *info) 169 { 170 return PFN_DOWN(info->start_addr); 171 } 172 173 static unsigned long acpi_meminfo_end_pfn(struct acpi_memory_info *info) 174 { 175 return PFN_UP(info->start_addr + info->length-1); 176 } 177 178 static int acpi_bind_memblk(struct memory_block *mem, void *arg) 179 { 180 return acpi_bind_one(&mem->dev, arg); 181 } 182 183 static int acpi_bind_memory_blocks(struct acpi_memory_info *info, 184 struct acpi_device *adev) 185 { 186 return walk_memory_range(acpi_meminfo_start_pfn(info), 187 acpi_meminfo_end_pfn(info), adev, 188 acpi_bind_memblk); 189 } 190 191 static int acpi_unbind_memblk(struct memory_block *mem, void *arg) 192 { 193 acpi_unbind_one(&mem->dev); 194 return 0; 195 } 196 197 static void acpi_unbind_memory_blocks(struct acpi_memory_info *info) 198 { 199 walk_memory_range(acpi_meminfo_start_pfn(info), 200 acpi_meminfo_end_pfn(info), NULL, acpi_unbind_memblk); 201 } 202 203 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device) 204 { 205 acpi_handle handle = mem_device->device->handle; 206 int result, num_enabled = 0; 207 struct acpi_memory_info *info; 208 int node; 209 210 node = acpi_get_node(handle); 211 /* 212 * Tell the VM there is more memory here... 213 * Note: Assume that this function returns zero on success 214 * We don't have memory-hot-add rollback function,now. 215 * (i.e. memory-hot-remove function) 216 */ 217 list_for_each_entry(info, &mem_device->res_list, list) { 218 if (info->enabled) { /* just sanity check...*/ 219 num_enabled++; 220 continue; 221 } 222 /* 223 * If the memory block size is zero, please ignore it. 224 * Don't try to do the following memory hotplug flowchart. 225 */ 226 if (!info->length) 227 continue; 228 if (node < 0) 229 node = memory_add_physaddr_to_nid(info->start_addr); 230 231 result = add_memory(node, info->start_addr, info->length); 232 233 /* 234 * If the memory block has been used by the kernel, add_memory() 235 * returns -EEXIST. If add_memory() returns the other error, it 236 * means that this memory block is not used by the kernel. 237 */ 238 if (result && result != -EEXIST) 239 continue; 240 241 result = acpi_bind_memory_blocks(info, mem_device->device); 242 if (result) { 243 acpi_unbind_memory_blocks(info); 244 return -ENODEV; 245 } 246 247 info->enabled = 1; 248 249 /* 250 * Add num_enable even if add_memory() returns -EEXIST, so the 251 * device is bound to this driver. 252 */ 253 num_enabled++; 254 } 255 if (!num_enabled) { 256 dev_err(&mem_device->device->dev, "add_memory failed\n"); 257 mem_device->state = MEMORY_INVALID_STATE; 258 return -EINVAL; 259 } 260 /* 261 * Sometimes the memory device will contain several memory blocks. 262 * When one memory block is hot-added to the system memory, it will 263 * be regarded as a success. 264 * Otherwise if the last memory block can't be hot-added to the system 265 * memory, it will be failure and the memory device can't be bound with 266 * driver. 267 */ 268 return 0; 269 } 270 271 static void acpi_memory_remove_memory(struct acpi_memory_device *mem_device) 272 { 273 acpi_handle handle = mem_device->device->handle; 274 struct acpi_memory_info *info, *n; 275 int nid = acpi_get_node(handle); 276 277 list_for_each_entry_safe(info, n, &mem_device->res_list, list) { 278 if (!info->enabled) 279 continue; 280 281 if (nid == NUMA_NO_NODE) 282 nid = memory_add_physaddr_to_nid(info->start_addr); 283 284 acpi_unbind_memory_blocks(info); 285 remove_memory(nid, info->start_addr, info->length); 286 list_del(&info->list); 287 kfree(info); 288 } 289 } 290 291 static void acpi_memory_device_free(struct acpi_memory_device *mem_device) 292 { 293 if (!mem_device) 294 return; 295 296 acpi_memory_free_device_resources(mem_device); 297 mem_device->device->driver_data = NULL; 298 kfree(mem_device); 299 } 300 301 static int acpi_memory_device_add(struct acpi_device *device, 302 const struct acpi_device_id *not_used) 303 { 304 struct acpi_memory_device *mem_device; 305 int result; 306 307 if (!device) 308 return -EINVAL; 309 310 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL); 311 if (!mem_device) 312 return -ENOMEM; 313 314 INIT_LIST_HEAD(&mem_device->res_list); 315 mem_device->device = device; 316 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME); 317 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS); 318 device->driver_data = mem_device; 319 320 /* Get the range from the _CRS */ 321 result = acpi_memory_get_device_resources(mem_device); 322 if (result) { 323 device->driver_data = NULL; 324 kfree(mem_device); 325 return result; 326 } 327 328 /* Set the device state */ 329 mem_device->state = MEMORY_POWER_ON_STATE; 330 331 result = acpi_memory_check_device(mem_device); 332 if (result) { 333 acpi_memory_device_free(mem_device); 334 return 0; 335 } 336 337 result = acpi_memory_enable_device(mem_device); 338 if (result) { 339 dev_err(&device->dev, "acpi_memory_enable_device() error\n"); 340 acpi_memory_device_free(mem_device); 341 return result; 342 } 343 344 dev_dbg(&device->dev, "Memory device configured by ACPI\n"); 345 return 1; 346 } 347 348 static void acpi_memory_device_remove(struct acpi_device *device) 349 { 350 struct acpi_memory_device *mem_device; 351 352 if (!device || !acpi_driver_data(device)) 353 return; 354 355 mem_device = acpi_driver_data(device); 356 acpi_memory_remove_memory(mem_device); 357 acpi_memory_device_free(mem_device); 358 } 359 360 static bool __initdata acpi_no_memhotplug; 361 362 void __init acpi_memory_hotplug_init(void) 363 { 364 if (acpi_no_memhotplug) { 365 memory_device_handler.attach = NULL; 366 acpi_scan_add_handler(&memory_device_handler); 367 return; 368 } 369 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory"); 370 } 371 372 static int __init disable_acpi_memory_hotplug(char *str) 373 { 374 acpi_no_memhotplug = true; 375 return 1; 376 } 377 __setup("acpi_no_memhotplug", disable_acpi_memory_hotplug); 378 379 #else 380 381 static struct acpi_scan_handler memory_device_handler = { 382 .ids = memory_device_ids, 383 }; 384 385 void __init acpi_memory_hotplug_init(void) 386 { 387 acpi_scan_add_handler(&memory_device_handler); 388 } 389 390 #endif /* CONFIG_ACPI_HOTPLUG_MEMORY */ 391