1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2004, 2013 Intel Corporation 4 * Author: Naveen B S <naveen.b.s@intel.com> 5 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 6 * 7 * All rights reserved. 8 * 9 * ACPI based HotPlug driver that supports Memory Hotplug 10 * This driver fields notifications from firmware for memory add 11 * and remove operations and alerts the VM of the affected memory 12 * ranges. 13 */ 14 15 #include <linux/acpi.h> 16 #include <linux/memory.h> 17 #include <linux/memory_hotplug.h> 18 19 #include "internal.h" 20 21 #define ACPI_MEMORY_DEVICE_CLASS "memory" 22 #define ACPI_MEMORY_DEVICE_HID "PNP0C80" 23 #define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device" 24 25 static const struct acpi_device_id memory_device_ids[] = { 26 {ACPI_MEMORY_DEVICE_HID, 0}, 27 {"", 0}, 28 }; 29 30 #ifdef CONFIG_ACPI_HOTPLUG_MEMORY 31 32 static int acpi_memory_device_add(struct acpi_device *device, 33 const struct acpi_device_id *not_used); 34 static void acpi_memory_device_remove(struct acpi_device *device); 35 36 static struct acpi_scan_handler memory_device_handler = { 37 .ids = memory_device_ids, 38 .attach = acpi_memory_device_add, 39 .detach = acpi_memory_device_remove, 40 .hotplug = { 41 .enabled = true, 42 }, 43 }; 44 45 struct acpi_memory_info { 46 struct list_head list; 47 u64 start_addr; /* Memory Range start physical addr */ 48 u64 length; /* Memory Range length */ 49 unsigned short caching; /* memory cache attribute */ 50 unsigned short write_protect; /* memory read/write attribute */ 51 unsigned int enabled:1; 52 }; 53 54 struct acpi_memory_device { 55 struct acpi_device *device; 56 struct list_head res_list; 57 }; 58 59 static acpi_status 60 acpi_memory_get_resource(struct acpi_resource *resource, void *context) 61 { 62 struct acpi_memory_device *mem_device = context; 63 struct acpi_resource_address64 address64; 64 struct acpi_memory_info *info, *new; 65 acpi_status status; 66 67 status = acpi_resource_to_address64(resource, &address64); 68 if (ACPI_FAILURE(status) || 69 (address64.resource_type != ACPI_MEMORY_RANGE)) 70 return AE_OK; 71 72 list_for_each_entry(info, &mem_device->res_list, list) { 73 /* Can we combine the resource range information? */ 74 if ((info->caching == address64.info.mem.caching) && 75 (info->write_protect == address64.info.mem.write_protect) && 76 (info->start_addr + info->length == address64.address.minimum)) { 77 info->length += address64.address.address_length; 78 return AE_OK; 79 } 80 } 81 82 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL); 83 if (!new) 84 return AE_ERROR; 85 86 INIT_LIST_HEAD(&new->list); 87 new->caching = address64.info.mem.caching; 88 new->write_protect = address64.info.mem.write_protect; 89 new->start_addr = address64.address.minimum; 90 new->length = address64.address.address_length; 91 list_add_tail(&new->list, &mem_device->res_list); 92 93 return AE_OK; 94 } 95 96 static void 97 acpi_memory_free_device_resources(struct acpi_memory_device *mem_device) 98 { 99 struct acpi_memory_info *info, *n; 100 101 list_for_each_entry_safe(info, n, &mem_device->res_list, list) 102 kfree(info); 103 INIT_LIST_HEAD(&mem_device->res_list); 104 } 105 106 static int 107 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device) 108 { 109 acpi_status status; 110 111 if (!list_empty(&mem_device->res_list)) 112 return 0; 113 114 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS, 115 acpi_memory_get_resource, mem_device); 116 if (ACPI_FAILURE(status)) { 117 acpi_memory_free_device_resources(mem_device); 118 return -EINVAL; 119 } 120 121 return 0; 122 } 123 124 static int acpi_memory_check_device(struct acpi_memory_device *mem_device) 125 { 126 unsigned long long current_status; 127 128 /* Get device present/absent information from the _STA */ 129 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, 130 METHOD_NAME__STA, NULL, 131 ¤t_status))) 132 return -ENODEV; 133 /* 134 * Check for device status. Device should be 135 * present/enabled/functioning. 136 */ 137 if (!((current_status & ACPI_STA_DEVICE_PRESENT) 138 && (current_status & ACPI_STA_DEVICE_ENABLED) 139 && (current_status & ACPI_STA_DEVICE_FUNCTIONING))) 140 return -ENODEV; 141 142 return 0; 143 } 144 145 static int acpi_bind_memblk(struct memory_block *mem, void *arg) 146 { 147 return acpi_bind_one(&mem->dev, arg); 148 } 149 150 static int acpi_bind_memory_blocks(struct acpi_memory_info *info, 151 struct acpi_device *adev) 152 { 153 return walk_memory_blocks(info->start_addr, info->length, adev, 154 acpi_bind_memblk); 155 } 156 157 static int acpi_unbind_memblk(struct memory_block *mem, void *arg) 158 { 159 acpi_unbind_one(&mem->dev); 160 return 0; 161 } 162 163 static void acpi_unbind_memory_blocks(struct acpi_memory_info *info) 164 { 165 walk_memory_blocks(info->start_addr, info->length, NULL, 166 acpi_unbind_memblk); 167 } 168 169 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device) 170 { 171 acpi_handle handle = mem_device->device->handle; 172 int result, num_enabled = 0; 173 struct acpi_memory_info *info; 174 int node; 175 176 node = acpi_get_node(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 MHP_NONE); 199 200 /* 201 * If the memory block has been used by the kernel, add_memory() 202 * returns -EEXIST. If add_memory() returns the other error, it 203 * means that this memory block is not used by the kernel. 204 */ 205 if (result && result != -EEXIST) 206 continue; 207 208 result = acpi_bind_memory_blocks(info, mem_device->device); 209 if (result) { 210 acpi_unbind_memory_blocks(info); 211 return -ENODEV; 212 } 213 214 info->enabled = 1; 215 216 /* 217 * Add num_enable even if add_memory() returns -EEXIST, so the 218 * device is bound to this driver. 219 */ 220 num_enabled++; 221 } 222 if (!num_enabled) { 223 dev_err(&mem_device->device->dev, "add_memory failed\n"); 224 return -EINVAL; 225 } 226 /* 227 * Sometimes the memory device will contain several memory blocks. 228 * When one memory block is hot-added to the system memory, it will 229 * be regarded as a success. 230 * Otherwise if the last memory block can't be hot-added to the system 231 * memory, it will be failure and the memory device can't be bound with 232 * driver. 233 */ 234 return 0; 235 } 236 237 static void acpi_memory_remove_memory(struct acpi_memory_device *mem_device) 238 { 239 acpi_handle handle = mem_device->device->handle; 240 struct acpi_memory_info *info, *n; 241 int nid = acpi_get_node(handle); 242 243 list_for_each_entry_safe(info, n, &mem_device->res_list, list) { 244 if (!info->enabled) 245 continue; 246 247 if (nid == NUMA_NO_NODE) 248 nid = memory_add_physaddr_to_nid(info->start_addr); 249 250 acpi_unbind_memory_blocks(info); 251 __remove_memory(nid, info->start_addr, info->length); 252 list_del(&info->list); 253 kfree(info); 254 } 255 } 256 257 static void acpi_memory_device_free(struct acpi_memory_device *mem_device) 258 { 259 if (!mem_device) 260 return; 261 262 acpi_memory_free_device_resources(mem_device); 263 mem_device->device->driver_data = NULL; 264 kfree(mem_device); 265 } 266 267 static int acpi_memory_device_add(struct acpi_device *device, 268 const struct acpi_device_id *not_used) 269 { 270 struct acpi_memory_device *mem_device; 271 int result; 272 273 if (!device) 274 return -EINVAL; 275 276 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL); 277 if (!mem_device) 278 return -ENOMEM; 279 280 INIT_LIST_HEAD(&mem_device->res_list); 281 mem_device->device = device; 282 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME); 283 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS); 284 device->driver_data = mem_device; 285 286 /* Get the range from the _CRS */ 287 result = acpi_memory_get_device_resources(mem_device); 288 if (result) { 289 device->driver_data = NULL; 290 kfree(mem_device); 291 return result; 292 } 293 294 result = acpi_memory_check_device(mem_device); 295 if (result) { 296 acpi_memory_device_free(mem_device); 297 return 0; 298 } 299 300 result = acpi_memory_enable_device(mem_device); 301 if (result) { 302 dev_err(&device->dev, "acpi_memory_enable_device() error\n"); 303 acpi_memory_device_free(mem_device); 304 return result; 305 } 306 307 dev_dbg(&device->dev, "Memory device configured by ACPI\n"); 308 return 1; 309 } 310 311 static void acpi_memory_device_remove(struct acpi_device *device) 312 { 313 struct acpi_memory_device *mem_device; 314 315 if (!device || !acpi_driver_data(device)) 316 return; 317 318 mem_device = acpi_driver_data(device); 319 acpi_memory_remove_memory(mem_device); 320 acpi_memory_device_free(mem_device); 321 } 322 323 static bool __initdata acpi_no_memhotplug; 324 325 void __init acpi_memory_hotplug_init(void) 326 { 327 if (acpi_no_memhotplug) { 328 memory_device_handler.attach = NULL; 329 acpi_scan_add_handler(&memory_device_handler); 330 return; 331 } 332 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory"); 333 } 334 335 static int __init disable_acpi_memory_hotplug(char *str) 336 { 337 acpi_no_memhotplug = true; 338 return 1; 339 } 340 __setup("acpi_no_memhotplug", disable_acpi_memory_hotplug); 341 342 #else 343 344 static struct acpi_scan_handler memory_device_handler = { 345 .ids = memory_device_ids, 346 }; 347 348 void __init acpi_memory_hotplug_init(void) 349 { 350 acpi_scan_add_handler(&memory_device_handler); 351 } 352 353 #endif /* CONFIG_ACPI_HOTPLUG_MEMORY */ 354