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>
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.
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
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.
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
30 #include <linux/acpi.h>
31 #include <linux/memory_hotplug.h>
35 #define ACPI_MEMORY_DEVICE_CLASS "memory"
36 #define ACPI_MEMORY_DEVICE_HID "PNP0C80"
37 #define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
39 #define _COMPONENT ACPI_MEMORY_DEVICE_COMPONENT
42 #define PREFIX "ACPI:memory_hp:"
44 ACPI_MODULE_NAME("acpi_memhotplug");
46 /* Memory Device States */
47 #define MEMORY_INVALID_STATE 0
48 #define MEMORY_POWER_ON_STATE 1
49 #define MEMORY_POWER_OFF_STATE 2
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);
55 static const struct acpi_device_id memory_device_ids[] = {
56 {ACPI_MEMORY_DEVICE_HID, 0},
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,
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;
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;
86 acpi_memory_get_resource(struct acpi_resource *resource, void *context)
88 struct acpi_memory_device *mem_device = context;
89 struct acpi_resource_address64 address64;
90 struct acpi_memory_info *info, *new;
93 status = acpi_resource_to_address64(resource, &address64);
94 if (ACPI_FAILURE(status) ||
95 (address64.resource_type != ACPI_MEMORY_RANGE))
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;
108 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
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);
123 acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
125 struct acpi_memory_info *info, *n;
127 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
129 INIT_LIST_HEAD(&mem_device->res_list);
133 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
137 if (!list_empty(&mem_device->res_list))
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);
150 static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
152 unsigned long long current_status;
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)))
159 * Check for device status. Device should be
160 * present/enabled/functioning.
162 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
163 && (current_status & ACPI_STA_DEVICE_ENABLED)
164 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
170 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
172 int result, num_enabled = 0;
173 struct acpi_memory_info *info;
176 node = acpi_get_node(mem_device->device->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) {
212 * Add num_enable even if add_memory() returns -EEXIST, so the
213 * device is bound to this driver.
218 dev_err(&mem_device->device->dev, "add_memory failed\n");
219 mem_device->state = MEMORY_INVALID_STATE;
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
233 static int acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
236 struct acpi_memory_info *info, *n;
238 nid = acpi_get_node(mem_device->device->handle);
240 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
242 /* The kernel does not use this memory block */
247 * The kernel uses this memory block, but it may be not
253 nid = memory_add_physaddr_to_nid(info->start_addr);
254 result = remove_memory(nid, info->start_addr, info->length);
258 list_del(&info->list);
265 static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
270 acpi_memory_free_device_resources(mem_device);
271 mem_device->device->driver_data = NULL;
275 static int acpi_memory_device_add(struct acpi_device *device,
276 const struct acpi_device_id *not_used)
278 struct acpi_memory_device *mem_device;
284 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
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;
294 /* Get the range from the _CRS */
295 result = acpi_memory_get_device_resources(mem_device);
301 /* Set the device state */
302 mem_device->state = MEMORY_POWER_ON_STATE;
304 result = acpi_memory_check_device(mem_device);
306 acpi_memory_device_free(mem_device);
310 result = acpi_memory_enable_device(mem_device);
312 dev_err(&device->dev, "acpi_memory_enable_device() error\n");
313 acpi_memory_device_free(mem_device);
317 dev_dbg(&device->dev, "Memory device configured by ACPI\n");
321 static void acpi_memory_device_remove(struct acpi_device *device)
323 struct acpi_memory_device *mem_device;
325 if (!device || !acpi_driver_data(device))
328 mem_device = acpi_driver_data(device);
329 acpi_memory_remove_memory(mem_device);
330 acpi_memory_device_free(mem_device);
333 void __init acpi_memory_hotplug_init(void)
335 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");