arch/x86/boot/compressed/eboot.c

   1 /* -----------------------------------------------------------------------
   2  *
   3  *   Copyright 2011 Intel Corporation; author Matt Fleming
   4  *
   5  *   This file is part of the Linux kernel, and is made available under
   6  *   the terms of the GNU General Public License version 2.
   7  *
   8  * ----------------------------------------------------------------------- */
   9
  10 #include <linux/efi.h>
  11 #include <linux/pci.h>
  12 #include <asm/efi.h>
  13 #include <asm/setup.h>
  14 #include <asm/desc.h>
  15
  16 #undef memcpy                   /* Use memcpy from misc.c */
  17
  18 #include "eboot.h"
  19
  20 static efi_system_table_t *sys_table;
  21
  22 struct efi_config *efi_early;
  23
  24 #define BOOT_SERVICES(bits)                                             \
  25 static void setup_boot_services##bits(struct efi_config *c)             \
  26 {                                                                       \
  27         efi_system_table_##bits##_t *table;                             \
  28         efi_boot_services_##bits##_t *bt;                               \
  29                                                                         \
  30         table = (typeof(table))sys_table;                               \
  31                                                                         \
  32         c->text_output = table->con_out;                                \
  33                                                                         \
  34         bt = (typeof(bt))(unsigned long)(table->boottime);              \
  35                                                                         \
  36         c->allocate_pool = bt->allocate_pool;                           \
  37         c->allocate_pages = bt->allocate_pages;                         \
  38         c->get_memory_map = bt->get_memory_map;                         \
  39         c->free_pool = bt->free_pool;                                   \
  40         c->free_pages = bt->free_pages;                                 \
  41         c->locate_handle = bt->locate_handle;                           \
  42         c->handle_protocol = bt->handle_protocol;                       \
  43         c->exit_boot_services = bt->exit_boot_services;                 \
  44 }
  45 BOOT_SERVICES(32);
  46 BOOT_SERVICES(64);
  47
  48 void efi_char16_printk(efi_system_table_t *, efi_char16_t *);
  49
  50 static efi_status_t
  51 __file_size32(void *__fh, efi_char16_t *filename_16,
  52               void **handle, u64 *file_sz)
  53 {
  54         efi_file_handle_32_t *h, *fh = __fh;
  55         efi_file_info_t *info;
  56         efi_status_t status;
  57         efi_guid_t info_guid = EFI_FILE_INFO_ID;
  58         u32 info_sz;
  59
  60         status = efi_early->call((unsigned long)fh->open, fh, &h, filename_16,
  61                                  EFI_FILE_MODE_READ, (u64)0);
  62         if (status != EFI_SUCCESS) {
  63                 efi_printk(sys_table, "Failed to open file: ");
  64                 efi_char16_printk(sys_table, filename_16);
  65                 efi_printk(sys_table, "\n");
  66                 return status;
  67         }
  68
  69         *handle = h;
  70
  71         info_sz = 0;
  72         status = efi_early->call((unsigned long)h->get_info, h, &info_guid,
  73                                  &info_sz, NULL);
  74         if (status != EFI_BUFFER_TOO_SMALL) {
  75                 efi_printk(sys_table, "Failed to get file info size\n");
  76                 return status;
  77         }
  78
  79 grow:
  80         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
  81                                 info_sz, (void **)&info);
  82         if (status != EFI_SUCCESS) {
  83                 efi_printk(sys_table, "Failed to alloc mem for file info\n");
  84                 return status;
  85         }
  86
  87         status = efi_early->call((unsigned long)h->get_info, h, &info_guid,
  88                                  &info_sz, info);
  89         if (status == EFI_BUFFER_TOO_SMALL) {
  90                 efi_call_early(free_pool, info);
  91                 goto grow;
  92         }
  93
  94         *file_sz = info->file_size;
  95         efi_call_early(free_pool, info);
  96
  97         if (status != EFI_SUCCESS)
  98                 efi_printk(sys_table, "Failed to get initrd info\n");
  99
 100         return status;
 101 }
 102
 103 static efi_status_t
 104 __file_size64(void *__fh, efi_char16_t *filename_16,
 105               void **handle, u64 *file_sz)
 106 {
 107         efi_file_handle_64_t *h, *fh = __fh;
 108         efi_file_info_t *info;
 109         efi_status_t status;
 110         efi_guid_t info_guid = EFI_FILE_INFO_ID;
 111         u64 info_sz;
 112
 113         status = efi_early->call((unsigned long)fh->open, fh, &h, filename_16,
 114                                  EFI_FILE_MODE_READ, (u64)0);
 115         if (status != EFI_SUCCESS) {
 116                 efi_printk(sys_table, "Failed to open file: ");
 117                 efi_char16_printk(sys_table, filename_16);
 118                 efi_printk(sys_table, "\n");
 119                 return status;
 120         }
 121
 122         *handle = h;
 123
 124         info_sz = 0;
 125         status = efi_early->call((unsigned long)h->get_info, h, &info_guid,
 126                                  &info_sz, NULL);
 127         if (status != EFI_BUFFER_TOO_SMALL) {
 128                 efi_printk(sys_table, "Failed to get file info size\n");
 129                 return status;
 130         }
 131
 132 grow:
 133         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
 134                                 info_sz, (void **)&info);
 135         if (status != EFI_SUCCESS) {
 136                 efi_printk(sys_table, "Failed to alloc mem for file info\n");
 137                 return status;
 138         }
 139
 140         status = efi_early->call((unsigned long)h->get_info, h, &info_guid,
 141                                  &info_sz, info);
 142         if (status == EFI_BUFFER_TOO_SMALL) {
 143                 efi_call_early(free_pool, info);
 144                 goto grow;
 145         }
 146
 147         *file_sz = info->file_size;
 148         efi_call_early(free_pool, info);
 149
 150         if (status != EFI_SUCCESS)
 151                 efi_printk(sys_table, "Failed to get initrd info\n");
 152
 153         return status;
 154 }
 155 efi_status_t
 156 efi_file_size(efi_system_table_t *sys_table, void *__fh,
 157               efi_char16_t *filename_16, void **handle, u64 *file_sz)
 158 {
 159         if (efi_early->is64)
 160                 return __file_size64(__fh, filename_16, handle, file_sz);
 161
 162         return __file_size32(__fh, filename_16, handle, file_sz);
 163 }
 164
 165 efi_status_t
 166 efi_file_read(void *handle, unsigned long *size, void *addr)
 167 {
 168         unsigned long func;
 169
 170         if (efi_early->is64) {
 171                 efi_file_handle_64_t *fh = handle;
 172
 173                 func = (unsigned long)fh->read;
 174                 return efi_early->call(func, handle, size, addr);
 175         } else {
 176                 efi_file_handle_32_t *fh = handle;
 177
 178                 func = (unsigned long)fh->read;
 179                 return efi_early->call(func, handle, size, addr);
 180         }
 181 }
 182
 183 efi_status_t efi_file_close(void *handle)
 184 {
 185         if (efi_early->is64) {
 186                 efi_file_handle_64_t *fh = handle;
 187
 188                 return efi_early->call((unsigned long)fh->close, handle);
 189         } else {
 190                 efi_file_handle_32_t *fh = handle;
 191
 192                 return efi_early->call((unsigned long)fh->close, handle);
 193         }
 194 }
 195
 196 static inline efi_status_t __open_volume32(void *__image, void **__fh)
 197 {
 198         efi_file_io_interface_t *io;
 199         efi_loaded_image_32_t *image = __image;
 200         efi_file_handle_32_t *fh;
 201         efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
 202         efi_status_t status;
 203         void *handle = (void *)(unsigned long)image->device_handle;
 204         unsigned long func;
 205
 206         status = efi_call_early(handle_protocol, handle,
 207                                 &fs_proto, (void **)&io);
 208         if (status != EFI_SUCCESS) {
 209                 efi_printk(sys_table, "Failed to handle fs_proto\n");
 210                 return status;
 211         }
 212
 213         func = (unsigned long)io->open_volume;
 214         status = efi_early->call(func, io, &fh);
 215         if (status != EFI_SUCCESS)
 216                 efi_printk(sys_table, "Failed to open volume\n");
 217
 218         *__fh = fh;
 219         return status;
 220 }
 221
 222 static inline efi_status_t __open_volume64(void *__image, void **__fh)
 223 {
 224         efi_file_io_interface_t *io;
 225         efi_loaded_image_64_t *image = __image;
 226         efi_file_handle_64_t *fh;
 227         efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
 228         efi_status_t status;
 229         void *handle = (void *)(unsigned long)image->device_handle;
 230         unsigned long func;
 231
 232         status = efi_call_early(handle_protocol, handle,
 233                                 &fs_proto, (void **)&io);
 234         if (status != EFI_SUCCESS) {
 235                 efi_printk(sys_table, "Failed to handle fs_proto\n");
 236                 return status;
 237         }
 238
 239         func = (unsigned long)io->open_volume;
 240         status = efi_early->call(func, io, &fh);
 241         if (status != EFI_SUCCESS)
 242                 efi_printk(sys_table, "Failed to open volume\n");
 243
 244         *__fh = fh;
 245         return status;
 246 }
 247
 248 efi_status_t
 249 efi_open_volume(efi_system_table_t *sys_table, void *__image, void **__fh)
 250 {
 251         if (efi_early->is64)
 252                 return __open_volume64(__image, __fh);
 253
 254         return __open_volume32(__image, __fh);
 255 }
 256
 257 void efi_char16_printk(efi_system_table_t *table, efi_char16_t *str)
 258 {
 259         unsigned long output_string;
 260         size_t offset;
 261
 262         if (efi_early->is64) {
 263                 struct efi_simple_text_output_protocol_64 *out;
 264                 u64 *func;
 265
 266                 offset = offsetof(typeof(*out), output_string);
 267                 output_string = efi_early->text_output + offset;
 268                 func = (u64 *)output_string;
 269
 270                 efi_early->call(*func, efi_early->text_output, str);
 271         } else {
 272                 struct efi_simple_text_output_protocol_32 *out;
 273                 u32 *func;
 274
 275                 offset = offsetof(typeof(*out), output_string);
 276                 output_string = efi_early->text_output + offset;
 277                 func = (u32 *)output_string;
 278
 279                 efi_early->call(*func, efi_early->text_output, str);
 280         }
 281 }
 282
 283 static void find_bits(unsigned long mask, u8 *pos, u8 *size)
 284 {
 285         u8 first, len;
 286
 287         first = 0;
 288         len = 0;
 289
 290         if (mask) {
 291                 while (!(mask & 0x1)) {
 292                         mask = mask >> 1;
 293                         first++;
 294                 }
 295
 296                 while (mask & 0x1) {
 297                         mask = mask >> 1;
 298                         len++;
 299                 }
 300         }
 301
 302         *pos = first;
 303         *size = len;
 304 }
 305
 306 static efi_status_t
 307 __setup_efi_pci32(efi_pci_io_protocol_32 *pci, struct pci_setup_rom **__rom)
 308 {
 309         struct pci_setup_rom *rom = NULL;
 310         efi_status_t status;
 311         unsigned long size;
 312         uint64_t attributes;
 313
 314         status = efi_early->call(pci->attributes, pci,
 315                                  EfiPciIoAttributeOperationGet, 0, 0,
 316                                  &attributes);
 317         if (status != EFI_SUCCESS)
 318                 return status;
 319
 320         if (!pci->romimage || !pci->romsize)
 321                 return EFI_INVALID_PARAMETER;
 322
 323         size = pci->romsize + sizeof(*rom);
 324
 325         status = efi_call_early(allocate_pool, EFI_LOADER_DATA, size, &rom);
 326         if (status != EFI_SUCCESS)
 327                 return status;
 328
 329         memset(rom, 0, sizeof(*rom));
 330
 331         rom->data.type = SETUP_PCI;
 332         rom->data.len = size - sizeof(struct setup_data);
 333         rom->data.next = 0;
 334         rom->pcilen = pci->romsize;
 335         *__rom = rom;
 336
 337         status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
 338                                  PCI_VENDOR_ID, 1, &(rom->vendor));
 339
 340         if (status != EFI_SUCCESS)
 341                 goto free_struct;
 342
 343         status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
 344                                  PCI_DEVICE_ID, 1, &(rom->devid));
 345
 346         if (status != EFI_SUCCESS)
 347                 goto free_struct;
 348
 349         status = efi_early->call(pci->get_location, pci, &(rom->segment),
 350                                  &(rom->bus), &(rom->device), &(rom->function));
 351
 352         if (status != EFI_SUCCESS)
 353                 goto free_struct;
 354
 355         memcpy(rom->romdata, pci->romimage, pci->romsize);
 356         return status;
 357
 358 free_struct:
 359         efi_call_early(free_pool, rom);
 360         return status;
 361 }
 362
 363 static efi_status_t
 364 setup_efi_pci32(struct boot_params *params, void **pci_handle,
 365                 unsigned long size)
 366 {
 367         efi_pci_io_protocol_32 *pci = NULL;
 368         efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
 369         u32 *handles = (u32 *)(unsigned long)pci_handle;
 370         efi_status_t status;
 371         unsigned long nr_pci;
 372         struct setup_data *data;
 373         int i;
 374
 375         data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
 376
 377         while (data && data->next)
 378                 data = (struct setup_data *)(unsigned long)data->next;
 379
 380         nr_pci = size / sizeof(u32);
 381         for (i = 0; i < nr_pci; i++) {
 382                 struct pci_setup_rom *rom = NULL;
 383                 u32 h = handles[i];
 384
 385                 status = efi_call_early(handle_protocol, h,
 386                                         &pci_proto, (void **)&pci);
 387
 388                 if (status != EFI_SUCCESS)
 389                         continue;
 390
 391                 if (!pci)
 392                         continue;
 393
 394                 status = __setup_efi_pci32(pci, &rom);
 395                 if (status != EFI_SUCCESS)
 396                         continue;
 397
 398                 if (data)
 399                         data->next = (unsigned long)rom;
 400                 else
 401                         params->hdr.setup_data = (unsigned long)rom;
 402
 403                 data = (struct setup_data *)rom;
 404
 405         }
 406
 407         return status;
 408 }
 409
 410 static efi_status_t
 411 __setup_efi_pci64(efi_pci_io_protocol_64 *pci, struct pci_setup_rom **__rom)
 412 {
 413         struct pci_setup_rom *rom;
 414         efi_status_t status;
 415         unsigned long size;
 416         uint64_t attributes;
 417
 418         status = efi_early->call(pci->attributes, pci,
 419                                  EfiPciIoAttributeOperationGet, 0,
 420                                  &attributes);
 421         if (status != EFI_SUCCESS)
 422                 return status;
 423
 424         if (!pci->romimage || !pci->romsize)
 425                 return EFI_INVALID_PARAMETER;
 426
 427         size = pci->romsize + sizeof(*rom);
 428
 429         status = efi_call_early(allocate_pool, EFI_LOADER_DATA, size, &rom);
 430         if (status != EFI_SUCCESS)
 431                 return status;
 432
 433         rom->data.type = SETUP_PCI;
 434         rom->data.len = size - sizeof(struct setup_data);
 435         rom->data.next = 0;
 436         rom->pcilen = pci->romsize;
 437         *__rom = rom;
 438
 439         status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
 440                                  PCI_VENDOR_ID, 1, &(rom->vendor));
 441
 442         if (status != EFI_SUCCESS)
 443                 goto free_struct;
 444
 445         status = efi_early->call(pci->pci.read, pci, EfiPciIoWidthUint16,
 446                                  PCI_DEVICE_ID, 1, &(rom->devid));
 447
 448         if (status != EFI_SUCCESS)
 449                 goto free_struct;
 450
 451         status = efi_early->call(pci->get_location, pci, &(rom->segment),
 452                                  &(rom->bus), &(rom->device), &(rom->function));
 453
 454         if (status != EFI_SUCCESS)
 455                 goto free_struct;
 456
 457         memcpy(rom->romdata, pci->romimage, pci->romsize);
 458         return status;
 459
 460 free_struct:
 461         efi_call_early(free_pool, rom);
 462         return status;
 463
 464 }
 465
 466 static efi_status_t
 467 setup_efi_pci64(struct boot_params *params, void **pci_handle,
 468                 unsigned long size)
 469 {
 470         efi_pci_io_protocol_64 *pci = NULL;
 471         efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
 472         u64 *handles = (u64 *)(unsigned long)pci_handle;
 473         efi_status_t status;
 474         unsigned long nr_pci;
 475         struct setup_data *data;
 476         int i;
 477
 478         data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
 479
 480         while (data && data->next)
 481                 data = (struct setup_data *)(unsigned long)data->next;
 482
 483         nr_pci = size / sizeof(u64);
 484         for (i = 0; i < nr_pci; i++) {
 485                 struct pci_setup_rom *rom = NULL;
 486                 u64 h = handles[i];
 487
 488                 status = efi_call_early(handle_protocol, h,
 489                                         &pci_proto, (void **)&pci);
 490
 491                 if (status != EFI_SUCCESS)
 492                         continue;
 493
 494                 if (!pci)
 495                         continue;
 496
 497                 status = __setup_efi_pci64(pci, &rom);
 498                 if (status != EFI_SUCCESS)
 499                         continue;
 500
 501                 if (data)
 502                         data->next = (unsigned long)rom;
 503                 else
 504                         params->hdr.setup_data = (unsigned long)rom;
 505
 506                 data = (struct setup_data *)rom;
 507
 508         }
 509
 510         return status;
 511 }
 512
 513 static efi_status_t setup_efi_pci(struct boot_params *params)
 514 {
 515         efi_status_t status;
 516         void **pci_handle = NULL;
 517         efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
 518         unsigned long size = 0;
 519
 520         status = efi_call_early(locate_handle,
 521                                 EFI_LOCATE_BY_PROTOCOL,
 522                                 &pci_proto, NULL, &size, pci_handle);
 523
 524         if (status == EFI_BUFFER_TOO_SMALL) {
 525                 status = efi_call_early(allocate_pool,
 526                                         EFI_LOADER_DATA,
 527                                         size, (void **)&pci_handle);
 528
 529                 if (status != EFI_SUCCESS)
 530                         return status;
 531
 532                 status = efi_call_early(locate_handle,
 533                                         EFI_LOCATE_BY_PROTOCOL, &pci_proto,
 534                                         NULL, &size, pci_handle);
 535         }
 536
 537         if (status != EFI_SUCCESS)
 538                 goto free_handle;
 539
 540         if (efi_early->is64)
 541                 status = setup_efi_pci64(params, pci_handle, size);
 542         else
 543                 status = setup_efi_pci32(params, pci_handle, size);
 544
 545 free_handle:
 546         efi_call_early(free_pool, pci_handle);
 547         return status;
 548 }
 549
 550 static void
 551 setup_pixel_info(struct screen_info *si, u32 pixels_per_scan_line,
 552                  struct efi_pixel_bitmask pixel_info, int pixel_format)
 553 {
 554         if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
 555                 si->lfb_depth = 32;
 556                 si->lfb_linelength = pixels_per_scan_line * 4;
 557                 si->red_size = 8;
 558                 si->red_pos = 0;
 559                 si->green_size = 8;
 560                 si->green_pos = 8;
 561                 si->blue_size = 8;
 562                 si->blue_pos = 16;
 563                 si->rsvd_size = 8;
 564                 si->rsvd_pos = 24;
 565         } else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
 566                 si->lfb_depth = 32;
 567                 si->lfb_linelength = pixels_per_scan_line * 4;
 568                 si->red_size = 8;
 569                 si->red_pos = 16;
 570                 si->green_size = 8;
 571                 si->green_pos = 8;
 572                 si->blue_size = 8;
 573                 si->blue_pos = 0;
 574                 si->rsvd_size = 8;
 575                 si->rsvd_pos = 24;
 576         } else if (pixel_format == PIXEL_BIT_MASK) {
 577                 find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
 578                 find_bits(pixel_info.green_mask, &si->green_pos,
 579                           &si->green_size);
 580                 find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
 581                 find_bits(pixel_info.reserved_mask, &si->rsvd_pos,
 582                           &si->rsvd_size);
 583                 si->lfb_depth = si->red_size + si->green_size +
 584                         si->blue_size + si->rsvd_size;
 585                 si->lfb_linelength = (pixels_per_scan_line * si->lfb_depth) / 8;
 586         } else {
 587                 si->lfb_depth = 4;
 588                 si->lfb_linelength = si->lfb_width / 2;
 589                 si->red_size = 0;
 590                 si->red_pos = 0;
 591                 si->green_size = 0;
 592                 si->green_pos = 0;
 593                 si->blue_size = 0;
 594                 si->blue_pos = 0;
 595                 si->rsvd_size = 0;
 596                 si->rsvd_pos = 0;
 597         }
 598 }
 599
 600 static efi_status_t
 601 __gop_query32(struct efi_graphics_output_protocol_32 *gop32,
 602               struct efi_graphics_output_mode_info **info,
 603               unsigned long *size, u32 *fb_base)
 604 {
 605         struct efi_graphics_output_protocol_mode_32 *mode;
 606         efi_status_t status;
 607         unsigned long m;
 608
 609         m = gop32->mode;
 610         mode = (struct efi_graphics_output_protocol_mode_32 *)m;
 611
 612         status = efi_early->call(gop32->query_mode, gop32,
 613                                  mode->mode, size, info);
 614         if (status != EFI_SUCCESS)
 615                 return status;
 616
 617         *fb_base = mode->frame_buffer_base;
 618         return status;
 619 }
 620
 621 static efi_status_t
 622 setup_gop32(struct screen_info *si, efi_guid_t *proto,
 623             unsigned long size, void **gop_handle)
 624 {
 625         struct efi_graphics_output_protocol_32 *gop32, *first_gop;
 626         unsigned long nr_gops;
 627         u16 width, height;
 628         u32 pixels_per_scan_line;
 629         u32 fb_base;
 630         struct efi_pixel_bitmask pixel_info;
 631         int pixel_format;
 632         efi_status_t status;
 633         u32 *handles = (u32 *)(unsigned long)gop_handle;
 634         int i;
 635
 636         first_gop = NULL;
 637         gop32 = NULL;
 638
 639         nr_gops = size / sizeof(u32);
 640         for (i = 0; i < nr_gops; i++) {
 641                 struct efi_graphics_output_mode_info *info = NULL;
 642                 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
 643                 bool conout_found = false;
 644                 void *dummy = NULL;
 645                 u32 h = handles[i];
 646
 647                 status = efi_call_early(handle_protocol, h,
 648                                         proto, (void **)&gop32);
 649                 if (status != EFI_SUCCESS)
 650                         continue;
 651
 652                 status = efi_call_early(handle_protocol, h,
 653                                         &conout_proto, &dummy);
 654                 if (status == EFI_SUCCESS)
 655                         conout_found = true;
 656
 657                 status = __gop_query32(gop32, &info, &size, &fb_base);
 658                 if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
 659                         /*
 660                          * Systems that use the UEFI Console Splitter may
 661                          * provide multiple GOP devices, not all of which are
 662                          * backed by real hardware. The workaround is to search
 663                          * for a GOP implementing the ConOut protocol, and if
 664                          * one isn't found, to just fall back to the first GOP.
 665                          */
 666                         width = info->horizontal_resolution;
 667                         height = info->vertical_resolution;
 668                         pixel_format = info->pixel_format;
 669                         pixel_info = info->pixel_information;
 670                         pixels_per_scan_line = info->pixels_per_scan_line;
 671
 672                         /*
 673                          * Once we've found a GOP supporting ConOut,
 674                          * don't bother looking any further.
 675                          */
 676                         first_gop = gop32;
 677                         if (conout_found)
 678                                 break;
 679                 }
 680         }
 681
 682         /* Did we find any GOPs? */
 683         if (!first_gop)
 684                 goto out;
 685
 686         /* EFI framebuffer */
 687         si->orig_video_isVGA = VIDEO_TYPE_EFI;
 688
 689         si->lfb_width = width;
 690         si->lfb_height = height;
 691         si->lfb_base = fb_base;
 692         si->pages = 1;
 693
 694         setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
 695
 696         si->lfb_size = si->lfb_linelength * si->lfb_height;
 697
 698         si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
 699 out:
 700         return status;
 701 }
 702
 703 static efi_status_t
 704 __gop_query64(struct efi_graphics_output_protocol_64 *gop64,
 705               struct efi_graphics_output_mode_info **info,
 706               unsigned long *size, u32 *fb_base)
 707 {
 708         struct efi_graphics_output_protocol_mode_64 *mode;
 709         efi_status_t status;
 710         unsigned long m;
 711
 712         m = gop64->mode;
 713         mode = (struct efi_graphics_output_protocol_mode_64 *)m;
 714
 715         status = efi_early->call(gop64->query_mode, gop64,
 716                                  mode->mode, size, info);
 717         if (status != EFI_SUCCESS)
 718                 return status;
 719
 720         *fb_base = mode->frame_buffer_base;
 721         return status;
 722 }
 723
 724 static efi_status_t
 725 setup_gop64(struct screen_info *si, efi_guid_t *proto,
 726             unsigned long size, void **gop_handle)
 727 {
 728         struct efi_graphics_output_protocol_64 *gop64, *first_gop;
 729         unsigned long nr_gops;
 730         u16 width, height;
 731         u32 pixels_per_scan_line;
 732         u32 fb_base;
 733         struct efi_pixel_bitmask pixel_info;
 734         int pixel_format;
 735         efi_status_t status;
 736         u64 *handles = (u64 *)(unsigned long)gop_handle;
 737         int i;
 738
 739         first_gop = NULL;
 740         gop64 = NULL;
 741
 742         nr_gops = size / sizeof(u64);
 743         for (i = 0; i < nr_gops; i++) {
 744                 struct efi_graphics_output_mode_info *info = NULL;
 745                 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
 746                 bool conout_found = false;
 747                 void *dummy = NULL;
 748                 u64 h = handles[i];
 749
 750                 status = efi_call_early(handle_protocol, h,
 751                                         proto, (void **)&gop64);
 752                 if (status != EFI_SUCCESS)
 753                         continue;
 754
 755                 status = efi_call_early(handle_protocol, h,
 756                                         &conout_proto, &dummy);
 757                 if (status == EFI_SUCCESS)
 758                         conout_found = true;
 759
 760                 status = __gop_query64(gop64, &info, &size, &fb_base);
 761                 if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
 762                         /*
 763                          * Systems that use the UEFI Console Splitter may
 764                          * provide multiple GOP devices, not all of which are
 765                          * backed by real hardware. The workaround is to search
 766                          * for a GOP implementing the ConOut protocol, and if
 767                          * one isn't found, to just fall back to the first GOP.
 768                          */
 769                         width = info->horizontal_resolution;
 770                         height = info->vertical_resolution;
 771                         pixel_format = info->pixel_format;
 772                         pixel_info = info->pixel_information;
 773                         pixels_per_scan_line = info->pixels_per_scan_line;
 774
 775                         /*
 776                          * Once we've found a GOP supporting ConOut,
 777                          * don't bother looking any further.
 778                          */
 779                         first_gop = gop64;
 780                         if (conout_found)
 781                                 break;
 782                 }
 783         }
 784
 785         /* Did we find any GOPs? */
 786         if (!first_gop)
 787                 goto out;
 788
 789         /* EFI framebuffer */
 790         si->orig_video_isVGA = VIDEO_TYPE_EFI;
 791
 792         si->lfb_width = width;
 793         si->lfb_height = height;
 794         si->lfb_base = fb_base;
 795         si->pages = 1;
 796
 797         setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
 798
 799         si->lfb_size = si->lfb_linelength * si->lfb_height;
 800
 801         si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
 802 out:
 803         return status;
 804 }
 805
 806 /*
 807  * See if we have Graphics Output Protocol
 808  */
 809 static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
 810                               unsigned long size)
 811 {
 812         efi_status_t status;
 813         void **gop_handle = NULL;
 814
 815         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
 816                                 size, (void **)&gop_handle);
 817         if (status != EFI_SUCCESS)
 818                 return status;
 819
 820         status = efi_call_early(locate_handle,
 821                                 EFI_LOCATE_BY_PROTOCOL,
 822                                 proto, NULL, &size, gop_handle);
 823         if (status != EFI_SUCCESS)
 824                 goto free_handle;
 825
 826         if (efi_early->is64)
 827                 status = setup_gop64(si, proto, size, gop_handle);
 828         else
 829                 status = setup_gop32(si, proto, size, gop_handle);
 830
 831 free_handle:
 832         efi_call_early(free_pool, gop_handle);
 833         return status;
 834 }
 835
 836 static efi_status_t
 837 setup_uga32(void **uga_handle, unsigned long size, u32 *width, u32 *height)
 838 {
 839         struct efi_uga_draw_protocol *uga = NULL, *first_uga;
 840         efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;
 841         unsigned long nr_ugas;
 842         u32 *handles = (u32 *)uga_handle;;
 843         efi_status_t status;
 844         int i;
 845
 846         first_uga = NULL;
 847         nr_ugas = size / sizeof(u32);
 848         for (i = 0; i < nr_ugas; i++) {
 849                 efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;
 850                 u32 w, h, depth, refresh;
 851                 void *pciio;
 852                 u32 handle = handles[i];
 853
 854                 status = efi_call_early(handle_protocol, handle,
 855                                         &uga_proto, (void **)&uga);
 856                 if (status != EFI_SUCCESS)
 857                         continue;
 858
 859                 efi_call_early(handle_protocol, handle, &pciio_proto, &pciio);
 860
 861                 status = efi_early->call((unsigned long)uga->get_mode, uga,
 862                                          &w, &h, &depth, &refresh);
 863                 if (status == EFI_SUCCESS && (!first_uga || pciio)) {
 864                         *width = w;
 865                         *height = h;
 866
 867                         /*
 868                          * Once we've found a UGA supporting PCIIO,
 869                          * don't bother looking any further.
 870                          */
 871                         if (pciio)
 872                                 break;
 873
 874                         first_uga = uga;
 875                 }
 876         }
 877
 878         return status;
 879 }
 880
 881 static efi_status_t
 882 setup_uga64(void **uga_handle, unsigned long size, u32 *width, u32 *height)
 883 {
 884         struct efi_uga_draw_protocol *uga = NULL, *first_uga;
 885         efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;
 886         unsigned long nr_ugas;
 887         u64 *handles = (u64 *)uga_handle;;
 888         efi_status_t status;
 889         int i;
 890
 891         first_uga = NULL;
 892         nr_ugas = size / sizeof(u64);
 893         for (i = 0; i < nr_ugas; i++) {
 894                 efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;
 895                 u32 w, h, depth, refresh;
 896                 void *pciio;
 897                 u64 handle = handles[i];
 898
 899                 status = efi_call_early(handle_protocol, handle,
 900                                         &uga_proto, (void **)&uga);
 901                 if (status != EFI_SUCCESS)
 902                         continue;
 903
 904                 efi_call_early(handle_protocol, handle, &pciio_proto, &pciio);
 905
 906                 status = efi_early->call((unsigned long)uga->get_mode, uga,
 907                                          &w, &h, &depth, &refresh);
 908                 if (status == EFI_SUCCESS && (!first_uga || pciio)) {
 909                         *width = w;
 910                         *height = h;
 911
 912                         /*
 913                          * Once we've found a UGA supporting PCIIO,
 914                          * don't bother looking any further.
 915                          */
 916                         if (pciio)
 917                                 break;
 918
 919                         first_uga = uga;
 920                 }
 921         }
 922
 923         return status;
 924 }
 925
 926 /*
 927  * See if we have Universal Graphics Adapter (UGA) protocol
 928  */
 929 static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
 930                               unsigned long size)
 931 {
 932         efi_status_t status;
 933         u32 width, height;
 934         void **uga_handle = NULL;
 935
 936         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
 937                                 size, (void **)&uga_handle);
 938         if (status != EFI_SUCCESS)
 939                 return status;
 940
 941         status = efi_call_early(locate_handle,
 942                                 EFI_LOCATE_BY_PROTOCOL,
 943                                 uga_proto, NULL, &size, uga_handle);
 944         if (status != EFI_SUCCESS)
 945                 goto free_handle;
 946
 947         height = 0;
 948         width = 0;
 949
 950         if (efi_early->is64)
 951                 status = setup_uga64(uga_handle, size, &width, &height);
 952         else
 953                 status = setup_uga32(uga_handle, size, &width, &height);
 954
 955         if (!width && !height)
 956                 goto free_handle;
 957
 958         /* EFI framebuffer */
 959         si->orig_video_isVGA = VIDEO_TYPE_EFI;
 960
 961         si->lfb_depth = 32;
 962         si->lfb_width = width;
 963         si->lfb_height = height;
 964
 965         si->red_size = 8;
 966         si->red_pos = 16;
 967         si->green_size = 8;
 968         si->green_pos = 8;
 969         si->blue_size = 8;
 970         si->blue_pos = 0;
 971         si->rsvd_size = 8;
 972         si->rsvd_pos = 24;
 973
 974 free_handle:
 975         efi_call_early(free_pool, uga_handle);
 976         return status;
 977 }
 978
 979 void setup_graphics(struct boot_params *boot_params)
 980 {
 981         efi_guid_t graphics_proto = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
 982         struct screen_info *si;
 983         efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;
 984         efi_status_t status;
 985         unsigned long size;
 986         void **gop_handle = NULL;
 987         void **uga_handle = NULL;
 988
 989         si = &boot_params->screen_info;
 990         memset(si, 0, sizeof(*si));
 991
 992         size = 0;
 993         status = efi_call_early(locate_handle,
 994                                 EFI_LOCATE_BY_PROTOCOL,
 995                                 &graphics_proto, NULL, &size, gop_handle);
 996         if (status == EFI_BUFFER_TOO_SMALL)
 997                 status = setup_gop(si, &graphics_proto, size);
 998
 999         if (status != EFI_SUCCESS) {
1000                 size = 0;
1001                 status = efi_call_early(locate_handle,
1002                                         EFI_LOCATE_BY_PROTOCOL,
1003                                         &uga_proto, NULL, &size, uga_handle);
1004                 if (status == EFI_BUFFER_TOO_SMALL)
1005                         setup_uga(si, &uga_proto, size);
1006         }
1007 }
1008
1009 /*
1010  * Because the x86 boot code expects to be passed a boot_params we
1011  * need to create one ourselves (usually the bootloader would create
1012  * one for us).
1013  *
1014  * The caller is responsible for filling out ->code32_start in the
1015  * returned boot_params.
1016  */
1017 struct boot_params *make_boot_params(struct efi_config *c)
1018 {
1019         struct boot_params *boot_params;
1020         struct sys_desc_table *sdt;
1021         struct apm_bios_info *bi;
1022         struct setup_header *hdr;
1023         struct efi_info *efi;
1024         efi_loaded_image_t *image;
1025         void *options, *handle;
1026         efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID;
1027         int options_size = 0;
1028         efi_status_t status;
1029         char *cmdline_ptr;
1030         u16 *s2;
1031         u8 *s1;
1032         int i;
1033         unsigned long ramdisk_addr;
1034         unsigned long ramdisk_size;
1035         unsigned long initrd_addr_max;
1036
1037         efi_early = c;
1038         sys_table = (efi_system_table_t *)(unsigned long)efi_early->table;
1039         handle = (void *)(unsigned long)efi_early->image_handle;
1040
1041         /* Check if we were booted by the EFI firmware */
1042         if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
1043                 return NULL;
1044
1045         if (efi_early->is64)
1046                 setup_boot_services64(efi_early);
1047         else
1048                 setup_boot_services32(efi_early);
1049
1050         status = efi_call_early(handle_protocol, handle,
1051                                 &proto, (void *)&image);
1052         if (status != EFI_SUCCESS) {
1053                 efi_printk(sys_table, "Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
1054                 return NULL;
1055         }
1056
1057         status = efi_low_alloc(sys_table, 0x4000, 1,
1058                                (unsigned long *)&boot_params);
1059         if (status != EFI_SUCCESS) {
1060                 efi_printk(sys_table, "Failed to alloc lowmem for boot params\n");
1061                 return NULL;
1062         }
1063
1064         memset(boot_params, 0x0, 0x4000);
1065
1066         hdr = &boot_params->hdr;
1067         efi = &boot_params->efi_info;
1068         bi = &boot_params->apm_bios_info;
1069         sdt = &boot_params->sys_desc_table;
1070
1071         /* Copy the second sector to boot_params */
1072         memcpy(&hdr->jump, image->image_base + 512, 512);
1073
1074         /*
1075          * Fill out some of the header fields ourselves because the
1076          * EFI firmware loader doesn't load the first sector.
1077          */
1078         hdr->root_flags = 1;
1079         hdr->vid_mode = 0xffff;
1080         hdr->boot_flag = 0xAA55;
1081
1082         hdr->type_of_loader = 0x21;
1083
1084         /* Convert unicode cmdline to ascii */
1085         cmdline_ptr = efi_convert_cmdline(sys_table, image, &options_size);
1086         if (!cmdline_ptr)
1087                 goto fail;
1088         hdr->cmd_line_ptr = (unsigned long)cmdline_ptr;
1089
1090         hdr->ramdisk_image = 0;
1091         hdr->ramdisk_size = 0;
1092
1093         /* Clear APM BIOS info */
1094         memset(bi, 0, sizeof(*bi));
1095
1096         memset(sdt, 0, sizeof(*sdt));
1097
1098         if (hdr->xloadflags & XLF_CAN_BE_LOADED_ABOVE_4G)
1099                 initrd_addr_max = -1UL;
1100         else
1101                 initrd_addr_max = hdr->initrd_addr_max;
1102
1103         status = handle_cmdline_files(sys_table, image,
1104                                       (char *)(unsigned long)hdr->cmd_line_ptr,
1105                                       "initrd=", initrd_addr_max,
1106                                       &ramdisk_addr, &ramdisk_size);
1107         if (status != EFI_SUCCESS)
1108                 goto fail2;
1109         hdr->ramdisk_image = ramdisk_addr & 0xffffffff;
1110         hdr->ramdisk_size  = ramdisk_size & 0xffffffff;
1111         boot_params->ext_ramdisk_image = (u64)ramdisk_addr >> 32;
1112         boot_params->ext_ramdisk_size  = (u64)ramdisk_size >> 32;
1113
1114         return boot_params;
1115 fail2:
1116         efi_free(sys_table, options_size, hdr->cmd_line_ptr);
1117 fail:
1118         efi_free(sys_table, 0x4000, (unsigned long)boot_params);
1119         return NULL;
1120 }
1121
1122 static void add_e820ext(struct boot_params *params,
1123                         struct setup_data *e820ext, u32 nr_entries)
1124 {
1125         struct setup_data *data;
1126         efi_status_t status;
1127         unsigned long size;
1128
1129         e820ext->type = SETUP_E820_EXT;
1130         e820ext->len = nr_entries * sizeof(struct e820entry);
1131         e820ext->next = 0;
1132
1133         data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
1134
1135         while (data && data->next)
1136                 data = (struct setup_data *)(unsigned long)data->next;
1137
1138         if (data)
1139                 data->next = (unsigned long)e820ext;
1140         else
1141                 params->hdr.setup_data = (unsigned long)e820ext;
1142 }
1143
1144 static efi_status_t setup_e820(struct boot_params *params,
1145                                struct setup_data *e820ext, u32 e820ext_size)
1146 {
1147         struct e820entry *e820_map = &params->e820_map[0];
1148         struct efi_info *efi = &params->efi_info;
1149         struct e820entry *prev = NULL;
1150         u32 nr_entries;
1151         u32 nr_desc;
1152         int i;
1153
1154         nr_entries = 0;
1155         nr_desc = efi->efi_memmap_size / efi->efi_memdesc_size;
1156
1157         for (i = 0; i < nr_desc; i++) {
1158                 efi_memory_desc_t *d;
1159                 unsigned int e820_type = 0;
1160                 unsigned long m = efi->efi_memmap;
1161
1162                 d = (efi_memory_desc_t *)(m + (i * efi->efi_memdesc_size));
1163                 switch (d->type) {
1164                 case EFI_RESERVED_TYPE:
1165                 case EFI_RUNTIME_SERVICES_CODE:
1166                 case EFI_RUNTIME_SERVICES_DATA:
1167                 case EFI_MEMORY_MAPPED_IO:
1168                 case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
1169                 case EFI_PAL_CODE:
1170                         e820_type = E820_RESERVED;
1171                         break;
1172
1173                 case EFI_UNUSABLE_MEMORY:
1174                         e820_type = E820_UNUSABLE;
1175                         break;
1176
1177                 case EFI_ACPI_RECLAIM_MEMORY:
1178                         e820_type = E820_ACPI;
1179                         break;
1180
1181                 case EFI_LOADER_CODE:
1182                 case EFI_LOADER_DATA:
1183                 case EFI_BOOT_SERVICES_CODE:
1184                 case EFI_BOOT_SERVICES_DATA:
1185                 case EFI_CONVENTIONAL_MEMORY:
1186                         e820_type = E820_RAM;
1187                         break;
1188
1189                 case EFI_ACPI_MEMORY_NVS:
1190                         e820_type = E820_NVS;
1191                         break;
1192
1193                 default:
1194                         continue;
1195                 }
1196
1197                 /* Merge adjacent mappings */
1198                 if (prev && prev->type == e820_type &&
1199                     (prev->addr + prev->size) == d->phys_addr) {
1200                         prev->size += d->num_pages << 12;
1201                         continue;
1202                 }
1203
1204                 if (nr_entries == ARRAY_SIZE(params->e820_map)) {
1205                         u32 need = (nr_desc - i) * sizeof(struct e820entry) +
1206                                    sizeof(struct setup_data);
1207
1208                         if (!e820ext || e820ext_size < need)
1209                                 return EFI_BUFFER_TOO_SMALL;
1210
1211                         /* boot_params map full, switch to e820 extended */
1212                         e820_map = (struct e820entry *)e820ext->data;
1213                 }
1214
1215                 e820_map->addr = d->phys_addr;
1216                 e820_map->size = d->num_pages << PAGE_SHIFT;
1217                 e820_map->type = e820_type;
1218                 prev = e820_map++;
1219                 nr_entries++;
1220         }
1221
1222         if (nr_entries > ARRAY_SIZE(params->e820_map)) {
1223                 u32 nr_e820ext = nr_entries - ARRAY_SIZE(params->e820_map);
1224
1225                 add_e820ext(params, e820ext, nr_e820ext);
1226                 nr_entries -= nr_e820ext;
1227         }
1228
1229         params->e820_entries = (u8)nr_entries;
1230
1231         return EFI_SUCCESS;
1232 }
1233
1234 static efi_status_t alloc_e820ext(u32 nr_desc, struct setup_data **e820ext,
1235                                   u32 *e820ext_size)
1236 {
1237         efi_status_t status;
1238         unsigned long size;
1239
1240         size = sizeof(struct setup_data) +
1241                 sizeof(struct e820entry) * nr_desc;
1242
1243         if (*e820ext) {
1244                 efi_call_early(free_pool, *e820ext);
1245                 *e820ext = NULL;
1246                 *e820ext_size = 0;
1247         }
1248
1249         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
1250                                 size, (void **)e820ext);
1251         if (status == EFI_SUCCESS)
1252                 *e820ext_size = size;
1253
1254         return status;
1255 }
1256
1257 static efi_status_t exit_boot(struct boot_params *boot_params,
1258                               void *handle, bool is64)
1259 {
1260         struct efi_info *efi = &boot_params->efi_info;
1261         unsigned long map_sz, key, desc_size;
1262         efi_memory_desc_t *mem_map;
1263         struct setup_data *e820ext;
1264         const char *signature;
1265         __u32 e820ext_size;
1266         __u32 nr_desc, prev_nr_desc;
1267         efi_status_t status;
1268         __u32 desc_version;
1269         bool called_exit = false;
1270         u8 nr_entries;
1271         int i;
1272
1273         nr_desc = 0;
1274         e820ext = NULL;
1275         e820ext_size = 0;
1276
1277 get_map:
1278         status = efi_get_memory_map(sys_table, &mem_map, &map_sz, &desc_size,
1279                                     &desc_version, &key);
1280
1281         if (status != EFI_SUCCESS)
1282                 return status;
1283
1284         prev_nr_desc = nr_desc;
1285         nr_desc = map_sz / desc_size;
1286         if (nr_desc > prev_nr_desc &&
1287             nr_desc > ARRAY_SIZE(boot_params->e820_map)) {
1288                 u32 nr_e820ext = nr_desc - ARRAY_SIZE(boot_params->e820_map);
1289
1290                 status = alloc_e820ext(nr_e820ext, &e820ext, &e820ext_size);
1291                 if (status != EFI_SUCCESS)
1292                         goto free_mem_map;
1293
1294                 efi_call_early(free_pool, mem_map);
1295                 goto get_map; /* Allocated memory, get map again */
1296         }
1297
1298         signature = is64 ? EFI64_LOADER_SIGNATURE : EFI32_LOADER_SIGNATURE;
1299         memcpy(&efi->efi_loader_signature, signature, sizeof(__u32));
1300
1301         efi->efi_systab = (unsigned long)sys_table;
1302         efi->efi_memdesc_size = desc_size;
1303         efi->efi_memdesc_version = desc_version;
1304         efi->efi_memmap = (unsigned long)mem_map;
1305         efi->efi_memmap_size = map_sz;
1306
1307 #ifdef CONFIG_X86_64
1308         efi->efi_systab_hi = (unsigned long)sys_table >> 32;
1309         efi->efi_memmap_hi = (unsigned long)mem_map >> 32;
1310 #endif
1311
1312         /* Might as well exit boot services now */
1313         status = efi_call_early(exit_boot_services, handle, key);
1314         if (status != EFI_SUCCESS) {
1315                 /*
1316                  * ExitBootServices() will fail if any of the event
1317                  * handlers change the memory map. In which case, we
1318                  * must be prepared to retry, but only once so that
1319                  * we're guaranteed to exit on repeated failures instead
1320                  * of spinning forever.
1321                  */
1322                 if (called_exit)
1323                         goto free_mem_map;
1324
1325                 called_exit = true;
1326                 efi_call_early(free_pool, mem_map);
1327                 goto get_map;
1328         }
1329
1330         /* Historic? */
1331         boot_params->alt_mem_k = 32 * 1024;
1332
1333         status = setup_e820(boot_params, e820ext, e820ext_size);
1334         if (status != EFI_SUCCESS)
1335                 return status;
1336
1337         return EFI_SUCCESS;
1338
1339 free_mem_map:
1340         efi_call_early(free_pool, mem_map);
1341         return status;
1342 }
1343
1344 /*
1345  * On success we return a pointer to a boot_params structure, and NULL
1346  * on failure.
1347  */
1348 struct boot_params *efi_main(struct efi_config *c,
1349                              struct boot_params *boot_params)
1350 {
1351         struct desc_ptr *gdt = NULL;
1352         efi_loaded_image_t *image;
1353         struct setup_header *hdr = &boot_params->hdr;
1354         efi_status_t status;
1355         struct desc_struct *desc;
1356         void *handle;
1357         efi_system_table_t *_table;
1358         bool is64;
1359
1360         efi_early = c;
1361
1362         _table = (efi_system_table_t *)(unsigned long)efi_early->table;
1363         handle = (void *)(unsigned long)efi_early->image_handle;
1364         is64 = efi_early->is64;
1365
1366         sys_table = _table;
1367
1368         /* Check if we were booted by the EFI firmware */
1369         if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
1370                 goto fail;
1371
1372         if (is64)
1373                 setup_boot_services64(efi_early);
1374         else
1375                 setup_boot_services32(efi_early);
1376
1377         setup_graphics(boot_params);
1378
1379         setup_efi_pci(boot_params);
1380
1381         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
1382                                 sizeof(*gdt), (void **)&gdt);
1383         if (status != EFI_SUCCESS) {
1384                 efi_printk(sys_table, "Failed to alloc mem for gdt structure\n");
1385                 goto fail;
1386         }
1387
1388         gdt->size = 0x800;
1389         status = efi_low_alloc(sys_table, gdt->size, 8,
1390                            (unsigned long *)&gdt->address);
1391         if (status != EFI_SUCCESS) {
1392                 efi_printk(sys_table, "Failed to alloc mem for gdt\n");
1393                 goto fail;
1394         }
1395
1396         /*
1397          * If the kernel isn't already loaded at the preferred load
1398          * address, relocate it.
1399          */
1400         if (hdr->pref_address != hdr->code32_start) {
1401                 unsigned long bzimage_addr = hdr->code32_start;
1402                 status = efi_relocate_kernel(sys_table, &bzimage_addr,
1403                                              hdr->init_size, hdr->init_size,
1404                                              hdr->pref_address,
1405                                              hdr->kernel_alignment);
1406                 if (status != EFI_SUCCESS)
1407                         goto fail;
1408
1409                 hdr->pref_address = hdr->code32_start;
1410                 hdr->code32_start = bzimage_addr;
1411         }
1412
1413         status = exit_boot(boot_params, handle, is64);
1414         if (status != EFI_SUCCESS)
1415                 goto fail;
1416
1417         memset((char *)gdt->address, 0x0, gdt->size);
1418         desc = (struct desc_struct *)gdt->address;
1419
1420         /* The first GDT is a dummy and the second is unused. */
1421         desc += 2;
1422
1423         desc->limit0 = 0xffff;
1424         desc->base0 = 0x0000;
1425         desc->base1 = 0x0000;
1426         desc->type = SEG_TYPE_CODE | SEG_TYPE_EXEC_READ;
1427         desc->s = DESC_TYPE_CODE_DATA;
1428         desc->dpl = 0;
1429         desc->p = 1;
1430         desc->limit = 0xf;
1431         desc->avl = 0;
1432         desc->l = 0;
1433         desc->d = SEG_OP_SIZE_32BIT;
1434         desc->g = SEG_GRANULARITY_4KB;
1435         desc->base2 = 0x00;
1436
1437         desc++;
1438         desc->limit0 = 0xffff;
1439         desc->base0 = 0x0000;
1440         desc->base1 = 0x0000;
1441         desc->type = SEG_TYPE_DATA | SEG_TYPE_READ_WRITE;
1442         desc->s = DESC_TYPE_CODE_DATA;
1443         desc->dpl = 0;
1444         desc->p = 1;
1445         desc->limit = 0xf;
1446         desc->avl = 0;
1447         desc->l = 0;
1448         desc->d = SEG_OP_SIZE_32BIT;
1449         desc->g = SEG_GRANULARITY_4KB;
1450         desc->base2 = 0x00;
1451
1452 #ifdef CONFIG_X86_64
1453         /* Task segment value */
1454         desc++;
1455         desc->limit0 = 0x0000;
1456         desc->base0 = 0x0000;
1457         desc->base1 = 0x0000;
1458         desc->type = SEG_TYPE_TSS;
1459         desc->s = 0;
1460         desc->dpl = 0;
1461         desc->p = 1;
1462         desc->limit = 0x0;
1463         desc->avl = 0;
1464         desc->l = 0;
1465         desc->d = 0;
1466         desc->g = SEG_GRANULARITY_4KB;
1467         desc->base2 = 0x00;
1468 #endif /* CONFIG_X86_64 */
1469
1470         asm volatile("cli");
1471         asm volatile ("lgdt %0" : : "m" (*gdt));
1472
1473         return boot_params;
1474 fail:
1475         return NULL;
1476 }