acpi_memhotplug.c 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  1. /*
  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>
  5. *
  6. * All rights reserved.
  7. *
  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.
  12. *
  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
  17. * details.
  18. *
  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.
  22. *
  23. *
  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
  27. * ranges.
  28. */
  29. #include <linux/acpi.h>
  30. #include <linux/memory_hotplug.h>
  31. #include "internal.h"
  32. #define ACPI_MEMORY_DEVICE_CLASS "memory"
  33. #define ACPI_MEMORY_DEVICE_HID "PNP0C80"
  34. #define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
  35. #define _COMPONENT ACPI_MEMORY_DEVICE_COMPONENT
  36. #undef PREFIX
  37. #define PREFIX "ACPI:memory_hp:"
  38. ACPI_MODULE_NAME("acpi_memhotplug");
  39. /* Memory Device States */
  40. #define MEMORY_INVALID_STATE 0
  41. #define MEMORY_POWER_ON_STATE 1
  42. #define MEMORY_POWER_OFF_STATE 2
  43. static int acpi_memory_device_add(struct acpi_device *device,
  44. const struct acpi_device_id *not_used);
  45. static void acpi_memory_device_remove(struct acpi_device *device);
  46. static const struct acpi_device_id memory_device_ids[] = {
  47. {ACPI_MEMORY_DEVICE_HID, 0},
  48. {"", 0},
  49. };
  50. static struct acpi_scan_handler memory_device_handler = {
  51. .ids = memory_device_ids,
  52. .attach = acpi_memory_device_add,
  53. .detach = acpi_memory_device_remove,
  54. .hotplug = {
  55. .enabled = true,
  56. },
  57. };
  58. struct acpi_memory_info {
  59. struct list_head list;
  60. u64 start_addr; /* Memory Range start physical addr */
  61. u64 length; /* Memory Range length */
  62. unsigned short caching; /* memory cache attribute */
  63. unsigned short write_protect; /* memory read/write attribute */
  64. unsigned int enabled:1;
  65. };
  66. struct acpi_memory_device {
  67. struct acpi_device * device;
  68. unsigned int state; /* State of the memory device */
  69. struct list_head res_list;
  70. };
  71. static acpi_status
  72. acpi_memory_get_resource(struct acpi_resource *resource, void *context)
  73. {
  74. struct acpi_memory_device *mem_device = context;
  75. struct acpi_resource_address64 address64;
  76. struct acpi_memory_info *info, *new;
  77. acpi_status status;
  78. status = acpi_resource_to_address64(resource, &address64);
  79. if (ACPI_FAILURE(status) ||
  80. (address64.resource_type != ACPI_MEMORY_RANGE))
  81. return AE_OK;
  82. list_for_each_entry(info, &mem_device->res_list, list) {
  83. /* Can we combine the resource range information? */
  84. if ((info->caching == address64.info.mem.caching) &&
  85. (info->write_protect == address64.info.mem.write_protect) &&
  86. (info->start_addr + info->length == address64.minimum)) {
  87. info->length += address64.address_length;
  88. return AE_OK;
  89. }
  90. }
  91. new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
  92. if (!new)
  93. return AE_ERROR;
  94. INIT_LIST_HEAD(&new->list);
  95. new->caching = address64.info.mem.caching;
  96. new->write_protect = address64.info.mem.write_protect;
  97. new->start_addr = address64.minimum;
  98. new->length = address64.address_length;
  99. list_add_tail(&new->list, &mem_device->res_list);
  100. return AE_OK;
  101. }
  102. static void
  103. acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
  104. {
  105. struct acpi_memory_info *info, *n;
  106. list_for_each_entry_safe(info, n, &mem_device->res_list, list)
  107. kfree(info);
  108. INIT_LIST_HEAD(&mem_device->res_list);
  109. }
  110. static int
  111. acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
  112. {
  113. acpi_status status;
  114. if (!list_empty(&mem_device->res_list))
  115. return 0;
  116. status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
  117. acpi_memory_get_resource, mem_device);
  118. if (ACPI_FAILURE(status)) {
  119. acpi_memory_free_device_resources(mem_device);
  120. return -EINVAL;
  121. }
  122. return 0;
  123. }
  124. static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
  125. {
  126. unsigned long long current_status;
  127. /* Get device present/absent information from the _STA */
  128. if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
  129. NULL, &current_status)))
  130. return -ENODEV;
  131. /*
  132. * Check for device status. Device should be
  133. * present/enabled/functioning.
  134. */
  135. if (!((current_status & ACPI_STA_DEVICE_PRESENT)
  136. && (current_status & ACPI_STA_DEVICE_ENABLED)
  137. && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
  138. return -ENODEV;
  139. return 0;
  140. }
  141. static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
  142. {
  143. int result, num_enabled = 0;
  144. struct acpi_memory_info *info;
  145. int node;
  146. node = acpi_get_node(mem_device->device->handle);
  147. /*
  148. * Tell the VM there is more memory here...
  149. * Note: Assume that this function returns zero on success
  150. * We don't have memory-hot-add rollback function,now.
  151. * (i.e. memory-hot-remove function)
  152. */
  153. list_for_each_entry(info, &mem_device->res_list, list) {
  154. if (info->enabled) { /* just sanity check...*/
  155. num_enabled++;
  156. continue;
  157. }
  158. /*
  159. * If the memory block size is zero, please ignore it.
  160. * Don't try to do the following memory hotplug flowchart.
  161. */
  162. if (!info->length)
  163. continue;
  164. if (node < 0)
  165. node = memory_add_physaddr_to_nid(info->start_addr);
  166. result = add_memory(node, info->start_addr, info->length);
  167. /*
  168. * If the memory block has been used by the kernel, add_memory()
  169. * returns -EEXIST. If add_memory() returns the other error, it
  170. * means that this memory block is not used by the kernel.
  171. */
  172. if (result && result != -EEXIST)
  173. continue;
  174. info->enabled = 1;
  175. /*
  176. * Add num_enable even if add_memory() returns -EEXIST, so the
  177. * device is bound to this driver.
  178. */
  179. num_enabled++;
  180. }
  181. if (!num_enabled) {
  182. dev_err(&mem_device->device->dev, "add_memory failed\n");
  183. mem_device->state = MEMORY_INVALID_STATE;
  184. return -EINVAL;
  185. }
  186. /*
  187. * Sometimes the memory device will contain several memory blocks.
  188. * When one memory block is hot-added to the system memory, it will
  189. * be regarded as a success.
  190. * Otherwise if the last memory block can't be hot-added to the system
  191. * memory, it will be failure and the memory device can't be bound with
  192. * driver.
  193. */
  194. return 0;
  195. }
  196. static int acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
  197. {
  198. int result = 0, nid;
  199. struct acpi_memory_info *info, *n;
  200. nid = acpi_get_node(mem_device->device->handle);
  201. list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
  202. if (!info->enabled)
  203. continue;
  204. if (nid < 0)
  205. nid = memory_add_physaddr_to_nid(info->start_addr);
  206. result = remove_memory(nid, info->start_addr, info->length);
  207. if (result)
  208. return result;
  209. list_del(&info->list);
  210. kfree(info);
  211. }
  212. return result;
  213. }
  214. static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
  215. {
  216. if (!mem_device)
  217. return;
  218. acpi_memory_free_device_resources(mem_device);
  219. mem_device->device->driver_data = NULL;
  220. kfree(mem_device);
  221. }
  222. static int acpi_memory_device_add(struct acpi_device *device,
  223. const struct acpi_device_id *not_used)
  224. {
  225. struct acpi_memory_device *mem_device;
  226. int result;
  227. if (!device)
  228. return -EINVAL;
  229. mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
  230. if (!mem_device)
  231. return -ENOMEM;
  232. INIT_LIST_HEAD(&mem_device->res_list);
  233. mem_device->device = device;
  234. sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
  235. sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
  236. device->driver_data = mem_device;
  237. /* Get the range from the _CRS */
  238. result = acpi_memory_get_device_resources(mem_device);
  239. if (result) {
  240. kfree(mem_device);
  241. return result;
  242. }
  243. /* Set the device state */
  244. mem_device->state = MEMORY_POWER_ON_STATE;
  245. result = acpi_memory_check_device(mem_device);
  246. if (result) {
  247. acpi_memory_device_free(mem_device);
  248. return 0;
  249. }
  250. result = acpi_memory_enable_device(mem_device);
  251. if (result) {
  252. dev_err(&device->dev, "acpi_memory_enable_device() error\n");
  253. acpi_memory_device_free(mem_device);
  254. return -ENODEV;
  255. }
  256. dev_dbg(&device->dev, "Memory device configured by ACPI\n");
  257. return 1;
  258. }
  259. static void acpi_memory_device_remove(struct acpi_device *device)
  260. {
  261. struct acpi_memory_device *mem_device;
  262. if (!device || !acpi_driver_data(device))
  263. return;
  264. mem_device = acpi_driver_data(device);
  265. acpi_memory_remove_memory(mem_device);
  266. acpi_memory_device_free(mem_device);
  267. }
  268. void __init acpi_memory_hotplug_init(void)
  269. {
  270. acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");
  271. }