[mirror_ubuntu-bionic-kernel.git] / drivers / firmware / efi / libstub / gop.c

/* -----------------------------------------------------------------------
 *
 *   Copyright 2011 Intel Corporation; author Matt Fleming
 *
 *   This file is part of the Linux kernel, and is made available under
 *   the terms of the GNU General Public License version 2.
 *
 * ----------------------------------------------------------------------- */

#include <linux/efi.h>
#include <linux/screen_info.h>
#include <asm/efi.h>
#include <asm/setup.h>

static void find_bits(unsigned long mask, u8 *pos, u8 *size)
{
	u8 first, len;

	first = 0;
	len = 0;

	if (mask) {
		while (!(mask & 0x1)) {
			mask = mask >> 1;
			first++;
		}

		while (mask & 0x1) {
			mask = mask >> 1;
			len++;
		}
	}

	*pos = first;
	*size = len;
}

static void
setup_pixel_info(struct screen_info *si, u32 pixels_per_scan_line,
		 struct efi_pixel_bitmask pixel_info, int pixel_format)
{
	if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
		si->lfb_depth = 32;
		si->lfb_linelength = pixels_per_scan_line * 4;
		si->red_size = 8;
		si->red_pos = 0;
		si->green_size = 8;
		si->green_pos = 8;
		si->blue_size = 8;
		si->blue_pos = 16;
		si->rsvd_size = 8;
		si->rsvd_pos = 24;
	} else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
		si->lfb_depth = 32;
		si->lfb_linelength = pixels_per_scan_line * 4;
		si->red_size = 8;
		si->red_pos = 16;
		si->green_size = 8;
		si->green_pos = 8;
		si->blue_size = 8;
		si->blue_pos = 0;
		si->rsvd_size = 8;
		si->rsvd_pos = 24;
	} else if (pixel_format == PIXEL_BIT_MASK) {
		find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
		find_bits(pixel_info.green_mask, &si->green_pos,
			  &si->green_size);
		find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
		find_bits(pixel_info.reserved_mask, &si->rsvd_pos,
			  &si->rsvd_size);
		si->lfb_depth = si->red_size + si->green_size +
			si->blue_size + si->rsvd_size;
		si->lfb_linelength = (pixels_per_scan_line * si->lfb_depth) / 8;
	} else {
		si->lfb_depth = 4;
		si->lfb_linelength = si->lfb_width / 2;
		si->red_size = 0;
		si->red_pos = 0;
		si->green_size = 0;
		si->green_pos = 0;
		si->blue_size = 0;
		si->blue_pos = 0;
		si->rsvd_size = 0;
		si->rsvd_pos = 0;
	}
}

static efi_status_t
__gop_query32(efi_system_table_t *sys_table_arg,
	      struct efi_graphics_output_protocol_32 *gop32,
	      struct efi_graphics_output_mode_info **info,
	      unsigned long *size, u64 *fb_base)
{
	struct efi_graphics_output_protocol_mode_32 *mode;
	efi_graphics_output_protocol_query_mode query_mode;
	efi_status_t status;
	unsigned long m;

	m = gop32->mode;
	mode = (struct efi_graphics_output_protocol_mode_32 *)m;
	query_mode = (void *)(unsigned long)gop32->query_mode;

	status = __efi_call_early(query_mode, (void *)gop32, mode->mode, size,
				  info);
	if (status != EFI_SUCCESS)
		return status;

	*fb_base = mode->frame_buffer_base;
	return status;
}

