1 // SPDX-License-Identifier: GPL-2.0-or-later
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>
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
15 #include <linux/acpi.h>
16 #include <linux/memory.h>
17 #include <linux/memory_hotplug.h>
21 #define ACPI_MEMORY_DEVICE_CLASS "memory"
22 #define ACPI_MEMORY_DEVICE_HID "PNP0C80"
23 #define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
25 static const struct acpi_device_id memory_device_ids[] = {
26 {ACPI_MEMORY_DEVICE_HID, 0},
30 #ifdef CONFIG_ACPI_HOTPLUG_MEMORY
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);
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,
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;
54 struct acpi_memory_device {
55 struct acpi_device *device;
56 struct list_head res_list;
60 acpi_memory_get_resource(struct acpi_resource *resource, void *context)
62 struct acpi_memory_device *mem_device = context;
63 struct acpi_resource_address64 address64;
64 struct acpi_memory_info *info, *new;
67 status = acpi_resource_to_address64(resource, &address64);
68 if (ACPI_FAILURE(status) ||
69 (address64.resource_type != ACPI_MEMORY_RANGE))
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;
82 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
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);
97 acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
99 struct acpi_memory_info *info, *n;
101 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
103 INIT_LIST_HEAD(&mem_device->res_list);
107 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
111 if (!list_empty(&mem_device->res_list))
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);
124 static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
126 unsigned long long current_status;
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,
134 * Check for device status. Device should be
135 * present/enabled/functioning.
137 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
138 && (current_status & ACPI_STA_DEVICE_ENABLED)
139 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
145 static int acpi_bind_memblk(struct memory_block *mem, void *arg)
147 return acpi_bind_one(&mem->dev, arg);
150 static int acpi_bind_memory_blocks(struct acpi_memory_info *info,
151 struct acpi_device *adev)
153 return walk_memory_blocks(info->start_addr, info->length, adev,
157 static int acpi_unbind_memblk(struct memory_block *mem, void *arg)
159 acpi_unbind_one(&mem->dev);
163 static void acpi_unbind_memory_blocks(struct acpi_memory_info *info)
165 walk_memory_blocks(info->start_addr, info->length, NULL,
169 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
171 acpi_handle handle = mem_device->device->handle;
172 int result, num_enabled = 0;
173 struct acpi_memory_info *info;
176 node = acpi_get_node(handle);
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)
183 list_for_each_entry(info, &mem_device->res_list, list) {
184 if (info->enabled) { /* just sanity check...*/
189 * If the memory block size is zero, please ignore it.
190 * Don't try to do the following memory hotplug flowchart.
195 node = memory_add_physaddr_to_nid(info->start_addr);
197 result = __add_memory(node, info->start_addr, info->length);
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.
204 if (result && result != -EEXIST)
207 result = acpi_bind_memory_blocks(info, mem_device->device);
209 acpi_unbind_memory_blocks(info);
216 * Add num_enable even if add_memory() returns -EEXIST, so the
217 * device is bound to this driver.
222 dev_err(&mem_device->device->dev, "add_memory failed\n");
226 * Sometimes the memory device will contain several memory blocks.
227 * When one memory block is hot-added to the system memory, it will
228 * be regarded as a success.
229 * Otherwise if the last memory block can't be hot-added to the system
230 * memory, it will be failure and the memory device can't be bound with
236 static void acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
238 acpi_handle handle = mem_device->device->handle;
239 struct acpi_memory_info *info, *n;
240 int nid = acpi_get_node(handle);
242 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
246 if (nid == NUMA_NO_NODE)
247 nid = memory_add_physaddr_to_nid(info->start_addr);
249 acpi_unbind_memory_blocks(info);
250 __remove_memory(nid, info->start_addr, info->length);
251 list_del(&info->list);
256 static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
261 acpi_memory_free_device_resources(mem_device);
262 mem_device->device->driver_data = NULL;
266 static int acpi_memory_device_add(struct acpi_device *device,
267 const struct acpi_device_id *not_used)
269 struct acpi_memory_device *mem_device;
275 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
279 INIT_LIST_HEAD(&mem_device->res_list);
280 mem_device->device = device;
281 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
282 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
283 device->driver_data = mem_device;
285 /* Get the range from the _CRS */
286 result = acpi_memory_get_device_resources(mem_device);
288 device->driver_data = NULL;
293 result = acpi_memory_check_device(mem_device);
295 acpi_memory_device_free(mem_device);
299 result = acpi_memory_enable_device(mem_device);
301 dev_err(&device->dev, "acpi_memory_enable_device() error\n");
302 acpi_memory_device_free(mem_device);
306 dev_dbg(&device->dev, "Memory device configured by ACPI\n");
310 static void acpi_memory_device_remove(struct acpi_device *device)
312 struct acpi_memory_device *mem_device;
314 if (!device || !acpi_driver_data(device))
317 mem_device = acpi_driver_data(device);
318 acpi_memory_remove_memory(mem_device);
319 acpi_memory_device_free(mem_device);
322 static bool __initdata acpi_no_memhotplug;
324 void __init acpi_memory_hotplug_init(void)
326 if (acpi_no_memhotplug) {
327 memory_device_handler.attach = NULL;
328 acpi_scan_add_handler(&memory_device_handler);
331 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");
334 static int __init disable_acpi_memory_hotplug(char *str)
336 acpi_no_memhotplug = true;
339 __setup("acpi_no_memhotplug", disable_acpi_memory_hotplug);
343 static struct acpi_scan_handler memory_device_handler = {
344 .ids = memory_device_ids,
347 void __init acpi_memory_hotplug_init(void)
349 acpi_scan_add_handler(&memory_device_handler);
352 #endif /* CONFIG_ACPI_HOTPLUG_MEMORY */