xref: /linux/drivers/acpi/prmt.c (revision bde5d79d00255db609fe9d859eef8c7b6d38b137)
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 
52 static LIST_HEAD(prm_module_list);
53 
54 struct prm_handler_info {
55 	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 
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;
72 	struct prm_handler_info handlers[] __counted_by(handler_count);
73 };
74 
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 
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;
99 	u64 *mmio_count;
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);
108 	if (!tm)
109 		goto parse_prmt_out1;
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 		 */
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);
127 		tm->mmio_info = kmalloc(mmio_range_size, GFP_KERNEL);
128 		if (!tm->mmio_info)
129 			goto parse_prmt_out3;
130 
131 		temp_mmio = memremap(module_info->mmio_list_pointer, mmio_range_size, MEMREMAP_WB);
132 		if (!temp_mmio)
133 			goto parse_prmt_out4;
134 		memmove(tm->mmio_info, temp_mmio, mmio_range_size);
135 	} else {
136 		tm->mmio_info = kmalloc(sizeof(*tm->mmio_info), GFP_KERNEL);
137 		if (!tm->mmio_info)
138 			goto parse_prmt_out2;
139 
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);
151 		th->handler_addr = (void *)efi_pa_va_lookup(handler_info->handler_address);
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;
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;
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 
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 int acpi_call_prm_handler(guid_t handler_guid, void *param_buffer)
218 {
219 	struct prm_handler_info *handler = find_prm_handler(&handler_guid);
220 	struct prm_module_info *module = find_prm_module(&handler_guid);
221 	struct prm_context_buffer context;
222 	efi_status_t status;
223 
224 	if (!module || !handler)
225 		return -ENODEV;
226 
227 	memset(&context, 0, sizeof(context));
228 	ACPI_COPY_NAMESEG(context.signature, "PRMC");
229 	context.identifier         = handler->guid;
230 	context.static_data_buffer = handler->static_data_buffer_addr;
231 	context.mmio_ranges        = module->mmio_info;
232 
233 	status = efi_call_acpi_prm_handler(handler->handler_addr,
234 					   (u64)param_buffer,
235 					   &context);
236 
237 	return efi_status_to_err(status);
238 }
239 EXPORT_SYMBOL_GPL(acpi_call_prm_handler);
240 
241 /*
242  * This is the PlatformRtMechanism opregion space handler.
243  * @function: indicates the read/write. In fact as the PlatformRtMechanism
244  * message is driven by command, only write is meaningful.
245  *
246  * @addr   : not used
247  * @bits   : not used.
248  * @value  : it is an in/out parameter. It points to the PRM message buffer.
249  * @handler_context: not used
250  */
251 static acpi_status acpi_platformrt_space_handler(u32 function,
252 						 acpi_physical_address addr,
253 						 u32 bits, acpi_integer *value,
254 						 void *handler_context,
255 						 void *region_context)
256 {
257 	struct prm_buffer *buffer = ACPI_CAST_PTR(struct prm_buffer, value);
258 	struct prm_handler_info *handler;
259 	struct prm_module_info *module;
260 	efi_status_t status;
261 	struct prm_context_buffer context;
262 
263 	if (!efi_enabled(EFI_RUNTIME_SERVICES)) {
264 		pr_err_ratelimited("PRM: EFI runtime services no longer available\n");
265 		return AE_NO_HANDLER;
266 	}
267 
268 	/*
269 	 * The returned acpi_status will always be AE_OK. Error values will be
270 	 * saved in the first byte of the PRM message buffer to be used by ASL.
271 	 */
272 	switch (buffer->prm_cmd) {
273 	case PRM_CMD_RUN_SERVICE:
274 
275 		handler = find_prm_handler(&buffer->handler_guid);
276 		module = find_prm_module(&buffer->handler_guid);
277 		if (!handler || !module)
278 			goto invalid_guid;
279 
280 		ACPI_COPY_NAMESEG(context.signature, "PRMC");
281 		context.revision = 0x0;
282 		context.reserved = 0x0;
283 		context.identifier = handler->guid;
284 		context.static_data_buffer = handler->static_data_buffer_addr;
285 		context.mmio_ranges = module->mmio_info;
286 
287 		status = efi_call_acpi_prm_handler(handler->handler_addr,
288 						   handler->acpi_param_buffer_addr,
289 						   &context);
290 		if (status == EFI_SUCCESS) {
291 			buffer->prm_status = PRM_HANDLER_SUCCESS;
292 		} else {
293 			buffer->prm_status = PRM_HANDLER_ERROR;
294 			buffer->efi_status = status;
295 		}
296 		break;
297 
298 	case PRM_CMD_START_TRANSACTION:
299 
300 		module = find_prm_module(&buffer->handler_guid);
301 		if (!module)
302 			goto invalid_guid;
303 
304 		if (module->updatable)
305 			module->updatable = false;
306 		else
307 			buffer->prm_status = UPDATE_LOCK_ALREADY_HELD;
308 		break;
309 
310 	case PRM_CMD_END_TRANSACTION:
311 
312 		module = find_prm_module(&buffer->handler_guid);
313 		if (!module)
314 			goto invalid_guid;
315 
316 		if (module->updatable)
317 			buffer->prm_status = UPDATE_UNLOCK_WITHOUT_LOCK;
318 		else
319 			module->updatable = true;
320 		break;
321 
322 	default:
323 
324 		buffer->prm_status = INVALID_PRM_COMMAND;
325 		break;
326 	}
327 
328 	return AE_OK;
329 
330 invalid_guid:
331 	buffer->prm_status = PRM_HANDLER_GUID_NOT_FOUND;
332 	return AE_OK;
333 }
334 
335 void __init init_prmt(void)
336 {
337 	struct acpi_table_header *tbl;
338 	acpi_status status;
339 	int mc;
340 
341 	status = acpi_get_table(ACPI_SIG_PRMT, 0, &tbl);
342 	if (ACPI_FAILURE(status))
343 		return;
344 
345 	mc = acpi_table_parse_entries(ACPI_SIG_PRMT, sizeof(struct acpi_table_prmt) +
346 					  sizeof (struct acpi_table_prmt_header),
347 					  0, acpi_parse_prmt, 0);
348 	acpi_put_table(tbl);
349 	/*
350 	 * Return immediately if PRMT table is not present or no PRM module found.
351 	 */
352 	if (mc <= 0)
353 		return;
354 
355 	pr_info("PRM: found %u modules\n", mc);
356 
357 	if (!efi_enabled(EFI_RUNTIME_SERVICES)) {
358 		pr_err("PRM: EFI runtime services unavailable\n");
359 		return;
360 	}
361 
362 	status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
363 						    ACPI_ADR_SPACE_PLATFORM_RT,
364 						    &acpi_platformrt_space_handler,
365 						    NULL, NULL);
366 	if (ACPI_FAILURE(status))
367 		pr_alert("PRM: OperationRegion handler could not be installed\n");
368 }
369