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