1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2004, 2013 Intel Corporation
4 * Author: Naveen B S <naveen.b.s@intel.com>
5 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
6 *
7 * All rights reserved.
8 *
9 * ACPI based HotPlug driver that supports Memory Hotplug
10 * This driver fields notifications from firmware for memory add
11 * and remove operations and alerts the VM of the affected memory
12 * ranges.
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
25 static 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
32 static int acpi_memory_device_add(struct acpi_device *device,
33 const struct acpi_device_id *not_used);
34 static void acpi_memory_device_remove(struct acpi_device *device);
35
36 static 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
45 struct acpi_memory_info {
46 struct list_head list;
47 u64 start_addr; /* Memory Range start physical addr */
48 u64 length; /* Memory Range length */
49 unsigned short caching; /* memory cache attribute */
50 unsigned short write_protect; /* memory read/write attribute */
51 unsigned int enabled:1;
52 };
53
54 struct acpi_memory_device {
55 struct acpi_device *device;
56 struct list_head res_list;
57 };
58
59 static acpi_status
acpi_memory_get_resource(struct acpi_resource * resource,void * context)60 acpi_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 /* Can we combine the resource range information? */
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
96 static void
acpi_memory_free_device_resources(struct acpi_memory_device * mem_device)97 acpi_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
106 static int
acpi_memory_get_device_resources(struct acpi_memory_device * mem_device)107 acpi_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
acpi_memory_check_device(struct acpi_memory_device * mem_device)124 static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
125 {
126 unsigned long long current_status;
127
128 /* Get device present/absent information from the _STA */
129 if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle,
130 METHOD_NAME__STA, NULL,
131 ¤t_status)))
132 return -ENODEV;
133 /*
134 * Check for device status. Device should be
135 * present/enabled/functioning.
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
acpi_bind_memblk(struct memory_block * mem,void * arg)145 static int acpi_bind_memblk(struct memory_block *mem, void *arg)
146 {
147 return acpi_bind_one(&mem->dev, arg);
148 }
149
acpi_bind_memory_blocks(struct acpi_memory_info * info,struct acpi_device * adev)150 static 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
acpi_unbind_memblk(struct memory_block * mem,void * arg)157 static int acpi_unbind_memblk(struct memory_block *mem, void *arg)
158 {
159 acpi_unbind_one(&mem->dev);
160 return 0;
161 }
162
acpi_unbind_memory_blocks(struct acpi_memory_info * info)163 static 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
acpi_memory_enable_device(struct acpi_memory_device * mem_device)169 static 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 * Tell the VM there is more memory here...
180 * Note: Assume that this function returns zero on success
181 * We don't have memory-hot-add rollback function,now.
182 * (i.e. memory-hot-remove function)
183 */
184 list_for_each_entry(info, &mem_device->res_list, list) {
185 if (info->enabled) { /* just sanity check...*/
186 num_enabled++;
187 continue;
188 }
189 /*
190 * If the memory block size is zero, please ignore it.
191 * Don't try to do the following memory hotplug flowchart.
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 * If the memory block has been used by the kernel, add_memory()
205 * returns -EEXIST. If add_memory() returns the other error, it
206 * means that this memory block is not used by the kernel.
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 * Add num_enable even if add_memory() returns -EEXIST, so the
221 * device is bound to this driver.
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 * Sometimes the memory device will contain several memory blocks.
231 * When one memory block is hot-added to the system memory, it will
232 * be regarded as a success.
233 * Otherwise if the last memory block can't be hot-added to the system
234 * memory, it will be failure and the memory device can't be bound with
235 * driver.
236 */
237 return 0;
238 }
239
acpi_memory_remove_memory(struct acpi_memory_device * mem_device)240 static 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
acpi_memory_device_free(struct acpi_memory_device * mem_device)260 static 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
acpi_memory_device_add(struct acpi_device * device,const struct acpi_device_id * not_used)270 static 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 /* Get the range from the _CRS */
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
acpi_memory_device_remove(struct acpi_device * device)314 static 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
326 static bool __initdata acpi_no_memhotplug;
327
acpi_memory_hotplug_init(void)328 void __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
disable_acpi_memory_hotplug(char * str)338 static 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
347 static struct acpi_scan_handler memory_device_handler = {
348 .ids = memory_device_ids,
349 };
350
acpi_memory_hotplug_init(void)351 void __init acpi_memory_hotplug_init(void)
352 {
353 acpi_scan_add_handler(&memory_device_handler);
354 }
355
356 #endif /* CONFIG_ACPI_HOTPLUG_MEMORY */
357