// SPDX-License-Identifier: GPL-2.0-only/* * Author: Erik Kaneda <erik.kaneda@intel.com> * Copyright 2020 Intel Corporation * * prmt.c * * Each PRM service is an executable that is run in a restricted environment * that is invoked by writing to the PlatformRtMechanism OperationRegion from * AML bytecode. * * init_prmt initializes the Platform Runtime Mechanism (PRM) services by * processing data in the PRMT as well as registering an ACPI OperationRegion * handler for the PlatformRtMechanism subtype. * */#include <linux/kernel.h>#include <linux/efi.h>#include <linux/acpi.h>#include <linux/prmt.h>#include <asm/efi.h> #pragma pack(1)struct prm_mmio_addr_range {	u64 phys_addr;	u64 virt_addr;	u32 length;}; struct prm_mmio_info {	u64 mmio_count;	struct prm_mmio_addr_range addr_ranges[];}; struct prm_buffer {	u8 prm_status;	u64 efi_status;	u8 prm_cmd;	guid_t handler_guid;}; struct prm_context_buffer {	char signature[ACPI_NAMESEG_SIZE];	u16 revision;	u16 reserved;	guid_t identifier;	u64 static_data_buffer;	struct prm_mmio_info *mmio_ranges;};#pragma pack() static LIST_HEAD(prm_module_list); struct prm_handler_info {	efi_guid_t guid;	efi_status_t (__efiapi *handler_addr)(u64, void *);	u64 static_data_buffer_addr;	u64 acpi_param_buffer_addr; 	struct list_head handler_list;}; struct prm_module_info {	guid_t guid;	u16 major_rev;	u16 minor_rev;	u16 handler_count;	struct prm_mmio_info *mmio_info;	bool updatable; 	struct list_head module_list;	struct prm_handler_info handlers[] __counted_by(handler_count);}; static u64 efi_pa_va_lookup(efi_guid_t *guid, u64 pa){	efi_memory_desc_t *md;	u64 pa_offset = pa & ~PAGE_MASK;	u64 page = pa & PAGE_MASK; 	for_each_efi_memory_desc(md) {		if ((md->attribute & EFI_MEMORY_RUNTIME) &&		    (md->phys_addr < pa && pa < md->phys_addr + PAGE_SIZE * md->num_pages)) {			return pa_offset + md->virt_addr + page - md->phys_addr;		}	} 	return 0;} #define get_first_handler(a) ((struct acpi_prmt_handler_info *) ((char *) (a) + a->handler_info_offset))#define get_next_handler(a) ((struct acpi_prmt_handler_info *) (sizeof(struct acpi_prmt_handler_info) + (char *) a)) static int __initacpi_parse_prmt(union acpi_subtable_headers *header, const unsigned long end){	struct acpi_prmt_module_info *module_info;	struct acpi_prmt_handler_info *handler_info;	struct prm_handler_info *th;	struct prm_module_info *tm;	u64 *mmio_count;	u64 cur_handler = 0;	u32 module_info_size = 0;	u64 mmio_range_size = 0;	void *temp_mmio; 	module_info = (struct acpi_prmt_module_info *) header;	module_info_size = struct_size(tm, handlers, module_info->handler_info_count);	tm = kmalloc(module_info_size, GFP_KERNEL);	if (!tm)		goto parse_prmt_out1; 	guid_copy(&tm->guid, (guid_t *) module_info->module_guid);	tm->major_rev = module_info->major_rev;	tm->minor_rev = module_info->minor_rev;	tm->handler_count = module_info->handler_info_count;	tm->updatable = true; 	if (module_info->mmio_list_pointer) {		/*		 * Each module is associated with a list of addr		 * ranges that it can use during the service		 */		mmio_count = (u64 *) memremap(module_info->mmio_list_pointer, 8, MEMREMAP_WB);		if (!mmio_count)			goto parse_prmt_out2; 		mmio_range_size = struct_size(tm->mmio_info, addr_ranges, *mmio_count);		tm->mmio_info = kmalloc(mmio_range_size, GFP_KERNEL);		if (!tm->mmio_info)			goto parse_prmt_out3; 		temp_mmio = memremap(module_info->mmio_list_pointer, mmio_range_size, MEMREMAP_WB);		if (!temp_mmio)			goto parse_prmt_out4;		memmove(tm->mmio_info, temp_mmio, mmio_range_size);	} else {		tm->mmio_info = kmalloc_obj(*tm->mmio_info);		if (!tm->mmio_info)			goto parse_prmt_out2; 		tm->mmio_info->mmio_count = 0;	} 	INIT_LIST_HEAD(&tm->module_list);	list_add(&tm->module_list, &prm_module_list); 	handler_info = get_first_handler(module_info);	do {		th = &tm->handlers[cur_handler]; 		guid_copy(&th->guid, (guid_t *)handler_info->handler_guid); 		/*		 * Print an error message if handler_address is NULL, the parse of VA also		 * can be skipped.		 */		if (unlikely(!handler_info->handler_address)) {			pr_info("Skipping handler with NULL address for GUID: %pUL",					(guid_t *)handler_info->handler_guid);			continue;		} 		th->handler_addr =			(void *)efi_pa_va_lookup(&th->guid, handler_info->handler_address);		/*		 * Print a warning message and skip the parse of VA if handler_addr is zero		 * which is not expected to ever happen.		 */		if (unlikely(!th->handler_addr)) {			pr_warn("Failed to find VA of handler for GUID: %pUL, PA: 0x%llx",				&th->guid, handler_info->handler_address);			continue;		} 		th->static_data_buffer_addr =			efi_pa_va_lookup(&th->guid, handler_info->static_data_buffer_address);		/*		 * According to the PRM specification, static_data_buffer_address can be zero,		 * so avoid printing a warning message in that case.  Otherwise, if the		 * return value of efi_pa_va_lookup() is zero, print the message.		 */		if (unlikely(!th->static_data_buffer_addr && handler_info->static_data_buffer_address))			pr_warn("Failed to find VA of static data buffer for GUID: %pUL, PA: 0x%llx",				&th->guid, handler_info->static_data_buffer_address); 		th->acpi_param_buffer_addr =			efi_pa_va_lookup(&th->guid, handler_info->acpi_param_buffer_address); 		/*		 * According to the PRM specification, acpi_param_buffer_address can be zero,		 * so avoid printing a warning message in that case.  Otherwise, if the		 * return value of efi_pa_va_lookup() is zero, print the message.		 */		if (unlikely(!th->acpi_param_buffer_addr && handler_info->acpi_param_buffer_address))			pr_warn("Failed to find VA of acpi param buffer for GUID: %pUL, PA: 0x%llx",				&th->guid, handler_info->acpi_param_buffer_address); 	} while (++cur_handler < tm->handler_count && (handler_info = get_next_handler(handler_info))); 	return 0; parse_prmt_out4:	kfree(tm->mmio_info);parse_prmt_out3:	memunmap(mmio_count);parse_prmt_out2:	kfree(tm);parse_prmt_out1:	return -ENOMEM;} #define GET_MODULE	0#define GET_HANDLER	1 static void *find_guid_info(const guid_t *guid, u8 mode){	struct prm_handler_info *cur_handler;	struct prm_module_info *cur_module;	int i = 0; 	list_for_each_entry(cur_module, &prm_module_list, module_list) {		for (i = 0; i < cur_module->handler_count; ++i) {			cur_handler = &cur_module->handlers[i];			if (guid_equal(guid, &cur_handler->guid)) {				if (mode == GET_MODULE)					return (void *)cur_module;				else					return (void *)cur_handler;			}		}	} 	return NULL;} static struct prm_module_info *find_prm_module(const guid_t *guid){	return (struct prm_module_info *)find_guid_info(guid, GET_MODULE);} static struct prm_handler_info *find_prm_handler(const guid_t *guid){	return (struct prm_handler_info *) find_guid_info(guid, GET_HANDLER);} bool acpi_prm_handler_available(const guid_t *guid){	return find_prm_handler(guid) && find_prm_module(guid);}EXPORT_SYMBOL_GPL(acpi_prm_handler_available); /* In-coming PRM commands */ #define PRM_CMD_RUN_SERVICE		0#define PRM_CMD_START_TRANSACTION	1#define PRM_CMD_END_TRANSACTION		2 /* statuses that can be passed back to ASL */ #define PRM_HANDLER_SUCCESS 		0#define PRM_HANDLER_ERROR 		1#define INVALID_PRM_COMMAND 		2#define PRM_HANDLER_GUID_NOT_FOUND 	3#define UPDATE_LOCK_ALREADY_HELD 	4#define UPDATE_UNLOCK_WITHOUT_LOCK 	5 int acpi_call_prm_handler(guid_t handler_guid, void *param_buffer){	struct prm_handler_info *handler = find_prm_handler(&handler_guid);	struct prm_module_info *module = find_prm_module(&handler_guid);	struct prm_context_buffer context;	efi_status_t status; 	if (!module || !handler)		return -ENODEV; 	memset(&context, 0, sizeof(context));	ACPI_COPY_NAMESEG(context.signature, "PRMC");	context.identifier         = handler->guid;	context.static_data_buffer = handler->static_data_buffer_addr;	context.mmio_ranges        = module->mmio_info; 	status = efi_call_acpi_prm_handler(handler->handler_addr,					   (u64)param_buffer,					   &context); 	return efi_status_to_err(status);}EXPORT_SYMBOL_GPL(acpi_call_prm_handler); /* * This is the PlatformRtMechanism opregion space handler. * @function: indicates the read/write. In fact as the PlatformRtMechanism * message is driven by command, only write is meaningful. * * @addr   : not used * @bits   : not used. * @value  : it is an in/out parameter. It points to the PRM message buffer. * @handler_context: not used */static acpi_status acpi_platformrt_space_handler(u32 function,						 acpi_physical_address addr,						 u32 bits, acpi_integer *value,						 void *handler_context,						 void *region_context){	struct prm_buffer *buffer = ACPI_CAST_PTR(struct prm_buffer, value);	struct prm_handler_info *handler;	struct prm_module_info *module;	efi_status_t status;	struct prm_context_buffer context; 	if (!efi_enabled(EFI_RUNTIME_SERVICES)) {		pr_err_ratelimited("PRM: EFI runtime services no longer available\n");		return AE_NO_HANDLER;	} 	/*	 * The returned acpi_status will always be AE_OK. Error values will be	 * saved in the first byte of the PRM message buffer to be used by ASL.	 */	switch (buffer->prm_cmd) {	case PRM_CMD_RUN_SERVICE: 		handler = find_prm_handler(&buffer->handler_guid);		module = find_prm_module(&buffer->handler_guid);		if (!handler || !module)			goto invalid_guid; 		if (!handler->handler_addr) {			buffer->prm_status = PRM_HANDLER_ERROR;			return AE_OK;		} 		ACPI_COPY_NAMESEG(context.signature, "PRMC");		context.revision = 0x0;		context.reserved = 0x0;		context.identifier = handler->guid;		context.static_data_buffer = handler->static_data_buffer_addr;		context.mmio_ranges = module->mmio_info; 		status = efi_call_acpi_prm_handler(handler->handler_addr,						   handler->acpi_param_buffer_addr,						   &context);		if (status == EFI_SUCCESS) {			buffer->prm_status = PRM_HANDLER_SUCCESS;		} else {			buffer->prm_status = PRM_HANDLER_ERROR;			buffer->efi_status = status;		}		break; 	case PRM_CMD_START_TRANSACTION: 		module = find_prm_module(&buffer->handler_guid);		if (!module)			goto invalid_guid; 		if (module->updatable)			module->updatable = false;		else			buffer->prm_status = UPDATE_LOCK_ALREADY_HELD;		break; 	case PRM_CMD_END_TRANSACTION: 		module = find_prm_module(&buffer->handler_guid);		if (!module)			goto invalid_guid; 		if (module->updatable)			buffer->prm_status = UPDATE_UNLOCK_WITHOUT_LOCK;		else			module->updatable = true;		break; 	default: 		buffer->prm_status = INVALID_PRM_COMMAND;		break;	} 	return AE_OK; invalid_guid:	buffer->prm_status = PRM_HANDLER_GUID_NOT_FOUND;	return AE_OK;} void __init init_prmt(void){	struct acpi_table_header *tbl;	acpi_status status;	int mc; 	status = acpi_get_table(ACPI_SIG_PRMT, 0, &tbl);	if (ACPI_FAILURE(status))		return; 	mc = acpi_table_parse_entries(ACPI_SIG_PRMT, sizeof(struct acpi_table_prmt) +					  sizeof (struct acpi_table_prmt_header),					  0, acpi_parse_prmt, 0);	acpi_put_table(tbl);	/*	 * Return immediately if PRMT table is not present or no PRM module found.	 */	if (mc <= 0)		return; 	pr_info("PRM: found %u modules\n", mc); 	if (!efi_enabled(EFI_RUNTIME_SERVICES)) {		pr_err("PRM: EFI runtime services unavailable\n");		return;	} 	status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,						    ACPI_ADR_SPACE_PLATFORM_RT,						    &acpi_platformrt_space_handler,						    NULL, NULL);	if (ACPI_FAILURE(status))		pr_alert("PRM: OperationRegion handler could not be installed\n");}