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