blob: 999adb5499c7270626466a7d74870531c3e3ae28 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Rafael J. Wysocki0a347642013-03-03 23:18:03 +01002 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
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
Nick Andrewc7060d92009-01-03 18:53:39 +110025 * This driver fields notifications from firmware for memory add
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 * and remove operations and alerts the VM of the affected memory
27 * ranges.
28 */
29
Toshi Kaniab6c5702012-11-20 23:42:28 +000030#include <linux/acpi.h>
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +020031#include <linux/memory.h>
Rafael J. Wysocki0a347642013-03-03 23:18:03 +010032#include <linux/memory_hotplug.h>
33
34#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#define ACPI_MEMORY_DEVICE_CLASS "memory"
37#define ACPI_MEMORY_DEVICE_HID "PNP0C80"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
39
40#define _COMPONENT ACPI_MEMORY_DEVICE_COMPONENT
41
Zhao Yakuiaa7b2b22009-07-03 10:49:03 +080042#undef PREFIX
43#define PREFIX "ACPI:memory_hp:"
44
Len Brownf52fd662007-02-12 22:42:12 -050045ACPI_MODULE_NAME("acpi_memhotplug");
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047/* Memory Device States */
48#define MEMORY_INVALID_STATE 0
49#define MEMORY_POWER_ON_STATE 1
50#define MEMORY_POWER_OFF_STATE 2
51
Rafael J. Wysocki0a347642013-03-03 23:18:03 +010052static int acpi_memory_device_add(struct acpi_device *device,
53 const struct acpi_device_id *not_used);
54static void acpi_memory_device_remove(struct acpi_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Thomas Renninger1ba90e32007-07-23 14:44:41 +020056static const struct acpi_device_id memory_device_ids[] = {
57 {ACPI_MEMORY_DEVICE_HID, 0},
58 {"", 0},
59};
Thomas Renninger1ba90e32007-07-23 14:44:41 +020060
Rafael J. Wysocki0a347642013-03-03 23:18:03 +010061static struct acpi_scan_handler memory_device_handler = {
Thomas Renninger1ba90e32007-07-23 14:44:41 +020062 .ids = memory_device_ids,
Rafael J. Wysocki0a347642013-03-03 23:18:03 +010063 .attach = acpi_memory_device_add,
64 .detach = acpi_memory_device_remove,
65 .hotplug = {
66 .enabled = true,
67 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070068};
69
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070070struct acpi_memory_info {
71 struct list_head list;
72 u64 start_addr; /* Memory Range start physical addr */
73 u64 length; /* Memory Range length */
74 unsigned short caching; /* memory cache attribute */
75 unsigned short write_protect; /* memory read/write attribute */
76 unsigned int enabled:1;
77};
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079struct acpi_memory_device {
Patrick Mochel3b748632006-05-19 16:54:38 -040080 struct acpi_device * device;
Len Brown4be44fc2005-08-05 00:44:28 -040081 unsigned int state; /* State of the memory device */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070082 struct list_head res_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083};
84
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070085static acpi_status
86acpi_memory_get_resource(struct acpi_resource *resource, void *context)
87{
88 struct acpi_memory_device *mem_device = context;
89 struct acpi_resource_address64 address64;
90 struct acpi_memory_info *info, *new;
91 acpi_status status;
92
93 status = acpi_resource_to_address64(resource, &address64);
94 if (ACPI_FAILURE(status) ||
95 (address64.resource_type != ACPI_MEMORY_RANGE))
96 return AE_OK;
97
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;
104 return AE_OK;
105 }
106 }
107
108 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
109 if (!new)
110 return AE_ERROR;
111
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);
118
119 return AE_OK;
120}
121
Wen Congyang386e52b2012-11-16 02:06:06 +0100122static void
123acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
124{
125 struct acpi_memory_info *info, *n;
126
127 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
128 kfree(info);
129 INIT_LIST_HEAD(&mem_device->res_list);
130}
131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132static int
133acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
134{
135 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
KAMEZAWA Hiroyuki5d2870f2006-08-05 12:15:04 -0700137 if (!list_empty(&mem_device->res_list))
138 return 0;
139
Patrick Mochelb8632782006-05-19 16:54:41 -0400140 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700141 acpi_memory_get_resource, mem_device);
142 if (ACPI_FAILURE(status)) {
Wen Congyang386e52b2012-11-16 02:06:06 +0100143 acpi_memory_free_device_resources(mem_device);
Patrick Mocheld550d982006-06-27 00:41:40 -0400144 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 }
146
Patrick Mocheld550d982006-06-27 00:41:40 -0400147 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
Len Brown4be44fc2005-08-05 00:44:28 -0400150static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Matthew Wilcox27663c52008-10-10 02:22:59 -0400152 unsigned long long current_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 /* Get device present/absent information from the _STA */
Patrick Mochelb8632782006-05-19 16:54:41 -0400155 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
Len Brown4be44fc2005-08-05 00:44:28 -0400156 NULL, &current_status)))
Patrick Mocheld550d982006-06-27 00:41:40 -0400157 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 /*
159 * Check for device status. Device should be
160 * present/enabled/functioning.
161 */
Bjorn Helgaasa0bd4ac2007-04-25 14:17:39 -0400162 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
163 && (current_status & ACPI_STA_DEVICE_ENABLED)
164 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
Patrick Mocheld550d982006-06-27 00:41:40 -0400165 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Patrick Mocheld550d982006-06-27 00:41:40 -0400167 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168}
169
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +0200170static unsigned long acpi_meminfo_start_pfn(struct acpi_memory_info *info)
171{
172 return PFN_DOWN(info->start_addr);
173}
174
175static unsigned long acpi_meminfo_end_pfn(struct acpi_memory_info *info)
176{
177 return PFN_UP(info->start_addr + info->length-1);
178}
179
180static int acpi_bind_memblk(struct memory_block *mem, void *arg)
181{
182 return acpi_bind_one(&mem->dev, (acpi_handle)arg);
183}
184
185static int acpi_bind_memory_blocks(struct acpi_memory_info *info,
186 acpi_handle handle)
187{
188 return walk_memory_range(acpi_meminfo_start_pfn(info),
189 acpi_meminfo_end_pfn(info), (void *)handle,
190 acpi_bind_memblk);
191}
192
193static int acpi_unbind_memblk(struct memory_block *mem, void *arg)
194{
195 acpi_unbind_one(&mem->dev);
196 return 0;
197}
198
199static void acpi_unbind_memory_blocks(struct acpi_memory_info *info,
200 acpi_handle handle)
201{
202 walk_memory_range(acpi_meminfo_start_pfn(info),
203 acpi_meminfo_end_pfn(info), NULL, acpi_unbind_memblk);
204}
205
Len Brown4be44fc2005-08-05 00:44:28 -0400206static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +0200208 acpi_handle handle = mem_device->device->handle;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700209 int result, num_enabled = 0;
210 struct acpi_memory_info *info;
Yasunori Goto1e3590e2006-06-27 02:53:31 -0700211 int node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +0200213 node = acpi_get_node(handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 /*
215 * Tell the VM there is more memory here...
216 * Note: Assume that this function returns zero on success
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700217 * We don't have memory-hot-add rollback function,now.
218 * (i.e. memory-hot-remove function)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700220 list_for_each_entry(info, &mem_device->res_list, list) {
KAMEZAWA Hiroyukifa25d8d2006-08-05 12:15:02 -0700221 if (info->enabled) { /* just sanity check...*/
Yasunori Gotodd56a8e2006-06-27 02:53:29 -0700222 num_enabled++;
223 continue;
224 }
Zhao Yakui5d2619f2009-07-07 10:56:11 +0800225 /*
226 * If the memory block size is zero, please ignore it.
227 * Don't try to do the following memory hotplug flowchart.
228 */
229 if (!info->length)
230 continue;
Keith Mannthey8c2676a2006-09-30 23:27:07 -0700231 if (node < 0)
232 node = memory_add_physaddr_to_nid(info->start_addr);
233
Yasunori Gotobc02af92006-06-27 02:53:30 -0700234 result = add_memory(node, info->start_addr, info->length);
Wen Congyang65479472012-11-16 02:10:37 +0100235
236 /*
237 * If the memory block has been used by the kernel, add_memory()
238 * returns -EEXIST. If add_memory() returns the other error, it
239 * means that this memory block is not used by the kernel.
240 */
Yasuaki Ishimatsufd4655c2013-03-22 01:53:49 +0000241 if (result && result != -EEXIST)
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700242 continue;
Wen Congyang65479472012-11-16 02:10:37 +0100243
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +0200244 result = acpi_bind_memory_blocks(info, handle);
245 if (result) {
246 acpi_unbind_memory_blocks(info, handle);
247 return -ENODEV;
248 }
249
Yasuaki Ishimatsubb49d822013-03-21 04:36:12 +0000250 info->enabled = 1;
251
Wen Congyang65479472012-11-16 02:10:37 +0100252 /*
253 * Add num_enable even if add_memory() returns -EEXIST, so the
254 * device is bound to this driver.
255 */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700256 num_enabled++;
257 }
258 if (!num_enabled) {
Toshi Kaniab6c5702012-11-20 23:42:28 +0000259 dev_err(&mem_device->device->dev, "add_memory failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 mem_device->state = MEMORY_INVALID_STATE;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700261 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
Zhao Yakui5d2619f2009-07-07 10:56:11 +0800263 /*
264 * Sometimes the memory device will contain several memory blocks.
265 * When one memory block is hot-added to the system memory, it will
266 * be regarded as a success.
267 * Otherwise if the last memory block can't be hot-added to the system
268 * memory, it will be failure and the memory device can't be bound with
269 * driver.
270 */
271 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272}
273
Rafael J. Wysocki242831e2013-05-27 12:58:46 +0200274static void acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +0200276 acpi_handle handle = mem_device->device->handle;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700277 struct acpi_memory_info *info, *n;
Rafael J. Wysocki242831e2013-05-27 12:58:46 +0200278 int nid = acpi_get_node(handle);
Tang Chen60a5a192013-02-22 16:33:14 -0800279
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700280 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
Wen Congyang65479472012-11-16 02:10:37 +0100281 if (!info->enabled)
Yasuaki Ishimatsufd4655c2013-03-22 01:53:49 +0000282 continue;
Wen Congyang65479472012-11-16 02:10:37 +0100283
Tang Chen60a5a192013-02-22 16:33:14 -0800284 if (nid < 0)
285 nid = memory_add_physaddr_to_nid(info->start_addr);
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +0200286
287 acpi_unbind_memory_blocks(info, handle);
Rafael J. Wysocki242831e2013-05-27 12:58:46 +0200288 remove_memory(nid, info->start_addr, info->length);
Yasuaki Ishimatsu19387b22012-11-15 06:59:31 +0000289 list_del(&info->list);
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700290 kfree(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 }
Yasuaki Ishimatsu19387b22012-11-15 06:59:31 +0000292}
293
Wen Congyang386e52b2012-11-16 02:06:06 +0100294static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
295{
296 if (!mem_device)
297 return;
298
299 acpi_memory_free_device_resources(mem_device);
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100300 mem_device->device->driver_data = NULL;
Wen Congyang386e52b2012-11-16 02:06:06 +0100301 kfree(mem_device);
302}
303
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100304static int acpi_memory_device_add(struct acpi_device *device,
305 const struct acpi_device_id *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306{
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100307 struct acpi_memory_device *mem_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
310 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400311 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
Burman Yan36bcbec2006-12-19 12:56:11 -0800313 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 if (!mem_device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400315 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700317 INIT_LIST_HEAD(&mem_device->res_list);
Patrick Mochel3b748632006-05-19 16:54:38 -0400318 mem_device->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
320 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700321 device->driver_data = mem_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
323 /* Get the range from the _CRS */
324 result = acpi_memory_get_device_resources(mem_device);
325 if (result) {
Toshi Kanid19f5032013-07-10 10:47:13 -0600326 device->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 kfree(mem_device);
Patrick Mocheld550d982006-06-27 00:41:40 -0400328 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 }
330
331 /* Set the device state */
332 mem_device->state = MEMORY_POWER_ON_STATE;
333
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100334 result = acpi_memory_check_device(mem_device);
335 if (result) {
336 acpi_memory_device_free(mem_device);
337 return 0;
Bjorn Helgaas80f20fe2009-06-22 20:41:25 +0000338 }
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100339
340 result = acpi_memory_enable_device(mem_device);
341 if (result) {
342 dev_err(&device->dev, "acpi_memory_enable_device() error\n");
343 acpi_memory_device_free(mem_device);
Rafael J. Wysockie2ff3942013-05-08 00:29:49 +0200344 return result;
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100345 }
346
347 dev_dbg(&device->dev, "Memory device configured by ACPI\n");
348 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100351static void acpi_memory_device_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100353 struct acpi_memory_device *mem_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355 if (!device || !acpi_driver_data(device))
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100356 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200358 mem_device = acpi_driver_data(device);
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100359 acpi_memory_remove_memory(mem_device);
Wen Congyang386e52b2012-11-16 02:06:06 +0100360 acpi_memory_device_free(mem_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100363void __init acpi_memory_hotplug_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364{
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100365 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366}