Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 40043927 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'efi-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull EFI updates from Thomas Gleixner:
 "The EFI pile:

   - Make mixed mode UEFI runtime service invocations mutually
     exclusive, as mandated by the UEFI spec

   - Perform UEFI runtime services calls from a work queue so the calls
     into the firmware occur from a kernel thread

   - Honor the UEFI memory map attributes for live memory regions
     configured by UEFI as a framebuffer. This works around a coherency
     problem with KVM guests running on ARM.

   - Cleanups, improvements and fixes all over the place"

* 'efi-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  efivars: Call guid_parse() against guid_t type of variable
  efi/cper: Use consistent types for UUIDs
  efi/x86: Replace references to efi_early->is64 with efi_is_64bit()
  efi: Deduplicate efi_open_volume()
  efi/x86: Add missing NULL initialization in UGA draw protocol discovery
  efi/x86: Merge 32-bit and 64-bit UGA draw protocol setup routines
  efi/x86: Align efi_uga_draw_protocol typedef names to convention
  efi/x86: Merge the setup_efi_pci32() and setup_efi_pci64() routines
  efi/x86: Prevent reentrant firmware calls in mixed mode
  efi/esrt: Only call efi_mem_reserve() for boot services memory
  fbdev/efifb: Honour UEFI memory map attributes when mapping the FB
  efi: Drop type and attribute checks in efi_mem_desc_lookup()
  efi/libstub/arm: Add opt-in Kconfig option for the DTB loader
  efi: Remove the declaration of efi_late_init() as the function is unused
  efi/cper: Avoid using get_seconds()
  efi: Use a work queue to invoke EFI Runtime Services
  efi/x86: Use non-blocking SetVariable() for efi_delete_dummy_variable()
  efi/x86: Clean up the eboot code
parents 0ad6b38a c4326563

arch/arm/include/asm/efi.h

+3 −0
Original line number Diff line number Diff line
@@ -58,6 +58,9 @@ void efi_virtmap_unload(void); 
#define efi_call_runtime(f, ...)	sys_table_arg->runtime->f(__VA_ARGS__)

#define efi_is_64bit()			(false)



