1 /* 2 * Common EFI (Extensible Firmware Interface) support functions 3 * Based on Extensible Firmware Interface Specification version 1.0 4 * 5 * Copyright (C) 1999 VA Linux Systems 6 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com> 7 * Copyright (C) 1999-2002 Hewlett-Packard Co. 8 * David Mosberger-Tang <davidm@hpl.hp.com> 9 * Stephane Eranian <eranian@hpl.hp.com> 10 * Copyright (C) 2005-2008 Intel Co. 11 * Fenghua Yu <fenghua.yu@intel.com> 12 * Bibo Mao <bibo.mao@intel.com> 13 * Chandramouli Narayanan <mouli@linux.intel.com> 14 * Huang Ying <ying.huang@intel.com> 15 * Copyright (C) 2013 SuSE Labs 16 * Borislav Petkov <bp@suse.de> - runtime services VA mapping 17 * 18 * Copied from efi_32.c to eliminate the duplicated code between EFI 19 * 32/64 support code. --ying 2007-10-26 20 * 21 * All EFI Runtime Services are not implemented yet as EFI only 22 * supports physical mode addressing on SoftSDV. This is to be fixed 23 * in a future version. --drummond 1999-07-20 24 * 25 * Implemented EFI runtime services and virtual mode calls. --davidm 26 * 27 * Goutham Rao: <goutham.rao@intel.com> 28 * Skip non-WB memory and ignore empty memory ranges. 29 */ 30 31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 32 33 #include <linux/kernel.h> 34 #include <linux/init.h> 35 #include <linux/efi.h> 36 #include <linux/efi-bgrt.h> 37 #include <linux/export.h> 38 #include <linux/bootmem.h> 39 #include <linux/slab.h> 40 #include <linux/memblock.h> 41 #include <linux/spinlock.h> 42 #include <linux/uaccess.h> 43 #include <linux/time.h> 44 #include <linux/io.h> 45 #include <linux/reboot.h> 46 #include <linux/bcd.h> 47 48 #include <asm/setup.h> 49 #include <asm/efi.h> 50 #include <asm/time.h> 51 #include <asm/cacheflush.h> 52 #include <asm/tlbflush.h> 53 #include <asm/x86_init.h> 54 #include <asm/rtc.h> 55 #include <asm/uv/uv.h> 56 57 #define EFI_DEBUG 58 59 #define EFI_MIN_RESERVE 5120 60 61 #define EFI_DUMMY_GUID \ 62 EFI_GUID(0x4424ac57, 0xbe4b, 0x47dd, 0x9e, 0x97, 0xed, 0x50, 0xf0, 0x9f, 0x92, 0xa9) 63 64 static efi_char16_t efi_dummy_name[6] = { 'D', 'U', 'M', 'M', 'Y', 0 }; 65 66 struct efi_memory_map memmap; 67 68 static struct efi efi_phys __initdata; 69 static efi_system_table_t efi_systab __initdata; 70 71 unsigned long x86_efi_facility; 72 73 static __initdata efi_config_table_type_t arch_tables[] = { 74 #ifdef CONFIG_X86_UV 75 {UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab}, 76 #endif 77 {NULL_GUID, NULL, NULL}, 78 }; 79 80 u64 efi_setup; /* efi setup_data physical address */ 81 82 /* 83 * Returns 1 if 'facility' is enabled, 0 otherwise. 84 */ 85 int efi_enabled(int facility) 86 { 87 return test_bit(facility, &x86_efi_facility) != 0; 88 } 89 EXPORT_SYMBOL(efi_enabled); 90 91 static bool __initdata disable_runtime = false; 92 static int __init setup_noefi(char *arg) 93 { 94 disable_runtime = true; 95 return 0; 96 } 97 early_param("noefi", setup_noefi); 98 99 int add_efi_memmap; 100 EXPORT_SYMBOL(add_efi_memmap); 101 102 static int __init setup_add_efi_memmap(char *arg) 103 { 104 add_efi_memmap = 1; 105 return 0; 106 } 107 early_param("add_efi_memmap", setup_add_efi_memmap); 108 109 static bool efi_no_storage_paranoia; 110 111 static int __init setup_storage_paranoia(char *arg) 112 { 113 efi_no_storage_paranoia = true; 114 return 0; 115 } 116 early_param("efi_no_storage_paranoia", setup_storage_paranoia); 117 118 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc) 119 { 120 unsigned long flags; 121 efi_status_t status; 122 123 spin_lock_irqsave(&rtc_lock, flags); 124 status = efi_call_virt2(get_time, tm, tc); 125 spin_unlock_irqrestore(&rtc_lock, flags); 126 return status; 127 } 128 129 static efi_status_t virt_efi_set_time(efi_time_t *tm) 130 { 131 unsigned long flags; 132 efi_status_t status; 133 134 spin_lock_irqsave(&rtc_lock, flags); 135 status = efi_call_virt1(set_time, tm); 136 spin_unlock_irqrestore(&rtc_lock, flags); 137 return status; 138 } 139 140 static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled, 141 efi_bool_t *pending, 142 efi_time_t *tm) 143 { 144 unsigned long flags; 145 efi_status_t status; 146 147 spin_lock_irqsave(&rtc_lock, flags); 148 status = efi_call_virt3(get_wakeup_time, 149 enabled, pending, tm); 150 spin_unlock_irqrestore(&rtc_lock, flags); 151 return status; 152 } 153 154 static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm) 155 { 156 unsigned long flags; 157 efi_status_t status; 158 159 spin_lock_irqsave(&rtc_lock, flags); 160 status = efi_call_virt2(set_wakeup_time, 161 enabled, tm); 162 spin_unlock_irqrestore(&rtc_lock, flags); 163 return status; 164 } 165 166 static efi_status_t virt_efi_get_variable(efi_char16_t *name, 167 efi_guid_t *vendor, 168 u32 *attr, 169 unsigned long *data_size, 170 void *data) 171 { 172 return efi_call_virt5(get_variable, 173 name, vendor, attr, 174 data_size, data); 175 } 176 177 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size, 178 efi_char16_t *name, 179 efi_guid_t *vendor) 180 { 181 return efi_call_virt3(get_next_variable, 182 name_size, name, vendor); 183 } 184 185 static efi_status_t virt_efi_set_variable(efi_char16_t *name, 186 efi_guid_t *vendor, 187 u32 attr, 188 unsigned long data_size, 189 void *data) 190 { 191 return efi_call_virt5(set_variable, 192 name, vendor, attr, 193 data_size, data); 194 } 195 196 static efi_status_t virt_efi_query_variable_info(u32 attr, 197 u64 *storage_space, 198 u64 *remaining_space, 199 u64 *max_variable_size) 200 { 201 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 202 return EFI_UNSUPPORTED; 203 204 return efi_call_virt4(query_variable_info, attr, storage_space, 205 remaining_space, max_variable_size); 206 } 207 208 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count) 209 { 210 return efi_call_virt1(get_next_high_mono_count, count); 211 } 212 213 static void virt_efi_reset_system(int reset_type, 214 efi_status_t status, 215 unsigned long data_size, 216 efi_char16_t *data) 217 { 218 efi_call_virt4(reset_system, reset_type, status, 219 data_size, data); 220 } 221 222 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules, 223 unsigned long count, 224 unsigned long sg_list) 225 { 226 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 227 return EFI_UNSUPPORTED; 228 229 return efi_call_virt3(update_capsule, capsules, count, sg_list); 230 } 231 232 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules, 233 unsigned long count, 234 u64 *max_size, 235 int *reset_type) 236 { 237 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 238 return EFI_UNSUPPORTED; 239 240 return efi_call_virt4(query_capsule_caps, capsules, count, max_size, 241 reset_type); 242 } 243 244 static efi_status_t __init phys_efi_set_virtual_address_map( 245 unsigned long memory_map_size, 246 unsigned long descriptor_size, 247 u32 descriptor_version, 248 efi_memory_desc_t *virtual_map) 249 { 250 efi_status_t status; 251 252 efi_call_phys_prelog(); 253 status = efi_call_phys4(efi_phys.set_virtual_address_map, 254 memory_map_size, descriptor_size, 255 descriptor_version, virtual_map); 256 efi_call_phys_epilog(); 257 return status; 258 } 259 260 static efi_status_t __init phys_efi_get_time(efi_time_t *tm, 261 efi_time_cap_t *tc) 262 { 263 unsigned long flags; 264 efi_status_t status; 265 266 spin_lock_irqsave(&rtc_lock, flags); 267 efi_call_phys_prelog(); 268 status = efi_call_phys2(efi_phys.get_time, virt_to_phys(tm), 269 virt_to_phys(tc)); 270 efi_call_phys_epilog(); 271 spin_unlock_irqrestore(&rtc_lock, flags); 272 return status; 273 } 274 275 int efi_set_rtc_mmss(const struct timespec *now) 276 { 277 unsigned long nowtime = now->tv_sec; 278 efi_status_t status; 279 efi_time_t eft; 280 efi_time_cap_t cap; 281 struct rtc_time tm; 282 283 status = efi.get_time(&eft, &cap); 284 if (status != EFI_SUCCESS) { 285 pr_err("Oops: efitime: can't read time!\n"); 286 return -1; 287 } 288 289 rtc_time_to_tm(nowtime, &tm); 290 if (!rtc_valid_tm(&tm)) { 291 eft.year = tm.tm_year + 1900; 292 eft.month = tm.tm_mon + 1; 293 eft.day = tm.tm_mday; 294 eft.minute = tm.tm_min; 295 eft.second = tm.tm_sec; 296 eft.nanosecond = 0; 297 } else { 298 printk(KERN_ERR 299 "%s: Invalid EFI RTC value: write of %lx to EFI RTC failed\n", 300 __FUNCTION__, nowtime); 301 return -1; 302 } 303 304 status = efi.set_time(&eft); 305 if (status != EFI_SUCCESS) { 306 pr_err("Oops: efitime: can't write time!\n"); 307 return -1; 308 } 309 return 0; 310 } 311 312 void efi_get_time(struct timespec *now) 313 { 314 efi_status_t status; 315 efi_time_t eft; 316 efi_time_cap_t cap; 317 318 status = efi.get_time(&eft, &cap); 319 if (status != EFI_SUCCESS) 320 pr_err("Oops: efitime: can't read time!\n"); 321 322 now->tv_sec = mktime(eft.year, eft.month, eft.day, eft.hour, 323 eft.minute, eft.second); 324 now->tv_nsec = 0; 325 } 326 327 /* 328 * Tell the kernel about the EFI memory map. This might include 329 * more than the max 128 entries that can fit in the e820 legacy 330 * (zeropage) memory map. 331 */ 332 333 static void __init do_add_efi_memmap(void) 334 { 335 void *p; 336 337 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 338 efi_memory_desc_t *md = p; 339 unsigned long long start = md->phys_addr; 340 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT; 341 int e820_type; 342 343 switch (md->type) { 344 case EFI_LOADER_CODE: 345 case EFI_LOADER_DATA: 346 case EFI_BOOT_SERVICES_CODE: 347 case EFI_BOOT_SERVICES_DATA: 348 case EFI_CONVENTIONAL_MEMORY: 349 if (md->attribute & EFI_MEMORY_WB) 350 e820_type = E820_RAM; 351 else 352 e820_type = E820_RESERVED; 353 break; 354 case EFI_ACPI_RECLAIM_MEMORY: 355 e820_type = E820_ACPI; 356 break; 357 case EFI_ACPI_MEMORY_NVS: 358 e820_type = E820_NVS; 359 break; 360 case EFI_UNUSABLE_MEMORY: 361 e820_type = E820_UNUSABLE; 362 break; 363 default: 364 /* 365 * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE 366 * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO 367 * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE 368 */ 369 e820_type = E820_RESERVED; 370 break; 371 } 372 e820_add_region(start, size, e820_type); 373 } 374 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 375 } 376 377 int __init efi_memblock_x86_reserve_range(void) 378 { 379 struct efi_info *e = &boot_params.efi_info; 380 unsigned long pmap; 381 382 #ifdef CONFIG_X86_32 383 /* Can't handle data above 4GB at this time */ 384 if (e->efi_memmap_hi) { 385 pr_err("Memory map is above 4GB, disabling EFI.\n"); 386 return -EINVAL; 387 } 388 pmap = e->efi_memmap; 389 #else 390 pmap = (e->efi_memmap | ((__u64)e->efi_memmap_hi << 32)); 391 #endif 392 memmap.phys_map = (void *)pmap; 393 memmap.nr_map = e->efi_memmap_size / 394 e->efi_memdesc_size; 395 memmap.desc_size = e->efi_memdesc_size; 396 memmap.desc_version = e->efi_memdesc_version; 397 398 memblock_reserve(pmap, memmap.nr_map * memmap.desc_size); 399 400 efi.memmap = &memmap; 401 402 return 0; 403 } 404 405 static void __init print_efi_memmap(void) 406 { 407 #ifdef EFI_DEBUG 408 efi_memory_desc_t *md; 409 void *p; 410 int i; 411 412 for (p = memmap.map, i = 0; 413 p < memmap.map_end; 414 p += memmap.desc_size, i++) { 415 md = p; 416 pr_info("mem%02u: type=%u, attr=0x%llx, " 417 "range=[0x%016llx-0x%016llx) (%lluMB)\n", 418 i, md->type, md->attribute, md->phys_addr, 419 md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT), 420 (md->num_pages >> (20 - EFI_PAGE_SHIFT))); 421 } 422 #endif /* EFI_DEBUG */ 423 } 424 425 void __init efi_reserve_boot_services(void) 426 { 427 void *p; 428 429 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 430 efi_memory_desc_t *md = p; 431 u64 start = md->phys_addr; 432 u64 size = md->num_pages << EFI_PAGE_SHIFT; 433 434 if (md->type != EFI_BOOT_SERVICES_CODE && 435 md->type != EFI_BOOT_SERVICES_DATA) 436 continue; 437 /* Only reserve where possible: 438 * - Not within any already allocated areas 439 * - Not over any memory area (really needed, if above?) 440 * - Not within any part of the kernel 441 * - Not the bios reserved area 442 */ 443 if ((start + size > __pa_symbol(_text) 444 && start <= __pa_symbol(_end)) || 445 !e820_all_mapped(start, start+size, E820_RAM) || 446 memblock_is_region_reserved(start, size)) { 447 /* Could not reserve, skip it */ 448 md->num_pages = 0; 449 memblock_dbg("Could not reserve boot range " 450 "[0x%010llx-0x%010llx]\n", 451 start, start+size-1); 452 } else 453 memblock_reserve(start, size); 454 } 455 } 456 457 void __init efi_unmap_memmap(void) 458 { 459 clear_bit(EFI_MEMMAP, &x86_efi_facility); 460 if (memmap.map) { 461 early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size); 462 memmap.map = NULL; 463 } 464 } 465 466 void __init efi_free_boot_services(void) 467 { 468 void *p; 469 470 if (!efi_is_native()) 471 return; 472 473 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 474 efi_memory_desc_t *md = p; 475 unsigned long long start = md->phys_addr; 476 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT; 477 478 if (md->type != EFI_BOOT_SERVICES_CODE && 479 md->type != EFI_BOOT_SERVICES_DATA) 480 continue; 481 482 /* Could not reserve boot area */ 483 if (!size) 484 continue; 485 486 free_bootmem_late(start, size); 487 } 488 489 efi_unmap_memmap(); 490 } 491 492 static int __init efi_systab_init(void *phys) 493 { 494 if (efi_enabled(EFI_64BIT)) { 495 efi_system_table_64_t *systab64; 496 struct efi_setup_data *data = NULL; 497 u64 tmp = 0; 498 499 if (efi_setup) { 500 data = early_memremap(efi_setup, sizeof(*data)); 501 if (!data) 502 return -ENOMEM; 503 } 504 systab64 = early_ioremap((unsigned long)phys, 505 sizeof(*systab64)); 506 if (systab64 == NULL) { 507 pr_err("Couldn't map the system table!\n"); 508 if (data) 509 early_iounmap(data, sizeof(*data)); 510 return -ENOMEM; 511 } 512 513 efi_systab.hdr = systab64->hdr; 514 efi_systab.fw_vendor = data ? (unsigned long)data->fw_vendor : 515 systab64->fw_vendor; 516 tmp |= data ? data->fw_vendor : systab64->fw_vendor; 517 efi_systab.fw_revision = systab64->fw_revision; 518 efi_systab.con_in_handle = systab64->con_in_handle; 519 tmp |= systab64->con_in_handle; 520 efi_systab.con_in = systab64->con_in; 521 tmp |= systab64->con_in; 522 efi_systab.con_out_handle = systab64->con_out_handle; 523 tmp |= systab64->con_out_handle; 524 efi_systab.con_out = systab64->con_out; 525 tmp |= systab64->con_out; 526 efi_systab.stderr_handle = systab64->stderr_handle; 527 tmp |= systab64->stderr_handle; 528 efi_systab.stderr = systab64->stderr; 529 tmp |= systab64->stderr; 530 efi_systab.runtime = data ? 531 (void *)(unsigned long)data->runtime : 532 (void *)(unsigned long)systab64->runtime; 533 tmp |= data ? data->runtime : systab64->runtime; 534 efi_systab.boottime = (void *)(unsigned long)systab64->boottime; 535 tmp |= systab64->boottime; 536 efi_systab.nr_tables = systab64->nr_tables; 537 efi_systab.tables = data ? (unsigned long)data->tables : 538 systab64->tables; 539 tmp |= data ? data->tables : systab64->tables; 540 541 early_iounmap(systab64, sizeof(*systab64)); 542 if (data) 543 early_iounmap(data, sizeof(*data)); 544 #ifdef CONFIG_X86_32 545 if (tmp >> 32) { 546 pr_err("EFI data located above 4GB, disabling EFI.\n"); 547 return -EINVAL; 548 } 549 #endif 550 } else { 551 efi_system_table_32_t *systab32; 552 553 systab32 = early_ioremap((unsigned long)phys, 554 sizeof(*systab32)); 555 if (systab32 == NULL) { 556 pr_err("Couldn't map the system table!\n"); 557 return -ENOMEM; 558 } 559 560 efi_systab.hdr = systab32->hdr; 561 efi_systab.fw_vendor = systab32->fw_vendor; 562 efi_systab.fw_revision = systab32->fw_revision; 563 efi_systab.con_in_handle = systab32->con_in_handle; 564 efi_systab.con_in = systab32->con_in; 565 efi_systab.con_out_handle = systab32->con_out_handle; 566 efi_systab.con_out = systab32->con_out; 567 efi_systab.stderr_handle = systab32->stderr_handle; 568 efi_systab.stderr = systab32->stderr; 569 efi_systab.runtime = (void *)(unsigned long)systab32->runtime; 570 efi_systab.boottime = (void *)(unsigned long)systab32->boottime; 571 efi_systab.nr_tables = systab32->nr_tables; 572 efi_systab.tables = systab32->tables; 573 574 early_iounmap(systab32, sizeof(*systab32)); 575 } 576 577 efi.systab = &efi_systab; 578 579 /* 580 * Verify the EFI Table 581 */ 582 if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) { 583 pr_err("System table signature incorrect!\n"); 584 return -EINVAL; 585 } 586 if ((efi.systab->hdr.revision >> 16) == 0) 587 pr_err("Warning: System table version " 588 "%d.%02d, expected 1.00 or greater!\n", 589 efi.systab->hdr.revision >> 16, 590 efi.systab->hdr.revision & 0xffff); 591 592 return 0; 593 } 594 595 static int __init efi_runtime_init(void) 596 { 597 efi_runtime_services_t *runtime; 598 599 /* 600 * Check out the runtime services table. We need to map 601 * the runtime services table so that we can grab the physical 602 * address of several of the EFI runtime functions, needed to 603 * set the firmware into virtual mode. 604 */ 605 runtime = early_ioremap((unsigned long)efi.systab->runtime, 606 sizeof(efi_runtime_services_t)); 607 if (!runtime) { 608 pr_err("Could not map the runtime service table!\n"); 609 return -ENOMEM; 610 } 611 /* 612 * We will only need *early* access to the following 613 * two EFI runtime services before set_virtual_address_map 614 * is invoked. 615 */ 616 efi_phys.get_time = (efi_get_time_t *)runtime->get_time; 617 efi_phys.set_virtual_address_map = 618 (efi_set_virtual_address_map_t *) 619 runtime->set_virtual_address_map; 620 /* 621 * Make efi_get_time can be called before entering 622 * virtual mode. 623 */ 624 efi.get_time = phys_efi_get_time; 625 early_iounmap(runtime, sizeof(efi_runtime_services_t)); 626 627 return 0; 628 } 629 630 static int __init efi_memmap_init(void) 631 { 632 /* Map the EFI memory map */ 633 memmap.map = early_ioremap((unsigned long)memmap.phys_map, 634 memmap.nr_map * memmap.desc_size); 635 if (memmap.map == NULL) { 636 pr_err("Could not map the memory map!\n"); 637 return -ENOMEM; 638 } 639 memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size); 640 641 if (add_efi_memmap) 642 do_add_efi_memmap(); 643 644 return 0; 645 } 646 647 /* 648 * A number of config table entries get remapped to virtual addresses 649 * after entering EFI virtual mode. However, the kexec kernel requires 650 * their physical addresses therefore we pass them via setup_data and 651 * correct those entries to their respective physical addresses here. 652 * 653 * Currently only handles smbios which is necessary for some firmware 654 * implementation. 655 */ 656 static int __init efi_reuse_config(u64 tables, int nr_tables) 657 { 658 int i, sz, ret = 0; 659 void *p, *tablep; 660 struct efi_setup_data *data; 661 662 if (!efi_setup) 663 return 0; 664 665 if (!efi_enabled(EFI_64BIT)) 666 return 0; 667 668 data = early_memremap(efi_setup, sizeof(*data)); 669 if (!data) { 670 ret = -ENOMEM; 671 goto out; 672 } 673 674 if (!data->smbios) 675 goto out_memremap; 676 677 sz = sizeof(efi_config_table_64_t); 678 679 p = tablep = early_memremap(tables, nr_tables * sz); 680 if (!p) { 681 pr_err("Could not map Configuration table!\n"); 682 ret = -ENOMEM; 683 goto out_memremap; 684 } 685 686 for (i = 0; i < efi.systab->nr_tables; i++) { 687 efi_guid_t guid; 688 689 guid = ((efi_config_table_64_t *)p)->guid; 690 691 if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID)) 692 ((efi_config_table_64_t *)p)->table = data->smbios; 693 p += sz; 694 } 695 early_iounmap(tablep, nr_tables * sz); 696 697 out_memremap: 698 early_iounmap(data, sizeof(*data)); 699 out: 700 return ret; 701 } 702 703 void __init efi_init(void) 704 { 705 efi_char16_t *c16; 706 char vendor[100] = "unknown"; 707 int i = 0; 708 void *tmp; 709 710 #ifdef CONFIG_X86_32 711 if (boot_params.efi_info.efi_systab_hi || 712 boot_params.efi_info.efi_memmap_hi) { 713 pr_info("Table located above 4GB, disabling EFI.\n"); 714 return; 715 } 716 efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab; 717 #else 718 efi_phys.systab = (efi_system_table_t *) 719 (boot_params.efi_info.efi_systab | 720 ((__u64)boot_params.efi_info.efi_systab_hi<<32)); 721 #endif 722 723 if (efi_systab_init(efi_phys.systab)) 724 return; 725 726 set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility); 727 728 efi.config_table = (unsigned long)efi.systab->tables; 729 efi.fw_vendor = (unsigned long)efi.systab->fw_vendor; 730 efi.runtime = (unsigned long)efi.systab->runtime; 731 732 /* 733 * Show what we know for posterity 734 */ 735 c16 = tmp = early_ioremap(efi.systab->fw_vendor, 2); 736 if (c16) { 737 for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i) 738 vendor[i] = *c16++; 739 vendor[i] = '\0'; 740 } else 741 pr_err("Could not map the firmware vendor!\n"); 742 early_iounmap(tmp, 2); 743 744 pr_info("EFI v%u.%.02u by %s\n", 745 efi.systab->hdr.revision >> 16, 746 efi.systab->hdr.revision & 0xffff, vendor); 747 748 if (efi_reuse_config(efi.systab->tables, efi.systab->nr_tables)) 749 return; 750 751 if (efi_config_init(arch_tables)) 752 return; 753 754 set_bit(EFI_CONFIG_TABLES, &x86_efi_facility); 755 756 /* 757 * Note: We currently don't support runtime services on an EFI 758 * that doesn't match the kernel 32/64-bit mode. 759 */ 760 761 if (!efi_is_native()) 762 pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n"); 763 else { 764 if (disable_runtime || efi_runtime_init()) 765 return; 766 set_bit(EFI_RUNTIME_SERVICES, &x86_efi_facility); 767 } 768 if (efi_memmap_init()) 769 return; 770 771 set_bit(EFI_MEMMAP, &x86_efi_facility); 772 773 print_efi_memmap(); 774 } 775 776 void __init efi_late_init(void) 777 { 778 efi_bgrt_init(); 779 } 780 781 void __init efi_set_executable(efi_memory_desc_t *md, bool executable) 782 { 783 u64 addr, npages; 784 785 addr = md->virt_addr; 786 npages = md->num_pages; 787 788 memrange_efi_to_native(&addr, &npages); 789 790 if (executable) 791 set_memory_x(addr, npages); 792 else 793 set_memory_nx(addr, npages); 794 } 795 796 void __init runtime_code_page_mkexec(void) 797 { 798 efi_memory_desc_t *md; 799 void *p; 800 801 /* Make EFI runtime service code area executable */ 802 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 803 md = p; 804 805 if (md->type != EFI_RUNTIME_SERVICES_CODE) 806 continue; 807 808 efi_set_executable(md, true); 809 } 810 } 811 812 void efi_memory_uc(u64 addr, unsigned long size) 813 { 814 unsigned long page_shift = 1UL << EFI_PAGE_SHIFT; 815 u64 npages; 816 817 npages = round_up(size, page_shift) / page_shift; 818 memrange_efi_to_native(&addr, &npages); 819 set_memory_uc(addr, npages); 820 } 821 822 void __init old_map_region(efi_memory_desc_t *md) 823 { 824 u64 start_pfn, end_pfn, end; 825 unsigned long size; 826 void *va; 827 828 start_pfn = PFN_DOWN(md->phys_addr); 829 size = md->num_pages << PAGE_SHIFT; 830 end = md->phys_addr + size; 831 end_pfn = PFN_UP(end); 832 833 if (pfn_range_is_mapped(start_pfn, end_pfn)) { 834 va = __va(md->phys_addr); 835 836 if (!(md->attribute & EFI_MEMORY_WB)) 837 efi_memory_uc((u64)(unsigned long)va, size); 838 } else 839 va = efi_ioremap(md->phys_addr, size, 840 md->type, md->attribute); 841 842 md->virt_addr = (u64) (unsigned long) va; 843 if (!va) 844 pr_err("ioremap of 0x%llX failed!\n", 845 (unsigned long long)md->phys_addr); 846 } 847 848 /* Merge contiguous regions of the same type and attribute */ 849 static void __init efi_merge_regions(void) 850 { 851 void *p; 852 efi_memory_desc_t *md, *prev_md = NULL; 853 854 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 855 u64 prev_size; 856 md = p; 857 858 if (!prev_md) { 859 prev_md = md; 860 continue; 861 } 862 863 if (prev_md->type != md->type || 864 prev_md->attribute != md->attribute) { 865 prev_md = md; 866 continue; 867 } 868 869 prev_size = prev_md->num_pages << EFI_PAGE_SHIFT; 870 871 if (md->phys_addr == (prev_md->phys_addr + prev_size)) { 872 prev_md->num_pages += md->num_pages; 873 md->type = EFI_RESERVED_TYPE; 874 md->attribute = 0; 875 continue; 876 } 877 prev_md = md; 878 } 879 } 880 881 static void __init get_systab_virt_addr(efi_memory_desc_t *md) 882 { 883 unsigned long size; 884 u64 end, systab; 885 886 size = md->num_pages << EFI_PAGE_SHIFT; 887 end = md->phys_addr + size; 888 systab = (u64)(unsigned long)efi_phys.systab; 889 if (md->phys_addr <= systab && systab < end) { 890 systab += md->virt_addr - md->phys_addr; 891 efi.systab = (efi_system_table_t *)(unsigned long)systab; 892 } 893 } 894 895 static int __init save_runtime_map(void) 896 { 897 efi_memory_desc_t *md; 898 void *tmp, *p, *q = NULL; 899 int count = 0; 900 901 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 902 md = p; 903 904 if (!(md->attribute & EFI_MEMORY_RUNTIME) || 905 (md->type == EFI_BOOT_SERVICES_CODE) || 906 (md->type == EFI_BOOT_SERVICES_DATA)) 907 continue; 908 tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL); 909 if (!tmp) 910 goto out; 911 q = tmp; 912 913 memcpy(q + count * memmap.desc_size, md, memmap.desc_size); 914 count++; 915 } 916 917 efi_runtime_map_setup(q, count, memmap.desc_size); 918 919 return 0; 920 out: 921 kfree(q); 922 return -ENOMEM; 923 } 924 925 /* 926 * Map efi regions which were passed via setup_data. The virt_addr is a fixed 927 * addr which was used in first kernel of a kexec boot. 928 */ 929 static void __init efi_map_regions_fixed(void) 930 { 931 void *p; 932 efi_memory_desc_t *md; 933 934 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 935 md = p; 936 efi_map_region_fixed(md); /* FIXME: add error handling */ 937 get_systab_virt_addr(md); 938 } 939 940 } 941 942 /* 943 * Map efi memory ranges for runtime serivce and update new_memmap with virtual 944 * addresses. 945 */ 946 static void * __init efi_map_regions(int *count) 947 { 948 efi_memory_desc_t *md; 949 void *p, *tmp, *new_memmap = NULL; 950 951 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 952 md = p; 953 if (!(md->attribute & EFI_MEMORY_RUNTIME)) { 954 #ifdef CONFIG_X86_64 955 if (md->type != EFI_BOOT_SERVICES_CODE && 956 md->type != EFI_BOOT_SERVICES_DATA) 957 #endif 958 continue; 959 } 960 961 efi_map_region(md); 962 get_systab_virt_addr(md); 963 964 tmp = krealloc(new_memmap, (*count + 1) * memmap.desc_size, 965 GFP_KERNEL); 966 if (!tmp) 967 goto out; 968 new_memmap = tmp; 969 memcpy(new_memmap + (*count * memmap.desc_size), md, 970 memmap.desc_size); 971 (*count)++; 972 } 973 974 return new_memmap; 975 out: 976 kfree(new_memmap); 977 return NULL; 978 } 979 980 /* 981 * This function will switch the EFI runtime services to virtual mode. 982 * Essentially, we look through the EFI memmap and map every region that 983 * has the runtime attribute bit set in its memory descriptor into the 984 * ->trampoline_pgd page table using a top-down VA allocation scheme. 985 * 986 * The old method which used to update that memory descriptor with the 987 * virtual address obtained from ioremap() is still supported when the 988 * kernel is booted with efi=old_map on its command line. Same old 989 * method enabled the runtime services to be called without having to 990 * thunk back into physical mode for every invocation. 991 * 992 * The new method does a pagetable switch in a preemption-safe manner 993 * so that we're in a different address space when calling a runtime 994 * function. For function arguments passing we do copy the PGDs of the 995 * kernel page table into ->trampoline_pgd prior to each call. 996 * 997 * Specially for kexec boot, efi runtime maps in previous kernel should 998 * be passed in via setup_data. In that case runtime ranges will be mapped 999 * to the same virtual addresses as the first kernel. 1000 */ 1001 void __init efi_enter_virtual_mode(void) 1002 { 1003 efi_status_t status; 1004 void *new_memmap = NULL; 1005 int err, count = 0; 1006 1007 efi.systab = NULL; 1008 1009 /* 1010 * We don't do virtual mode, since we don't do runtime services, on 1011 * non-native EFI 1012 */ 1013 if (!efi_is_native()) { 1014 efi_unmap_memmap(); 1015 return; 1016 } 1017 1018 if (efi_setup) { 1019 efi_map_regions_fixed(); 1020 } else { 1021 efi_merge_regions(); 1022 new_memmap = efi_map_regions(&count); 1023 if (!new_memmap) { 1024 pr_err("Error reallocating memory, EFI runtime non-functional!\n"); 1025 return; 1026 } 1027 } 1028 1029 err = save_runtime_map(); 1030 if (err) 1031 pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n"); 1032 1033 BUG_ON(!efi.systab); 1034 1035 efi_setup_page_tables(); 1036 efi_sync_low_kernel_mappings(); 1037 1038 if (!efi_setup) { 1039 status = phys_efi_set_virtual_address_map( 1040 memmap.desc_size * count, 1041 memmap.desc_size, 1042 memmap.desc_version, 1043 (efi_memory_desc_t *)__pa(new_memmap)); 1044 1045 if (status != EFI_SUCCESS) { 1046 pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n", 1047 status); 1048 panic("EFI call to SetVirtualAddressMap() failed!"); 1049 } 1050 } 1051 1052 /* 1053 * Now that EFI is in virtual mode, update the function 1054 * pointers in the runtime service table to the new virtual addresses. 1055 * 1056 * Call EFI services through wrapper functions. 1057 */ 1058 efi.runtime_version = efi_systab.hdr.revision; 1059 efi.get_time = virt_efi_get_time; 1060 efi.set_time = virt_efi_set_time; 1061 efi.get_wakeup_time = virt_efi_get_wakeup_time; 1062 efi.set_wakeup_time = virt_efi_set_wakeup_time; 1063 efi.get_variable = virt_efi_get_variable; 1064 efi.get_next_variable = virt_efi_get_next_variable; 1065 efi.set_variable = virt_efi_set_variable; 1066 efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count; 1067 efi.reset_system = virt_efi_reset_system; 1068 efi.set_virtual_address_map = NULL; 1069 efi.query_variable_info = virt_efi_query_variable_info; 1070 efi.update_capsule = virt_efi_update_capsule; 1071 efi.query_capsule_caps = virt_efi_query_capsule_caps; 1072 1073 efi_runtime_mkexec(); 1074 1075 kfree(new_memmap); 1076 1077 /* clean DUMMY object */ 1078 efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID, 1079 EFI_VARIABLE_NON_VOLATILE | 1080 EFI_VARIABLE_BOOTSERVICE_ACCESS | 1081 EFI_VARIABLE_RUNTIME_ACCESS, 1082 0, NULL); 1083 } 1084 1085 /* 1086 * Convenience functions to obtain memory types and attributes 1087 */ 1088 u32 efi_mem_type(unsigned long phys_addr) 1089 { 1090 efi_memory_desc_t *md; 1091 void *p; 1092 1093 if (!efi_enabled(EFI_MEMMAP)) 1094 return 0; 1095 1096 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 1097 md = p; 1098 if ((md->phys_addr <= phys_addr) && 1099 (phys_addr < (md->phys_addr + 1100 (md->num_pages << EFI_PAGE_SHIFT)))) 1101 return md->type; 1102 } 1103 return 0; 1104 } 1105 1106 u64 efi_mem_attributes(unsigned long phys_addr) 1107 { 1108 efi_memory_desc_t *md; 1109 void *p; 1110 1111 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 1112 md = p; 1113 if ((md->phys_addr <= phys_addr) && 1114 (phys_addr < (md->phys_addr + 1115 (md->num_pages << EFI_PAGE_SHIFT)))) 1116 return md->attribute; 1117 } 1118 return 0; 1119 } 1120 1121 /* 1122 * Some firmware has serious problems when using more than 50% of the EFI 1123 * variable store, i.e. it triggers bugs that can brick machines. Ensure that 1124 * we never use more than this safe limit. 1125 * 1126 * Return EFI_SUCCESS if it is safe to write 'size' bytes to the variable 1127 * store. 1128 */ 1129 efi_status_t efi_query_variable_store(u32 attributes, unsigned long size) 1130 { 1131 efi_status_t status; 1132 u64 storage_size, remaining_size, max_size; 1133 1134 if (!(attributes & EFI_VARIABLE_NON_VOLATILE)) 1135 return 0; 1136 1137 status = efi.query_variable_info(attributes, &storage_size, 1138 &remaining_size, &max_size); 1139 if (status != EFI_SUCCESS) 1140 return status; 1141 1142 /* 1143 * Some firmware implementations refuse to boot if there's insufficient 1144 * space in the variable store. We account for that by refusing the 1145 * write if permitting it would reduce the available space to under 1146 * 5KB. This figure was provided by Samsung, so should be safe. 1147 */ 1148 if ((remaining_size - size < EFI_MIN_RESERVE) && 1149 !efi_no_storage_paranoia) { 1150 1151 /* 1152 * Triggering garbage collection may require that the firmware 1153 * generate a real EFI_OUT_OF_RESOURCES error. We can force 1154 * that by attempting to use more space than is available. 1155 */ 1156 unsigned long dummy_size = remaining_size + 1024; 1157 void *dummy = kzalloc(dummy_size, GFP_ATOMIC); 1158 1159 if (!dummy) 1160 return EFI_OUT_OF_RESOURCES; 1161 1162 status = efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID, 1163 EFI_VARIABLE_NON_VOLATILE | 1164 EFI_VARIABLE_BOOTSERVICE_ACCESS | 1165 EFI_VARIABLE_RUNTIME_ACCESS, 1166 dummy_size, dummy); 1167 1168 if (status == EFI_SUCCESS) { 1169 /* 1170 * This should have failed, so if it didn't make sure 1171 * that we delete it... 1172 */ 1173 efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID, 1174 EFI_VARIABLE_NON_VOLATILE | 1175 EFI_VARIABLE_BOOTSERVICE_ACCESS | 1176 EFI_VARIABLE_RUNTIME_ACCESS, 1177 0, dummy); 1178 } 1179 1180 kfree(dummy); 1181 1182 /* 1183 * The runtime code may now have triggered a garbage collection 1184 * run, so check the variable info again 1185 */ 1186 status = efi.query_variable_info(attributes, &storage_size, 1187 &remaining_size, &max_size); 1188 1189 if (status != EFI_SUCCESS) 1190 return status; 1191 1192 /* 1193 * There still isn't enough room, so return an error 1194 */ 1195 if (remaining_size - size < EFI_MIN_RESERVE) 1196 return EFI_OUT_OF_RESOURCES; 1197 } 1198 1199 return EFI_SUCCESS; 1200 } 1201 EXPORT_SYMBOL_GPL(efi_query_variable_store); 1202 1203 static int __init parse_efi_cmdline(char *str) 1204 { 1205 if (*str == '=') 1206 str++; 1207 1208 if (!strncmp(str, "old_map", 7)) 1209 set_bit(EFI_OLD_MEMMAP, &x86_efi_facility); 1210 1211 return 0; 1212 } 1213 early_param("efi", parse_efi_cmdline); 1214 1215 void __init efi_apply_memmap_quirks(void) 1216 { 1217 /* 1218 * Once setup is done earlier, unmap the EFI memory map on mismatched 1219 * firmware/kernel architectures since there is no support for runtime 1220 * services. 1221 */ 1222 if (!efi_is_native()) { 1223 pr_info("efi: Setup done, disabling due to 32/64-bit mismatch\n"); 1224 efi_unmap_memmap(); 1225 } 1226 1227 /* 1228 * UV doesn't support the new EFI pagetable mapping yet. 1229 */ 1230 if (is_uv_system()) 1231 set_bit(EFI_OLD_MEMMAP, &x86_efi_facility); 1232 } 1233