blob: 7a0f4aa4fa1e355919301ccfb2bd82e4fac6e21b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2004 Intel Corporation <naveen.b.s@intel.com>
3 *
4 * All rights reserved.
5 *
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.
10 *
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
15 * details.
16 *
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.
20 *
21 *
22 * ACPI based HotPlug driver that supports Memory Hotplug
Nick Andrewc7060d92009-01-03 18:53:39 +110023 * This driver fields notifications from firmware for memory add
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 * and remove operations and alerts the VM of the affected memory
25 * ranges.
26 */
27
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>
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define ACPI_MEMORY_DEVICE_CLASS "memory"
36#define ACPI_MEMORY_DEVICE_HID "PNP0C80"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
38
39#define _COMPONENT ACPI_MEMORY_DEVICE_COMPONENT
40
Len Brownf52fd662007-02-12 22:42:12 -050041ACPI_MODULE_NAME("acpi_memhotplug");
42MODULE_AUTHOR("Naveen B S <naveen.b.s@intel.com>");
Len Brown7cda93e2007-02-12 23:50:02 -050043MODULE_DESCRIPTION("Hotplug Mem Driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070044MODULE_LICENSE("GPL");
45
Linus Torvalds1da177e2005-04-16 15:20:36 -070046/* Memory Device States */
47#define MEMORY_INVALID_STATE 0
48#define MEMORY_POWER_ON_STATE 1
49#define MEMORY_POWER_OFF_STATE 2
50
Len Brown4be44fc2005-08-05 00:44:28 -040051static int acpi_memory_device_add(struct acpi_device *device);
52static int acpi_memory_device_remove(struct acpi_device *device, int type);
Yasunori Goto1f425992006-06-27 02:53:28 -070053static int acpi_memory_device_start(struct acpi_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Thomas Renninger1ba90e32007-07-23 14:44:41 +020055static const struct acpi_device_id memory_device_ids[] = {
56 {ACPI_MEMORY_DEVICE_HID, 0},
57 {"", 0},
58};
59MODULE_DEVICE_TABLE(acpi, memory_device_ids);
60
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static struct acpi_driver acpi_memory_device_driver = {
Len Brownc2b6705b2007-02-12 23:33:40 -050062 .name = "acpi_memhotplug",
Len Brown4be44fc2005-08-05 00:44:28 -040063 .class = ACPI_MEMORY_DEVICE_CLASS,
Thomas Renninger1ba90e32007-07-23 14:44:41 +020064 .ids = memory_device_ids,
Len Brown4be44fc2005-08-05 00:44:28 -040065 .ops = {
66 .add = acpi_memory_device_add,
67 .remove = acpi_memory_device_remove,
Yasunori Goto1f425992006-06-27 02:53:28 -070068 .start = acpi_memory_device_start,
Len Brown4be44fc2005-08-05 00:44:28 -040069 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070070};
71
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070072struct acpi_memory_info {
73 struct list_head list;
74 u64 start_addr; /* Memory Range start physical addr */
75 u64 length; /* Memory Range length */
76 unsigned short caching; /* memory cache attribute */
77 unsigned short write_protect; /* memory read/write attribute */
78 unsigned int enabled:1;
79};
80
Linus Torvalds1da177e2005-04-16 15:20:36 -070081struct acpi_memory_device {
Patrick Mochel3b748632006-05-19 16:54:38 -040082 struct acpi_device * device;
Len Brown4be44fc2005-08-05 00:44:28 -040083 unsigned int state; /* State of the memory device */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070084 struct list_head res_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085};
86
Yasunori Goto887b9592006-10-19 23:28:31 -070087static int acpi_hotmem_initialized;
88
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070089static acpi_status
90acpi_memory_get_resource(struct acpi_resource *resource, void *context)
91{
92 struct acpi_memory_device *mem_device = context;
93 struct acpi_resource_address64 address64;
94 struct acpi_memory_info *info, *new;
95 acpi_status status;
96
97 status = acpi_resource_to_address64(resource, &address64);
98 if (ACPI_FAILURE(status) ||
99 (address64.resource_type != ACPI_MEMORY_RANGE))
100 return AE_OK;
101
102 list_for_each_entry(info, &mem_device->res_list, list) {
103 /* Can we combine the resource range information? */
104 if ((info->caching == address64.info.mem.caching) &&
105 (info->write_protect == address64.info.mem.write_protect) &&
106 (info->start_addr + info->length == address64.minimum)) {
107 info->length += address64.address_length;
108 return AE_OK;
109 }
110 }
111
112 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
113 if (!new)
114 return AE_ERROR;
115
116 INIT_LIST_HEAD(&new->list);
117 new->caching = address64.info.mem.caching;
118 new->write_protect = address64.info.mem.write_protect;
119 new->start_addr = address64.minimum;
120 new->length = address64.address_length;
121 list_add_tail(&new->list, &mem_device->res_list);
122
123 return AE_OK;
124}
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126static int
127acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
128{
129 acpi_status status;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700130 struct acpi_memory_info *info, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
KAMEZAWA Hiroyuki5d2870f2006-08-05 12:15:04 -0700133 if (!list_empty(&mem_device->res_list))
134 return 0;
135
Patrick Mochelb8632782006-05-19 16:54:41 -0400136 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700137 acpi_memory_get_resource, mem_device);
138 if (ACPI_FAILURE(status)) {
139 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
140 kfree(info);
KAMEZAWA Hiroyuki5d2870f2006-08-05 12:15:04 -0700141 INIT_LIST_HEAD(&mem_device->res_list);
Patrick Mocheld550d982006-06-27 00:41:40 -0400142 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 }
144
Patrick Mocheld550d982006-06-27 00:41:40 -0400145 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146}
147
148static int
149acpi_memory_get_device(acpi_handle handle,
Len Brown4be44fc2005-08-05 00:44:28 -0400150 struct acpi_memory_device **mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 acpi_status status;
153 acpi_handle phandle;
154 struct acpi_device *device = NULL;
155 struct acpi_device *pdevice = NULL;
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158 if (!acpi_bus_get_device(handle, &device) && device)
159 goto end;
160
161 status = acpi_get_parent(handle, &phandle);
162 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400163 ACPI_EXCEPTION((AE_INFO, status, "Cannot find acpi parent"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400164 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 }
166
167 /* Get the parent device */
168 status = acpi_bus_get_device(phandle, &pdevice);
169 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400170 ACPI_EXCEPTION((AE_INFO, status, "Cannot get acpi bus device"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400171 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 }
173
174 /*
175 * Now add the notified device. This creates the acpi_device
176 * and invokes .add function
177 */
178 status = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
179 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400180 ACPI_EXCEPTION((AE_INFO, status, "Cannot add acpi bus"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400181 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 }
183
Len Brown4be44fc2005-08-05 00:44:28 -0400184 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 *mem_device = acpi_driver_data(device);
186 if (!(*mem_device)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400187 printk(KERN_ERR "\n driver data not found");
Patrick Mocheld550d982006-06-27 00:41:40 -0400188 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 }
190
Patrick Mocheld550d982006-06-27 00:41:40 -0400191 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
193
Len Brown4be44fc2005-08-05 00:44:28 -0400194static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
Matthew Wilcox27663c52008-10-10 02:22:59 -0400196 unsigned long long current_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 /* Get device present/absent information from the _STA */
Patrick Mochelb8632782006-05-19 16:54:41 -0400199 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
Len Brown4be44fc2005-08-05 00:44:28 -0400200 NULL, &current_status)))
Patrick Mocheld550d982006-06-27 00:41:40 -0400201 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 /*
203 * Check for device status. Device should be
204 * present/enabled/functioning.
205 */
Bjorn Helgaasa0bd4ac2007-04-25 14:17:39 -0400206 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
207 && (current_status & ACPI_STA_DEVICE_ENABLED)
208 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
Patrick Mocheld550d982006-06-27 00:41:40 -0400209 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Patrick Mocheld550d982006-06-27 00:41:40 -0400211 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212}
213
Len Brown4be44fc2005-08-05 00:44:28 -0400214static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700216 int result, num_enabled = 0;
217 struct acpi_memory_info *info;
Yasunori Goto1e3590e2006-06-27 02:53:31 -0700218 int node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221 /* Get the range from the _CRS */
222 result = acpi_memory_get_device_resources(mem_device);
223 if (result) {
Len Brown64684632006-06-26 23:41:38 -0400224 printk(KERN_ERR PREFIX "get_device_resources failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 mem_device->state = MEMORY_INVALID_STATE;
226 return result;
227 }
228
Patrick Mochelb8632782006-05-19 16:54:41 -0400229 node = acpi_get_node(mem_device->device->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 /*
231 * Tell the VM there is more memory here...
232 * Note: Assume that this function returns zero on success
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700233 * We don't have memory-hot-add rollback function,now.
234 * (i.e. memory-hot-remove function)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700236 list_for_each_entry(info, &mem_device->res_list, list) {
KAMEZAWA Hiroyukifa25d8d2006-08-05 12:15:02 -0700237 if (info->enabled) { /* just sanity check...*/
Yasunori Gotodd56a8e2006-06-27 02:53:29 -0700238 num_enabled++;
239 continue;
240 }
Keith Mannthey8c2676a2006-09-30 23:27:07 -0700241
242 if (node < 0)
243 node = memory_add_physaddr_to_nid(info->start_addr);
244
Yasunori Gotobc02af92006-06-27 02:53:30 -0700245 result = add_memory(node, info->start_addr, info->length);
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700246 if (result)
247 continue;
248 info->enabled = 1;
249 num_enabled++;
250 }
251 if (!num_enabled) {
akpm@osdl.org0a1f1ab2006-06-30 03:15:00 -0400252 printk(KERN_ERR PREFIX "add_memory failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 mem_device->state = MEMORY_INVALID_STATE;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700254 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 }
256
257 return result;
258}
259
Len Brown4be44fc2005-08-05 00:44:28 -0400260static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
262 acpi_status status;
Len Brown4be44fc2005-08-05 00:44:28 -0400263 struct acpi_object_list arg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 union acpi_object arg;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400265 unsigned long long current_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 /* Issue the _EJ0 command */
269 arg_list.count = 1;
270 arg_list.pointer = &arg;
271 arg.type = ACPI_TYPE_INTEGER;
272 arg.integer.value = 1;
Patrick Mochelb8632782006-05-19 16:54:41 -0400273 status = acpi_evaluate_object(mem_device->device->handle,
Len Brown4be44fc2005-08-05 00:44:28 -0400274 "_EJ0", &arg_list, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 /* Return on _EJ0 failure */
276 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400277 ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400278 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280
281 /* Evalute _STA to check if the device is disabled */
Patrick Mochelb8632782006-05-19 16:54:41 -0400282 status = acpi_evaluate_integer(mem_device->device->handle, "_STA",
Len Brown4be44fc2005-08-05 00:44:28 -0400283 NULL, &current_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400285 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 /* Check for device status. Device should be disabled */
Bjorn Helgaasa0bd4ac2007-04-25 14:17:39 -0400288 if (current_status & ACPI_STA_DEVICE_ENABLED)
Patrick Mocheld550d982006-06-27 00:41:40 -0400289 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Patrick Mocheld550d982006-06-27 00:41:40 -0400291 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292}
293
Len Brown4be44fc2005-08-05 00:44:28 -0400294static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295{
296 int result;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700297 struct acpi_memory_info *info, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 /*
301 * Ask the VM to offline this memory range.
302 * Note: Assume that this function returns zero on success
303 */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700304 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
305 if (info->enabled) {
306 result = remove_memory(info->start_addr, info->length);
307 if (result)
308 return result;
309 }
310 kfree(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 }
312
313 /* Power-off and eject the device */
314 result = acpi_memory_powerdown_device(mem_device);
315 if (result) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 /* Set the status of the device to invalid */
317 mem_device->state = MEMORY_INVALID_STATE;
318 return result;
319 }
320
321 mem_device->state = MEMORY_POWER_OFF_STATE;
322 return result;
323}
324
Len Brown4be44fc2005-08-05 00:44:28 -0400325static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326{
327 struct acpi_memory_device *mem_device;
328 struct acpi_device *device;
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
331 switch (event) {
332 case ACPI_NOTIFY_BUS_CHECK:
333 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400334 "\nReceived BUS CHECK notification for device\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 /* Fall Through */
336 case ACPI_NOTIFY_DEVICE_CHECK:
337 if (event == ACPI_NOTIFY_DEVICE_CHECK)
338 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400339 "\nReceived DEVICE CHECK notification for device\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 if (acpi_memory_get_device(handle, &mem_device)) {
Len Brown64684632006-06-26 23:41:38 -0400341 printk(KERN_ERR PREFIX "Cannot find driver data\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400342 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 }
344
345 if (!acpi_memory_check_device(mem_device)) {
346 if (acpi_memory_enable_device(mem_device))
Len Brown64684632006-06-26 23:41:38 -0400347 printk(KERN_ERR PREFIX
348 "Cannot enable memory device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 }
350 break;
351 case ACPI_NOTIFY_EJECT_REQUEST:
352 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400353 "\nReceived EJECT REQUEST notification for device\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355 if (acpi_bus_get_device(handle, &device)) {
Len Brown64684632006-06-26 23:41:38 -0400356 printk(KERN_ERR PREFIX "Device doesn't exist\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 break;
358 }
359 mem_device = acpi_driver_data(device);
360 if (!mem_device) {
Len Brown64684632006-06-26 23:41:38 -0400361 printk(KERN_ERR PREFIX "Driver Data is NULL\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 break;
363 }
364
365 /*
366 * Currently disabling memory device from kernel mode
367 * TBD: Can also be disabled from user mode scripts
368 * TBD: Can also be disabled by Callback registration
Len Brown4be44fc2005-08-05 00:44:28 -0400369 * with generic sysfs driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 */
371 if (acpi_memory_disable_device(mem_device))
Len Brown64684632006-06-26 23:41:38 -0400372 printk(KERN_ERR PREFIX
373 "Disable memory device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 /*
375 * TBD: Invoke acpi_bus_remove to cleanup data structures
376 */
377 break;
378 default:
379 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400380 "Unsupported event [0x%x]\n", event));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 break;
382 }
383
Patrick Mocheld550d982006-06-27 00:41:40 -0400384 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385}
386
Len Brown4be44fc2005-08-05 00:44:28 -0400387static int acpi_memory_device_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
389 int result;
390 struct acpi_memory_device *mem_device = NULL;
391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400394 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Burman Yan36bcbec2006-12-19 12:56:11 -0800396 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (!mem_device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400398 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700400 INIT_LIST_HEAD(&mem_device->res_list);
Patrick Mochel3b748632006-05-19 16:54:38 -0400401 mem_device->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
403 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700404 device->driver_data = mem_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 /* Get the range from the _CRS */
407 result = acpi_memory_get_device_resources(mem_device);
408 if (result) {
409 kfree(mem_device);
Patrick Mocheld550d982006-06-27 00:41:40 -0400410 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 }
412
413 /* Set the device state */
414 mem_device->state = MEMORY_POWER_ON_STATE;
415
Yasunori Goto6cbe44c2006-10-19 23:28:30 -0700416 printk(KERN_DEBUG "%s \n", acpi_device_name(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Patrick Mocheld550d982006-06-27 00:41:40 -0400418 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420
Len Brown4be44fc2005-08-05 00:44:28 -0400421static int acpi_memory_device_remove(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
423 struct acpi_memory_device *mem_device = NULL;
424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400427 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200429 mem_device = acpi_driver_data(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 kfree(mem_device);
431
Patrick Mocheld550d982006-06-27 00:41:40 -0400432 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433}
434
Yasunori Goto1f425992006-06-27 02:53:28 -0700435static int acpi_memory_device_start (struct acpi_device *device)
436{
437 struct acpi_memory_device *mem_device;
438 int result = 0;
439
Yasunori Goto887b9592006-10-19 23:28:31 -0700440 /*
441 * Early boot code has recognized memory area by EFI/E820.
442 * If DSDT shows these memory devices on boot, hotplug is not necessary
443 * for them. So, it just returns until completion of this driver's
444 * start up.
445 */
446 if (!acpi_hotmem_initialized)
447 return 0;
448
Yasunori Goto1f425992006-06-27 02:53:28 -0700449 mem_device = acpi_driver_data(device);
450
451 if (!acpi_memory_check_device(mem_device)) {
452 /* call add_memory func */
453 result = acpi_memory_enable_device(mem_device);
454 if (result)
Lin Ming55ac9a02008-09-28 14:51:56 +0800455 printk(KERN_ERR PREFIX
456 "Error in acpi_memory_enable_device\n");
Yasunori Goto1f425992006-06-27 02:53:28 -0700457 }
Len Brownd120cfb2006-06-29 19:57:46 -0400458 return result;
Yasunori Goto1f425992006-06-27 02:53:28 -0700459}
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461/*
462 * Helper function to check for memory device
463 */
Len Brown4be44fc2005-08-05 00:44:28 -0400464static acpi_status is_memory_device(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
466 char *hardware_id;
467 acpi_status status;
Len Brown4be44fc2005-08-05 00:44:28 -0400468 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 struct acpi_device_info *info;
470
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 status = acpi_get_object_info(handle, &buffer);
473 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400474 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
476 info = buffer.pointer;
477 if (!(info->valid & ACPI_VALID_HID)) {
Len Brown02438d82006-06-30 03:19:10 -0400478 kfree(buffer.pointer);
Patrick Mocheld550d982006-06-27 00:41:40 -0400479 return AE_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 }
481
482 hardware_id = info->hardware_id.value;
483 if ((hardware_id == NULL) ||
Len Brown4be44fc2005-08-05 00:44:28 -0400484 (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 status = AE_ERROR;
486
Len Brown02438d82006-06-30 03:19:10 -0400487 kfree(buffer.pointer);
Patrick Mocheld550d982006-06-27 00:41:40 -0400488 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489}
490
491static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400492acpi_memory_register_notify_handler(acpi_handle handle,
493 u32 level, void *ctxt, void **retv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494{
495 acpi_status status;
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498 status = is_memory_device(handle);
Yasunori Goto07dd4852006-08-14 22:37:32 -0700499 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400500 return AE_OK; /* continue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Thomas Renningera6fc6722006-06-26 23:58:43 -0400502 status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
503 acpi_memory_device_notify, NULL);
504 /* continue */
Patrick Mocheld550d982006-06-27 00:41:40 -0400505 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506}
507
508static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400509acpi_memory_deregister_notify_handler(acpi_handle handle,
510 u32 level, void *ctxt, void **retv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
512 acpi_status status;
513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515 status = is_memory_device(handle);
Yasunori Goto07dd4852006-08-14 22:37:32 -0700516 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400517 return AE_OK; /* continue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519 status = acpi_remove_notify_handler(handle,
Len Brown4be44fc2005-08-05 00:44:28 -0400520 ACPI_SYSTEM_NOTIFY,
521 acpi_memory_device_notify);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Patrick Mocheld550d982006-06-27 00:41:40 -0400523 return AE_OK; /* continue */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
Len Brown4be44fc2005-08-05 00:44:28 -0400526static int __init acpi_memory_device_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
528 int result;
529 acpi_status status;
530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532 result = acpi_bus_register_driver(&acpi_memory_device_driver);
533
534 if (result < 0)
Patrick Mocheld550d982006-06-27 00:41:40 -0400535 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
Len Brown4be44fc2005-08-05 00:44:28 -0400538 ACPI_UINT32_MAX,
539 acpi_memory_register_notify_handler,
540 NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Len Brown4be44fc2005-08-05 00:44:28 -0400542 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400543 ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 acpi_bus_unregister_driver(&acpi_memory_device_driver);
Patrick Mocheld550d982006-06-27 00:41:40 -0400545 return -ENODEV;
Len Brown4be44fc2005-08-05 00:44:28 -0400546 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
Yasunori Goto887b9592006-10-19 23:28:31 -0700548 acpi_hotmem_initialized = 1;
Patrick Mocheld550d982006-06-27 00:41:40 -0400549 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550}
551
Len Brown4be44fc2005-08-05 00:44:28 -0400552static void __exit acpi_memory_device_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553{
554 acpi_status status;
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 /*
558 * Adding this to un-install notification handlers for all the device
559 * handles.
560 */
561 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
Len Brown4be44fc2005-08-05 00:44:28 -0400562 ACPI_UINT32_MAX,
563 acpi_memory_deregister_notify_handler,
564 NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
Len Brown4be44fc2005-08-05 00:44:28 -0400566 if (ACPI_FAILURE(status))
Thomas Renningera6fc6722006-06-26 23:58:43 -0400567 ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 acpi_bus_unregister_driver(&acpi_memory_device_driver);
570
Patrick Mocheld550d982006-06-27 00:41:40 -0400571 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572}
573
574module_init(acpi_memory_device_init);
575module_exit(acpi_memory_device_exit);