static efi_status_t
setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si,
            efi_guid_t *proto, unsigned long size, void **gop_handle)
{
	struct efi_graphics_output_protocol_32 *gop32, *first_gop;
	unsigned long nr_gops;
	u16 width, height;
	u32 pixels_per_scan_line;
	u32 ext_lfb_base;
	u64 fb_base;
	struct efi_pixel_bitmask pixel_info;
	int pixel_format;
	efi_status_t status;
	u32 *handles = (u32 *)(unsigned long)gop_handle;
	int i;

	first_gop = NULL;
	gop32 = NULL;

	nr_gops = size / sizeof(u32);
	for (i = 0; i < nr_gops; i++) {
		struct efi_graphics_output_mode_info *info = NULL;
		efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
		bool conout_found = false;
		void *dummy = NULL;
		efi_handle_t h = (efi_handle_t)(unsigned long)handles[i];
		u64 current_fb_base;

		status = efi_call_early(handle_protocol, h,
					proto, (void **)&gop32);
		if (status != EFI_SUCCESS)
			continue;

		status = efi_call_early(handle_protocol, h,
					&conout_proto, &dummy);
		if (status == EFI_SUCCESS)
			conout_found = true;

		status = __gop_query32(sys_table_arg, gop32, &info, &size,
				       &current_fb_base);
		if (status == EFI_SUCCESS && (!first_gop || conout_found) &&
		    info->pixel_format != PIXEL_BLT_ONLY) {
			/*
			 * Systems that use the UEFI Console Splitter may
			 * provide multiple GOP devices, not all of which are
			 * backed by real hardware. The workaround is to search
			 * for a GOP implementing the ConOut protocol, and if
			 * one isn't found, to just fall back to the first GOP.
			 */
			width = info->horizontal_resolution;
			height = info->vertical_resolution;
			pixel_format = info->pixel_format;
			pixel_info = info->pixel_information;
			pixels_per_scan_line = info->pixels_per_scan_line;
			fb_base = current_fb_base;

			/*
			 * Once we've found a GOP supporting ConOut,
			 * don't bother looking any further.
			 */
			first_gop = gop32;
			if (conout_found)
				break;
		}
	}

	/* Did we find any GOPs? */
	if (!first_gop)
		return EFI_NOT_FOUND;

	/* EFI framebuffer */
	si->orig_video_isVGA = VIDEO_TYPE_EFI;

	si->lfb_width = width;
	si->lfb_height = height;
	si->lfb_base = fb_base;

	ext_lfb_base = (u64)(unsigned long)fb_base >> 32;
	if (ext_lfb_base) {
		si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
		si->ext_lfb_base = ext_lfb_base;
	}

	si->pages = 1;

	setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);

	si->lfb_size = si->lfb_linelength * si->lfb_height;

	si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;

	return EFI_SUCCESS;
}

static efi_status_t
__gop_query64(efi_system_table_t *sys_table_arg,
	      struct efi_graphics_output_protocol_64 *gop64,
	      struct efi_graphics_output_mode_info **info,
	      unsigned long *size, u64 *fb_base)
{
	struct efi_graphics_output_protocol_mode_64 *mode;
	efi_graphics_output_protocol_query_mode query_mode;
	efi_status_t status;
	unsigned long m;

	m = gop64->mode;
	mode = (struct efi_graphics_output_protocol_mode_64 *)m;
	query_mode = (void *)(unsigned long)gop64->query_mode;

	status = __efi_call_early(query_mode, (void *)gop64, mode->mode, size,
				  info);
	if (status != EFI_SUCCESS)
		return status;

	*fb_base = mode->frame_buffer_base;
	return status;
}

