mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-27 16:55:13 +07:00
540f4c0e89
The UEFI Specification permits Graphics Output Protocol (GOP) instances
without direct framebuffer access. This is indicated in the Mode structure
with a PixelFormat enumeration value of PIXEL_BLT_ONLY. Given that the
kernel does not know how to drive a Blt() only framebuffer (which is only
permitted before ExitBootServices() anyway), we should disregard such
framebuffers when looking for a GOP instance that is suitable for use as
the boot console.
So modify the EFI GOP initialization to not use a PIXEL_BLT_ONLY instance,
preventing attempts later in boot to use an invalid screen_info.lfb_base
address.
Signed-off-by: Eugene Cohen <eugene@hp.com>
[ Moved the Blt() only check into the loop and clarified that Blt() only GOPs are unusable by the kernel. ]
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: <stable@vger.kernel.org> # v4.7+
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: leif.lindholm@linaro.org
Cc: linux-efi@vger.kernel.org
Cc: lorenzo.pieralisi@arm.com
Fixes: 9822504c1f ("efifb: Enable the efi-framebuffer platform driver ...")
Link: http://lkml.kernel.org/r/20170404152744.26687-2-ard.biesheuvel@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
357 lines
9.2 KiB
C
357 lines
9.2 KiB
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 = EFI_NOT_FOUND;
|
|
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,
|
|
¤t_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)
|
|
goto out;
|
|
|
|
/* 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;
|
|
out:
|
|
return status;
|
|
}
|
|
|
|
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 = EFI_NOT_FOUND;
|
|
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,
|
|
¤t_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)
|
|
goto out;
|
|
|
|
/* 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;
|
|
out:
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
}
|