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

Pull EFI updates from Ingo Molnar:
 "The main changes in this cycle were:

   - Drop the unused EFI_SYSTEM_TABLES efi.flags bit and ensure the
     ARM/arm64 EFI System Table mapping is read-only (Ard Biesheuvel)

   - Add a comment to explain that one of the code paths in the x86/pat
     code is only executed for EFI boot (Matt Fleming)

   - Improve Secure Boot status checks on arm64 and handle unexpected
     errors (Linn Crosetto)

   - Remove the global EFI memory map variable 'memmap' as the same
     information is already available in efi::memmap (Matt Fleming)

   - Add EFI Memory Attribute table support for ARM/arm64 (Ard
     Biesheuvel)

   - Add EFI GOP framebuffer support for ARM/arm64 (Ard Biesheuvel)

   - Add EFI Bootloader Control driver for storing reboot(2) data in EFI
     variables for consumption by bootloaders (Jeremy Compostella)

   - Add Core EFI capsule support (Matt Fleming)

   - Add EFI capsule char driver (Kweh, Hock Leong)

   - Unify EFI memory map code for ARM and arm64 (Ard Biesheuvel)

   - Add generic EFI support for detecting when firmware corrupts CPU
     status register bits (like IRQ flags) when performing EFI runtime
     service calls (Mark Rutland)

  ... and other misc cleanups"

* 'efi-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (46 commits)
  efivarfs: Make efivarfs_file_ioctl() static
  efi: Merge boolean flag arguments
  efi/capsule: Move 'capsule' to the stack in efi_capsule_supported()
  efibc: Fix excessive stack footprint warning
  efi/capsule: Make efi_capsule_pending() lockless
  efi: Remove unnecessary (and buggy) .memmap initialization from the Xen EFI driver
  efi/runtime-wrappers: Remove ARCH_EFI_IRQ_FLAGS_MASK #ifdef
  x86/efi: Enable runtime call flag checking
  arm/efi: Enable runtime call flag checking
  arm64/efi: Enable runtime call flag checking
  efi/runtime-wrappers: Detect firmware IRQ flag corruption
  efi/runtime-wrappers: Remove redundant #ifdefs
  x86/efi: Move to generic {__,}efi_call_virt()
  arm/efi: Move to generic {__,}efi_call_virt()
  arm64/efi: Move to generic {__,}efi_call_virt()
  efi/runtime-wrappers: Add {__,}efi_call_virt() templates
  efi/arm-init: Reserve rather than unmap the memory map for ARM as well
  efi: Add misc char driver interface to update EFI firmware
  x86/efi: Force EFI reboot to process pending capsules
  efi: Add 'capsule' update support
  ...

1 files changed, 354 insertions, 0 deletions

diff --git a/drivers/firmware/efi/libstub/gop.c b/drivers/firmware/efi/libstub/gop.c
new file mode 100644
index 000000000000..932742e4cf23
--- /dev/null
+++ b/drivers/firmware/efi/libstub/gop.c
@@ -0,0 +1,354 @@
+/* -----------------------------------------------------------------------
+ *
+ *   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,
+                                       &current_fb_base);
+                if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
+                        /*
+                         * 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,
+                                       &current_fb_base);
+                if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
+                        /*
+                         * 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;
+}