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