blob: 5e6301e949206adb9f9b512a4b44b9d093e588df [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. Wysocki0a347642013-03-03 23:18:03 +010031#include <linux/memory_hotplug.h>
32
33#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
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
Zhao Yakuiaa7b2b22009-07-03 10:49:03 +080041#undef PREFIX
42#define PREFIX "ACPI:memory_hp:"
43
Len Brownf52fd662007-02-12 22:42:12 -050044ACPI_MODULE_NAME("acpi_memhotplug");
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
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
Rafael J. Wysocki0a347642013-03-03 23:18:03 +010051static int acpi_memory_device_add(struct acpi_device *device,
52 const struct acpi_device_id *not_used);
53static void acpi_memory_device_remove(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};
Thomas Renninger1ba90e32007-07-23 14:44:41 +020059
Rafael J. Wysocki0a347642013-03-03 23:18:03 +010060static struct acpi_scan_handler memory_device_handler = {
Thomas Renninger1ba90e32007-07-23 14:44:41 +020061 .ids = memory_device_ids,
Rafael J. Wysocki0a347642013-03-03 23:18:03 +010062 .attach = acpi_memory_device_add,
63 .detach = acpi_memory_device_remove,
64 .hotplug = {
65 .enabled = true,
66 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070067};
68
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070069struct acpi_memory_info {
70 struct list_head list;
71 u64 start_addr; /* Memory Range start physical addr */
72 u64 length; /* Memory Range length */
73 unsigned short caching; /* memory cache attribute */
74 unsigned short write_protect; /* memory read/write attribute */
75 unsigned int enabled:1;
76};
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078struct acpi_memory_device {
Patrick Mochel3b748632006-05-19 16:54:38 -040079 struct acpi_device * device;
Len Brown4be44fc2005-08-05 00:44:28 -040080 unsigned int state; /* State of the memory device */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070081 struct list_head res_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082};
83
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -070084static acpi_status
85acpi_memory_get_resource(struct acpi_resource *resource, void *context)
86{
87 struct acpi_memory_device *mem_device = context;
88 struct acpi_resource_address64 address64;
89 struct acpi_memory_info *info, *new;
90 acpi_status status;
91
92 status = acpi_resource_to_address64(resource, &address64);
93 if (ACPI_FAILURE(status) ||
94 (address64.resource_type != ACPI_MEMORY_RANGE))
95 return AE_OK;
96
97 list_for_each_entry(info, &mem_device->res_list, list) {
98 /* Can we combine the resource range information? */
99 if ((info->caching == address64.info.mem.caching) &&
100 (info->write_protect == address64.info.mem.write_protect) &&
101 (info->start_addr + info->length == address64.minimum)) {
102 info->length += address64.address_length;
103 return AE_OK;
104 }
105 }
106
107 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
108 if (!new)
109 return AE_ERROR;
110
111 INIT_LIST_HEAD(&new->list);
112 new->caching = address64.info.mem.caching;
113 new->write_protect = address64.info.mem.write_protect;
114 new->start_addr = address64.minimum;
115 new->length = address64.address_length;
116 list_add_tail(&new->list, &mem_device->res_list);
117
118 return AE_OK;
119}
120
Wen Congyang386e52b2012-11-16 02:06:06 +0100121static void
122acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
123{
124 struct acpi_memory_info *info, *n;
125
126 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
127 kfree(info);
128 INIT_LIST_HEAD(&mem_device->res_list);
129}
130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131static int
132acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
133{
134 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
KAMEZAWA Hiroyuki5d2870f2006-08-05 12:15:04 -0700136 if (!list_empty(&mem_device->res_list))
137 return 0;
138
Patrick Mochelb8632782006-05-19 16:54:41 -0400139 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700140 acpi_memory_get_resource, mem_device);
141 if (ACPI_FAILURE(status)) {
Wen Congyang386e52b2012-11-16 02:06:06 +0100142 acpi_memory_free_device_resources(mem_device);
Patrick Mocheld550d982006-06-27 00:41:40 -0400143 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 }
145
Patrick Mocheld550d982006-06-27 00:41:40 -0400146 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
Len Brown4be44fc2005-08-05 00:44:28 -0400149static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
Matthew Wilcox27663c52008-10-10 02:22:59 -0400151 unsigned long long current_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 /* Get device present/absent information from the _STA */
Patrick Mochelb8632782006-05-19 16:54:41 -0400154 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
Len Brown4be44fc2005-08-05 00:44:28 -0400155 NULL, &current_status)))
Patrick Mocheld550d982006-06-27 00:41:40 -0400156 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 /*
158 * Check for device status. Device should be
159 * present/enabled/functioning.
160 */
Bjorn Helgaasa0bd4ac2007-04-25 14:17:39 -0400161 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
162 && (current_status & ACPI_STA_DEVICE_ENABLED)
163 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
Patrick Mocheld550d982006-06-27 00:41:40 -0400164 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Patrick Mocheld550d982006-06-27 00:41:40 -0400166 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Len Brown4be44fc2005-08-05 00:44:28 -0400169static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700171 int result, num_enabled = 0;
172 struct acpi_memory_info *info;
Yasunori Goto1e3590e2006-06-27 02:53:31 -0700173 int node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
Patrick Mochelb8632782006-05-19 16:54:41 -0400175 node = acpi_get_node(mem_device->device->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 /*
177 * Tell the VM there is more memory here...
178 * Note: Assume that this function returns zero on success
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700179 * We don't have memory-hot-add rollback function,now.
180 * (i.e. memory-hot-remove function)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700182 list_for_each_entry(info, &mem_device->res_list, list) {
KAMEZAWA Hiroyukifa25d8d2006-08-05 12:15:02 -0700183 if (info->enabled) { /* just sanity check...*/
Yasunori Gotodd56a8e2006-06-27 02:53:29 -0700184 num_enabled++;
185 continue;
186 }
Zhao Yakui5d2619f2009-07-07 10:56:11 +0800187 /*
188 * If the memory block size is zero, please ignore it.
189 * Don't try to do the following memory hotplug flowchart.
190 */
191 if (!info->length)
192 continue;
Keith Mannthey8c2676a2006-09-30 23:27:07 -0700193 if (node < 0)
194 node = memory_add_physaddr_to_nid(info->start_addr);
195
Yasunori Gotobc02af92006-06-27 02:53:30 -0700196 result = add_memory(node, info->start_addr, info->length);
Wen Congyang65479472012-11-16 02:10:37 +0100197
198 /*
199 * If the memory block has been used by the kernel, add_memory()
200 * returns -EEXIST. If add_memory() returns the other error, it
201 * means that this memory block is not used by the kernel.
202 */
Yasuaki Ishimatsufd4655c2013-03-22 01:53:49 +0000203 if (result && result != -EEXIST)
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700204 continue;
Wen Congyang65479472012-11-16 02:10:37 +0100205
Yasuaki Ishimatsubb49d822013-03-21 04:36:12 +0000206 info->enabled = 1;
207
Wen Congyang65479472012-11-16 02:10:37 +0100208 /*
209 * Add num_enable even if add_memory() returns -EEXIST, so the
210 * device is bound to this driver.
211 */
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700212 num_enabled++;
213 }
214 if (!num_enabled) {
Toshi Kaniab6c5702012-11-20 23:42:28 +0000215 dev_err(&mem_device->device->dev, "add_memory failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 mem_device->state = MEMORY_INVALID_STATE;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700217 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 }
Zhao Yakui5d2619f2009-07-07 10:56:11 +0800219 /*
220 * Sometimes the memory device will contain several memory blocks.
221 * When one memory block is hot-added to the system memory, it will
222 * be regarded as a success.
223 * Otherwise if the last memory block can't be hot-added to the system
224 * memory, it will be failure and the memory device can't be bound with
225 * driver.
226 */
227 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228}
229
Yasuaki Ishimatsu19387b22012-11-15 06:59:31 +0000230static int acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
Tang Chen60a5a192013-02-22 16:33:14 -0800232 int result = 0, nid;
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700233 struct acpi_memory_info *info, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Tang Chen60a5a192013-02-22 16:33:14 -0800235 nid = acpi_get_node(mem_device->device->handle);
236
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700237 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
Wen Congyang65479472012-11-16 02:10:37 +0100238 if (!info->enabled)
Yasuaki Ishimatsufd4655c2013-03-22 01:53:49 +0000239 continue;
Wen Congyang65479472012-11-16 02:10:37 +0100240
Tang Chen60a5a192013-02-22 16:33:14 -0800241 if (nid < 0)
242 nid = memory_add_physaddr_to_nid(info->start_addr);
243 result = remove_memory(nid, info->start_addr, info->length);
Wen Congyang65479472012-11-16 02:10:37 +0100244 if (result)
245 return result;
Yasuaki Ishimatsu19387b22012-11-15 06:59:31 +0000246
247 list_del(&info->list);
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700248 kfree(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 }
250
Wen Congyang65479472012-11-16 02:10:37 +0100251 return result;
Yasuaki Ishimatsu19387b22012-11-15 06:59:31 +0000252}
253
Wen Congyang386e52b2012-11-16 02:06:06 +0100254static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
255{
256 if (!mem_device)
257 return;
258
259 acpi_memory_free_device_resources(mem_device);
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100260 mem_device->device->driver_data = NULL;
Wen Congyang386e52b2012-11-16 02:06:06 +0100261 kfree(mem_device);
262}
263
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100264static int acpi_memory_device_add(struct acpi_device *device,
265 const struct acpi_device_id *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100267 struct acpi_memory_device *mem_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400271 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Burman Yan36bcbec2006-12-19 12:56:11 -0800273 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 if (!mem_device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400275 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
KAMEZAWA Hiroyuki9ac02392006-06-27 02:53:27 -0700277 INIT_LIST_HEAD(&mem_device->res_list);
Patrick Mochel3b748632006-05-19 16:54:38 -0400278 mem_device->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
280 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700281 device->driver_data = mem_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
283 /* Get the range from the _CRS */
284 result = acpi_memory_get_device_resources(mem_device);
285 if (result) {
286 kfree(mem_device);
Patrick Mocheld550d982006-06-27 00:41:40 -0400287 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 }
289
290 /* Set the device state */
291 mem_device->state = MEMORY_POWER_ON_STATE;
292
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100293 result = acpi_memory_check_device(mem_device);
294 if (result) {
295 acpi_memory_device_free(mem_device);
296 return 0;
Bjorn Helgaas80f20fe2009-06-22 20:41:25 +0000297 }
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100298
299 result = acpi_memory_enable_device(mem_device);
300 if (result) {
301 dev_err(&device->dev, "acpi_memory_enable_device() error\n");
302 acpi_memory_device_free(mem_device);
303 return -ENODEV;
304 }
305
306 dev_dbg(&device->dev, "Memory device configured by ACPI\n");
307 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308}
309
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100310static void acpi_memory_device_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100312 struct acpi_memory_device *mem_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
314 if (!device || !acpi_driver_data(device))
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100315 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200317 mem_device = acpi_driver_data(device);
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100318 acpi_memory_remove_memory(mem_device);
Wen Congyang386e52b2012-11-16 02:06:06 +0100319 acpi_memory_device_free(mem_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320}
321
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100322void __init acpi_memory_hotplug_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Rafael J. Wysocki0a347642013-03-03 23:18:03 +0100324 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}