2 * Copyright (C) 2004 Intel Corporation <naveen.b.s@intel.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
14 * NON INFRINGEMENT. See the GNU General Public License for more
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 * ACPI based HotPlug driver that supports Memory Hotplug
23 * This driver fields notifications from firmware for memory add
24 * and remove operations and alerts the VM of the affected memory
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/types.h>
32 #include <linux/memory_hotplug.h>
33 #include <acpi/acpi_drivers.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");
45 MODULE_AUTHOR("Naveen B S <naveen.b.s@intel.com>");
46 MODULE_DESCRIPTION("Hotplug Mem Driver");
47 MODULE_LICENSE("GPL");
49 /* Memory Device States */
50 #define MEMORY_INVALID_STATE 0
51 #define MEMORY_POWER_ON_STATE 1
52 #define MEMORY_POWER_OFF_STATE 2
54 static int acpi_memory_device_add(struct acpi_device *device);
55 static int acpi_memory_device_remove(struct acpi_device *device, int type);
56 static int acpi_memory_device_start(struct acpi_device *device);
58 static const struct acpi_device_id memory_device_ids[] = {
59 {ACPI_MEMORY_DEVICE_HID, 0},
62 MODULE_DEVICE_TABLE(acpi, memory_device_ids);
64 static struct acpi_driver acpi_memory_device_driver = {
65 .name = "acpi_memhotplug",
66 .class = ACPI_MEMORY_DEVICE_CLASS,
67 .ids = memory_device_ids,
69 .add = acpi_memory_device_add,
70 .remove = acpi_memory_device_remove,
71 .start = acpi_memory_device_start,
75 struct acpi_memory_info {
76 struct list_head list;
77 u64 start_addr; /* Memory Range start physical addr */
78 u64 length; /* Memory Range length */
79 unsigned short caching; /* memory cache attribute */
80 unsigned short write_protect; /* memory read/write attribute */
81 unsigned int enabled:1;
84 struct acpi_memory_device {
85 struct acpi_device * device;
86 unsigned int state; /* State of the memory device */
87 struct list_head res_list;
90 static int acpi_hotmem_initialized;
93 acpi_memory_get_resource(struct acpi_resource *resource, void *context)
95 struct acpi_memory_device *mem_device = context;
96 struct acpi_resource_address64 address64;
97 struct acpi_memory_info *info, *new;
100 status = acpi_resource_to_address64(resource, &address64);
101 if (ACPI_FAILURE(status) ||
102 (address64.resource_type != ACPI_MEMORY_RANGE))
105 list_for_each_entry(info, &mem_device->res_list, list) {
106 /* Can we combine the resource range information? */
107 if ((info->caching == address64.info.mem.caching) &&
108 (info->write_protect == address64.info.mem.write_protect) &&
109 (info->start_addr + info->length == address64.minimum)) {
110 info->length += address64.address_length;
115 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
119 INIT_LIST_HEAD(&new->list);
120 new->caching = address64.info.mem.caching;
121 new->write_protect = address64.info.mem.write_protect;
122 new->start_addr = address64.minimum;
123 new->length = address64.address_length;
124 list_add_tail(&new->list, &mem_device->res_list);
130 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
133 struct acpi_memory_info *info, *n;
136 if (!list_empty(&mem_device->res_list))
139 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
140 acpi_memory_get_resource, mem_device);
141 if (ACPI_FAILURE(status)) {
142 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
144 INIT_LIST_HEAD(&mem_device->res_list);
152 acpi_memory_get_device(acpi_handle handle,
153 struct acpi_memory_device **mem_device)
157 struct acpi_device *device = NULL;
158 struct acpi_device *pdevice = NULL;
162 if (!acpi_bus_get_device(handle, &device) && device)
165 status = acpi_get_parent(handle, &phandle);
166 if (ACPI_FAILURE(status)) {
167 ACPI_EXCEPTION((AE_INFO, status, "Cannot find acpi parent"));
171 /* Get the parent device */
172 result = acpi_bus_get_device(phandle, &pdevice);
174 printk(KERN_WARNING PREFIX "Cannot get acpi bus device");
179 * Now add the notified device. This creates the acpi_device
180 * and invokes .add function
182 result = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
184 printk(KERN_WARNING PREFIX "Cannot add acpi bus");
189 *mem_device = acpi_driver_data(device);
190 if (!(*mem_device)) {
191 printk(KERN_ERR "\n driver data not found");
198 static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
200 unsigned long long current_status;
202 /* Get device present/absent information from the _STA */
203 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
204 NULL, ¤t_status)))
207 * Check for device status. Device should be
208 * present/enabled/functioning.
210 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
211 && (current_status & ACPI_STA_DEVICE_ENABLED)
212 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
218 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
220 int result, num_enabled = 0;
221 struct acpi_memory_info *info;
225 /* Get the range from the _CRS */
226 result = acpi_memory_get_device_resources(mem_device);
228 printk(KERN_ERR PREFIX "get_device_resources failed\n");
229 mem_device->state = MEMORY_INVALID_STATE;
233 node = acpi_get_node(mem_device->device->handle);
235 * Tell the VM there is more memory here...
236 * Note: Assume that this function returns zero on success
237 * We don't have memory-hot-add rollback function,now.
238 * (i.e. memory-hot-remove function)
240 list_for_each_entry(info, &mem_device->res_list, list) {
241 if (info->enabled) { /* just sanity check...*/
247 node = memory_add_physaddr_to_nid(info->start_addr);
249 result = add_memory(node, info->start_addr, info->length);
256 printk(KERN_ERR PREFIX "add_memory failed\n");
257 mem_device->state = MEMORY_INVALID_STATE;
264 static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
267 struct acpi_object_list arg_list;
268 union acpi_object arg;
269 unsigned long long current_status;
272 /* Issue the _EJ0 command */
274 arg_list.pointer = &arg;
275 arg.type = ACPI_TYPE_INTEGER;
276 arg.integer.value = 1;
277 status = acpi_evaluate_object(mem_device->device->handle,
278 "_EJ0", &arg_list, NULL);
279 /* Return on _EJ0 failure */
280 if (ACPI_FAILURE(status)) {
281 ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));
285 /* Evalute _STA to check if the device is disabled */
286 status = acpi_evaluate_integer(mem_device->device->handle, "_STA",
287 NULL, ¤t_status);
288 if (ACPI_FAILURE(status))
291 /* Check for device status. Device should be disabled */
292 if (current_status & ACPI_STA_DEVICE_ENABLED)
298 static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
301 struct acpi_memory_info *info, *n;
305 * Ask the VM to offline this memory range.
306 * Note: Assume that this function returns zero on success
308 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
310 result = remove_memory(info->start_addr, info->length);
317 /* Power-off and eject the device */
318 result = acpi_memory_powerdown_device(mem_device);
320 /* Set the status of the device to invalid */
321 mem_device->state = MEMORY_INVALID_STATE;
325 mem_device->state = MEMORY_POWER_OFF_STATE;
329 static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
331 struct acpi_memory_device *mem_device;
332 struct acpi_device *device;
336 case ACPI_NOTIFY_BUS_CHECK:
337 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
338 "\nReceived BUS CHECK notification for device\n"));
340 case ACPI_NOTIFY_DEVICE_CHECK:
341 if (event == ACPI_NOTIFY_DEVICE_CHECK)
342 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
343 "\nReceived DEVICE CHECK notification for device\n"));
344 if (acpi_memory_get_device(handle, &mem_device)) {
345 printk(KERN_ERR PREFIX "Cannot find driver data\n");
349 if (!acpi_memory_check_device(mem_device)) {
350 if (acpi_memory_enable_device(mem_device))
351 printk(KERN_ERR PREFIX
352 "Cannot enable memory device\n");
355 case ACPI_NOTIFY_EJECT_REQUEST:
356 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
357 "\nReceived EJECT REQUEST notification for device\n"));
359 if (acpi_bus_get_device(handle, &device)) {
360 printk(KERN_ERR PREFIX "Device doesn't exist\n");
363 mem_device = acpi_driver_data(device);
365 printk(KERN_ERR PREFIX "Driver Data is NULL\n");
370 * Currently disabling memory device from kernel mode
371 * TBD: Can also be disabled from user mode scripts
372 * TBD: Can also be disabled by Callback registration
373 * with generic sysfs driver
375 if (acpi_memory_disable_device(mem_device))
376 printk(KERN_ERR PREFIX
377 "Disable memory device\n");
379 * TBD: Invoke acpi_bus_remove to cleanup data structures
383 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
384 "Unsupported event [0x%x]\n", event));
391 static int acpi_memory_device_add(struct acpi_device *device)
394 struct acpi_memory_device *mem_device = NULL;
400 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
404 INIT_LIST_HEAD(&mem_device->res_list);
405 mem_device->device = device;
406 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
407 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
408 device->driver_data = mem_device;
410 /* Get the range from the _CRS */
411 result = acpi_memory_get_device_resources(mem_device);
417 /* Set the device state */
418 mem_device->state = MEMORY_POWER_ON_STATE;
420 printk(KERN_DEBUG "%s \n", acpi_device_name(device));
425 static int acpi_memory_device_remove(struct acpi_device *device, int type)
427 struct acpi_memory_device *mem_device = NULL;
430 if (!device || !acpi_driver_data(device))
433 mem_device = acpi_driver_data(device);
439 static int acpi_memory_device_start (struct acpi_device *device)
441 struct acpi_memory_device *mem_device;
445 * Early boot code has recognized memory area by EFI/E820.
446 * If DSDT shows these memory devices on boot, hotplug is not necessary
447 * for them. So, it just returns until completion of this driver's
450 if (!acpi_hotmem_initialized)
453 mem_device = acpi_driver_data(device);
455 if (!acpi_memory_check_device(mem_device)) {
456 /* call add_memory func */
457 result = acpi_memory_enable_device(mem_device);
459 printk(KERN_ERR PREFIX
460 "Error in acpi_memory_enable_device\n");
466 * Helper function to check for memory device
468 static acpi_status is_memory_device(acpi_handle handle)
472 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
473 struct acpi_device_info *info;
476 status = acpi_get_object_info(handle, &buffer);
477 if (ACPI_FAILURE(status))
480 info = buffer.pointer;
481 if (!(info->valid & ACPI_VALID_HID)) {
482 kfree(buffer.pointer);
486 hardware_id = info->hardware_id.value;
487 if ((hardware_id == NULL) ||
488 (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
491 kfree(buffer.pointer);
496 acpi_memory_register_notify_handler(acpi_handle handle,
497 u32 level, void *ctxt, void **retv)
502 status = is_memory_device(handle);
503 if (ACPI_FAILURE(status))
504 return AE_OK; /* continue */
506 status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
507 acpi_memory_device_notify, NULL);
513 acpi_memory_deregister_notify_handler(acpi_handle handle,
514 u32 level, void *ctxt, void **retv)
519 status = is_memory_device(handle);
520 if (ACPI_FAILURE(status))
521 return AE_OK; /* continue */
523 status = acpi_remove_notify_handler(handle,
525 acpi_memory_device_notify);
527 return AE_OK; /* continue */
530 static int __init acpi_memory_device_init(void)
536 result = acpi_bus_register_driver(&acpi_memory_device_driver);
541 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
543 acpi_memory_register_notify_handler,
546 if (ACPI_FAILURE(status)) {
547 ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
548 acpi_bus_unregister_driver(&acpi_memory_device_driver);
552 acpi_hotmem_initialized = 1;
556 static void __exit acpi_memory_device_exit(void)
562 * Adding this to un-install notification handlers for all the device
565 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
567 acpi_memory_deregister_notify_handler,
570 if (ACPI_FAILURE(status))
571 ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
573 acpi_bus_unregister_driver(&acpi_memory_device_driver);
578 module_init(acpi_memory_device_init);
579 module_exit(acpi_memory_device_exit);