1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/acpi.h>
16#include <linux/memory.h>
17#include <linux/memory_hotplug.h>
18
19#include "internal.h"
20
21#define ACPI_MEMORY_DEVICE_CLASS "memory"
22#define ACPI_MEMORY_DEVICE_HID "PNP0C80"
23#define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
24
25static const struct acpi_device_id memory_device_ids[] = {
26 {ACPI_MEMORY_DEVICE_HID, 0},
27 {"", 0},
28};
29
30#ifdef CONFIG_ACPI_HOTPLUG_MEMORY
31
32static int acpi_memory_device_add(struct acpi_device *device,
33 const struct acpi_device_id *not_used);
34static void acpi_memory_device_remove(struct acpi_device *device);
35
36static struct acpi_scan_handler memory_device_handler = {
37 .ids = memory_device_ids,
38 .attach = acpi_memory_device_add,
39 .detach = acpi_memory_device_remove,
40 .hotplug = {
41 .enabled = true,
42 },
43};
44
45struct acpi_memory_info {
46 struct list_head list;
47 u64 start_addr;
48 u64 length;
49 unsigned short caching;
50 unsigned short write_protect;
51 unsigned int enabled:1;
52};
53
54struct acpi_memory_device {
55 struct acpi_device *device;
56 struct list_head res_list;
57 int mgid;
58};
59
60static acpi_status
61acpi_memory_get_resource(struct acpi_resource *resource, void *context)
62{
63 struct acpi_memory_device *mem_device = context;
64 struct acpi_resource_address64 address64;
65 struct acpi_memory_info *info, *new;
66 acpi_status status;
67
68 status = acpi_resource_to_address64(resource, &address64);
69 if (ACPI_FAILURE(status) ||
70 (address64.resource_type != ACPI_MEMORY_RANGE))
71 return AE_OK;
72
73 list_for_each_entry(info, &mem_device->res_list, list) {
74
75 if ((info->caching == address64.info.mem.caching) &&
76 (info->write_protect == address64.info.mem.write_protect) &&
77 (info->start_addr + info->length == address64.address.minimum)) {
78 info->length += address64.address.address_length;
79 return AE_OK;
80 }
81 }
82
83 new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
84 if (!new)
85 return AE_ERROR;
86
87 INIT_LIST_HEAD(&new->list);
88 new->caching = address64.info.mem.caching;
89 new->write_protect = address64.info.mem.write_protect;
90 new->start_addr = address64.address.minimum;
91 new->length = address64.address.address_length;
92 list_add_tail(&new->list, &mem_device->res_list);
93
94 return AE_OK;
95}
96
97static void
98acpi_memory_free_device_resources(struct acpi_memory_device *mem_device)
99{
100 struct acpi_memory_info *info, *n;
101
102 list_for_each_entry_safe(info, n, &mem_device->res_list, list)
103 kfree(info);
104 INIT_LIST_HEAD(&mem_device->res_list);
105}
106
107static int
108acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
109{
110 acpi_status status;
111
112 if (!list_empty(&mem_device->res_list))
113 return 0;
114
115 status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
116 acpi_memory_get_resource, mem_device);
117 if (ACPI_FAILURE(status)) {
118 acpi_memory_free_device_resources(mem_device);
119 return -EINVAL;
120 }
121
122 return 0;
123}
124
125static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
126{
127 unsigned long long current_status;
128
129
130 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle,
131 METHOD_NAME__STA, NULL,
132 ¤t_status)))
133 return -ENODEV;
134
135
136
137
138 if (!((current_status & ACPI_STA_DEVICE_PRESENT)
139 && (current_status & ACPI_STA_DEVICE_ENABLED)
140 && (current_status & ACPI_STA_DEVICE_FUNCTIONING)))
141 return -ENODEV;
142
143 return 0;
144}
145
146static int acpi_bind_memblk(struct memory_block *mem, void *arg)
147{
148 return acpi_bind_one(&mem->dev, arg);
149}
150
151static int acpi_bind_memory_blocks(struct acpi_memory_info *info,
152 struct acpi_device *adev)
153{
154 return walk_memory_blocks(info->start_addr, info->length, adev,
155 acpi_bind_memblk);
156}
157
158static int acpi_unbind_memblk(struct memory_block *mem, void *arg)
159{
160 acpi_unbind_one(&mem->dev);
161 return 0;
162}
163
164static void acpi_unbind_memory_blocks(struct acpi_memory_info *info)
165{
166 walk_memory_blocks(info->start_addr, info->length, NULL,
167 acpi_unbind_memblk);
168}
169
170static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
171{
172 acpi_handle handle = mem_device->device->handle;
173 mhp_t mhp_flags = MHP_NID_IS_MGID;
174 int result, num_enabled = 0;
175 struct acpi_memory_info *info;
176 u64 total_length = 0;
177 int node, mgid;
178
179 node = acpi_get_node(handle);
180
181 list_for_each_entry(info, &mem_device->res_list, list) {
182 if (!info->length)
183 continue;
184
185 if (node < 0)
186 node = memory_add_physaddr_to_nid(info->start_addr);
187 total_length += info->length;
188 }
189
190 if (!total_length) {
191 dev_err(&mem_device->device->dev, "device is empty\n");
192 return -EINVAL;
193 }
194
195 mgid = memory_group_register_static(node, PFN_UP(total_length));
196 if (mgid < 0)
197 return mgid;
198 mem_device->mgid = mgid;
199
200
201
202
203
204
205
206 list_for_each_entry(info, &mem_device->res_list, list) {
207
208
209
210
211 if (!info->length)
212 continue;
213
214 if (mhp_supports_memmap_on_memory(info->length))
215 mhp_flags |= MHP_MEMMAP_ON_MEMORY;
216 result = __add_memory(mgid, info->start_addr, info->length,
217 mhp_flags);
218
219
220
221
222
223
224 if (result && result != -EEXIST)
225 continue;
226
227 result = acpi_bind_memory_blocks(info, mem_device->device);
228 if (result) {
229 acpi_unbind_memory_blocks(info);
230 return -ENODEV;
231 }
232
233 info->enabled = 1;
234
235
236
237
238
239 num_enabled++;
240 }
241 if (!num_enabled) {
242 dev_err(&mem_device->device->dev, "add_memory failed\n");
243 return -EINVAL;
244 }
245
246
247
248
249
250
251
252
253 return 0;
254}
255
256static void acpi_memory_remove_memory(struct acpi_memory_device *mem_device)
257{
258 struct acpi_memory_info *info, *n;
259
260 list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
261 if (!info->enabled)
262 continue;
263
264 acpi_unbind_memory_blocks(info);
265 __remove_memory(info->start_addr, info->length);
266 list_del(&info->list);
267 kfree(info);
268 }
269}
270
271static void acpi_memory_device_free(struct acpi_memory_device *mem_device)
272{
273 if (!mem_device)
274 return;
275
276
277 if (mem_device->mgid >= 0)
278 memory_group_unregister(mem_device->mgid);
279
280 acpi_memory_free_device_resources(mem_device);
281 mem_device->device->driver_data = NULL;
282 kfree(mem_device);
283}
284
285static int acpi_memory_device_add(struct acpi_device *device,
286 const struct acpi_device_id *not_used)
287{
288 struct acpi_memory_device *mem_device;
289 int result;
290
291 if (!device)
292 return -EINVAL;
293
294 mem_device = kzalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
295 if (!mem_device)
296 return -ENOMEM;
297
298 INIT_LIST_HEAD(&mem_device->res_list);
299 mem_device->device = device;
300 mem_device->mgid = -1;
301 sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
302 sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
303 device->driver_data = mem_device;
304
305
306 result = acpi_memory_get_device_resources(mem_device);
307 if (result) {
308 device->driver_data = NULL;
309 kfree(mem_device);
310 return result;
311 }
312
313 result = acpi_memory_check_device(mem_device);
314 if (result) {
315 acpi_memory_device_free(mem_device);
316 return 0;
317 }
318
319 result = acpi_memory_enable_device(mem_device);
320 if (result) {
321 dev_err(&device->dev, "acpi_memory_enable_device() error\n");
322 acpi_memory_device_free(mem_device);
323 return result;
324 }
325
326 dev_dbg(&device->dev, "Memory device configured by ACPI\n");
327 return 1;
328}
329
330static void acpi_memory_device_remove(struct acpi_device *device)
331{
332 struct acpi_memory_device *mem_device;
333
334 if (!device || !acpi_driver_data(device))
335 return;
336
337 mem_device = acpi_driver_data(device);
338 acpi_memory_remove_memory(mem_device);
339 acpi_memory_device_free(mem_device);
340}
341
342static bool __initdata acpi_no_memhotplug;
343
344void __init acpi_memory_hotplug_init(void)
345{
346 if (acpi_no_memhotplug) {
347 memory_device_handler.attach = NULL;
348 acpi_scan_add_handler(&memory_device_handler);
349 return;
350 }
351 acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");
352}
353
354static int __init disable_acpi_memory_hotplug(char *str)
355{
356 acpi_no_memhotplug = true;
357 return 1;
358}
359__setup("acpi_no_memhotplug", disable_acpi_memory_hotplug);
360
361#else
362
363static struct acpi_scan_handler memory_device_handler = {
364 .ids = memory_device_ids,
365};
366
367void __init acpi_memory_hotplug_init(void)
368{
369 acpi_scan_add_handler(&memory_device_handler);
370}
371
372#endif
373