static efi_status_t
setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si,
	    efi_guid_t *proto, unsigned long size, void **gop_handle)
{
	struct efi_graphics_output_protocol_64 *gop64, *first_gop;
	unsigned long nr_gops;
	u16 width, height;
	u32 pixels_per_scan_line;
	u32 ext_lfb_base;
	u64 fb_base;
	struct efi_pixel_bitmask pixel_info;
	int pixel_format;
	efi_status_t status;
	u64 *handles = (u64 *)(unsigned long)gop_handle;
	int i;

	first_gop = NULL;
	gop64 = NULL;

	nr_gops = size / sizeof(u64);
	for (i = 0; i < nr_gops; i++) {
		struct efi_graphics_output_mode_info *info = NULL;
		efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
		bool conout_found = false;
		void *dummy = NULL;
		efi_handle_t h = (efi_handle_t)(unsigned long)handles[i];
		u64 current_fb_base;

		status = efi_call_early(handle_protocol, h,
					proto, (void **)&gop64);
		if (status != EFI_SUCCESS)
			continue;

		status = efi_call_early(handle_protocol, h,
					&conout_proto, &dummy);
		if (status == EFI_SUCCESS)
			conout_found = true;

		status = __gop_query64(sys_table_arg, gop64, &info, &size,
				       &current_fb_base);
		if (status == EFI_SUCCESS && (!first_gop || conout_found) &&
		    info->pixel_format != PIXEL_BLT_ONLY) {
			/*
			 * Systems that use the UEFI Console Splitter may
			 * provide multiple GOP devices, not all of which are
			 * backed by real hardware. The workaround is to search
			 * for a GOP implementing the ConOut protocol, and if
			 * one isn't found, to just fall back to the first GOP.
			 */
			width = info->horizontal_resolution;
			height = info->vertical_resolution;
			pixel_format = info->pixel_format;
			pixel_info = info->pixel_information;
			pixels_per_scan_line = info->pixels_per_scan_line;
			fb_base = current_fb_base;

			/*
			 * Once we've found a GOP supporting ConOut,
			 * don't bother looking any further.
			 */
			first_gop = gop64;
			if (conout_found)
				break;
		}
	}

	/* Did we find any GOPs? */
	if (!first_gop)
		return EFI_NOT_FOUND;

	/* EFI framebuffer */
	si->orig_video_isVGA = VIDEO_TYPE_EFI;

	si->lfb_width = width;
	si->lfb_height = height;
	si->lfb_base = fb_base;

	ext_lfb_base = (u64)(unsigned long)fb_base >> 32;
	if (ext_lfb_base) {
		si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
		si->ext_lfb_base = ext_lfb_base;
	}

	si->pages = 1;

	setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);

	si->lfb_size = si->lfb_linelength * si->lfb_height;

	si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;

	return EFI_SUCCESS;
}

/*
 * See if we have Graphics Output Protocol
 */
efi_status_t efi_setup_gop(efi_system_table_t *sys_table_arg,
			   struct screen_info *si, efi_guid_t *proto,
			   unsigned long size)
{
	efi_status_t status;
	void **gop_handle = NULL;

	status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
				size, (void **)&gop_handle);
	if (status != EFI_SUCCESS)
		return status;

	status = efi_call_early(locate_handle,
				EFI_LOCATE_BY_PROTOCOL,
				proto, NULL, &size, gop_handle);
	if (status != EFI_SUCCESS)
		goto free_handle;

	if (efi_is_64bit()) {
		status = setup_gop64(sys_table_arg, si, proto, size,
				     gop_handle);
	} else {
		status = setup_gop32(sys_table_arg, si, proto, size,
				     gop_handle);
	}

