1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
35#define ACPI_MEMORY_DEVICE_CLASS "memory"
36#define ACPI_MEMORY_DEVICE_HID "PNP0C80"
37#define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
38
39#define _COMPONENT ACPI_MEMORY_DEVICE_COMPONENT
40
41#undef PREFIX
42#define PREFIX "ACPI:memory_hp:"
43
44ACPI_MODULE_NAME("acpi_memhotplug");
45MODULE_AUTHOR("Naveen B S <naveen.b.s@intel.com>");
46MODULE_DESCRIPTION("Hotplug Mem Driver");
47MODULE_LICENSE("GPL");
48
49
50#define MEMORY_INVALID_STATE 0
51#define MEMORY_POWER_ON_STATE 1
52#define MEMORY_POWER_OFF_STATE 2
53
54static int acpi_memory_device_add(struct acpi_device *device);
55static int acpi_memory_device_remove(struct acpi_device *device, int type);
56
57static const struct acpi_device_id memory_device_ids[] = {
58 {ACPI_MEMORY_DEVICE_HID, 0},
59 {"", 0},
60};
61MODULE_DEVICE_TABLE(acpi, memory_device_ids);
62
63static struct acpi_driver acpi_memory_device_driver = {
64 .name = "acpi_memhotplug",
65 .class = ACPI_MEMORY_DEVICE_CLASS,
66 .ids = memory_device_ids,
67 .ops = {
68 .add = acpi_memory_device_add,
69 .remove = acpi_memory_device_remove,
70 },
71};
72
73struct acpi_memory_info {
74 struct list_head list;
75 u64 start_addr;
76 u64 length;
77 unsigned short caching;
78 unsigned short write_protect;
79 unsigned int enabled:1;
80};
81
82struct acpi_memory_device {
83 struct acpi_device * device;
84 unsigned int state;
85 struct list_head res_list;
86};
87
88static int acpi_hotmem_initialized;
89
90static acpi_status
91acpi_memory_get_resource(struct acpi_resource *resource, void *context)
92{
93 struct acpi_memory_device *mem_device = context;
94 struct acpi_resource_address64 address64;
95 struct acpi_memory_info *info, *new;
96 acpi_status status;
97
98 status = acpi_resource_to_address64(resource, &address64);
99 if (ACPI_FAILURE(status) ||
100 (address64.resource_type != ACPI_MEMORY_RANGE))
101 return AE_OK;
102
103 list_for_each_entry(info, &mem_device->res_list, list) {
104
105 if ((info->caching == address64.info.mem.caching) &&
106 (info->write_protect == address64.info.mem.write_protect) &&
107 (info->start_addr + info->length == address64.minimum)) {
108 info->length += address64.address_length;
109 return AE_OK;
110 }
111 }
112
113 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
114 if (!new)
115 return AE_ERROR;
116
117 INIT_LIST_HEAD(&new->list);
118 new->caching = address64.info.mem.caching;
119 new->write_protect = address64.info.mem.write_protect;
120 new->start_addr = address64.minimum;
121 new->length = address64.address_length;
122 list_add_tail(&new->list, &mem_device->res_list);
123
124 return AE_OK;
125}
126
127static int
128acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
129{
130 acpi_status status;
131 struct acpi_memory_info *info, *n;
132
133
134 if (!list_empty(&mem_device->res_list))
135 return 0;
136
137 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
138 acpi_memory_get_resource, mem_device);
139 if (ACPI_FAILURE(status)) {
140 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
141 kfree(info);
142 INIT_LIST_HEAD(&mem_device->res_list);
143 return -EINVAL;
144 }
145
146 return 0;
147}
148
149static int
150acpi_memory_get_device(acpi_handle handle,
151 struct acpi_memory_device **mem_device)
152{
153 acpi_status status;
154 acpi_handle phandle;
155 struct acpi_device *device = NULL;
156 struct acpi_device *pdevice = NULL;
157 int result;
158
159
160 if (!acpi_bus_get_device(handle, &device) && device)
161 goto end;
162
163 status = acpi_get_parent(handle, &phandle);
164 if (ACPI_FAILURE(status)) {
165 ACPI_EXCEPTION((AE_INFO, status, "Cannot find acpi parent"));
166 return -EINVAL;
167 }
168
169
170 result = acpi_bus_get_device(phandle, &pdevice);
171 if (result) {
172 printk(KERN_WARNING PREFIX "Cannot get acpi bus device");
173 return -EINVAL;
174 }
175
176
177
178
179
180 result = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
181 if (result) {
182 printk(KERN_WARNING PREFIX "Cannot add acpi bus");
183 return -EINVAL;
184 }
185
186 end:
187 *mem_device = acpi_driver_data(device);
188 if (!(*mem_device)) {
189 printk(KERN_ERR "\n driver data not found");
190 return -ENODEV;
191 }
192
193 return 0;
194}
195
196static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
197{
198 unsigned long long current_status;
199
200
201 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
202 NULL, ¤t_status)))
203 return -ENODEV;
204
205
206
207
208 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
209 && (current_status & ACPI_STA_DEVICE_ENABLED)
210 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
211 return -ENODEV;
212
213 return 0;
214}
215
216static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
217{
218 int result, num_enabled = 0;
219 struct acpi_memory_info *info;
220 int node;
221
222
223
224 result = acpi_memory_get_device_resources(mem_device);
225 if (result) {
226 printk(KERN_ERR PREFIX "get_device_resources failed\n");
227 mem_device->state = MEMORY_INVALID_STATE;
228 return result;
229 }
230
231 node = acpi_get_node(mem_device->device->handle);
232
233
234
235
236
237
238 list_for_each_entry(info, &mem_device->res_list, list) {
239 if (info->enabled) {
240 num_enabled++;
241 continue;
242 }
243
244
245
246
247 if (!info->length)
248 continue;
249 if (node < 0)
250 node = memory_add_physaddr_to_nid(info->start_addr);
251
252 result = add_memory(node, info->start_addr, info->length);
253 if (result)
254 continue;
255 info->enabled = 1;
256 num_enabled++;
257 }
258 if (!num_enabled) {
259 printk(KERN_ERR PREFIX "add_memory failed\n");
260 mem_device->state = MEMORY_INVALID_STATE;
261 return -EINVAL;
262 }
263
264
265
266
267
268
269
270
271 return 0;
272}
273
274static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
275{
276 acpi_status status;
277 struct acpi_object_list arg_list;
278 union acpi_object arg;
279 unsigned long long current_status;
280
281
282
283 arg_list.count = 1;
284 arg_list.pointer = &arg;
285 arg.type = ACPI_TYPE_INTEGER;
286 arg.integer.value = 1;
287 status = acpi_evaluate_object(mem_device->device->handle,
288 "_EJ0", &arg_list, NULL);
289
290 if (ACPI_FAILURE(status)) {
291 ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));
292 return -ENODEV;
293 }
294
295
296 status = acpi_evaluate_integer(mem_device->device->handle, "_STA",
297 NULL, ¤t_status);
298 if (ACPI_FAILURE(status))
299 return -ENODEV;
300
301
302 if (current_status & ACPI_STA_DEVICE_ENABLED)
303 return -EINVAL;
304
305 return 0;
306}
307
308static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
309{
310 int result;
311 struct acpi_memory_info *info, *n;
312
313
314
315
316
317
318 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
319 if (info->enabled) {
320 result = remove_memory(info->start_addr, info->length);
321 if (result)
322 return result;
323 }
324 kfree(info);
325 }
326
327
328 result = acpi_memory_powerdown_device(mem_device);
329 if (result) {
330
331 mem_device->state = MEMORY_INVALID_STATE;
332 return result;
333 }
334
335 mem_device->state = MEMORY_POWER_OFF_STATE;
336 return result;
337}
338
339static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
340{
341 struct acpi_memory_device *mem_device;
342 struct acpi_device *device;
343
344
345 switch (event) {
346 case ACPI_NOTIFY_BUS_CHECK:
347 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
348 "\nReceived BUS CHECK notification for device\n"));
349
350 case ACPI_NOTIFY_DEVICE_CHECK:
351 if (event == ACPI_NOTIFY_DEVICE_CHECK)
352 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
353 "\nReceived DEVICE CHECK notification for device\n"));
354 if (acpi_memory_get_device(handle, &mem_device)) {
355 printk(KERN_ERR PREFIX "Cannot find driver data\n");
356 return;
357 }
358
359 if (!acpi_memory_check_device(mem_device)) {
360 if (acpi_memory_enable_device(mem_device))
361 printk(KERN_ERR PREFIX
362 "Cannot enable memory device\n");
363 }
364 break;
365 case ACPI_NOTIFY_EJECT_REQUEST:
366 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
367 "\nReceived EJECT REQUEST notification for device\n"));
368
369 if (acpi_bus_get_device(handle, &device)) {
370 printk(KERN_ERR PREFIX "Device doesn't exist\n");
371 break;
372 }
373 mem_device = acpi_driver_data(device);
374 if (!mem_device) {
375 printk(KERN_ERR PREFIX "Driver Data is NULL\n");
376 break;
377 }
378
379
380
381
382
383
384
385 if (acpi_memory_disable_device(mem_device))
386 printk(KERN_ERR PREFIX
387 "Disable memory device\n");
388
389
390
391 break;
392 default:
393 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
394 "Unsupported event [0x%x]\n", event));
395 break;
396 }
397
398 return;
399}
400
401static int acpi_memory_device_add(struct acpi_device *device)
402{
403 int result;
404 struct acpi_memory_device *mem_device = NULL;
405
406
407 if (!device)
408 return -EINVAL;
409
410 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
411 if (!mem_device)
412 return -ENOMEM;
413
414 INIT_LIST_HEAD(&mem_device->res_list);
415 mem_device->device = device;
416 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
417 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
418 device->driver_data = mem_device;
419
420
421 result = acpi_memory_get_device_resources(mem_device);
422 if (result) {
423 kfree(mem_device);
424 return result;
425 }
426
427
428 mem_device->state = MEMORY_POWER_ON_STATE;
429
430 printk(KERN_DEBUG "%s \n", acpi_device_name(device));
431
432
433
434
435
436
437
438 if (!acpi_hotmem_initialized)
439 return 0;
440
441 if (!acpi_memory_check_device(mem_device)) {
442
443 result = acpi_memory_enable_device(mem_device);
444 if (result)
445 printk(KERN_ERR PREFIX
446 "Error in acpi_memory_enable_device\n");
447 }
448 return result;
449}
450
451static int acpi_memory_device_remove(struct acpi_device *device, int type)
452{
453 struct acpi_memory_device *mem_device = NULL;
454
455
456 if (!device || !acpi_driver_data(device))
457 return -EINVAL;
458
459 mem_device = acpi_driver_data(device);
460 kfree(mem_device);
461
462 return 0;
463}
464
465
466
467
468static acpi_status is_memory_device(acpi_handle handle)
469{
470 char *hardware_id;
471 acpi_status status;
472 struct acpi_device_info *info;
473
474 status = acpi_get_object_info(handle, &info);
475 if (ACPI_FAILURE(status))
476 return status;
477
478 if (!(info->valid & ACPI_VALID_HID)) {
479 kfree(info);
480 return AE_ERROR;
481 }
482
483 hardware_id = info->hardware_id.string;
484 if ((hardware_id == NULL) ||
485 (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
486 status = AE_ERROR;
487
488 kfree(info);
489 return status;
490}
491
492static acpi_status
493acpi_memory_register_notify_handler(acpi_handle handle,
494 u32 level, void *ctxt, void **retv)
495{
496 acpi_status status;
497
498
499 status = is_memory_device(handle);
500 if (ACPI_FAILURE(status))
501 return AE_OK;
502
503 status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
504 acpi_memory_device_notify, NULL);
505
506 return AE_OK;
507}
508
509static acpi_status
510acpi_memory_deregister_notify_handler(acpi_handle handle,
511 u32 level, void *ctxt, void **retv)
512{
513 acpi_status status;
514
515
516 status = is_memory_device(handle);
517 if (ACPI_FAILURE(status))
518 return AE_OK;
519
520 status = acpi_remove_notify_handler(handle,
521 ACPI_SYSTEM_NOTIFY,
522 acpi_memory_device_notify);
523
524 return AE_OK;
525}
526
527static int __init acpi_memory_device_init(void)
528{
529 int result;
530 acpi_status status;
531
532
533 result = acpi_bus_register_driver(&acpi_memory_device_driver);
534
535 if (result < 0)
536 return -ENODEV;
537
538 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
539 ACPI_UINT32_MAX,
540 acpi_memory_register_notify_handler,
541 NULL, NULL);
542
543 if (ACPI_FAILURE(status)) {
544 ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
545 acpi_bus_unregister_driver(&acpi_memory_device_driver);
546 return -ENODEV;
547 }
548
549 acpi_hotmem_initialized = 1;
550 return 0;
551}
552
553static void __exit acpi_memory_device_exit(void)
554{
555 acpi_status status;
556
557
558
559
560
561
562 status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
563 ACPI_UINT32_MAX,
564 acpi_memory_deregister_notify_handler,
565 NULL, NULL);
566
567 if (ACPI_FAILURE(status))
568 ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
569
570 acpi_bus_unregister_driver(&acpi_memory_device_driver);
571
572 return;
573}
574
575module_init(acpi_memory_device_init);
576module_exit(acpi_memory_device_exit);
577