Commit | Line | Data |
---|---|---|
cefc7ca4 EK |
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) | |
24 | struct prm_mmio_addr_range { | |
25 | u64 phys_addr; | |
26 | u64 virt_addr; | |
27 | u32 length; | |
28 | }; | |
29 | ||
30 | struct prm_mmio_info { | |
31 | u64 mmio_count; | |
32 | struct prm_mmio_addr_range addr_ranges[]; | |
33 | }; | |
34 | ||
35 | struct prm_buffer { | |
36 | u8 prm_status; | |
37 | u64 efi_status; | |
38 | u8 prm_cmd; | |
39 | guid_t handler_guid; | |
40 | }; | |
41 | ||
42 | struct 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 | ||
d7a188bb | 52 | static LIST_HEAD(prm_module_list); |
cefc7ca4 EK |
53 | |
54 | struct prm_handler_info { | |
55 | guid_t guid; | |
e38abdab | 56 | efi_status_t (__efiapi *handler_addr)(u64, void *); |
cefc7ca4 EK |
57 | u64 static_data_buffer_addr; |
58 | u64 acpi_param_buffer_addr; | |
59 | ||
60 | struct list_head handler_list; | |
61 | }; | |
62 | ||
63 | struct 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; | |
2e893457 | 72 | struct prm_handler_info handlers[] __counted_by(handler_count); |
cefc7ca4 EK |
73 | }; |
74 | ||
cefc7ca4 EK |
75 | static u64 efi_pa_va_lookup(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->phys_addr < pa && pa < md->phys_addr + PAGE_SIZE * md->num_pages) | |
83 | return pa_offset + md->virt_addr + page - md->phys_addr; | |
84 | } | |
85 | ||
86 | return 0; | |
87 | } | |
88 | ||
cefc7ca4 EK |
89 | #define get_first_handler(a) ((struct acpi_prmt_handler_info *) ((char *) (a) + a->handler_info_offset)) |
90 | #define get_next_handler(a) ((struct acpi_prmt_handler_info *) (sizeof(struct acpi_prmt_handler_info) + (char *) a)) | |
91 | ||
92 | static int __init | |
93 | acpi_parse_prmt(union acpi_subtable_headers *header, const unsigned long end) | |
94 | { | |
95 | struct acpi_prmt_module_info *module_info; | |
96 | struct acpi_prmt_handler_info *handler_info; | |
97 | struct prm_handler_info *th; | |
98 | struct prm_module_info *tm; | |
c52ca713 | 99 | u64 *mmio_count; |
cefc7ca4 EK |
100 | u64 cur_handler = 0; |
101 | u32 module_info_size = 0; | |
102 | u64 mmio_range_size = 0; | |
103 | void *temp_mmio; | |
104 | ||
105 | module_info = (struct acpi_prmt_module_info *) header; | |
106 | module_info_size = struct_size(tm, handlers, module_info->handler_info_count); | |
107 | tm = kmalloc(module_info_size, GFP_KERNEL); | |
c52ca713 AL |
108 | if (!tm) |
109 | goto parse_prmt_out1; | |
cefc7ca4 EK |
110 | |
111 | guid_copy(&tm->guid, (guid_t *) module_info->module_guid); | |
112 | tm->major_rev = module_info->major_rev; | |
113 | tm->minor_rev = module_info->minor_rev; | |
114 | tm->handler_count = module_info->handler_info_count; | |
115 | tm->updatable = true; | |
116 | ||
117 | if (module_info->mmio_list_pointer) { | |
118 | /* | |
119 | * Each module is associated with a list of addr | |
120 | * ranges that it can use during the service | |
121 | */ | |
c52ca713 AL |
122 | mmio_count = (u64 *) memremap(module_info->mmio_list_pointer, 8, MEMREMAP_WB); |
123 | if (!mmio_count) | |
124 | goto parse_prmt_out2; | |
125 | ||
126 | mmio_range_size = struct_size(tm->mmio_info, addr_ranges, *mmio_count); | |
cefc7ca4 | 127 | tm->mmio_info = kmalloc(mmio_range_size, GFP_KERNEL); |
c52ca713 AL |
128 | if (!tm->mmio_info) |
129 | goto parse_prmt_out3; | |
130 | ||
cefc7ca4 | 131 | temp_mmio = memremap(module_info->mmio_list_pointer, mmio_range_size, MEMREMAP_WB); |
c52ca713 AL |
132 | if (!temp_mmio) |
133 | goto parse_prmt_out4; | |
cefc7ca4 EK |
134 | memmove(tm->mmio_info, temp_mmio, mmio_range_size); |
135 | } else { | |
c52ca713 AL |
136 | tm->mmio_info = kmalloc(sizeof(*tm->mmio_info), GFP_KERNEL); |
137 | if (!tm->mmio_info) | |
138 | goto parse_prmt_out2; | |
139 | ||
cefc7ca4 EK |
140 | tm->mmio_info->mmio_count = 0; |
141 | } | |
142 | ||
143 | INIT_LIST_HEAD(&tm->module_list); | |
144 | list_add(&tm->module_list, &prm_module_list); | |
145 | ||
146 | handler_info = get_first_handler(module_info); | |
147 | do { | |
148 | th = &tm->handlers[cur_handler]; | |
149 | ||
150 | guid_copy(&th->guid, (guid_t *)handler_info->handler_guid); | |
353efd5e | 151 | th->handler_addr = (void *)efi_pa_va_lookup(handler_info->handler_address); |
cefc7ca4 EK |
152 | th->static_data_buffer_addr = efi_pa_va_lookup(handler_info->static_data_buffer_address); |
153 | th->acpi_param_buffer_addr = efi_pa_va_lookup(handler_info->acpi_param_buffer_address); | |
154 | } while (++cur_handler < tm->handler_count && (handler_info = get_next_handler(handler_info))); | |
155 | ||
156 | return 0; | |
c52ca713 AL |
157 | |
158 | parse_prmt_out4: | |
159 | kfree(tm->mmio_info); | |
160 | parse_prmt_out3: | |
161 | memunmap(mmio_count); | |
162 | parse_prmt_out2: | |
163 | kfree(tm); | |
164 | parse_prmt_out1: | |
165 | return -ENOMEM; | |
cefc7ca4 EK |
166 | } |
167 | ||
168 | #define GET_MODULE 0 | |
169 | #define GET_HANDLER 1 | |
170 | ||
171 | static void *find_guid_info(const guid_t *guid, u8 mode) | |
172 | { | |
173 | struct prm_handler_info *cur_handler; | |
174 | struct prm_module_info *cur_module; | |
175 | int i = 0; | |
176 | ||
177 | list_for_each_entry(cur_module, &prm_module_list, module_list) { | |
178 | for (i = 0; i < cur_module->handler_count; ++i) { | |
179 | cur_handler = &cur_module->handlers[i]; | |
180 | if (guid_equal(guid, &cur_handler->guid)) { | |
181 | if (mode == GET_MODULE) | |
182 | return (void *)cur_module; | |
183 | else | |
184 | return (void *)cur_handler; | |
185 | } | |
186 | } | |
187 | } | |
188 | ||
189 | return NULL; | |
190 | } | |
191 | ||
cefc7ca4 EK |
192 | static struct prm_module_info *find_prm_module(const guid_t *guid) |
193 | { | |
194 | return (struct prm_module_info *)find_guid_info(guid, GET_MODULE); | |
195 | } | |
196 | ||
197 | static struct prm_handler_info *find_prm_handler(const guid_t *guid) | |
198 | { | |
199 | return (struct prm_handler_info *) find_guid_info(guid, GET_HANDLER); | |
200 | } | |
201 | ||
202 | /* In-coming PRM commands */ | |
203 | ||
204 | #define PRM_CMD_RUN_SERVICE 0 | |
205 | #define PRM_CMD_START_TRANSACTION 1 | |
206 | #define PRM_CMD_END_TRANSACTION 2 | |
207 | ||
208 | /* statuses that can be passed back to ASL */ | |
209 | ||
210 | #define PRM_HANDLER_SUCCESS 0 | |
211 | #define PRM_HANDLER_ERROR 1 | |
212 | #define INVALID_PRM_COMMAND 2 | |
213 | #define PRM_HANDLER_GUID_NOT_FOUND 3 | |
214 | #define UPDATE_LOCK_ALREADY_HELD 4 | |
215 | #define UPDATE_UNLOCK_WITHOUT_LOCK 5 | |
216 | ||
217 | /* | |
218 | * This is the PlatformRtMechanism opregion space handler. | |
219 | * @function: indicates the read/write. In fact as the PlatformRtMechanism | |
220 | * message is driven by command, only write is meaningful. | |
221 | * | |
222 | * @addr : not used | |
223 | * @bits : not used. | |
224 | * @value : it is an in/out parameter. It points to the PRM message buffer. | |
225 | * @handler_context: not used | |
226 | */ | |
227 | static acpi_status acpi_platformrt_space_handler(u32 function, | |
228 | acpi_physical_address addr, | |
229 | u32 bits, acpi_integer *value, | |
230 | void *handler_context, | |
231 | void *region_context) | |
232 | { | |
233 | struct prm_buffer *buffer = ACPI_CAST_PTR(struct prm_buffer, value); | |
234 | struct prm_handler_info *handler; | |
235 | struct prm_module_info *module; | |
236 | efi_status_t status; | |
237 | struct prm_context_buffer context; | |
238 | ||
182da6f2 AB |
239 | if (!efi_enabled(EFI_RUNTIME_SERVICES)) { |
240 | pr_err_ratelimited("PRM: EFI runtime services no longer available\n"); | |
241 | return AE_NO_HANDLER; | |
242 | } | |
243 | ||
cefc7ca4 EK |
244 | /* |
245 | * The returned acpi_status will always be AE_OK. Error values will be | |
246 | * saved in the first byte of the PRM message buffer to be used by ASL. | |
247 | */ | |
248 | switch (buffer->prm_cmd) { | |
249 | case PRM_CMD_RUN_SERVICE: | |
250 | ||
251 | handler = find_prm_handler(&buffer->handler_guid); | |
252 | module = find_prm_module(&buffer->handler_guid); | |
253 | if (!handler || !module) | |
254 | goto invalid_guid; | |
255 | ||
256 | ACPI_COPY_NAMESEG(context.signature, "PRMC"); | |
257 | context.revision = 0x0; | |
258 | context.reserved = 0x0; | |
259 | context.identifier = handler->guid; | |
260 | context.static_data_buffer = handler->static_data_buffer_addr; | |
261 | context.mmio_ranges = module->mmio_info; | |
262 | ||
5894cf57 AB |
263 | status = efi_call_acpi_prm_handler(handler->handler_addr, |
264 | handler->acpi_param_buffer_addr, | |
265 | &context); | |
cefc7ca4 EK |
266 | if (status == EFI_SUCCESS) { |
267 | buffer->prm_status = PRM_HANDLER_SUCCESS; | |
268 | } else { | |
269 | buffer->prm_status = PRM_HANDLER_ERROR; | |
270 | buffer->efi_status = status; | |
271 | } | |
272 | break; | |
273 | ||
274 | case PRM_CMD_START_TRANSACTION: | |
275 | ||
276 | module = find_prm_module(&buffer->handler_guid); | |
277 | if (!module) | |
278 | goto invalid_guid; | |
279 | ||
280 | if (module->updatable) | |
281 | module->updatable = false; | |
282 | else | |
283 | buffer->prm_status = UPDATE_LOCK_ALREADY_HELD; | |
284 | break; | |
285 | ||
286 | case PRM_CMD_END_TRANSACTION: | |
287 | ||
288 | module = find_prm_module(&buffer->handler_guid); | |
289 | if (!module) | |
290 | goto invalid_guid; | |
291 | ||
292 | if (module->updatable) | |
293 | buffer->prm_status = UPDATE_UNLOCK_WITHOUT_LOCK; | |
294 | else | |
295 | module->updatable = true; | |
296 | break; | |
297 | ||
298 | default: | |
299 | ||
300 | buffer->prm_status = INVALID_PRM_COMMAND; | |
301 | break; | |
302 | } | |
303 | ||
304 | return AE_OK; | |
305 | ||
306 | invalid_guid: | |
307 | buffer->prm_status = PRM_HANDLER_GUID_NOT_FOUND; | |
308 | return AE_OK; | |
309 | } | |
310 | ||
311 | void __init init_prmt(void) | |
312 | { | |
3265cc3e | 313 | struct acpi_table_header *tbl; |
cefc7ca4 | 314 | acpi_status status; |
3265cc3e AL |
315 | int mc; |
316 | ||
317 | status = acpi_get_table(ACPI_SIG_PRMT, 0, &tbl); | |
318 | if (ACPI_FAILURE(status)) | |
319 | return; | |
320 | ||
321 | mc = acpi_table_parse_entries(ACPI_SIG_PRMT, sizeof(struct acpi_table_prmt) + | |
cefc7ca4 EK |
322 | sizeof (struct acpi_table_prmt_header), |
323 | 0, acpi_parse_prmt, 0); | |
3265cc3e | 324 | acpi_put_table(tbl); |
2bbfa0ad AL |
325 | /* |
326 | * Return immediately if PRMT table is not present or no PRM module found. | |
327 | */ | |
328 | if (mc <= 0) | |
329 | return; | |
330 | ||
cefc7ca4 EK |
331 | pr_info("PRM: found %u modules\n", mc); |
332 | ||
182da6f2 AB |
333 | if (!efi_enabled(EFI_RUNTIME_SERVICES)) { |
334 | pr_err("PRM: EFI runtime services unavailable\n"); | |
335 | return; | |
336 | } | |
337 | ||
cefc7ca4 EK |
338 | status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT, |
339 | ACPI_ADR_SPACE_PLATFORM_RT, | |
340 | &acpi_platformrt_space_handler, | |
341 | NULL, NULL); | |
342 | if (ACPI_FAILURE(status)) | |
343 | pr_alert("PRM: OperationRegion handler could not be installed\n"); | |
344 | } |