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