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 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * 23 * 24 * ACPI based HotPlug driver that supports Memory Hotplug 25 * This driver fields notifications from firmware for memory add 26 * and remove operations and alerts the VM of the affected memory 27 * ranges. 28 */ 29 30 #include <linux/acpi.h> 31 #include <linux/memory_hotplug.h> 32 33 #include "internal.h" 34 35 #define ACPI_MEMORY_DEVICE_CLASS "memory" 36 #define ACPI_MEMORY_DEVICE_HID "PNP0C80" 37 #define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device" 38 39 #define _COMPONENT ACPI_MEMORY_DEVICE_COMPONENT 40 41 #undef PREFIX 42 #define PREFIX "ACPI:memory_hp:" 43 44 ACPI_MODULE_NAME("acpi_memhotplug"); 45 46 /* Memory Device States */ 47 #define MEMORY_INVALID_STATE 0 48 #define MEMORY_POWER_ON_STATE 1 49 #define MEMORY_POWER_OFF_STATE 2 50 51 static int acpi_memory_device_add(struct acpi_device *device, 52 const struct acpi_device_id *not_used); 53 static void acpi_memory_device_remove(struct acpi_device *device); 54 55 static const struct acpi_device_id memory_device_ids[] = { 56 {ACPI_MEMORY_DEVICE_HID, 0}, 57 {"", 0}, 58 }; 59 60 static struct acpi_scan_handler memory_device_handler = { 61 .ids = memory_device_ids, 62 .attach = acpi_memory_device_add, 63 .detach = acpi_memory_device_remove, 64 .hotplug = { 65 .enabled = true, 66 }, 67 }; 68 69 struct acpi_memory_info { 70 struct list_head list; 71 u64 start_addr; /* Memory Range start physical addr */ 72 u64 length; /* Memory Range length */ 73 unsigned short caching; /* memory cache attribute */ 74 unsigned short write_protect; /* memory read/write attribute */ 75 unsigned int enabled:1; 76 unsigned int failed:1; 77 }; 78 79 struct acpi_memory_device { 80 struct acpi_device * device; 81 unsigned int state; /* State of the memory device */ 82 struct list_head res_list; 83 }; 84 85 static acpi_status 86 acpi_memory_get_resource(struct acpi_resource *resource, void *context) 87 { 88 struct acpi_memory_device *mem_device = context; 89 struct acpi_resource_address64 address64; 90 struct acpi_memory_info *info, *new; 91 acpi_status status; 92 93 status = acpi_resource_to_address64(resource, &address64); 94 if (ACPI_FAILURE(status) || 95 (address64.resource_type != ACPI_MEMORY_RANGE)) 96 return AE_OK; 97 98 list_for_each_entry(info, &mem_device->res_list, list) { 99 /* Can we combine the resource range information? */ 100 if ((info->caching == address64.info.mem.caching) && 101 (info->write_protect == address64.info.mem.write_protect) && 102 (info->start_addr + info->length == address64.minimum)) { 103 info->length += address64.address_length; 104 return AE_OK; 105 } 106 } 107 108 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL); 109 if (!new) 110 return AE_ERROR; 111 112 INIT_LIST_HEAD(&new->list); 113 new->caching = address64.info.mem.caching; 114 new->write_protect = address64.info.mem.write_protect; 115 new->start_addr = address64.minimum; 116 new->length = address64.address_length; 117 list_add_tail(&new->list, &mem_device->res_list); 118 119 return AE_OK; 120 } 121 122 static void 123 acpi_memory_free_device_resources(struct acpi_memory_device *mem_device) 124 { 125 struct acpi_memory_info *info, *n; 126 127 list_for_each_entry_safe(info, n, &mem_device->res_list, list) 128 kfree(info); 129 INIT_LIST_HEAD(&mem_device->res_list); 130 } 131 132 static int 133 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device) 134 { 135 acpi_status status; 136 137 if (!list_empty(&mem_device->res_list)) 138 return 0; 139 140 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS, 141 acpi_memory_get_resource, mem_device); 142 if (ACPI_FAILURE(status)) { 143 acpi_memory_free_device_resources(mem_device); 144 return -EINVAL; 145 } 146 147 return 0; 148 } 149 150 static int acpi_memory_check_device(struct acpi_memory_device *mem_device) 151 { 152 unsigned long long current_status; 153 154 /* Get device present/absent information from the _STA */ 155 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA", 156 NULL, ¤t_status))) 157 return -ENODEV; 158 /* 159 * Check for device status. Device should be 160 * present/enabled/functioning. 161 */ 162 if (!((current_status & ACPI_STA_DEVICE_PRESENT) 163 && (current_status & ACPI_STA_DEVICE_ENABLED) 164 && (current_status & ACPI_STA_DEVICE_FUNCTIONING))) 165 return -ENODEV; 166 167 return 0; 168 } 169 170 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device) 171 { 172 int result, num_enabled = 0; 173 struct acpi_memory_info *info; 174 int node; 175 176 node = acpi_get_node(mem_device->device->handle); 177 /* 178 * Tell the VM there is more memory here... 179 * Note: Assume that this function returns zero on success 180 * We don't have memory-hot-add rollback function,now. 181 * (i.e. memory-hot-remove function) 182 */ 183 list_for_each_entry(info, &mem_device->res_list, list) { 184 if (info->enabled) { /* just sanity check...*/ 185 num_enabled++; 186 continue; 187 } 188 /* 189 * If the memory block size is zero, please ignore it. 190 * Don't try to do the following memory hotplug flowchart. 191 */ 192 if (!info->length) 193 continue; 194 if (node < 0) 195 node = memory_add_physaddr_to_nid(info->start_addr); 196 197 result = add_memory(node, info->start_addr, info->length); 198 199 /* 200 * If the memory block has been used by the kernel, add_memory() 201 * returns -EEXIST. If add_memory() returns the other error, it 202 * means that this memory block is not used by the kernel. 203 */ 204 if (result && result != -EEXIST) { 205 info->failed = 1; 206 continue; 207 } 208 209 if (!result) 210 info->enabled = 1; 211 /* 212 * Add num_enable even if add_memory() returns -EEXIST, so the 213 * device is bound to this driver. 214 */ 215 num_enabled++; 216 } 217 if (!num_enabled) { 218 dev_err(&mem_device->device->dev, "add_memory failed\n"); 219 mem_device->state = MEMORY_INVALID_STATE; 220 return -EINVAL; 221 } 222 /* 223 * Sometimes the memory device will contain several memory blocks. 224 * When one memory block is hot-added to the system memory, it will 225 * be regarded as a success. 226 * Otherwise if the last memory block can't be hot-added to the system 227 * memory, it will be failure and the memory device can't be bound with 228 * driver. 229 */ 230 return 0; 231 } 232 233 static int acpi_memory_remove_memory(struct acpi_memory_device *mem_device) 234 { 235 int result = 0, nid; 236 struct acpi_memory_info *info, *n; 237 238 nid = acpi_get_node(mem_device->device->handle); 239 240 list_for_each_entry_safe(info, n, &mem_device->res_list, list) { 241 if (info->failed) 242 /* The kernel does not use this memory block */ 243 continue; 244 245 if (!info->enabled) 246 /* 247 * The kernel uses this memory block, but it may be not 248 * managed by us. 249 */ 250 return -EBUSY; 251 252 if (nid < 0) 253 nid = memory_add_physaddr_to_nid(info->start_addr); 254 result = remove_memory(nid, info->start_addr, info->length); 255 if (result) 256 return result; 257 258 list_del(&info->list); 259 kfree(info); 260 } 261 262 return result; 263 } 264 265 static void acpi_memory_device_free(struct acpi_memory_device *mem_device) 266 { 267 if (!mem_device) 268 return; 269 270 acpi_memory_free_device_resources(mem_device); 271 mem_device->device->driver_data = NULL; 272 kfree(mem_device); 273 } 274 275 static int acpi_memory_device_add(struct acpi_device *device, 276 const struct acpi_device_id *not_used) 277 { 278 struct acpi_memory_device *mem_device; 279 int result; 280 281 if (!device) 282 return -EINVAL; 283 284 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL); 285 if (!mem_device) 286 return -ENOMEM; 287 288 INIT_LIST_HEAD(&mem_device->res_list); 289 mem_device->device = device; 290 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME); 291 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS); 292 device->driver_data = mem_device; 293 294 /* Get the range from the _CRS */ 295 result = acpi_memory_get_device_resources(mem_device); 296 if (result) { 297 kfree(mem_device); 298 return result; 299 } 300 301 /* Set the device state */ 302 mem_device->state = MEMORY_POWER_ON_STATE; 303 304 result = acpi_memory_check_device(mem_device); 305 if (result) { 306 acpi_memory_device_free(mem_device); 307 return 0; 308 } 309 310 result = acpi_memory_enable_device(mem_device); 311 if (result) { 312 dev_err(&device->dev, "acpi_memory_enable_device() error\n"); 313 acpi_memory_device_free(mem_device); 314 return -ENODEV; 315 } 316 317 dev_dbg(&device->dev, "Memory device configured by ACPI\n"); 318 return 1; 319 } 320 321 static void acpi_memory_device_remove(struct acpi_device *device) 322 { 323 struct acpi_memory_device *mem_device; 324 325 if (!device || !acpi_driver_data(device)) 326 return; 327 328 mem_device = acpi_driver_data(device); 329 acpi_memory_remove_memory(mem_device); 330 acpi_memory_device_free(mem_device); 331 } 332 333 void __init acpi_memory_hotplug_init(void) 334 { 335 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory"); 336 } 337