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