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