Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Author: Erik Kaneda <erik.kaneda@intel.com>
4 * Copyright 2020 Intel Corporation
5 *
6 * prmt.c
7 *
8 * Each PRM service is an executable that is run in a restricted environment
9 * that is invoked by writing to the PlatformRtMechanism OperationRegion from
10 * AML bytecode.
11 *
12 * init_prmt initializes the Platform Runtime Mechanism (PRM) services by
13 * processing data in the PRMT as well as registering an ACPI OperationRegion
14 * handler for the PlatformRtMechanism subtype.
15 *
16 */
17#include <linux/kernel.h>
18#include <linux/efi.h>
19#include <linux/acpi.h>
20#include <linux/prmt.h>
21#include <asm/efi.h>
22
23#pragma pack(1)
24struct prm_mmio_addr_range {
25 u64 phys_addr;
26 u64 virt_addr;
27 u32 length;
28};
29
30struct prm_mmio_info {
31 u64 mmio_count;
32 struct prm_mmio_addr_range addr_ranges[];
33};
34
35struct prm_buffer {
36 u8 prm_status;
37 u64 efi_status;
38 u8 prm_cmd;
39 guid_t handler_guid;
40};
41
42struct prm_context_buffer {
43 char signature[ACPI_NAMESEG_SIZE];
44 u16 revision;
45 u16 reserved;
46 guid_t identifier;
47 u64 static_data_buffer;
48 struct prm_mmio_info *mmio_ranges;
49};
50#pragma pack()
51
52static LIST_HEAD(prm_module_list);
53
54struct prm_handler_info {
55 efi_guid_t guid;
56 efi_status_t (__efiapi *handler_addr)(u64, void *);
57 u64 static_data_buffer_addr;
58 u64 acpi_param_buffer_addr;
59
60 struct list_head handler_list;
61};
62
63struct prm_module_info {
64 guid_t guid;
65 u16 major_rev;
66 u16 minor_rev;
67 u16 handler_count;
68 struct prm_mmio_info *mmio_info;
69 bool updatable;
70
71 struct list_head module_list;
72 struct prm_handler_info handlers[] __counted_by(handler_count);
73};
74
75static u64 efi_pa_va_lookup(efi_guid_t *guid, u64 pa)
76{
77 efi_memory_desc_t *md;
78 u64 pa_offset = pa & ~PAGE_MASK;
79 u64 page = pa & PAGE_MASK;
80
81 for_each_efi_memory_desc(md) {
82 if ((md->attribute & EFI_MEMORY_RUNTIME) &&
83 (md->phys_addr < pa && pa < md->phys_addr + PAGE_SIZE * md->num_pages)) {
84 return pa_offset + md->virt_addr + page - md->phys_addr;
85 }
86 }
87
88 pr_warn("Failed to find VA for GUID: %pUL, PA: 0x%llx", guid, pa);
89
90 return 0;
91}
92
93#define get_first_handler(a) ((struct acpi_prmt_handler_info *) ((char *) (a) + a->handler_info_offset))
94#define get_next_handler(a) ((struct acpi_prmt_handler_info *) (sizeof(struct acpi_prmt_handler_info) + (char *) a))
95
96static int __init
97acpi_parse_prmt(union acpi_subtable_headers *header, const unsigned long end)
98{
99 struct acpi_prmt_module_info *module_info;
100 struct acpi_prmt_handler_info *handler_info;
101 struct prm_handler_info *th;
102 struct prm_module_info *tm;
103 u64 *mmio_count;
104 u64 cur_handler = 0;
105 u32 module_info_size = 0;
106 u64 mmio_range_size = 0;
107 void *temp_mmio;
108
109 module_info = (struct acpi_prmt_module_info *) header;
110 module_info_size = struct_size(tm, handlers, module_info->handler_info_count);
111 tm = kmalloc(module_info_size, GFP_KERNEL);
112 if (!tm)
113 goto parse_prmt_out1;
114
115 guid_copy(&tm->guid, (guid_t *) module_info->module_guid);
116 tm->major_rev = module_info->major_rev;
117 tm->minor_rev = module_info->minor_rev;
118 tm->handler_count = module_info->handler_info_count;
119 tm->updatable = true;
120
121 if (module_info->mmio_list_pointer) {
122 /*
123 * Each module is associated with a list of addr
124 * ranges that it can use during the service
125 */
126 mmio_count = (u64 *) memremap(module_info->mmio_list_pointer, 8, MEMREMAP_WB);
127 if (!mmio_count)
128 goto parse_prmt_out2;
129
130 mmio_range_size = struct_size(tm->mmio_info, addr_ranges, *mmio_count);
131 tm->mmio_info = kmalloc(mmio_range_size, GFP_KERNEL);
132 if (!tm->mmio_info)
133 goto parse_prmt_out3;
134
135 temp_mmio = memremap(module_info->mmio_list_pointer, mmio_range_size, MEMREMAP_WB);
136 if (!temp_mmio)
137 goto parse_prmt_out4;
138 memmove(tm->mmio_info, temp_mmio, mmio_range_size);
139 } else {
140 tm->mmio_info = kmalloc(sizeof(*tm->mmio_info), GFP_KERNEL);
141 if (!tm->mmio_info)
142 goto parse_prmt_out2;
143
144 tm->mmio_info->mmio_count = 0;
145 }
146
147 INIT_LIST_HEAD(&tm->module_list);
148 list_add(&tm->module_list, &prm_module_list);
149
150 handler_info = get_first_handler(module_info);
151 do {
152 th = &tm->handlers[cur_handler];
153
154 guid_copy(&th->guid, (guid_t *)handler_info->handler_guid);
155 th->handler_addr =
156 (void *)efi_pa_va_lookup(&th->guid, handler_info->handler_address);
157
158 th->static_data_buffer_addr =
159 efi_pa_va_lookup(&th->guid, handler_info->static_data_buffer_address);
160
161 th->acpi_param_buffer_addr =
162 efi_pa_va_lookup(&th->guid, handler_info->acpi_param_buffer_address);
163
164 } while (++cur_handler < tm->handler_count && (handler_info = get_next_handler(handler_info)));
165
166 return 0;
167
168parse_prmt_out4:
169 kfree(tm->mmio_info);
170parse_prmt_out3:
171 memunmap(mmio_count);
172parse_prmt_out2:
173 kfree(tm);
174parse_prmt_out1:
175 return -ENOMEM;
176}
177
178#define GET_MODULE 0
179#define GET_HANDLER 1
180
181static void *find_guid_info(const guid_t *guid, u8 mode)
182{
183 struct prm_handler_info *cur_handler;
184 struct prm_module_info *cur_module;
185 int i = 0;
186
187 list_for_each_entry(cur_module, &prm_module_list, module_list) {
188 for (i = 0; i < cur_module->handler_count; ++i) {
189 cur_handler = &cur_module->handlers[i];
190 if (guid_equal(guid, &cur_handler->guid)) {
191 if (mode == GET_MODULE)
192 return (void *)cur_module;
193 else
194 return (void *)cur_handler;
195 }
196 }
197 }
198
199 return NULL;
200}
201
202static struct prm_module_info *find_prm_module(const guid_t *guid)
203{
204 return (struct prm_module_info *)find_guid_info(guid, GET_MODULE);
205}
206
207static struct prm_handler_info *find_prm_handler(const guid_t *guid)
208{
209 return (struct prm_handler_info *) find_guid_info(guid, GET_HANDLER);
210}
211
212/* In-coming PRM commands */
213
214#define PRM_CMD_RUN_SERVICE 0
215#define PRM_CMD_START_TRANSACTION 1
216#define PRM_CMD_END_TRANSACTION 2
217
218/* statuses that can be passed back to ASL */
219
220#define PRM_HANDLER_SUCCESS 0
221#define PRM_HANDLER_ERROR 1
222#define INVALID_PRM_COMMAND 2
223#define PRM_HANDLER_GUID_NOT_FOUND 3
224#define UPDATE_LOCK_ALREADY_HELD 4
225#define UPDATE_UNLOCK_WITHOUT_LOCK 5
226
227int acpi_call_prm_handler(guid_t handler_guid, void *param_buffer)
228{
229 struct prm_handler_info *handler = find_prm_handler(&handler_guid);
230 struct prm_module_info *module = find_prm_module(&handler_guid);
231 struct prm_context_buffer context;
232 efi_status_t status;
233
234 if (!module || !handler)
235 return -ENODEV;
236
237 memset(&context, 0, sizeof(context));
238 ACPI_COPY_NAMESEG(context.signature, "PRMC");
239 context.identifier = handler->guid;
240 context.static_data_buffer = handler->static_data_buffer_addr;
241 context.mmio_ranges = module->mmio_info;
242
243 status = efi_call_acpi_prm_handler(handler->handler_addr,
244 (u64)param_buffer,
245 &context);
246
247 return efi_status_to_err(status);
248}
249EXPORT_SYMBOL_GPL(acpi_call_prm_handler);
250
251/*
252 * This is the PlatformRtMechanism opregion space handler.
253 * @function: indicates the read/write. In fact as the PlatformRtMechanism
254 * message is driven by command, only write is meaningful.
255 *
256 * @addr : not used
257 * @bits : not used.
258 * @value : it is an in/out parameter. It points to the PRM message buffer.
259 * @handler_context: not used
260 */
261static acpi_status acpi_platformrt_space_handler(u32 function,
262 acpi_physical_address addr,
263 u32 bits, acpi_integer *value,
264 void *handler_context,
265 void *region_context)
266{
267 struct prm_buffer *buffer = ACPI_CAST_PTR(struct prm_buffer, value);
268 struct prm_handler_info *handler;
269 struct prm_module_info *module;
270 efi_status_t status;
271 struct prm_context_buffer context;
272
273 if (!efi_enabled(EFI_RUNTIME_SERVICES)) {
274 pr_err_ratelimited("PRM: EFI runtime services no longer available\n");
275 return AE_NO_HANDLER;
276 }
277
278 /*
279 * The returned acpi_status will always be AE_OK. Error values will be
280 * saved in the first byte of the PRM message buffer to be used by ASL.
281 */
282 switch (buffer->prm_cmd) {
283 case PRM_CMD_RUN_SERVICE:
284
285 handler = find_prm_handler(&buffer->handler_guid);
286 module = find_prm_module(&buffer->handler_guid);
287 if (!handler || !module)
288 goto invalid_guid;
289
290 if (!handler->handler_addr) {
291 buffer->prm_status = PRM_HANDLER_ERROR;
292 return AE_OK;
293 }
294
295 ACPI_COPY_NAMESEG(context.signature, "PRMC");
296 context.revision = 0x0;
297 context.reserved = 0x0;
298 context.identifier = handler->guid;
299 context.static_data_buffer = handler->static_data_buffer_addr;
300 context.mmio_ranges = module->mmio_info;
301
302 status = efi_call_acpi_prm_handler(handler->handler_addr,
303 handler->acpi_param_buffer_addr,
304 &context);
305 if (status == EFI_SUCCESS) {
306 buffer->prm_status = PRM_HANDLER_SUCCESS;
307 } else {
308 buffer->prm_status = PRM_HANDLER_ERROR;
309 buffer->efi_status = status;
310 }
311 break;
312
313 case PRM_CMD_START_TRANSACTION:
314
315 module = find_prm_module(&buffer->handler_guid);
316 if (!module)
317 goto invalid_guid;
318
319 if (module->updatable)
320 module->updatable = false;
321 else
322 buffer->prm_status = UPDATE_LOCK_ALREADY_HELD;
323 break;
324
325 case PRM_CMD_END_TRANSACTION:
326
327 module = find_prm_module(&buffer->handler_guid);
328 if (!module)
329 goto invalid_guid;
330
331 if (module->updatable)
332 buffer->prm_status = UPDATE_UNLOCK_WITHOUT_LOCK;
333 else
334 module->updatable = true;
335 break;
336
337 default:
338
339 buffer->prm_status = INVALID_PRM_COMMAND;
340 break;
341 }
342
343 return AE_OK;
344
345invalid_guid:
346 buffer->prm_status = PRM_HANDLER_GUID_NOT_FOUND;
347 return AE_OK;
348}
349
350void __init init_prmt(void)
351{
352 struct acpi_table_header *tbl;
353 acpi_status status;
354 int mc;
355
356 status = acpi_get_table(ACPI_SIG_PRMT, 0, &tbl);
357 if (ACPI_FAILURE(status))
358 return;
359
360 mc = acpi_table_parse_entries(ACPI_SIG_PRMT, sizeof(struct acpi_table_prmt) +
361 sizeof (struct acpi_table_prmt_header),
362 0, acpi_parse_prmt, 0);
363 acpi_put_table(tbl);
364 /*
365 * Return immediately if PRMT table is not present or no PRM module found.
366 */
367 if (mc <= 0)
368 return;
369
370 pr_info("PRM: found %u modules\n", mc);
371
372 if (!efi_enabled(EFI_RUNTIME_SERVICES)) {
373 pr_err("PRM: EFI runtime services unavailable\n");
374 return;
375 }
376
377 status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
378 ACPI_ADR_SPACE_PLATFORM_RT,
379 &acpi_platformrt_space_handler,
380 NULL, NULL);
381 if (ACPI_FAILURE(status))
382 pr_alert("PRM: OperationRegion handler could not be installed\n");
383}