#define efi_table_attr(table, attr, instance)				\

	((table##_t *)instance)->attr



#define efi_call_proto(protocol, f, instance, ...)			\

	((protocol##_t *)instance)->f(instance, ##__VA_ARGS__)

arch/arm64/include/asm/efi.h

+3 −0
Original line number Diff line number Diff line
@@ -87,6 +87,9 @@ static inline unsigned long efi_get_max_initrd_addr(unsigned long dram_base, 
#define efi_call_runtime(f, ...)	sys_table_arg->runtime->f(__VA_ARGS__)

#define efi_is_64bit()			(true)



#define efi_table_attr(table, attr, instance)				\

	((table##_t *)instance)->attr



#define efi_call_proto(protocol, f, instance, ...)			\

	((protocol##_t *)instance)->f(instance, ##__VA_ARGS__)

arch/x86/boot/compressed/eboot.c

+183 −362
Original line number Diff line number Diff line
@@ -41,67 +41,6 @@ static void setup_boot_services##bits(struct efi_config *c) \ 
BOOT_SERVICES(32);

BOOT_SERVICES(64);



static inline efi_status_t __open_volume32(void *__image, void **__fh)

{

	efi_file_io_interface_t *io;

	efi_loaded_image_32_t *image = __image;

	efi_file_handle_32_t *fh;

	efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;

	efi_status_t status;

	void *handle = (void *)(unsigned long)image->device_handle;

	unsigned long func;



	status = efi_call_early(handle_protocol, handle,

				&fs_proto, (void **)&io);

	if (status != EFI_SUCCESS) {

		efi_printk(sys_table, "Failed to handle fs_proto\n");

		return status;

	}



	func = (unsigned long)io->open_volume;

	status = efi_early->call(func, io, &fh);

	if (status != EFI_SUCCESS)

		efi_printk(sys_table, "Failed to open volume\n");



	*__fh = fh;

	return status;

}



static inline efi_status_t __open_volume64(void *__image, void **__fh)

{

	efi_file_io_interface_t *io;

	efi_loaded_image_64_t *image = __image;

	efi_file_handle_64_t *fh;

	efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;

	efi_status_t status;

	void *handle = (void *)(unsigned long)image->device_handle;

	unsigned long func;



	status = efi_call_early(handle_protocol, handle,

				&fs_proto, (void **)&io);

	if (status != EFI_SUCCESS) {

		efi_printk(sys_table, "Failed to handle fs_proto\n");

		return status;

	}



	func = (unsigned long)io->open_volume;

	status = efi_early->call(func, io, &fh);

	if (status != EFI_SUCCESS)

		efi_printk(sys_table, "Failed to open volume\n");



	*__fh = fh;

	return status;

}



efi_status_t

efi_open_volume(efi_system_table_t *sys_table, void *__image, void **__fh)

{

	if (efi_early->is64)

		return __open_volume64(__image, __fh);



	return __open_volume32(__image, __fh);

}



void efi_char16_printk(efi_system_table_t *table, efi_char16_t *str)

{

	efi_call_proto(efi_simple_text_output_protocol, output_string,
@@ -109,7 +48,7 @@ void efi_char16_printk(efi_system_table_t *table, efi_char16_t *str) 
}



static efi_status_t

__setup_efi_pci(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)

preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)

{

	struct pci_setup_rom *rom = NULL;

	efi_status_t status;
@@ -134,7 +73,7 @@ __setup_efi_pci(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom) 


	status = efi_call_early(allocate_pool, EFI_LOADER_DATA, size, &rom);

	if (status != EFI_SUCCESS) {

		efi_printk(sys_table, "Failed to alloc mem for rom\n");

		efi_printk(sys_table, "Failed to allocate memory for 'rom'\n");

		return status;

	}
@@ -179,96 +118,6 @@ __setup_efi_pci(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom) 
	return status;

}



static void

setup_efi_pci32(struct boot_params *params, void **pci_handle,

		unsigned long size)

{

	efi_pci_io_protocol_t *pci = NULL;

	efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;

	u32 *handles = (u32 *)(unsigned long)pci_handle;

	efi_status_t status;

	unsigned long nr_pci;

	struct setup_data *data;

	int i;



	data = (struct setup_data *)(unsigned long)params->hdr.setup_data;



	while (data && data->next)

		data = (struct setup_data *)(unsigned long)data->next;



	nr_pci = size / sizeof(u32);

	for (i = 0; i < nr_pci; i++) {

		struct pci_setup_rom *rom = NULL;

		u32 h = handles[i];



		status = efi_call_early(handle_protocol, h,

					&pci_proto, (void **)&pci);



		if (status != EFI_SUCCESS)

			continue;



		if (!pci)

			continue;



		status = __setup_efi_pci(pci, &rom);

		if (status != EFI_SUCCESS)

			continue;



		if (data)

			data->next = (unsigned long)rom;

		else

			params->hdr.setup_data = (unsigned long)rom;



		data = (struct setup_data *)rom;



	}

}



static void

setup_efi_pci64(struct boot_params *params, void **pci_handle,

		unsigned long size)

{

	efi_pci_io_protocol_t *pci = NULL;

	efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;

	u64 *handles = (u64 *)(unsigned long)pci_handle;

	efi_status_t status;

	unsigned long nr_pci;

	struct setup_data *data;

	int i;



	data = (struct setup_data *)(unsigned long)params->hdr.setup_data;



	while (data && data->next)

		data = (struct setup_data *)(unsigned long)data->next;



	nr_pci = size / sizeof(u64);

	for (i = 0; i < nr_pci; i++) {

		struct pci_setup_rom *rom = NULL;

		u64 h = handles[i];



		status = efi_call_early(handle_protocol, h,

					&pci_proto, (void **)&pci);



		if (status != EFI_SUCCESS)

			continue;



		if (!pci)

			continue;



		status = __setup_efi_pci(pci, &rom);

		if (status != EFI_SUCCESS)

			continue;



		if (data)

			data->next = (unsigned long)rom;

		else

			params->hdr.setup_data = (unsigned long)rom;



		data = (struct setup_data *)rom;



	}

}



/*

 * There's no way to return an informative status from this function,

 * because any analysis (and printing of error messages) needs to be
@@ -284,6 +133,9 @@ static void setup_efi_pci(struct boot_params *params) 
	void **pci_handle = NULL;

	efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;

	unsigned long size = 0;

	unsigned long nr_pci;

	struct setup_data *data;

	int i;



	status = efi_call_early(locate_handle,

				EFI_LOCATE_BY_PROTOCOL,
@@ -295,7 +147,7 @@ static void setup_efi_pci(struct boot_params *params) 
					size, (void **)&pci_handle);



		if (status != EFI_SUCCESS) {

			efi_printk(sys_table, "Failed to alloc mem for pci_handle\n");

			efi_printk(sys_table, "Failed to allocate memory for 'pci_handle'\n");

			return;

		}
@@ -307,10 +159,34 @@ static void setup_efi_pci(struct boot_params *params) 
	if (status != EFI_SUCCESS)

		goto free_handle;



	if (efi_early->is64)

		setup_efi_pci64(params, pci_handle, size);

	data = (struct setup_data *)(unsigned long)params->hdr.setup_data;



	while (data && data->next)

		data = (struct setup_data *)(unsigned long)data->next;



	nr_pci = size / (efi_is_64bit() ? sizeof(u64) : sizeof(u32));

	for (i = 0; i < nr_pci; i++) {

		efi_pci_io_protocol_t *pci = NULL;

		struct pci_setup_rom *rom;



		status = efi_call_early(handle_protocol,

					efi_is_64bit() ? ((u64 *)pci_handle)[i]

						       : ((u32 *)pci_handle)[i],

					&pci_proto, (void **)&pci);

		if (status != EFI_SUCCESS || !pci)

			continue;



		status = preserve_pci_rom_image(pci, &rom);

		if (status != EFI_SUCCESS)

			continue;



		if (data)

			data->next = (unsigned long)rom;

		else

		setup_efi_pci32(params, pci_handle, size);

			params->hdr.setup_data = (unsigned long)rom;



		data = (struct setup_data *)rom;

	}



free_handle:

	efi_call_early(free_pool, pci_handle);
@@ -341,8 +217,7 @@ static void retrieve_apple_device_properties(struct boot_params *boot_params) 
		status = efi_call_early(allocate_pool, EFI_LOADER_DATA,

					size + sizeof(struct setup_data), &new);

		if (status != EFI_SUCCESS) {

			efi_printk(sys_table,

					"Failed to alloc mem for properties\n");

			efi_printk(sys_table, "Failed to allocate memory for 'properties'\n");

			return;

		}
@@ -358,9 +233,9 @@ static void retrieve_apple_device_properties(struct boot_params *boot_params) 
	new->next = 0;



	data = (struct setup_data *)(unsigned long)boot_params->hdr.setup_data;

	if (!data)

	if (!data) {

		boot_params->hdr.setup_data = (unsigned long)new;

	else {

	} else {

		while (data->next)

			data = (struct setup_data *)(unsigned long)data->next;

		data->next = (unsigned long)new;
@@ -380,81 +255,55 @@ static void setup_quirks(struct boot_params *boot_params) 
	}

}



/*

 * See if we have Universal Graphics Adapter (UGA) protocol

 */

static efi_status_t

setup_uga32(void **uga_handle, unsigned long size, u32 *width, u32 *height)

setup_uga(struct screen_info *si, efi_guid_t *uga_proto, unsigned long size)

{

	struct efi_uga_draw_protocol *uga = NULL, *first_uga;

	efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;

	efi_status_t status;

	u32 width, height;

	void **uga_handle = NULL;

	efi_uga_draw_protocol_t *uga = NULL, *first_uga;

	unsigned long nr_ugas;

	u32 *handles = (u32 *)uga_handle;

	efi_status_t status = EFI_INVALID_PARAMETER;

	int i;



	first_uga = NULL;

	nr_ugas = size / sizeof(u32);

	for (i = 0; i < nr_ugas; i++) {

		efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;

		u32 w, h, depth, refresh;

		void *pciio;

		u32 handle = handles[i];



		status = efi_call_early(handle_protocol, handle,

					&uga_proto, (void **)&uga);

	status = efi_call_early(allocate_pool, EFI_LOADER_DATA,

				size, (void **)&uga_handle);

	if (status != EFI_SUCCESS)

			continue;



		efi_call_early(handle_protocol, handle, &pciio_proto, &pciio);



		status = efi_early->call((unsigned long)uga->get_mode, uga,

					 &w, &h, &depth, &refresh);

		if (status == EFI_SUCCESS && (!first_uga || pciio)) {

			*width = w;

			*height = h;



			/*

			 * Once we've found a UGA supporting PCIIO,

			 * don't bother looking any further.

			 */

			if (pciio)

				break;



			first_uga = uga;

		}

	}



		return status;

}



static efi_status_t

setup_uga64(void **uga_handle, unsigned long size, u32 *width, u32 *height)

{

	struct efi_uga_draw_protocol *uga = NULL, *first_uga;

	efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;

	unsigned long nr_ugas;

	u64 *handles = (u64 *)uga_handle;

	efi_status_t status = EFI_INVALID_PARAMETER;

	int i;

	status = efi_call_early(locate_handle,

				EFI_LOCATE_BY_PROTOCOL,

				uga_proto, NULL, &size, uga_handle);

	if (status != EFI_SUCCESS)

		goto free_handle;



	height = 0;

	width = 0;



	first_uga = NULL;

	nr_ugas = size / sizeof(u64);

	nr_ugas = size / (efi_is_64bit() ? sizeof(u64) : sizeof(u32));

	for (i = 0; i < nr_ugas; i++) {

		efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;

		u32 w, h, depth, refresh;

		void *pciio;

		u64 handle = handles[i];

		unsigned long handle = efi_is_64bit() ? ((u64 *)uga_handle)[i]

						      : ((u32 *)uga_handle)[i];



		status = efi_call_early(handle_protocol, handle,

					&uga_proto, (void **)&uga);

					uga_proto, (void **)&uga);

		if (status != EFI_SUCCESS)

			continue;



		pciio = NULL;

		efi_call_early(handle_protocol, handle, &pciio_proto, &pciio);



		status = efi_early->call((unsigned long)uga->get_mode, uga,

		status = efi_call_proto(efi_uga_draw_protocol, get_mode, uga,

					&w, &h, &depth, &refresh);

		if (status == EFI_SUCCESS && (!first_uga || pciio)) {

			*width = w;

			*height = h;

			width = w;

			height = h;



			/*

			 * Once we've found a UGA supporting PCIIO,
@@ -467,38 +316,6 @@ setup_uga64(void **uga_handle, unsigned long size, u32 *width, u32 *height) 
		}

	}



	return status;

}



/*

 * See if we have Universal Graphics Adapter (UGA) protocol

 */

static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,

			      unsigned long size)

{

	efi_status_t status;

	u32 width, height;

	void **uga_handle = NULL;



	status = efi_call_early(allocate_pool, EFI_LOADER_DATA,

				size, (void **)&uga_handle);

	if (status != EFI_SUCCESS)

		return status;



	status = efi_call_early(locate_handle,

				EFI_LOCATE_BY_PROTOCOL,

				uga_proto, NULL, &size, uga_handle);

	if (status != EFI_SUCCESS)

		goto free_handle;



	height = 0;

	width = 0;



	if (efi_early->is64)

		status = setup_uga64(uga_handle, size, &width, &height);

	else

		status = setup_uga32(uga_handle, size, &width, &height);



	if (!width && !height)

		goto free_handle;
@@ -520,6 +337,7 @@ static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto, 


free_handle:

	efi_call_early(free_pool, uga_handle);



	return status;

}
@@ -586,7 +404,7 @@ struct boot_params *make_boot_params(struct efi_config *c) 
	if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)

		return NULL;



	if (efi_early->is64)

	if (efi_is_64bit())

		setup_boot_services64(efi_early);

	else

		setup_boot_services32(efi_early);
@@ -601,7 +419,7 @@ struct boot_params *make_boot_params(struct efi_config *c) 
	status = efi_low_alloc(sys_table, 0x4000, 1,

			       (unsigned long *)&boot_params);

	if (status != EFI_SUCCESS) {

		efi_printk(sys_table, "Failed to alloc lowmem for boot params\n");

		efi_printk(sys_table, "Failed to allocate lowmem for boot params\n");

		return NULL;

	}
@@ -627,6 +445,7 @@ struct boot_params *make_boot_params(struct efi_config *c) 
	cmdline_ptr = efi_convert_cmdline(sys_table, image, &options_size);

	if (!cmdline_ptr)

		goto fail;



	hdr->cmd_line_ptr = (unsigned long)cmdline_ptr;

	/* Fill in upper bits of command line address, NOP on 32 bit  */

	boot_params->ext_cmd_line_ptr = (u64)(unsigned long)cmdline_ptr >> 32;
@@ -663,10 +482,12 @@ struct boot_params *make_boot_params(struct efi_config *c) 
	boot_params->ext_ramdisk_size  = (u64)ramdisk_size >> 32;



	return boot_params;



fail2:

	efi_free(sys_table, options_size, hdr->cmd_line_ptr);

fail:

	efi_free(sys_table, 0x4000, (unsigned long)boot_params);



	return NULL;

}
@@ -692,8 +513,8 @@ static void add_e820ext(struct boot_params *params, 
		params->hdr.setup_data = (unsigned long)e820ext;

}



static efi_status_t setup_e820(struct boot_params *params,

			       struct setup_data *e820ext, u32 e820ext_size)

static efi_status_t

setup_e820(struct boot_params *params, struct setup_data *e820ext, u32 e820ext_size)

{

	struct boot_e820_entry *entry = params->e820_table;

	struct efi_info *efi = &params->efi_info;
@@ -818,7 +639,6 @@ struct exit_boot_struct { 
	struct efi_info		*efi;

	struct setup_data	*e820ext;

	__u32			e820ext_size;

	bool is64;

};



static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg,
@@ -845,7 +665,8 @@ static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg, 
		first = false;

	}



	signature = p->is64 ? EFI64_LOADER_SIGNATURE : EFI32_LOADER_SIGNATURE;

	signature = efi_is_64bit() ? EFI64_LOADER_SIGNATURE

				   : EFI32_LOADER_SIGNATURE;

	memcpy(&p->efi->efi_loader_signature, signature, sizeof(__u32));



	p->efi->efi_systab		= (unsigned long)sys_table_arg;
@@ -862,8 +683,7 @@ static efi_status_t exit_boot_func(efi_system_table_t *sys_table_arg, 
	return EFI_SUCCESS;

}



static efi_status_t exit_boot(struct boot_params *boot_params,

			      void *handle, bool is64)

static efi_status_t exit_boot(struct boot_params *boot_params, void *handle)

{

	unsigned long map_sz, key, desc_size, buff_size;

	efi_memory_desc_t *mem_map;
@@ -884,7 +704,6 @@ static efi_status_t exit_boot(struct boot_params *boot_params, 
	priv.efi		= &boot_params->efi_info;

	priv.e820ext		= NULL;

	priv.e820ext_size	= 0;

	priv.is64 =		is64;



	/* Might as well exit boot services now */

	status = efi_exit_boot_services(sys_table, handle, &map, &priv,
@@ -894,6 +713,7 @@ static efi_status_t exit_boot(struct boot_params *boot_params, 


	e820ext			= priv.e820ext;

	e820ext_size		= priv.e820ext_size;



	/* Historic? */

	boot_params->alt_mem_k	= 32 * 1024;
@@ -908,8 +728,8 @@ static efi_status_t exit_boot(struct boot_params *boot_params, 
 * On success we return a pointer to a boot_params structure, and NULL

 * on failure.

 */

struct boot_params *efi_main(struct efi_config *c,

			     struct boot_params *boot_params)

struct boot_params *

efi_main(struct efi_config *c, struct boot_params *boot_params)

{

	struct desc_ptr *gdt = NULL;

	efi_loaded_image_t *image;
@@ -918,13 +738,11 @@ struct boot_params *efi_main(struct efi_config *c, 
	struct desc_struct *desc;

	void *handle;

	efi_system_table_t *_table;

	bool is64;



	efi_early = c;



	_table = (efi_system_table_t *)(unsigned long)efi_early->table;

	handle = (void *)(unsigned long)efi_early->image_handle;

	is64 = efi_early->is64;



	sys_table = _table;
@@ -932,7 +750,7 @@ struct boot_params *efi_main(struct efi_config *c, 
	if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)

		goto fail;



	if (is64)

	if (efi_is_64bit())

		setup_boot_services64(efi_early);

	else

		setup_boot_services32(efi_early);
@@ -957,7 +775,7 @@ struct boot_params *efi_main(struct efi_config *c, 
	status = efi_call_early(allocate_pool, EFI_LOADER_DATA,

				sizeof(*gdt), (void **)&gdt);

	if (status != EFI_SUCCESS) {

		efi_printk(sys_table, "Failed to alloc mem for gdt structure\n");

		efi_printk(sys_table, "Failed to allocate memory for 'gdt' structure\n");

		goto fail;

	}
@@ -965,7 +783,7 @@ struct boot_params *efi_main(struct efi_config *c, 
	status = efi_low_alloc(sys_table, gdt->size, 8,

			   (unsigned long *)&gdt->address);

	if (status != EFI_SUCCESS) {

		efi_printk(sys_table, "Failed to alloc mem for gdt\n");

		efi_printk(sys_table, "Failed to allocate memory for 'gdt'\n");

		goto fail;

	}
@@ -988,7 +806,7 @@ struct boot_params *efi_main(struct efi_config *c, 
		hdr->code32_start = bzimage_addr;

	}



	status = exit_boot(boot_params, handle, is64);

	status = exit_boot(boot_params, handle);

	if (status != EFI_SUCCESS) {

		efi_printk(sys_table, "exit_boot() failed!\n");

		goto fail;
@@ -1015,6 +833,7 @@ struct boot_params *efi_main(struct efi_config *c, 
		desc->d		= SEG_OP_SIZE_32BIT;

		desc->g		= SEG_GRANULARITY_4KB;

		desc->base2	= 0x00;



		desc++;

	} else {

		/* Second entry is unused on 32-bit */
@@ -1031,6 +850,7 @@ struct boot_params *efi_main(struct efi_config *c, 
	desc->p		= 1;

	desc->limit1	= 0xf;

	desc->avl	= 0;



	if (IS_ENABLED(CONFIG_X86_64)) {

		desc->l = 1;

		desc->d = 0;
@@ -1082,5 +902,6 @@ struct boot_params *efi_main(struct efi_config *c, 
	return boot_params;

fail:

	efi_printk(sys_table, "efi_main() failed!\n");



	return NULL;

}

arch/x86/boot/compressed/eboot.h

+6 −6
Original line number Diff line number Diff line
@@ -12,22 +12,22 @@ 


#define DESC_TYPE_CODE_DATA	(1 << 0)



struct efi_uga_draw_protocol_32 {

typedef struct {

	u32 get_mode;

	u32 set_mode;

	u32 blt;

};

} efi_uga_draw_protocol_32_t;



struct efi_uga_draw_protocol_64 {

typedef struct {

	u64 get_mode;

	u64 set_mode;

	u64 blt;

};

} efi_uga_draw_protocol_64_t;



struct efi_uga_draw_protocol {

typedef struct {

	void *get_mode;

	void *set_mode;

	void *blt;

};

} efi_uga_draw_protocol_t;



#endif /* BOOT_COMPRESSED_EBOOT_H */

arch/x86/platform/efi/efi_64.c

+98 −3
Original line number Diff line number Diff line
@@ -636,6 +636,8 @@ void efi_switch_mm(struct mm_struct *mm) 
#ifdef CONFIG_EFI_MIXED

extern efi_status_t efi64_thunk(u32, ...);



static DEFINE_SPINLOCK(efi_runtime_lock);



#define runtime_service32(func)						 \

({									 \

	u32 table = (u32)(unsigned long)efi.systab;			 \
@@ -657,17 +659,14 @@ extern efi_status_t efi64_thunk(u32, ...); 
#define efi_thunk(f, ...)						\

({									\

	efi_status_t __s;						\

	unsigned long __flags;						\

	u32 __func;							\

									\

	local_irq_save(__flags);					\

	arch_efi_call_virt_setup();					\

									\

	__func = runtime_service32(f);					\

	__s = efi64_thunk(__func, __VA_ARGS__);				\

									\

	arch_efi_call_virt_teardown();					\

	local_irq_restore(__flags);					\

									\

	__s;								\

})
@@ -702,14 +701,17 @@ static efi_status_t efi_thunk_get_time(efi_time_t *tm, efi_time_cap_t *tc) 
{

	efi_status_t status;

	u32 phys_tm, phys_tc;

	unsigned long flags;



	spin_lock(&rtc_lock);

	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_tm = virt_to_phys_or_null(tm);

	phys_tc = virt_to_phys_or_null(tc);



	status = efi_thunk(get_time, phys_tm, phys_tc);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);

	spin_unlock(&rtc_lock);



	return status;
@@ -719,13 +721,16 @@ static efi_status_t efi_thunk_set_time(efi_time_t *tm) 
{

	efi_status_t status;

	u32 phys_tm;

	unsigned long flags;



	spin_lock(&rtc_lock);

	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_tm = virt_to_phys_or_null(tm);



	status = efi_thunk(set_time, phys_tm);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);

	spin_unlock(&rtc_lock);



	return status;
@@ -737,8 +742,10 @@ efi_thunk_get_wakeup_time(efi_bool_t *enabled, efi_bool_t *pending, 
{

	efi_status_t status;

	u32 phys_enabled, phys_pending, phys_tm;

	unsigned long flags;



	spin_lock(&rtc_lock);

	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_enabled = virt_to_phys_or_null(enabled);

	phys_pending = virt_to_phys_or_null(pending);
@@ -747,6 +754,7 @@ efi_thunk_get_wakeup_time(efi_bool_t *enabled, efi_bool_t *pending, 
	status = efi_thunk(get_wakeup_time, phys_enabled,

			     phys_pending, phys_tm);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);

	spin_unlock(&rtc_lock);



	return status;
@@ -757,13 +765,16 @@ efi_thunk_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm) 
{

	efi_status_t status;

	u32 phys_tm;

	unsigned long flags;



	spin_lock(&rtc_lock);

	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_tm = virt_to_phys_or_null(tm);



	status = efi_thunk(set_wakeup_time, enabled, phys_tm);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);

	spin_unlock(&rtc_lock);



	return status;
@@ -781,6 +792,9 @@ efi_thunk_get_variable(efi_char16_t *name, efi_guid_t *vendor, 
	efi_status_t status;

	u32 phys_name, phys_vendor, phys_attr;

	u32 phys_data_size, phys_data;

	unsigned long flags;



	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_data_size = virt_to_phys_or_null(data_size);

	phys_vendor = virt_to_phys_or_null(vendor);
@@ -791,6 +805,8 @@ efi_thunk_get_variable(efi_char16_t *name, efi_guid_t *vendor, 
	status = efi_thunk(get_variable, phys_name, phys_vendor,

			   phys_attr, phys_data_size, phys_data);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);



	return status;

}
@@ -800,6 +816,9 @@ efi_thunk_set_variable(efi_char16_t *name, efi_guid_t *vendor, 
{

	u32 phys_name, phys_vendor, phys_data;

	efi_status_t status;

	unsigned long flags;



	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_name = virt_to_phys_or_null_size(name, efi_name_size(name));

	phys_vendor = virt_to_phys_or_null(vendor);
@@ -809,6 +828,33 @@ efi_thunk_set_variable(efi_char16_t *name, efi_guid_t *vendor, 
	status = efi_thunk(set_variable, phys_name, phys_vendor,

			   attr, data_size, phys_data);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);



	return status;

}



static efi_status_t

efi_thunk_set_variable_nonblocking(efi_char16_t *name, efi_guid_t *vendor,

				   u32 attr, unsigned long data_size,

				   void *data)

{

	u32 phys_name, phys_vendor, phys_data;

	efi_status_t status;

	unsigned long flags;



	if (!spin_trylock_irqsave(&efi_runtime_lock, flags))

		return EFI_NOT_READY;



	phys_name = virt_to_phys_or_null_size(name, efi_name_size(name));

	phys_vendor = virt_to_phys_or_null(vendor);

	phys_data = virt_to_phys_or_null_size(data, data_size);



	/* If data_size is > sizeof(u32) we've got problems */

	status = efi_thunk(set_variable, phys_name, phys_vendor,

			   attr, data_size, phys_data);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);



	return status;

}
@@ -819,6 +865,9 @@ efi_thunk_get_next_variable(unsigned long *name_size, 
{

	efi_status_t status;

	u32 phys_name_size, phys_name, phys_vendor;

	unsigned long flags;



	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_name_size = virt_to_phys_or_null(name_size);

	phys_vendor = virt_to_phys_or_null(vendor);
@@ -827,6 +876,8 @@ efi_thunk_get_next_variable(unsigned long *name_size, 
	status = efi_thunk(get_next_variable, phys_name_size,

			   phys_name, phys_vendor);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);



	return status;

}
@@ -835,10 +886,15 @@ efi_thunk_get_next_high_mono_count(u32 *count) 
{

	efi_status_t status;

	u32 phys_count;

	unsigned long flags;



	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_count = virt_to_phys_or_null(count);

	status = efi_thunk(get_next_high_mono_count, phys_count);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);



	return status;

}
@@ -847,10 +903,15 @@ efi_thunk_reset_system(int reset_type, efi_status_t status, 
		       unsigned long data_size, efi_char16_t *data)

{

	u32 phys_data;

	unsigned long flags;



	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_data = virt_to_phys_or_null_size(data, data_size);



	efi_thunk(reset_system, reset_type, status, data_size, phys_data);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);

}



static efi_status_t
@@ -872,10 +933,40 @@ efi_thunk_query_variable_info(u32 attr, u64 *storage_space, 
{

	efi_status_t status;

	u32 phys_storage, phys_remaining, phys_max;

	unsigned long flags;



	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)

		return EFI_UNSUPPORTED;



	spin_lock_irqsave(&efi_runtime_lock, flags);



	phys_storage = virt_to_phys_or_null(storage_space);

	phys_remaining = virt_to_phys_or_null(remaining_space);

	phys_max = virt_to_phys_or_null(max_variable_size);



	status = efi_thunk(query_variable_info, attr, phys_storage,

			   phys_remaining, phys_max);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);



	return status;

}



static efi_status_t

efi_thunk_query_variable_info_nonblocking(u32 attr, u64 *storage_space,

					  u64 *remaining_space,

					  u64 *max_variable_size)

{

	efi_status_t status;

	u32 phys_storage, phys_remaining, phys_max;

	unsigned long flags;



	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)

		return EFI_UNSUPPORTED;



	if (!spin_trylock_irqsave(&efi_runtime_lock, flags))

		return EFI_NOT_READY;



	phys_storage = virt_to_phys_or_null(storage_space);

	phys_remaining = virt_to_phys_or_null(remaining_space);

	phys_max = virt_to_phys_or_null(max_variable_size);
@@ -883,6 +974,8 @@ efi_thunk_query_variable_info(u32 attr, u64 *storage_space, 
	status = efi_thunk(query_variable_info, attr, phys_storage,

			   phys_remaining, phys_max);



	spin_unlock_irqrestore(&efi_runtime_lock, flags);



	return status;

}
@@ -908,9 +1001,11 @@ void efi_thunk_runtime_setup(void) 
	efi.get_variable = efi_thunk_get_variable;

	efi.get_next_variable = efi_thunk_get_next_variable;

	efi.set_variable = efi_thunk_set_variable;

	efi.set_variable_nonblocking = efi_thunk_set_variable_nonblocking;

	efi.get_next_high_mono_count = efi_thunk_get_next_high_mono_count;

	efi.reset_system = efi_thunk_reset_system;

	efi.query_variable_info = efi_thunk_query_variable_info;

	efi.query_variable_info_nonblocking = efi_thunk_query_variable_info_nonblocking;

	efi.update_capsule = efi_thunk_update_capsule;

	efi.query_capsule_caps = efi_thunk_query_capsule_caps;

}