free_handle:
	efi_call_early(free_pool, gop_handle);
	return status;
}
Commit	Line	Data
fc372064 AB	1	/* -----------------------------------------------------------------------
	2	*
	3	* Copyright 2011 Intel Corporation; author Matt Fleming
	4	*
	5	* This file is part of the Linux kernel, and is made available under
	6	* the terms of the GNU General Public License version 2.
	7	*
	8	* ----------------------------------------------------------------------- */
	9
	10	#include <linux/efi.h>
	11	#include <linux/screen_info.h>
	12	#include <asm/efi.h>
	13	#include <asm/setup.h>
	14
	15	static void find_bits(unsigned long mask, u8 pos, u8 size)
	16	{
	17	u8 first, len;
	18
	19	first = 0;
	20	len = 0;
	21
	22	if (mask) {
	23	while (!(mask & 0x1)) {
	24	mask = mask >> 1;
	25	first++;
	26	}
	27
	28	while (mask & 0x1) {
	29	mask = mask >> 1;
	30	len++;
	31	}
	32	}
	33
	34	*pos = first;
	35	*size = len;
	36	}
	37
	38	static void
	39	setup_pixel_info(struct screen_info *si, u32 pixels_per_scan_line,
	40	struct efi_pixel_bitmask pixel_info, int pixel_format)
	41	{
	42	if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
	43	si->lfb_depth = 32;
	44	si->lfb_linelength = pixels_per_scan_line * 4;
	45	si->red_size = 8;
	46	si->red_pos = 0;
	47	si->green_size = 8;
	48	si->green_pos = 8;
	49	si->blue_size = 8;
	50	si->blue_pos = 16;
	51	si->rsvd_size = 8;
	52	si->rsvd_pos = 24;
	53	} else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
	54	si->lfb_depth = 32;
	55	si->lfb_linelength = pixels_per_scan_line * 4;
	56	si->red_size = 8;
	57	si->red_pos = 16;
	58	si->green_size = 8;
	59	si->green_pos = 8;
	60	si->blue_size = 8;
	61	si->blue_pos = 0;
	62	si->rsvd_size = 8;
	63	si->rsvd_pos = 24;
	64	} else if (pixel_format == PIXEL_BIT_MASK) {
65	find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
66	find_bits(pixel_info.green_mask, &si->green_pos,
67	&si->green_size);
68	find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
69	find_bits(pixel_info.reserved_mask, &si->rsvd_pos,
70	&si->rsvd_size);
71	si->lfb_depth = si->red_size + si->green_size +
72	si->blue_size + si->rsvd_size;
73	si->lfb_linelength = (pixels_per_scan_line * si->lfb_depth) / 8;
74	} else {
75	si->lfb_depth = 4;
76	si->lfb_linelength = si->lfb_width / 2;
77	si->red_size = 0;
78	si->red_pos = 0;
79	si->green_size = 0;
80	si->green_pos = 0;
81	si->blue_size = 0;
82	si->blue_pos = 0;
83	si->rsvd_size = 0;
84	si->rsvd_pos = 0;
85	}
86	}
87
88	static efi_status_t
89	__gop_query32(efi_system_table_t *sys_table_arg,
90	struct efi_graphics_output_protocol_32 *gop32,
91	struct efi_graphics_output_mode_info **info,
92	unsigned long size, u64 fb_base)
93	{
94	struct efi_graphics_output_protocol_mode_32 *mode;
95	efi_graphics_output_protocol_query_mode query_mode;
96	efi_status_t status;
97	unsigned long m;
98
99	m = gop32->mode;
100	mode = (struct efi_graphics_output_protocol_mode_32 *)m;
101	query_mode = (void *)(unsigned long)gop32->query_mode;
102
103	status = __efi_call_early(query_mode, (void *)gop32, mode->mode, size,
104	info);
105	if (status != EFI_SUCCESS)
106	return status;
107
108	*fb_base = mode->frame_buffer_base;
109	return status;
110	}
111
112	static efi_status_t
113	setup_gop32(efi_system_table_t sys_table_arg, struct screen_info si,
114	efi_guid_t proto, unsigned long size, void *gop_handle)
115	{
116	struct efi_graphics_output_protocol_32 gop32, first_gop;
117	unsigned long nr_gops;
118	u16 width, height;
119	u32 pixels_per_scan_line;
120	u32 ext_lfb_base;
121	u64 fb_base;
122	struct efi_pixel_bitmask pixel_info;
123	int pixel_format;
cd514b32	124	efi_status_t status;
fc372064 AB	125	u32 handles = (u32 )(unsigned long)gop_handle;
	126	int i;
	127
	128	first_gop = NULL;
	129	gop32 = NULL;
	130
	131	nr_gops = size / sizeof(u32);
	132	for (i = 0; i < nr_gops; i++) {
	133	struct efi_graphics_output_mode_info *info = NULL;
	134	efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
	135	bool conout_found = false;
	136	void *dummy = NULL;
	137	efi_handle_t h = (efi_handle_t)(unsigned long)handles[i];
	138	u64 current_fb_base;
	139
	140	status = efi_call_early(handle_protocol, h,
	141	proto, (void **)&gop32);
	142	if (status != EFI_SUCCESS)
	143	continue;
	144
	145	status = efi_call_early(handle_protocol, h,
	146	&conout_proto, &dummy);
	147	if (status == EFI_SUCCESS)
	148	conout_found = true;
	149
	150	status = __gop_query32(sys_table_arg, gop32, &info, &size,
	151	&current_fb_base);
540f4c0e CE	152	if (status == EFI_SUCCESS && (!first_gop \|\| conout_found) &&
540f4c0e CE	153	info->pixel_format != PIXEL_BLT_ONLY) {
fc372064 AB	154	/*
	155	* Systems that use the UEFI Console Splitter may
	156	* provide multiple GOP devices, not all of which are
	157	* backed by real hardware. The workaround is to search
	158	* for a GOP implementing the ConOut protocol, and if
	159	* one isn't found, to just fall back to the first GOP.
	160	*/
	161	width = info->horizontal_resolution;
	162	height = info->vertical_resolution;
	163	pixel_format = info->pixel_format;
	164	pixel_info = info->pixel_information;
	165	pixels_per_scan_line = info->pixels_per_scan_line;
	166	fb_base = current_fb_base;
	167
	168	/*
	169	* Once we've found a GOP supporting ConOut,
	170	* don't bother looking any further.
	171	*/
	172	first_gop = gop32;
	173	if (conout_found)
	174	break;
	175	}
	176	}
	177
	178	/* Did we find any GOPs? */
	179	if (!first_gop)
cd514b32	180	return EFI_NOT_FOUND;
fc372064 AB	181
	182	/* EFI framebuffer */
	183	si->orig_video_isVGA = VIDEO_TYPE_EFI;
	184
	185	si->lfb_width = width;
	186	si->lfb_height = height;
	187	si->lfb_base = fb_base;
	188
	189	ext_lfb_base = (u64)(unsigned long)fb_base >> 32;
	190	if (ext_lfb_base) {
	191	si->capabilities \|= VIDEO_CAPABILITY_64BIT_BASE;
	192	si->ext_lfb_base = ext_lfb_base;
	193	}
	194
	195	si->pages = 1;
	196
	197	setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
	198
	199	si->lfb_size = si->lfb_linelength * si->lfb_height;
	200
	201	si->capabilities \|= VIDEO_CAPABILITY_SKIP_QUIRKS;
cd514b32	202
dde8ed99	203	return EFI_SUCCESS;
fc372064 AB	204	}
	205
	206	static efi_status_t
	207	__gop_query64(efi_system_table_t *sys_table_arg,
	208	struct efi_graphics_output_protocol_64 *gop64,
	209	struct efi_graphics_output_mode_info **info,
	210	unsigned long size, u64 fb_base)
	211	{
	212	struct efi_graphics_output_protocol_mode_64 *mode;
	213	efi_graphics_output_protocol_query_mode query_mode;
	214	efi_status_t status;
	215	unsigned long m;
	216
	217	m = gop64->mode;
	218	mode = (struct efi_graphics_output_protocol_mode_64 *)m;
	219	query_mode = (void *)(unsigned long)gop64->query_mode;
	220
	221	status = __efi_call_early(query_mode, (void *)gop64, mode->mode, size,
	222	info);
	223	if (status != EFI_SUCCESS)
	224	return status;
	225
	226	*fb_base = mode->frame_buffer_base;
	227	return status;
	228	}
	229
	230	static efi_status_t
	231	setup_gop64(efi_system_table_t sys_table_arg, struct screen_info si,
	232	efi_guid_t proto, unsigned long size, void *gop_handle)
	233	{
	234	struct efi_graphics_output_protocol_64 gop64, first_gop;
	235	unsigned long nr_gops;
	236	u16 width, height;
	237	u32 pixels_per_scan_line;
	238	u32 ext_lfb_base;
	239	u64 fb_base;
	240	struct efi_pixel_bitmask pixel_info;
	241	int pixel_format;
cd514b32	242	efi_status_t status;
fc372064 AB	243	u64 handles = (u64 )(unsigned long)gop_handle;
	244	int i;
	245
	246	first_gop = NULL;
	247	gop64 = NULL;
	248
	249	nr_gops = size / sizeof(u64);
	250	for (i = 0; i < nr_gops; i++) {
	251	struct efi_graphics_output_mode_info *info = NULL;
	252	efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
	253	bool conout_found = false;
	254	void *dummy = NULL;
	255	efi_handle_t h = (efi_handle_t)(unsigned long)handles[i];
	256	u64 current_fb_base;
	257
	258	status = efi_call_early(handle_protocol, h,
	259	proto, (void **)&gop64);
	260	if (status != EFI_SUCCESS)
	261	continue;
	262
	263	status = efi_call_early(handle_protocol, h,
	264	&conout_proto, &dummy);
	265	if (status == EFI_SUCCESS)
	266	conout_found = true;
	267
	268	status = __gop_query64(sys_table_arg, gop64, &info, &size,
	269	&current_fb_base);
540f4c0e CE	270	if (status == EFI_SUCCESS && (!first_gop \|\| conout_found) &&
540f4c0e CE	271	info->pixel_format != PIXEL_BLT_ONLY) {
fc372064 AB	272	/*
	273	* Systems that use the UEFI Console Splitter may
	274	* provide multiple GOP devices, not all of which are
	275	* backed by real hardware. The workaround is to search
	276	* for a GOP implementing the ConOut protocol, and if
	277	* one isn't found, to just fall back to the first GOP.
	278	*/
	279	width = info->horizontal_resolution;
	280	height = info->vertical_resolution;
	281	pixel_format = info->pixel_format;
	282	pixel_info = info->pixel_information;
	283	pixels_per_scan_line = info->pixels_per_scan_line;
	284	fb_base = current_fb_base;
	285
	286	/*
	287	* Once we've found a GOP supporting ConOut,
	288	* don't bother looking any further.
	289	*/
	290	first_gop = gop64;
	291	if (conout_found)
	292	break;
	293	}
	294	}
	295
	296	/* Did we find any GOPs? */
	297	if (!first_gop)
cd514b32	298	return EFI_NOT_FOUND;
fc372064 AB	299
	300	/* EFI framebuffer */
	301	si->orig_video_isVGA = VIDEO_TYPE_EFI;
	302
	303	si->lfb_width = width;
	304	si->lfb_height = height;
	305	si->lfb_base = fb_base;
	306
	307	ext_lfb_base = (u64)(unsigned long)fb_base >> 32;
	308	if (ext_lfb_base) {
	309	si->capabilities \|= VIDEO_CAPABILITY_64BIT_BASE;
	310	si->ext_lfb_base = ext_lfb_base;
	311	}
	312
	313	si->pages = 1;
	314
	315	setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
	316
	317	si->lfb_size = si->lfb_linelength * si->lfb_height;
	318
	319	si->capabilities \|= VIDEO_CAPABILITY_SKIP_QUIRKS;
cd514b32	320
dde8ed99	321	return EFI_SUCCESS;
fc372064 AB	322	}
	323
	324	/*
	325	* See if we have Graphics Output Protocol
	326	*/
	327	efi_status_t efi_setup_gop(efi_system_table_t *sys_table_arg,
	328	struct screen_info si, efi_guid_t proto,
	329	unsigned long size)
	330	{
	331	efi_status_t status;
	332	void **gop_handle = NULL;
	333
	334	status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
	335	size, (void **)&gop_handle);
	336	if (status != EFI_SUCCESS)
	337	return status;
	338
	339	status = efi_call_early(locate_handle,
	340	EFI_LOCATE_BY_PROTOCOL,
	341	proto, NULL, &size, gop_handle);
	342	if (status != EFI_SUCCESS)
	343	goto free_handle;
	344
	345	if (efi_is_64bit()) {
	346	status = setup_gop64(sys_table_arg, si, proto, size,
	347	gop_handle);
	348	} else {
	349	status = setup_gop32(sys_table_arg, si, proto, size,
	350	gop_handle);
	351	}
	352
	353	free_handle:
	354	efi_call_early(free_pool, gop_handle);
	355	return status;
	356	}