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
  23 #include "../../../../drivers/firmware/efi/efi-stub-helper.c"
  24
  25
  26
  27 static void find_bits(unsigned long mask, u8 *pos, u8 *size)
  28 {
  29         u8 first, len;
  30
  31         first = 0;
  32         len = 0;
  33
  34         if (mask) {
  35                 while (!(mask & 0x1)) {
  36                         mask = mask >> 1;
  37                         first++;
  38                 }
  39
  40                 while (mask & 0x1) {
  41                         mask = mask >> 1;
  42                         len++;
  43                 }
  44         }
  45
  46         *pos = first;
  47         *size = len;
  48 }
  49
  50 static efi_status_t setup_efi_pci(struct boot_params *params)
  51 {
  52         efi_pci_io_protocol *pci;
  53         efi_status_t status;
  54         void **pci_handle;
  55         efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
  56         unsigned long nr_pci, size = 0;
  57         int i;
  58         struct setup_data *data;
  59
  60         data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
  61
  62         while (data && data->next)
  63                 data = (struct setup_data *)(unsigned long)data->next;
  64
  65         status = efi_call_phys5(sys_table->boottime->locate_handle,
  66                                 EFI_LOCATE_BY_PROTOCOL, &pci_proto,
  67                                 NULL, &size, pci_handle);
  68
  69         if (status == EFI_BUFFER_TOO_SMALL) {
  70                 status = efi_call_phys3(sys_table->boottime->allocate_pool,
  71                                         EFI_LOADER_DATA, size, &pci_handle);
  72
  73                 if (status != EFI_SUCCESS)
  74                         return status;
  75
  76                 status = efi_call_phys5(sys_table->boottime->locate_handle,
  77                                         EFI_LOCATE_BY_PROTOCOL, &pci_proto,
  78                                         NULL, &size, pci_handle);
  79         }
  80
  81         if (status != EFI_SUCCESS)
  82                 goto free_handle;
  83
  84         nr_pci = size / sizeof(void *);
  85         for (i = 0; i < nr_pci; i++) {
  86                 void *h = pci_handle[i];
  87                 uint64_t attributes;
  88                 struct pci_setup_rom *rom;
  89
  90                 status = efi_call_phys3(sys_table->boottime->handle_protocol,
  91                                         h, &pci_proto, &pci);
  92
  93                 if (status != EFI_SUCCESS)
  94                         continue;
  95
  96                 if (!pci)
  97                         continue;
  98
  99 #ifdef CONFIG_X86_64
 100                 status = efi_call_phys4(pci->attributes, pci,
 101                                         EfiPciIoAttributeOperationGet, 0,
 102                                         &attributes);
 103 #else
 104                 status = efi_call_phys5(pci->attributes, pci,
 105                                         EfiPciIoAttributeOperationGet, 0, 0,
 106                                         &attributes);
 107 #endif
 108                 if (status != EFI_SUCCESS)
 109                         continue;
 110
 111                 if (!pci->romimage || !pci->romsize)
 112                         continue;
 113
 114                 size = pci->romsize + sizeof(*rom);
 115
 116                 status = efi_call_phys3(sys_table->boottime->allocate_pool,
 117                                 EFI_LOADER_DATA, size, &rom);
 118
 119                 if (status != EFI_SUCCESS)
 120                         continue;
 121
 122                 rom->data.type = SETUP_PCI;
 123                 rom->data.len = size - sizeof(struct setup_data);
 124                 rom->data.next = 0;
 125                 rom->pcilen = pci->romsize;
 126
 127                 status = efi_call_phys5(pci->pci.read, pci,
 128                                         EfiPciIoWidthUint16, PCI_VENDOR_ID,
 129                                         1, &(rom->vendor));
 130
 131                 if (status != EFI_SUCCESS)
 132                         goto free_struct;
 133
 134                 status = efi_call_phys5(pci->pci.read, pci,
 135                                         EfiPciIoWidthUint16, PCI_DEVICE_ID,
 136                                         1, &(rom->devid));
 137
 138                 if (status != EFI_SUCCESS)
 139                         goto free_struct;
 140
 141                 status = efi_call_phys5(pci->get_location, pci,
 142                                         &(rom->segment), &(rom->bus),
 143                                         &(rom->device), &(rom->function));
 144
 145                 if (status != EFI_SUCCESS)
 146                         goto free_struct;
 147
 148                 memcpy(rom->romdata, pci->romimage, pci->romsize);
 149
 150                 if (data)
 151                         data->next = (unsigned long)rom;
 152                 else
 153                         params->hdr.setup_data = (unsigned long)rom;
 154
 155                 data = (struct setup_data *)rom;
 156
 157                 continue;
 158         free_struct:
 159                 efi_call_phys1(sys_table->boottime->free_pool, rom);
 160         }
 161
 162 free_handle:
 163         efi_call_phys1(sys_table->boottime->free_pool, pci_handle);
 164         return status;
 165 }
 166
 167 /*
 168  * See if we have Graphics Output Protocol
 169  */
 170 static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
 171                               unsigned long size)
 172 {
 173         struct efi_graphics_output_protocol *gop, *first_gop;
 174         struct efi_pixel_bitmask pixel_info;
 175         unsigned long nr_gops;
 176         efi_status_t status;
 177         void **gop_handle;
 178         u16 width, height;
 179         u32 fb_base, fb_size;
 180         u32 pixels_per_scan_line;
 181         int pixel_format;
 182         int i;
 183
 184         status = efi_call_phys3(sys_table->boottime->allocate_pool,
 185                                 EFI_LOADER_DATA, size, &gop_handle);
 186         if (status != EFI_SUCCESS)
 187                 return status;
 188
 189         status = efi_call_phys5(sys_table->boottime->locate_handle,
 190                                 EFI_LOCATE_BY_PROTOCOL, proto,
 191                                 NULL, &size, gop_handle);
 192         if (status != EFI_SUCCESS)
 193                 goto free_handle;
 194
 195         first_gop = NULL;
 196
 197         nr_gops = size / sizeof(void *);
 198         for (i = 0; i < nr_gops; i++) {
 199                 struct efi_graphics_output_mode_info *info;
 200                 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
 201                 bool conout_found = false;
 202                 void *dummy;
 203                 void *h = gop_handle[i];
 204
 205                 status = efi_call_phys3(sys_table->boottime->handle_protocol,
 206                                         h, proto, &gop);
 207                 if (status != EFI_SUCCESS)
 208                         continue;
 209
 210                 status = efi_call_phys3(sys_table->boottime->handle_protocol,
 211                                         h, &conout_proto, &dummy);
 212
 213                 if (status == EFI_SUCCESS)
 214                         conout_found = true;
 215
 216                 status = efi_call_phys4(gop->query_mode, gop,
 217                                         gop->mode->mode, &size, &info);
 218                 if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
 219                         /*
 220                          * Systems that use the UEFI Console Splitter may
 221                          * provide multiple GOP devices, not all of which are
 222                          * backed by real hardware. The workaround is to search
 223                          * for a GOP implementing the ConOut protocol, and if
 224                          * one isn't found, to just fall back to the first GOP.
 225                          */
 226                         width = info->horizontal_resolution;
 227                         height = info->vertical_resolution;
 228                         fb_base = gop->mode->frame_buffer_base;
 229                         fb_size = gop->mode->frame_buffer_size;
 230                         pixel_format = info->pixel_format;
 231                         pixel_info = info->pixel_information;
 232                         pixels_per_scan_line = info->pixels_per_scan_line;
 233
 234                         /*
 235                          * Once we've found a GOP supporting ConOut,
 236                          * don't bother looking any further.
 237                          */
 238                         first_gop = gop;
 239                         if (conout_found)
 240                                 break;
 241                 }
 242         }
 243
 244         /* Did we find any GOPs? */
 245         if (!first_gop)
 246                 goto free_handle;
 247
 248         /* EFI framebuffer */
 249         si->orig_video_isVGA = VIDEO_TYPE_EFI;
 250
 251         si->lfb_width = width;
 252         si->lfb_height = height;
 253         si->lfb_base = fb_base;
 254         si->pages = 1;
 255
 256         if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
 257                 si->lfb_depth = 32;
 258                 si->lfb_linelength = pixels_per_scan_line * 4;
 259                 si->red_size = 8;
 260                 si->red_pos = 0;
 261                 si->green_size = 8;
 262                 si->green_pos = 8;
 263                 si->blue_size = 8;
 264                 si->blue_pos = 16;
 265                 si->rsvd_size = 8;
 266                 si->rsvd_pos = 24;
 267         } else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
 268                 si->lfb_depth = 32;
 269                 si->lfb_linelength = pixels_per_scan_line * 4;
 270                 si->red_size = 8;
 271                 si->red_pos = 16;
 272                 si->green_size = 8;
 273                 si->green_pos = 8;
 274                 si->blue_size = 8;
 275                 si->blue_pos = 0;
 276                 si->rsvd_size = 8;
 277                 si->rsvd_pos = 24;
 278         } else if (pixel_format == PIXEL_BIT_MASK) {
 279                 find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
 280                 find_bits(pixel_info.green_mask, &si->green_pos,
 281                           &si->green_size);
 282                 find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
 283                 find_bits(pixel_info.reserved_mask, &si->rsvd_pos,
 284                           &si->rsvd_size);
 285                 si->lfb_depth = si->red_size + si->green_size +
 286                         si->blue_size + si->rsvd_size;
 287                 si->lfb_linelength = (pixels_per_scan_line * si->lfb_depth) / 8;
 288         } else {
 289                 si->lfb_depth = 4;
 290                 si->lfb_linelength = si->lfb_width / 2;
 291                 si->red_size = 0;
 292                 si->red_pos = 0;
 293                 si->green_size = 0;
 294                 si->green_pos = 0;
 295                 si->blue_size = 0;
 296                 si->blue_pos = 0;
 297                 si->rsvd_size = 0;
 298                 si->rsvd_pos = 0;
 299         }
 300
 301         si->lfb_size = si->lfb_linelength * si->lfb_height;
 302
 303         si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
 304
 305 free_handle:
 306         efi_call_phys1(sys_table->boottime->free_pool, gop_handle);
 307         return status;
 308 }
 309
 310 /*
 311  * See if we have Universal Graphics Adapter (UGA) protocol
 312  */
 313 static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
 314                               unsigned long size)
 315 {
 316         struct efi_uga_draw_protocol *uga, *first_uga;
 317         unsigned long nr_ugas;
 318         efi_status_t status;
 319         u32 width, height;
 320         void **uga_handle = NULL;
 321         int i;
 322
 323         status = efi_call_phys3(sys_table->boottime->allocate_pool,
 324                                 EFI_LOADER_DATA, size, &uga_handle);
 325         if (status != EFI_SUCCESS)
 326                 return status;
 327
 328         status = efi_call_phys5(sys_table->boottime->locate_handle,
 329                                 EFI_LOCATE_BY_PROTOCOL, uga_proto,
 330                                 NULL, &size, uga_handle);
 331         if (status != EFI_SUCCESS)
 332                 goto free_handle;
 333
 334         first_uga = NULL;
 335
 336         nr_ugas = size / sizeof(void *);
 337         for (i = 0; i < nr_ugas; i++) {
 338                 efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;
 339                 void *handle = uga_handle[i];
 340                 u32 w, h, depth, refresh;
 341                 void *pciio;
 342
 343                 status = efi_call_phys3(sys_table->boottime->handle_protocol,
 344                                         handle, uga_proto, &uga);
 345                 if (status != EFI_SUCCESS)
 346                         continue;
 347
 348                 efi_call_phys3(sys_table->boottime->handle_protocol,
 349                                handle, &pciio_proto, &pciio);
 350
 351                 status = efi_call_phys5(uga->get_mode, uga, &w, &h,
 352                                         &depth, &refresh);
 353                 if (status == EFI_SUCCESS && (!first_uga || pciio)) {
 354                         width = w;
 355                         height = h;
 356
 357                         /*
 358                          * Once we've found a UGA supporting PCIIO,
 359                          * don't bother looking any further.
 360                          */
 361                         if (pciio)
 362                                 break;
 363
 364                         first_uga = uga;
 365                 }
 366         }
 367
 368         if (!first_uga)
 369                 goto free_handle;
 370
 371         /* EFI framebuffer */
 372         si->orig_video_isVGA = VIDEO_TYPE_EFI;
 373
 374         si->lfb_depth = 32;
 375         si->lfb_width = width;
 376         si->lfb_height = height;
 377
 378         si->red_size = 8;
 379         si->red_pos = 16;
 380         si->green_size = 8;
 381         si->green_pos = 8;
 382         si->blue_size = 8;
 383         si->blue_pos = 0;
 384         si->rsvd_size = 8;
 385         si->rsvd_pos = 24;
 386
 387
 388 free_handle:
 389         efi_call_phys1(sys_table->boottime->free_pool, uga_handle);
 390         return status;
 391 }
 392
 393 void setup_graphics(struct boot_params *boot_params)
 394 {
 395         efi_guid_t graphics_proto = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
 396         struct screen_info *si;
 397         efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;
 398         efi_status_t status;
 399         unsigned long size;
 400         void **gop_handle = NULL;
 401         void **uga_handle = NULL;
 402
 403         si = &boot_params->screen_info;
 404         memset(si, 0, sizeof(*si));
 405
 406         size = 0;
 407         status = efi_call_phys5(sys_table->boottime->locate_handle,
 408                                 EFI_LOCATE_BY_PROTOCOL, &graphics_proto,
 409                                 NULL, &size, gop_handle);
 410         if (status == EFI_BUFFER_TOO_SMALL)
 411                 status = setup_gop(si, &graphics_proto, size);
 412
 413         if (status != EFI_SUCCESS) {
 414                 size = 0;
 415                 status = efi_call_phys5(sys_table->boottime->locate_handle,
 416                                         EFI_LOCATE_BY_PROTOCOL, &uga_proto,
 417                                         NULL, &size, uga_handle);
 418                 if (status == EFI_BUFFER_TOO_SMALL)
 419                         setup_uga(si, &uga_proto, size);
 420         }
 421 }
 422
 423
 424 /*
 425  * Because the x86 boot code expects to be passed a boot_params we
 426  * need to create one ourselves (usually the bootloader would create
 427  * one for us).
 428  *
 429  * The caller is responsible for filling out ->code32_start in the
 430  * returned boot_params.
 431  */
 432 struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
 433 {
 434         struct boot_params *boot_params;
 435         struct sys_desc_table *sdt;
 436         struct apm_bios_info *bi;
 437         struct setup_header *hdr;
 438         struct efi_info *efi;
 439         efi_loaded_image_t *image;
 440         void *options;
 441         efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID;
 442         int options_size = 0;
 443         efi_status_t status;
 444         char *cmdline_ptr;
 445         u16 *s2;
 446         u8 *s1;
 447         int i;
 448         unsigned long ramdisk_addr;
 449         unsigned long ramdisk_size;
 450
 451         sys_table = _table;
 452
 453         /* Check if we were booted by the EFI firmware */
 454         if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
 455                 return NULL;
 456
 457         status = efi_call_phys3(sys_table->boottime->handle_protocol,
 458                                 handle, &proto, (void *)&image);
 459         if (status != EFI_SUCCESS) {
 460                 efi_printk(sys_table, "Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
 461                 return NULL;
 462         }
 463
 464         status = efi_low_alloc(sys_table, 0x4000, 1,
 465                                (unsigned long *)&boot_params);
 466         if (status != EFI_SUCCESS) {
 467                 efi_printk(sys_table, "Failed to alloc lowmem for boot params\n");
 468                 return NULL;
 469         }
 470
 471         memset(boot_params, 0x0, 0x4000);
 472
 473         hdr = &boot_params->hdr;
 474         efi = &boot_params->efi_info;
 475         bi = &boot_params->apm_bios_info;
 476         sdt = &boot_params->sys_desc_table;
 477
 478         /* Copy the second sector to boot_params */
 479         memcpy(&hdr->jump, image->image_base + 512, 512);
 480
 481         /*
 482          * Fill out some of the header fields ourselves because the
 483          * EFI firmware loader doesn't load the first sector.
 484          */
 485         hdr->root_flags = 1;
 486         hdr->vid_mode = 0xffff;
 487         hdr->boot_flag = 0xAA55;
 488
 489         hdr->type_of_loader = 0x21;
 490
 491         /* Convert unicode cmdline to ascii */
 492         cmdline_ptr = efi_convert_cmdline_to_ascii(sys_table, image,
 493                                                    &options_size);
 494         if (!cmdline_ptr)
 495                 goto fail;
 496         hdr->cmd_line_ptr = (unsigned long)cmdline_ptr;
 497
 498         hdr->ramdisk_image = 0;
 499         hdr->ramdisk_size = 0;
 500
 501         /* Clear APM BIOS info */
 502         memset(bi, 0, sizeof(*bi));
 503
 504         memset(sdt, 0, sizeof(*sdt));
 505
 506         status = handle_cmdline_files(sys_table, image,
 507                                       (char *)(unsigned long)hdr->cmd_line_ptr,
 508                                       "initrd=", hdr->initrd_addr_max,
 509                                       &ramdisk_addr, &ramdisk_size);
 510         if (status != EFI_SUCCESS)
 511                 goto fail2;
 512         hdr->ramdisk_image = ramdisk_addr;
 513         hdr->ramdisk_size = ramdisk_size;
 514
 515         return boot_params;
 516 fail2:
 517         efi_free(sys_table, options_size, hdr->cmd_line_ptr);
 518 fail:
 519         efi_free(sys_table, 0x4000, (unsigned long)boot_params);
 520         return NULL;
 521 }
 522
 523 static void add_e820ext(struct boot_params *params,
 524                         struct setup_data *e820ext, u32 nr_entries)
 525 {
 526         struct setup_data *data;
 527         efi_status_t status;
 528         unsigned long size;
 529
 530         e820ext->type = SETUP_E820_EXT;
 531         e820ext->len = nr_entries * sizeof(struct e820entry);
 532         e820ext->next = 0;
 533
 534         data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
 535
 536         while (data && data->next)
 537                 data = (struct setup_data *)(unsigned long)data->next;
 538
 539         if (data)
 540                 data->next = (unsigned long)e820ext;
 541         else
 542                 params->hdr.setup_data = (unsigned long)e820ext;
 543 }
 544
 545 static efi_status_t setup_e820(struct boot_params *params,
 546                                struct setup_data *e820ext, u32 e820ext_size)
 547 {
 548         struct e820entry *e820_map = &params->e820_map[0];
 549         struct efi_info *efi = &params->efi_info;
 550         struct e820entry *prev = NULL;
 551         u32 nr_entries;
 552         u32 nr_desc;
 553         int i;
 554
 555         nr_entries = 0;
 556         nr_desc = efi->efi_memmap_size / efi->efi_memdesc_size;
 557
 558         for (i = 0; i < nr_desc; i++) {
 559                 efi_memory_desc_t *d;
 560                 unsigned int e820_type = 0;
 561                 unsigned long m = efi->efi_memmap;
 562
 563                 d = (efi_memory_desc_t *)(m + (i * efi->efi_memdesc_size));
 564                 switch (d->type) {
 565                 case EFI_RESERVED_TYPE:
 566                 case EFI_RUNTIME_SERVICES_CODE:
 567                 case EFI_RUNTIME_SERVICES_DATA:
 568                 case EFI_MEMORY_MAPPED_IO:
 569                 case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
 570                 case EFI_PAL_CODE:
 571                         e820_type = E820_RESERVED;
 572                         break;
 573
 574                 case EFI_UNUSABLE_MEMORY:
 575                         e820_type = E820_UNUSABLE;
 576                         break;
 577
 578                 case EFI_ACPI_RECLAIM_MEMORY:
 579                         e820_type = E820_ACPI;
 580                         break;
 581
 582                 case EFI_LOADER_CODE:
 583                 case EFI_LOADER_DATA:
 584                 case EFI_BOOT_SERVICES_CODE:
 585                 case EFI_BOOT_SERVICES_DATA:
 586                 case EFI_CONVENTIONAL_MEMORY:
 587                         e820_type = E820_RAM;
 588                         break;
 589
 590                 case EFI_ACPI_MEMORY_NVS:
 591                         e820_type = E820_NVS;
 592                         break;
 593
 594                 default:
 595                         continue;
 596                 }
 597
 598                 /* Merge adjacent mappings */
 599                 if (prev && prev->type == e820_type &&
 600                     (prev->addr + prev->size) == d->phys_addr) {
 601                         prev->size += d->num_pages << 12;
 602                         continue;
 603                 }
 604
 605                 if (nr_entries == ARRAY_SIZE(params->e820_map)) {
 606                         u32 need = (nr_desc - i) * sizeof(struct e820entry) +
 607                                    sizeof(struct setup_data);
 608
 609                         if (!e820ext || e820ext_size < need)
 610                                 return EFI_BUFFER_TOO_SMALL;
 611
 612                         /* boot_params map full, switch to e820 extended */
 613                         e820_map = (struct e820entry *)e820ext->data;
 614                 }
 615
 616                 e820_map->addr = d->phys_addr;
 617                 e820_map->size = d->num_pages << PAGE_SHIFT;
 618                 e820_map->type = e820_type;
 619                 prev = e820_map++;
 620                 nr_entries++;
 621         }
 622
 623         if (nr_entries > ARRAY_SIZE(params->e820_map)) {
 624                 u32 nr_e820ext = nr_entries - ARRAY_SIZE(params->e820_map);
 625
 626                 add_e820ext(params, e820ext, nr_e820ext);
 627                 nr_entries -= nr_e820ext;
 628         }
 629
 630         params->e820_entries = (u8)nr_entries;
 631
 632         return EFI_SUCCESS;
 633 }
 634
 635 static efi_status_t alloc_e820ext(u32 nr_desc, struct setup_data **e820ext,
 636                                   u32 *e820ext_size)
 637 {
 638         efi_status_t status;
 639         unsigned long size;
 640
 641         size = sizeof(struct setup_data) +
 642                 sizeof(struct e820entry) * nr_desc;
 643
 644         if (*e820ext) {
 645                 efi_call_phys1(sys_table->boottime->free_pool, *e820ext);
 646                 *e820ext = NULL;
 647                 *e820ext_size = 0;
 648         }
 649
 650         status = efi_call_phys3(sys_table->boottime->allocate_pool,
 651                                 EFI_LOADER_DATA, size, e820ext);
 652
 653         if (status == EFI_SUCCESS)
 654                 *e820ext_size = size;
 655
 656         return status;
 657 }
 658
 659 static efi_status_t exit_boot(struct boot_params *boot_params,
 660                               void *handle)
 661 {
 662         struct efi_info *efi = &boot_params->efi_info;
 663         unsigned long map_sz, key, desc_size;
 664         efi_memory_desc_t *mem_map;
 665         struct setup_data *e820ext;
 666         __u32 e820ext_size;
 667         __u32 nr_desc, prev_nr_desc;
 668         efi_status_t status;
 669         __u32 desc_version;
 670         bool called_exit = false;
 671         u8 nr_entries;
 672         int i;
 673
 674         nr_desc = 0;
 675         e820ext = NULL;
 676         e820ext_size = 0;
 677
 678 get_map:
 679         status = efi_get_memory_map(sys_table, &mem_map, &map_sz, &desc_size,
 680                                     &desc_version, &key);
 681
 682         if (status != EFI_SUCCESS)
 683                 return status;
 684
 685         prev_nr_desc = nr_desc;
 686         nr_desc = map_sz / desc_size;
 687         if (nr_desc > prev_nr_desc &&
 688             nr_desc > ARRAY_SIZE(boot_params->e820_map)) {
 689                 u32 nr_e820ext = nr_desc - ARRAY_SIZE(boot_params->e820_map);
 690
 691                 status = alloc_e820ext(nr_e820ext, &e820ext, &e820ext_size);
 692                 if (status != EFI_SUCCESS)
 693                         goto free_mem_map;
 694
 695                 efi_call_phys1(sys_table->boottime->free_pool, mem_map);
 696                 goto get_map; /* Allocated memory, get map again */
 697         }
 698
 699         memcpy(&efi->efi_loader_signature, EFI_LOADER_SIGNATURE, sizeof(__u32));
 700         efi->efi_systab = (unsigned long)sys_table;
 701         efi->efi_memdesc_size = desc_size;
 702         efi->efi_memdesc_version = desc_version;
 703         efi->efi_memmap = (unsigned long)mem_map;
 704         efi->efi_memmap_size = map_sz;
 705
 706 #ifdef CONFIG_X86_64
 707         efi->efi_systab_hi = (unsigned long)sys_table >> 32;
 708         efi->efi_memmap_hi = (unsigned long)mem_map >> 32;
 709 #endif
 710
 711         /* Might as well exit boot services now */
 712         status = efi_call_phys2(sys_table->boottime->exit_boot_services,
 713                                 handle, key);
 714         if (status != EFI_SUCCESS) {
 715                 /*
 716                  * ExitBootServices() will fail if any of the event
 717                  * handlers change the memory map. In which case, we
 718                  * must be prepared to retry, but only once so that
 719                  * we're guaranteed to exit on repeated failures instead
 720                  * of spinning forever.
 721                  */
 722                 if (called_exit)
 723                         goto free_mem_map;
 724
 725                 called_exit = true;
 726                 efi_call_phys1(sys_table->boottime->free_pool, mem_map);
 727                 goto get_map;
 728         }
 729
 730         /* Historic? */
 731         boot_params->alt_mem_k = 32 * 1024;
 732
 733         status = setup_e820(boot_params, e820ext, e820ext_size);
 734         if (status != EFI_SUCCESS)
 735                 return status;
 736
 737         return EFI_SUCCESS;
 738
 739 free_mem_map:
 740         efi_call_phys1(sys_table->boottime->free_pool, mem_map);
 741         return status;
 742 }
 743
 744
 745 /*
 746  * On success we return a pointer to a boot_params structure, and NULL
 747  * on failure.
 748  */
 749 struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
 750                              struct boot_params *boot_params)
 751 {
 752         struct desc_ptr *gdt;
 753         efi_loaded_image_t *image;
 754         struct setup_header *hdr = &boot_params->hdr;
 755         efi_status_t status;
 756         struct desc_struct *desc;
 757
 758         sys_table = _table;
 759
 760         /* Check if we were booted by the EFI firmware */
 761         if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
 762                 goto fail;
 763
 764         setup_graphics(boot_params);
 765
 766         setup_efi_pci(boot_params);
 767
 768         status = efi_call_phys3(sys_table->boottime->allocate_pool,
 769                                 EFI_LOADER_DATA, sizeof(*gdt),
 770                                 (void **)&gdt);
 771         if (status != EFI_SUCCESS) {
 772                 efi_printk(sys_table, "Failed to alloc mem for gdt structure\n");
 773                 goto fail;
 774         }
 775
 776         gdt->size = 0x800;
 777         status = efi_low_alloc(sys_table, gdt->size, 8,
 778                            (unsigned long *)&gdt->address);
 779         if (status != EFI_SUCCESS) {
 780                 efi_printk(sys_table, "Failed to alloc mem for gdt\n");
 781                 goto fail;
 782         }
 783
 784         /*
 785          * If the kernel isn't already loaded at the preferred load
 786          * address, relocate it.
 787          */
 788         if (hdr->pref_address != hdr->code32_start) {
 789                 unsigned long bzimage_addr = hdr->code32_start;
 790                 status = efi_relocate_kernel(sys_table, &bzimage_addr,
 791                                              hdr->init_size, hdr->init_size,
 792                                              hdr->pref_address,
 793                                              hdr->kernel_alignment);
 794                 if (status != EFI_SUCCESS)
 795                         goto fail;
 796
 797                 hdr->pref_address = hdr->code32_start;
 798                 hdr->code32_start = bzimage_addr;
 799         }
 800
 801         status = exit_boot(boot_params, handle);
 802         if (status != EFI_SUCCESS)
 803                 goto fail;
 804
 805         memset((char *)gdt->address, 0x0, gdt->size);
 806         desc = (struct desc_struct *)gdt->address;
 807
 808         /* The first GDT is a dummy and the second is unused. */
 809         desc += 2;
 810
 811         desc->limit0 = 0xffff;
 812         desc->base0 = 0x0000;
 813         desc->base1 = 0x0000;
 814         desc->type = SEG_TYPE_CODE | SEG_TYPE_EXEC_READ;
 815         desc->s = DESC_TYPE_CODE_DATA;
 816         desc->dpl = 0;
 817         desc->p = 1;
 818         desc->limit = 0xf;
 819         desc->avl = 0;
 820         desc->l = 0;
 821         desc->d = SEG_OP_SIZE_32BIT;
 822         desc->g = SEG_GRANULARITY_4KB;
 823         desc->base2 = 0x00;
 824
 825         desc++;
 826         desc->limit0 = 0xffff;
 827         desc->base0 = 0x0000;
 828         desc->base1 = 0x0000;
 829         desc->type = SEG_TYPE_DATA | SEG_TYPE_READ_WRITE;
 830         desc->s = DESC_TYPE_CODE_DATA;
 831         desc->dpl = 0;
 832         desc->p = 1;
 833         desc->limit = 0xf;
 834         desc->avl = 0;
 835         desc->l = 0;
 836         desc->d = SEG_OP_SIZE_32BIT;
 837         desc->g = SEG_GRANULARITY_4KB;
 838         desc->base2 = 0x00;
 839
 840 #ifdef CONFIG_X86_64
 841         /* Task segment value */
 842         desc++;
 843         desc->limit0 = 0x0000;
 844         desc->base0 = 0x0000;
 845         desc->base1 = 0x0000;
 846         desc->type = SEG_TYPE_TSS;
 847         desc->s = 0;
 848         desc->dpl = 0;
 849         desc->p = 1;
 850         desc->limit = 0x0;
 851         desc->avl = 0;
 852         desc->l = 0;
 853         desc->d = 0;
 854         desc->g = SEG_GRANULARITY_4KB;
 855         desc->base2 = 0x00;
 856 #endif /* CONFIG_X86_64 */
 857
 858         asm volatile("cli");
 859         asm volatile ("lgdt %0" : : "m" (*gdt));
 860
 861         return boot_params;
 862 fail:
 863         return NULL;
 864 }