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	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(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
92static int __init
93acpi_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
158parse_prmt_out4:
159	kfree(tm->mmio_info);
160parse_prmt_out3:
161	memunmap(mmio_count);
162parse_prmt_out2:
163	kfree(tm);
164parse_prmt_out1:
165	return -ENOMEM;
166}
167
168#define GET_MODULE	0
169#define GET_HANDLER	1
170
171static 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
192static 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
197static 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 */
227static 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
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
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
263		status = efi_call_acpi_prm_handler(handler->handler_addr,
264						   handler->acpi_param_buffer_addr,
265						   &context);
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
306invalid_guid:
307	buffer->prm_status = PRM_HANDLER_GUID_NOT_FOUND;
308	return AE_OK;
309}
310
311void __init init_prmt(void)
312{
313	struct acpi_table_header *tbl;
314	acpi_status status;
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) +
322					  sizeof (struct acpi_table_prmt_header),
323					  0, acpi_parse_prmt, 0);
324	acpi_put_table(tbl);
325	/*
326	 * Return immediately if PRMT table is not present or no PRM module found.
327	 */
328	if (mc <= 0)
329		return;
330
331	pr_info("PRM: found %u modules\n", mc);
332
333	if (!efi_enabled(EFI_RUNTIME_SERVICES)) {
334		pr_err("PRM: EFI runtime services unavailable\n");
335		return;
336	}
337
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}
345