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/bitops.h>
   9 #include <linux/ctype.h>
  10 #include <linux/efi.h>
  11 #include <linux/screen_info.h>
  12 #include <linux/string.h>
  13 #include <asm/efi.h>
  14 #include <asm/setup.h>
  15
  16 #include "efistub.h"
  17
  18 enum efi_cmdline_option {
  19         EFI_CMDLINE_NONE,
  20         EFI_CMDLINE_MODE_NUM,
  21         EFI_CMDLINE_RES,
  22         EFI_CMDLINE_AUTO,
  23         EFI_CMDLINE_LIST
  24 };
  25
  26 static struct {
  27         enum efi_cmdline_option option;
  28         union {
  29                 u32 mode;
  30                 struct {
  31                         u32 width, height;
  32                         int format;
  33                         u8 depth;
  34                 } res;
  35         };
  36 } cmdline = { .option = EFI_CMDLINE_NONE };
  37
  38 static bool parse_modenum(char *option, char **next)
  39 {
  40         u32 m;
  41
  42         if (!strstarts(option, "mode="))
  43                 return false;
  44         option += strlen("mode=");
  45         m = simple_strtoull(option, &option, 0);
  46         if (*option && *option++ != ',')
  47                 return false;
  48         cmdline.option = EFI_CMDLINE_MODE_NUM;
  49         cmdline.mode   = m;
  50
  51         *next = option;
  52         return true;
  53 }
  54
  55 static bool parse_res(char *option, char **next)
  56 {
  57         u32 w, h, d = 0;
  58         int pf = -1;
  59
  60         if (!isdigit(*option))
  61                 return false;
  62         w = simple_strtoull(option, &option, 10);
  63         if (*option++ != 'x' || !isdigit(*option))
  64                 return false;
  65         h = simple_strtoull(option, &option, 10);
  66         if (*option == '-') {
  67                 option++;
  68                 if (strstarts(option, "rgb")) {
  69                         option += strlen("rgb");
  70                         pf = PIXEL_RGB_RESERVED_8BIT_PER_COLOR;
  71                 } else if (strstarts(option, "bgr")) {
  72                         option += strlen("bgr");
  73                         pf = PIXEL_BGR_RESERVED_8BIT_PER_COLOR;
  74                 } else if (isdigit(*option))
  75                         d = simple_strtoull(option, &option, 10);
  76                 else
  77                         return false;
  78         }
  79         if (*option && *option++ != ',')
  80                 return false;
  81         cmdline.option     = EFI_CMDLINE_RES;
  82         cmdline.res.width  = w;
  83         cmdline.res.height = h;
  84         cmdline.res.format = pf;
  85         cmdline.res.depth  = d;
  86
  87         *next = option;
  88         return true;
  89 }
  90
  91 static bool parse_auto(char *option, char **next)
  92 {
  93         if (!strstarts(option, "auto"))
  94                 return false;
  95         option += strlen("auto");
  96         if (*option && *option++ != ',')
  97                 return false;
  98         cmdline.option = EFI_CMDLINE_AUTO;
  99
 100         *next = option;
 101         return true;
 102 }
 103
 104 static bool parse_list(char *option, char **next)
 105 {
 106         if (!strstarts(option, "list"))
 107                 return false;
 108         option += strlen("list");
 109         if (*option && *option++ != ',')
 110                 return false;
 111         cmdline.option = EFI_CMDLINE_LIST;
 112
 113         *next = option;
 114         return true;
 115 }
 116
 117 void efi_parse_option_graphics(char *option)
 118 {
 119         while (*option) {
 120                 if (parse_modenum(option, &option))
 121                         continue;
 122                 if (parse_res(option, &option))
 123                         continue;
 124                 if (parse_auto(option, &option))
 125                         continue;
 126                 if (parse_list(option, &option))
 127                         continue;
 128
 129                 while (*option && *option++ != ',')
 130                         ;
 131         }
 132 }
 133
 134 static u32 choose_mode_modenum(efi_graphics_output_protocol_t *gop)
 135 {
 136         efi_status_t status;
 137
 138         efi_graphics_output_protocol_mode_t *mode;
 139         efi_graphics_output_mode_info_t *info;
 140         unsigned long info_size;
 141
 142         u32 max_mode, cur_mode;
 143         int pf;
 144
 145         mode = efi_table_attr(gop, mode);
 146
 147         cur_mode = efi_table_attr(mode, mode);
 148         if (cmdline.mode == cur_mode)
 149                 return cur_mode;
 150
 151         max_mode = efi_table_attr(mode, max_mode);
 152         if (cmdline.mode >= max_mode) {
 153                 efi_err("Requested mode is invalid\n");
 154                 return cur_mode;
 155         }
 156
 157         status = efi_call_proto(gop, query_mode, cmdline.mode,
 158                                 &info_size, &info);
 159         if (status != EFI_SUCCESS) {
 160                 efi_err("Couldn't get mode information\n");
 161                 return cur_mode;
 162         }
 163
 164         pf = info->pixel_format;
 165
 166         efi_bs_call(free_pool, info);
 167
 168         if (pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX) {
 169                 efi_err("Invalid PixelFormat\n");
 170                 return cur_mode;
 171         }
 172
 173         return cmdline.mode;
 174 }
 175
 176 static u8 pixel_bpp(int pixel_format, efi_pixel_bitmask_t pixel_info)
 177 {
 178         if (pixel_format == PIXEL_BIT_MASK) {
 179                 u32 mask = pixel_info.red_mask | pixel_info.green_mask |
 180                            pixel_info.blue_mask | pixel_info.reserved_mask;
 181                 if (!mask)
 182                         return 0;
 183                 return __fls(mask) - __ffs(mask) + 1;
 184         } else
 185                 return 32;
 186 }
 187
 188 static u32 choose_mode_res(efi_graphics_output_protocol_t *gop)
 189 {
 190         efi_status_t status;
 191
 192         efi_graphics_output_protocol_mode_t *mode;
 193         efi_graphics_output_mode_info_t *info;
 194         unsigned long info_size;
 195
 196         u32 max_mode, cur_mode;
 197         int pf;
 198         efi_pixel_bitmask_t pi;
 199         u32 m, w, h;
 200
 201         mode = efi_table_attr(gop, mode);
 202
 203         cur_mode = efi_table_attr(mode, mode);
 204         info = efi_table_attr(mode, info);
 205         pf = info->pixel_format;
 206         pi = info->pixel_information;
 207         w  = info->horizontal_resolution;
 208         h  = info->vertical_resolution;
 209
 210         if (w == cmdline.res.width && h == cmdline.res.height &&
 211             (cmdline.res.format < 0 || cmdline.res.format == pf) &&
 212             (!cmdline.res.depth || cmdline.res.depth == pixel_bpp(pf, pi)))
 213                 return cur_mode;
 214
 215         max_mode = efi_table_attr(mode, max_mode);
 216
 217         for (m = 0; m < max_mode; m++) {
 218                 if (m == cur_mode)
 219                         continue;
 220
 221                 status = efi_call_proto(gop, query_mode, m,
 222                                         &info_size, &info);
 223                 if (status != EFI_SUCCESS)
 224                         continue;
 225
 226                 pf = info->pixel_format;
 227                 pi = info->pixel_information;
 228                 w  = info->horizontal_resolution;
 229                 h  = info->vertical_resolution;
 230
 231                 efi_bs_call(free_pool, info);
 232
 233                 if (pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX)
 234                         continue;
 235                 if (w == cmdline.res.width && h == cmdline.res.height &&
 236                     (cmdline.res.format < 0 || cmdline.res.format == pf) &&
 237                     (!cmdline.res.depth || cmdline.res.depth == pixel_bpp(pf, pi)))
 238                         return m;
 239         }
 240
 241         efi_err("Couldn't find requested mode\n");
 242
 243         return cur_mode;
 244 }
 245
 246 static u32 choose_mode_auto(efi_graphics_output_protocol_t *gop)
 247 {
 248         efi_status_t status;
 249
 250         efi_graphics_output_protocol_mode_t *mode;
 251         efi_graphics_output_mode_info_t *info;
 252         unsigned long info_size;
 253
 254         u32 max_mode, cur_mode, best_mode, area;
 255         u8 depth;
 256         int pf;
 257         efi_pixel_bitmask_t pi;
 258         u32 m, w, h, a;
 259         u8 d;
 260
 261         mode = efi_table_attr(gop, mode);
 262
 263         cur_mode = efi_table_attr(mode, mode);
 264         max_mode = efi_table_attr(mode, max_mode);
 265
 266         info = efi_table_attr(mode, info);
 267
 268         pf = info->pixel_format;
 269         pi = info->pixel_information;
 270         w  = info->horizontal_resolution;
 271         h  = info->vertical_resolution;
 272
 273         best_mode = cur_mode;
 274         area = w * h;
 275         depth = pixel_bpp(pf, pi);
 276
 277         for (m = 0; m < max_mode; m++) {
 278                 if (m == cur_mode)
 279                         continue;
 280
 281                 status = efi_call_proto(gop, query_mode, m,
 282                                         &info_size, &info);
 283                 if (status != EFI_SUCCESS)
 284                         continue;
 285
 286                 pf = info->pixel_format;
 287                 pi = info->pixel_information;
 288                 w  = info->horizontal_resolution;
 289                 h  = info->vertical_resolution;
 290
 291                 efi_bs_call(free_pool, info);
 292
 293                 if (pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX)
 294                         continue;
 295                 a = w * h;
 296                 if (a < area)
 297                         continue;
 298                 d = pixel_bpp(pf, pi);
 299                 if (a > area || d > depth) {
 300                         best_mode = m;
 301                         area = a;
 302                         depth = d;
 303                 }
 304         }
 305
 306         return best_mode;
 307 }
 308
 309 static u32 choose_mode_list(efi_graphics_output_protocol_t *gop)
 310 {
 311         efi_status_t status;
 312
 313         efi_graphics_output_protocol_mode_t *mode;
 314         efi_graphics_output_mode_info_t *info;
 315         unsigned long info_size;
 316
 317         u32 max_mode, cur_mode;
 318         int pf;
 319         efi_pixel_bitmask_t pi;
 320         u32 m, w, h;
 321         u8 d;
 322         const char *dstr;
 323         bool valid;
 324         efi_input_key_t key;
 325
 326         mode = efi_table_attr(gop, mode);
 327
 328         cur_mode = efi_table_attr(mode, mode);
 329         max_mode = efi_table_attr(mode, max_mode);
 330
 331         efi_printk("Available graphics modes are 0-%u\n", max_mode-1);
 332         efi_puts("  * = current mode\n"
 333                  "  - = unusable mode\n");
 334         for (m = 0; m < max_mode; m++) {
 335                 status = efi_call_proto(gop, query_mode, m,
 336                                         &info_size, &info);
 337                 if (status != EFI_SUCCESS)
 338                         continue;
 339
 340                 pf = info->pixel_format;
 341                 pi = info->pixel_information;
 342                 w  = info->horizontal_resolution;
 343                 h  = info->vertical_resolution;
 344
 345                 efi_bs_call(free_pool, info);
 346
 347                 valid = !(pf == PIXEL_BLT_ONLY || pf >= PIXEL_FORMAT_MAX);
 348                 d = 0;
 349                 switch (pf) {
 350                 case PIXEL_RGB_RESERVED_8BIT_PER_COLOR:
 351                         dstr = "rgb";
 352                         break;
 353                 case PIXEL_BGR_RESERVED_8BIT_PER_COLOR:
 354                         dstr = "bgr";
 355                         break;
 356                 case PIXEL_BIT_MASK:
 357                         dstr = "";
 358                         d = pixel_bpp(pf, pi);
 359                         break;
 360                 case PIXEL_BLT_ONLY:
 361                         dstr = "blt";
 362                         break;
 363                 default:
 364                         dstr = "xxx";
 365                         break;
 366                 }
 367
 368                 efi_printk("Mode %3u %c%c: Resolution %ux%u-%s%.0hhu\n",
 369                            m,
 370                            m == cur_mode ? '*' : ' ',
 371                            !valid ? '-' : ' ',
 372                            w, h, dstr, d);
 373         }
 374
 375         efi_puts("\nPress any key to continue (or wait 10 seconds)\n");
 376         status = efi_wait_for_key(10 * EFI_USEC_PER_SEC, &key);
 377         if (status != EFI_SUCCESS && status != EFI_TIMEOUT) {
 378                 efi_err("Unable to read key, continuing in 10 seconds\n");
 379                 efi_bs_call(stall, 10 * EFI_USEC_PER_SEC);
 380         }
 381
 382         return cur_mode;
 383 }
 384
 385 static void set_mode(efi_graphics_output_protocol_t *gop)
 386 {
 387         efi_graphics_output_protocol_mode_t *mode;
 388         u32 cur_mode, new_mode;
 389
 390         switch (cmdline.option) {
 391         case EFI_CMDLINE_MODE_NUM:
 392                 new_mode = choose_mode_modenum(gop);
 393                 break;
 394         case EFI_CMDLINE_RES:
 395                 new_mode = choose_mode_res(gop);
 396                 break;
 397         case EFI_CMDLINE_AUTO:
 398                 new_mode = choose_mode_auto(gop);
 399                 break;
 400         case EFI_CMDLINE_LIST:
 401                 new_mode = choose_mode_list(gop);
 402                 break;
 403         default:
 404                 return;
 405         }
 406
 407         mode = efi_table_attr(gop, mode);
 408         cur_mode = efi_table_attr(mode, mode);
 409
 410         if (new_mode == cur_mode)
 411                 return;
 412
 413         if (efi_call_proto(gop, set_mode, new_mode) != EFI_SUCCESS)
 414                 efi_err("Failed to set requested mode\n");
 415 }
 416
 417 static void find_bits(u32 mask, u8 *pos, u8 *size)
 418 {
 419         if (!mask) {
 420                 *pos = *size = 0;
 421                 return;
 422         }
 423
 424         /* UEFI spec guarantees that the set bits are contiguous */
 425         *pos  = __ffs(mask);
 426         *size = __fls(mask) - *pos + 1;
 427 }
 428
 429 static void
 430 setup_pixel_info(struct screen_info *si, u32 pixels_per_scan_line,
 431                  efi_pixel_bitmask_t pixel_info, int pixel_format)
 432 {
 433         if (pixel_format == PIXEL_BIT_MASK) {
 434                 find_bits(pixel_info.red_mask,
 435                           &si->red_pos, &si->red_size);
 436                 find_bits(pixel_info.green_mask,
 437                           &si->green_pos, &si->green_size);
 438                 find_bits(pixel_info.blue_mask,
 439                           &si->blue_pos, &si->blue_size);
 440                 find_bits(pixel_info.reserved_mask,
 441                           &si->rsvd_pos, &si->rsvd_size);
 442                 si->lfb_depth = si->red_size + si->green_size +
 443                         si->blue_size + si->rsvd_size;
 444                 si->lfb_linelength = (pixels_per_scan_line * si->lfb_depth) / 8;
 445         } else {
 446                 if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
 447                         si->red_pos   = 0;
 448                         si->blue_pos  = 16;
 449                 } else /* PIXEL_BGR_RESERVED_8BIT_PER_COLOR */ {
 450                         si->blue_pos  = 0;
 451                         si->red_pos   = 16;
 452                 }
 453
 454                 si->green_pos = 8;
 455                 si->rsvd_pos  = 24;
 456                 si->red_size = si->green_size =
 457                         si->blue_size = si->rsvd_size = 8;
 458
 459                 si->lfb_depth = 32;
 460                 si->lfb_linelength = pixels_per_scan_line * 4;
 461         }
 462 }
 463
 464 static efi_graphics_output_protocol_t *
 465 find_gop(efi_guid_t *proto, unsigned long size, void **handles)
 466 {
 467         efi_graphics_output_protocol_t *first_gop;
 468         efi_handle_t h;
 469         int i;
 470
 471         first_gop = NULL;
 472
 473         for_each_efi_handle(h, handles, size, i) {
 474                 efi_status_t status;
 475
 476                 efi_graphics_output_protocol_t *gop;
 477                 efi_graphics_output_protocol_mode_t *mode;
 478                 efi_graphics_output_mode_info_t *info;
 479
 480                 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
 481                 void *dummy = NULL;
 482
 483                 status = efi_bs_call(handle_protocol, h, proto, (void **)&gop);
 484                 if (status != EFI_SUCCESS)
 485                         continue;
 486
 487                 mode = efi_table_attr(gop, mode);
 488                 info = efi_table_attr(mode, info);
 489                 if (info->pixel_format == PIXEL_BLT_ONLY ||
 490                     info->pixel_format >= PIXEL_FORMAT_MAX)
 491                         continue;
 492
 493                 /*
 494                  * Systems that use the UEFI Console Splitter may
 495                  * provide multiple GOP devices, not all of which are
 496                  * backed by real hardware. The workaround is to search
 497                  * for a GOP implementing the ConOut protocol, and if
 498                  * one isn't found, to just fall back to the first GOP.
 499                  *
 500                  * Once we've found a GOP supporting ConOut,
 501                  * don't bother looking any further.
 502                  */
 503                 status = efi_bs_call(handle_protocol, h, &conout_proto, &dummy);
 504                 if (status == EFI_SUCCESS)
 505                         return gop;
 506
 507                 if (!first_gop)
 508                         first_gop = gop;
 509         }
 510
 511         return first_gop;
 512 }
 513
 514 static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
 515                               unsigned long size, void **handles)
 516 {
 517         efi_graphics_output_protocol_t *gop;
 518         efi_graphics_output_protocol_mode_t *mode;
 519         efi_graphics_output_mode_info_t *info;
 520
 521         gop = find_gop(proto, size, handles);
 522
 523         /* Did we find any GOPs? */
 524         if (!gop)
 525                 return EFI_NOT_FOUND;
 526
 527         /* Change mode if requested */
 528         set_mode(gop);
 529
 530         /* EFI framebuffer */
 531         mode = efi_table_attr(gop, mode);
 532         info = efi_table_attr(mode, info);
 533
 534         si->orig_video_isVGA = VIDEO_TYPE_EFI;
 535
 536         si->lfb_width  = info->horizontal_resolution;
 537         si->lfb_height = info->vertical_resolution;
 538
 539         efi_set_u64_split(efi_table_attr(mode, frame_buffer_base),
 540                           &si->lfb_base, &si->ext_lfb_base);
 541         if (si->ext_lfb_base)
 542                 si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
 543
 544         si->pages = 1;
 545
 546         setup_pixel_info(si, info->pixels_per_scan_line,
 547                              info->pixel_information, info->pixel_format);
 548
 549         si->lfb_size = si->lfb_linelength * si->lfb_height;
 550
 551         si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
 552
 553         return EFI_SUCCESS;
 554 }
 555
 556 /*
 557  * See if we have Graphics Output Protocol
 558  */
 559 efi_status_t efi_setup_gop(struct screen_info *si, efi_guid_t *proto,
 560                            unsigned long size)
 561 {
 562         efi_status_t status;
 563         void **gop_handle = NULL;
 564
 565         status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, size,
 566                              (void **)&gop_handle);
 567         if (status != EFI_SUCCESS)
 568                 return status;
 569
 570         status = efi_bs_call(locate_handle, EFI_LOCATE_BY_PROTOCOL, proto, NULL,
 571                              &size, gop_handle);
 572         if (status != EFI_SUCCESS)
 573                 goto free_handle;
 574
 575         status = setup_gop(si, proto, size, gop_handle);
 576
 577 free_handle:
 578         efi_bs_call(free_pool, gop_handle);
 579         return status;
 580 }