drivers/firmware/efi/libstub/gop.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* -----------------------------------------------------------------------
   3  *
   4  *   Copyright 2011 Intel Corporation; author Matt Fleming
   5  *
   6  * ----------------------------------------------------------------------- */
   7
   8 #include <linux/efi.h>
   9 #include <linux/screen_info.h>
  10 #include <asm/efi.h>
  11 #include <asm/setup.h>
  12
  13 #include "efistub.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                  efi_pixel_bitmask_t 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_graphics_output_protocol_t *
  89 find_gop(efi_guid_t *proto, unsigned long size, void **handles)
  90 {
  91         efi_graphics_output_protocol_t *gop, *first_gop;
  92         efi_graphics_output_protocol_mode_t *mode;
  93         efi_graphics_output_mode_info_t *info = NULL;
  94         efi_status_t status;
  95         efi_handle_t h;
  96         int i;
  97
  98         first_gop = NULL;
  99
 100         for_each_efi_handle(h, handles, size, i) {
 101                 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
 102                 bool conout_found = false;
 103                 void *dummy = NULL;
 104
 105                 status = efi_bs_call(handle_protocol, h, proto, (void **)&gop);
 106                 if (status != EFI_SUCCESS)
 107                         continue;
 108
 109                 mode = efi_table_attr(gop, mode);
 110                 info = efi_table_attr(mode, info);
 111                 if (info->pixel_format == PIXEL_BLT_ONLY)
 112                         continue;
 113
 114                 status = efi_bs_call(handle_protocol, h, &conout_proto, &dummy);
 115                 if (status == EFI_SUCCESS)
 116                         conout_found = true;
 117
 118                 if (!first_gop || conout_found) {
 119                         /*
 120                          * Systems that use the UEFI Console Splitter may
 121                          * provide multiple GOP devices, not all of which are
 122                          * backed by real hardware. The workaround is to search
 123                          * for a GOP implementing the ConOut protocol, and if
 124                          * one isn't found, to just fall back to the first GOP.
 125                          *
 126                          * Once we've found a GOP supporting ConOut,
 127                          * don't bother looking any further.
 128                          */
 129                         first_gop = gop;
 130                         if (conout_found)
 131                                 break;
 132                 }
 133         }
 134
 135         return first_gop;
 136 }
 137
 138 static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
 139                               unsigned long size, void **handles)
 140 {
 141         efi_graphics_output_protocol_t *gop;
 142         efi_graphics_output_protocol_mode_t *mode;
 143         efi_graphics_output_mode_info_t *info = NULL;
 144         efi_physical_addr_t fb_base;
 145
 146         gop = find_gop(proto, size, handles);
 147
 148         /* Did we find any GOPs? */
 149         if (!gop)
 150                 return EFI_NOT_FOUND;
 151
 152         /* EFI framebuffer */
 153         mode = efi_table_attr(gop, mode);
 154         info = efi_table_attr(mode, info);
 155
 156         si->orig_video_isVGA = VIDEO_TYPE_EFI;
 157
 158         si->lfb_width  = info->horizontal_resolution;
 159         si->lfb_height = info->vertical_resolution;
 160
 161         fb_base          = efi_table_attr(mode, frame_buffer_base);
 162         si->lfb_base     = fb_base;
 163         si->ext_lfb_base = (u64)(unsigned long)fb_base >> 32;
 164         if (si->ext_lfb_base)
 165                 si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
 166
 167         si->pages = 1;
 168
 169         setup_pixel_info(si, info->pixels_per_scan_line,
 170                              info->pixel_information, info->pixel_format);
 171
 172         si->lfb_size = si->lfb_linelength * si->lfb_height;
 173
 174         si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
 175
 176         return EFI_SUCCESS;
 177 }
 178
 179 /*
 180  * See if we have Graphics Output Protocol
 181  */
 182 efi_status_t efi_setup_gop(struct screen_info *si, efi_guid_t *proto,
 183                            unsigned long size)
 184 {
 185         efi_status_t status;
 186         void **gop_handle = NULL;
 187
 188         status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,
 189                              (void **)&gop_handle);
 190         if (status != EFI_SUCCESS)
 191                 return status;
 192
 193         status = efi_bs_call(locate_handle, EFI_LOCATE_BY_PROTOCOL, proto, NULL,
 194                              &size, gop_handle);
 195         if (status != EFI_SUCCESS)
 196                 goto free_handle;
 197
 198         status = setup_gop(si, proto, size, gop_handle);
 199
 200 free_handle:
 201         efi_bs_call(free_pool, gop_handle);
 202         return status;
 203 }