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 #include <linux/kernel.h> 30 #include <linux/init.h> 31 #include <linux/efi.h> 32 #include <linux/export.h> 33 #include <linux/bootmem.h> 34 #include <linux/memblock.h> 35 #include <linux/spinlock.h> 36 #include <linux/uaccess.h> 37 #include <linux/time.h> 38 #include <linux/io.h> 39 #include <linux/reboot.h> 40 #include <linux/bcd.h> 41 42 #include <asm/setup.h> 43 #include <asm/efi.h> 44 #include <asm/time.h> 45 #include <asm/cacheflush.h> 46 #include <asm/tlbflush.h> 47 #include <asm/x86_init.h> 48 49 #define EFI_DEBUG 1 50 #define PFX "EFI: " 51 52 int efi_enabled; 53 EXPORT_SYMBOL(efi_enabled); 54 55 struct efi __read_mostly efi = { 56 .mps = EFI_INVALID_TABLE_ADDR, 57 .acpi = EFI_INVALID_TABLE_ADDR, 58 .acpi20 = EFI_INVALID_TABLE_ADDR, 59 .smbios = EFI_INVALID_TABLE_ADDR, 60 .sal_systab = EFI_INVALID_TABLE_ADDR, 61 .boot_info = EFI_INVALID_TABLE_ADDR, 62 .hcdp = EFI_INVALID_TABLE_ADDR, 63 .uga = EFI_INVALID_TABLE_ADDR, 64 .uv_systab = EFI_INVALID_TABLE_ADDR, 65 }; 66 EXPORT_SYMBOL(efi); 67 68 struct efi_memory_map memmap; 69 70 static struct efi efi_phys __initdata; 71 static efi_system_table_t efi_systab __initdata; 72 73 static int __init setup_noefi(char *arg) 74 { 75 efi_enabled = 0; 76 return 0; 77 } 78 early_param("noefi", setup_noefi); 79 80 int add_efi_memmap; 81 EXPORT_SYMBOL(add_efi_memmap); 82 83 static int __init setup_add_efi_memmap(char *arg) 84 { 85 add_efi_memmap = 1; 86 return 0; 87 } 88 early_param("add_efi_memmap", setup_add_efi_memmap); 89 90 91 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc) 92 { 93 unsigned long flags; 94 efi_status_t status; 95 96 spin_lock_irqsave(&rtc_lock, flags); 97 status = efi_call_virt2(get_time, tm, tc); 98 spin_unlock_irqrestore(&rtc_lock, flags); 99 return status; 100 } 101 102 static efi_status_t virt_efi_set_time(efi_time_t *tm) 103 { 104 unsigned long flags; 105 efi_status_t status; 106 107 spin_lock_irqsave(&rtc_lock, flags); 108 status = efi_call_virt1(set_time, tm); 109 spin_unlock_irqrestore(&rtc_lock, flags); 110 return status; 111 } 112 113 static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled, 114 efi_bool_t *pending, 115 efi_time_t *tm) 116 { 117 unsigned long flags; 118 efi_status_t status; 119 120 spin_lock_irqsave(&rtc_lock, flags); 121 status = efi_call_virt3(get_wakeup_time, 122 enabled, pending, tm); 123 spin_unlock_irqrestore(&rtc_lock, flags); 124 return status; 125 } 126 127 static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm) 128 { 129 unsigned long flags; 130 efi_status_t status; 131 132 spin_lock_irqsave(&rtc_lock, flags); 133 status = efi_call_virt2(set_wakeup_time, 134 enabled, tm); 135 spin_unlock_irqrestore(&rtc_lock, flags); 136 return status; 137 } 138 139 static efi_status_t virt_efi_get_variable(efi_char16_t *name, 140 efi_guid_t *vendor, 141 u32 *attr, 142 unsigned long *data_size, 143 void *data) 144 { 145 return efi_call_virt5(get_variable, 146 name, vendor, attr, 147 data_size, data); 148 } 149 150 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size, 151 efi_char16_t *name, 152 efi_guid_t *vendor) 153 { 154 return efi_call_virt3(get_next_variable, 155 name_size, name, vendor); 156 } 157 158 static efi_status_t virt_efi_set_variable(efi_char16_t *name, 159 efi_guid_t *vendor, 160 u32 attr, 161 unsigned long data_size, 162 void *data) 163 { 164 return efi_call_virt5(set_variable, 165 name, vendor, attr, 166 data_size, data); 167 } 168 169 static efi_status_t virt_efi_query_variable_info(u32 attr, 170 u64 *storage_space, 171 u64 *remaining_space, 172 u64 *max_variable_size) 173 { 174 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 175 return EFI_UNSUPPORTED; 176 177 return efi_call_virt4(query_variable_info, attr, storage_space, 178 remaining_space, max_variable_size); 179 } 180 181 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count) 182 { 183 return efi_call_virt1(get_next_high_mono_count, count); 184 } 185 186 static void virt_efi_reset_system(int reset_type, 187 efi_status_t status, 188 unsigned long data_size, 189 efi_char16_t *data) 190 { 191 efi_call_virt4(reset_system, reset_type, status, 192 data_size, data); 193 } 194 195 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules, 196 unsigned long count, 197 unsigned long sg_list) 198 { 199 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 200 return EFI_UNSUPPORTED; 201 202 return efi_call_virt3(update_capsule, capsules, count, sg_list); 203 } 204 205 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules, 206 unsigned long count, 207 u64 *max_size, 208 int *reset_type) 209 { 210 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 211 return EFI_UNSUPPORTED; 212 213 return efi_call_virt4(query_capsule_caps, capsules, count, max_size, 214 reset_type); 215 } 216 217 static efi_status_t __init phys_efi_set_virtual_address_map( 218 unsigned long memory_map_size, 219 unsigned long descriptor_size, 220 u32 descriptor_version, 221 efi_memory_desc_t *virtual_map) 222 { 223 efi_status_t status; 224 225 efi_call_phys_prelog(); 226 status = efi_call_phys4(efi_phys.set_virtual_address_map, 227 memory_map_size, descriptor_size, 228 descriptor_version, virtual_map); 229 efi_call_phys_epilog(); 230 return status; 231 } 232 233 static efi_status_t __init phys_efi_get_time(efi_time_t *tm, 234 efi_time_cap_t *tc) 235 { 236 unsigned long flags; 237 efi_status_t status; 238 239 spin_lock_irqsave(&rtc_lock, flags); 240 efi_call_phys_prelog(); 241 status = efi_call_phys2(efi_phys.get_time, virt_to_phys(tm), 242 virt_to_phys(tc)); 243 efi_call_phys_epilog(); 244 spin_unlock_irqrestore(&rtc_lock, flags); 245 return status; 246 } 247 248 int efi_set_rtc_mmss(unsigned long nowtime) 249 { 250 int real_seconds, real_minutes; 251 efi_status_t status; 252 efi_time_t eft; 253 efi_time_cap_t cap; 254 255 status = efi.get_time(&eft, &cap); 256 if (status != EFI_SUCCESS) { 257 printk(KERN_ERR "Oops: efitime: can't read time!\n"); 258 return -1; 259 } 260 261 real_seconds = nowtime % 60; 262 real_minutes = nowtime / 60; 263 if (((abs(real_minutes - eft.minute) + 15)/30) & 1) 264 real_minutes += 30; 265 real_minutes %= 60; 266 eft.minute = real_minutes; 267 eft.second = real_seconds; 268 269 status = efi.set_time(&eft); 270 if (status != EFI_SUCCESS) { 271 printk(KERN_ERR "Oops: efitime: can't write time!\n"); 272 return -1; 273 } 274 return 0; 275 } 276 277 unsigned long efi_get_time(void) 278 { 279 efi_status_t status; 280 efi_time_t eft; 281 efi_time_cap_t cap; 282 283 status = efi.get_time(&eft, &cap); 284 if (status != EFI_SUCCESS) 285 printk(KERN_ERR "Oops: efitime: can't read time!\n"); 286 287 return mktime(eft.year, eft.month, eft.day, eft.hour, 288 eft.minute, eft.second); 289 } 290 291 /* 292 * Tell the kernel about the EFI memory map. This might include 293 * more than the max 128 entries that can fit in the e820 legacy 294 * (zeropage) memory map. 295 */ 296 297 static void __init do_add_efi_memmap(void) 298 { 299 void *p; 300 301 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 302 efi_memory_desc_t *md = p; 303 unsigned long long start = md->phys_addr; 304 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT; 305 int e820_type; 306 307 switch (md->type) { 308 case EFI_LOADER_CODE: 309 case EFI_LOADER_DATA: 310 case EFI_BOOT_SERVICES_CODE: 311 case EFI_BOOT_SERVICES_DATA: 312 case EFI_CONVENTIONAL_MEMORY: 313 if (md->attribute & EFI_MEMORY_WB) 314 e820_type = E820_RAM; 315 else 316 e820_type = E820_RESERVED; 317 break; 318 case EFI_ACPI_RECLAIM_MEMORY: 319 e820_type = E820_ACPI; 320 break; 321 case EFI_ACPI_MEMORY_NVS: 322 e820_type = E820_NVS; 323 break; 324 case EFI_UNUSABLE_MEMORY: 325 e820_type = E820_UNUSABLE; 326 break; 327 default: 328 /* 329 * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE 330 * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO 331 * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE 332 */ 333 e820_type = E820_RESERVED; 334 break; 335 } 336 e820_add_region(start, size, e820_type); 337 } 338 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 339 } 340 341 void __init efi_memblock_x86_reserve_range(void) 342 { 343 unsigned long pmap; 344 345 #ifdef CONFIG_X86_32 346 pmap = boot_params.efi_info.efi_memmap; 347 #else 348 pmap = (boot_params.efi_info.efi_memmap | 349 ((__u64)boot_params.efi_info.efi_memmap_hi<<32)); 350 #endif 351 memmap.phys_map = (void *)pmap; 352 memmap.nr_map = boot_params.efi_info.efi_memmap_size / 353 boot_params.efi_info.efi_memdesc_size; 354 memmap.desc_version = boot_params.efi_info.efi_memdesc_version; 355 memmap.desc_size = boot_params.efi_info.efi_memdesc_size; 356 memblock_reserve(pmap, memmap.nr_map * memmap.desc_size); 357 } 358 359 #if EFI_DEBUG 360 static void __init print_efi_memmap(void) 361 { 362 efi_memory_desc_t *md; 363 void *p; 364 int i; 365 366 for (p = memmap.map, i = 0; 367 p < memmap.map_end; 368 p += memmap.desc_size, i++) { 369 md = p; 370 printk(KERN_INFO PFX "mem%02u: type=%u, attr=0x%llx, " 371 "range=[0x%016llx-0x%016llx) (%lluMB)\n", 372 i, md->type, md->attribute, md->phys_addr, 373 md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT), 374 (md->num_pages >> (20 - EFI_PAGE_SHIFT))); 375 } 376 } 377 #endif /* EFI_DEBUG */ 378 379 void __init efi_reserve_boot_services(void) 380 { 381 void *p; 382 383 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 384 efi_memory_desc_t *md = p; 385 u64 start = md->phys_addr; 386 u64 size = md->num_pages << EFI_PAGE_SHIFT; 387 388 if (md->type != EFI_BOOT_SERVICES_CODE && 389 md->type != EFI_BOOT_SERVICES_DATA) 390 continue; 391 /* Only reserve where possible: 392 * - Not within any already allocated areas 393 * - Not over any memory area (really needed, if above?) 394 * - Not within any part of the kernel 395 * - Not the bios reserved area 396 */ 397 if ((start+size >= virt_to_phys(_text) 398 && start <= virt_to_phys(_end)) || 399 !e820_all_mapped(start, start+size, E820_RAM) || 400 memblock_is_region_reserved(start, size)) { 401 /* Could not reserve, skip it */ 402 md->num_pages = 0; 403 memblock_dbg(PFX "Could not reserve boot range " 404 "[0x%010llx-0x%010llx]\n", 405 start, start+size-1); 406 } else 407 memblock_reserve(start, size); 408 } 409 } 410 411 static void __init efi_free_boot_services(void) 412 { 413 void *p; 414 415 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 416 efi_memory_desc_t *md = p; 417 unsigned long long start = md->phys_addr; 418 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT; 419 420 if (md->type != EFI_BOOT_SERVICES_CODE && 421 md->type != EFI_BOOT_SERVICES_DATA) 422 continue; 423 424 /* Could not reserve boot area */ 425 if (!size) 426 continue; 427 428 free_bootmem_late(start, size); 429 } 430 } 431 432 void __init efi_init(void) 433 { 434 efi_config_table_t *config_tables; 435 efi_runtime_services_t *runtime; 436 efi_char16_t *c16; 437 char vendor[100] = "unknown"; 438 int i = 0; 439 void *tmp; 440 441 #ifdef CONFIG_X86_32 442 efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab; 443 #else 444 efi_phys.systab = (efi_system_table_t *) 445 (boot_params.efi_info.efi_systab | 446 ((__u64)boot_params.efi_info.efi_systab_hi<<32)); 447 #endif 448 449 efi.systab = early_ioremap((unsigned long)efi_phys.systab, 450 sizeof(efi_system_table_t)); 451 if (efi.systab == NULL) 452 printk(KERN_ERR "Couldn't map the EFI system table!\n"); 453 memcpy(&efi_systab, efi.systab, sizeof(efi_system_table_t)); 454 early_iounmap(efi.systab, sizeof(efi_system_table_t)); 455 efi.systab = &efi_systab; 456 457 /* 458 * Verify the EFI Table 459 */ 460 if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) 461 printk(KERN_ERR "EFI system table signature incorrect!\n"); 462 if ((efi.systab->hdr.revision >> 16) == 0) 463 printk(KERN_ERR "Warning: EFI system table version " 464 "%d.%02d, expected 1.00 or greater!\n", 465 efi.systab->hdr.revision >> 16, 466 efi.systab->hdr.revision & 0xffff); 467 468 /* 469 * Show what we know for posterity 470 */ 471 c16 = tmp = early_ioremap(efi.systab->fw_vendor, 2); 472 if (c16) { 473 for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i) 474 vendor[i] = *c16++; 475 vendor[i] = '\0'; 476 } else 477 printk(KERN_ERR PFX "Could not map the firmware vendor!\n"); 478 early_iounmap(tmp, 2); 479 480 printk(KERN_INFO "EFI v%u.%.02u by %s\n", 481 efi.systab->hdr.revision >> 16, 482 efi.systab->hdr.revision & 0xffff, vendor); 483 484 /* 485 * Let's see what config tables the firmware passed to us. 486 */ 487 config_tables = early_ioremap( 488 efi.systab->tables, 489 efi.systab->nr_tables * sizeof(efi_config_table_t)); 490 if (config_tables == NULL) 491 printk(KERN_ERR "Could not map EFI Configuration Table!\n"); 492 493 printk(KERN_INFO); 494 for (i = 0; i < efi.systab->nr_tables; i++) { 495 if (!efi_guidcmp(config_tables[i].guid, MPS_TABLE_GUID)) { 496 efi.mps = config_tables[i].table; 497 printk(" MPS=0x%lx ", config_tables[i].table); 498 } else if (!efi_guidcmp(config_tables[i].guid, 499 ACPI_20_TABLE_GUID)) { 500 efi.acpi20 = config_tables[i].table; 501 printk(" ACPI 2.0=0x%lx ", config_tables[i].table); 502 } else if (!efi_guidcmp(config_tables[i].guid, 503 ACPI_TABLE_GUID)) { 504 efi.acpi = config_tables[i].table; 505 printk(" ACPI=0x%lx ", config_tables[i].table); 506 } else if (!efi_guidcmp(config_tables[i].guid, 507 SMBIOS_TABLE_GUID)) { 508 efi.smbios = config_tables[i].table; 509 printk(" SMBIOS=0x%lx ", config_tables[i].table); 510 #ifdef CONFIG_X86_UV 511 } else if (!efi_guidcmp(config_tables[i].guid, 512 UV_SYSTEM_TABLE_GUID)) { 513 efi.uv_systab = config_tables[i].table; 514 printk(" UVsystab=0x%lx ", config_tables[i].table); 515 #endif 516 } else if (!efi_guidcmp(config_tables[i].guid, 517 HCDP_TABLE_GUID)) { 518 efi.hcdp = config_tables[i].table; 519 printk(" HCDP=0x%lx ", config_tables[i].table); 520 } else if (!efi_guidcmp(config_tables[i].guid, 521 UGA_IO_PROTOCOL_GUID)) { 522 efi.uga = config_tables[i].table; 523 printk(" UGA=0x%lx ", config_tables[i].table); 524 } 525 } 526 printk("\n"); 527 early_iounmap(config_tables, 528 efi.systab->nr_tables * sizeof(efi_config_table_t)); 529 530 /* 531 * Check out the runtime services table. We need to map 532 * the runtime services table so that we can grab the physical 533 * address of several of the EFI runtime functions, needed to 534 * set the firmware into virtual mode. 535 */ 536 runtime = early_ioremap((unsigned long)efi.systab->runtime, 537 sizeof(efi_runtime_services_t)); 538 if (runtime != NULL) { 539 /* 540 * We will only need *early* access to the following 541 * two EFI runtime services before set_virtual_address_map 542 * is invoked. 543 */ 544 efi_phys.get_time = (efi_get_time_t *)runtime->get_time; 545 efi_phys.set_virtual_address_map = 546 (efi_set_virtual_address_map_t *) 547 runtime->set_virtual_address_map; 548 /* 549 * Make efi_get_time can be called before entering 550 * virtual mode. 551 */ 552 efi.get_time = phys_efi_get_time; 553 } else 554 printk(KERN_ERR "Could not map the EFI runtime service " 555 "table!\n"); 556 early_iounmap(runtime, sizeof(efi_runtime_services_t)); 557 558 /* Map the EFI memory map */ 559 memmap.map = early_ioremap((unsigned long)memmap.phys_map, 560 memmap.nr_map * memmap.desc_size); 561 if (memmap.map == NULL) 562 printk(KERN_ERR "Could not map the EFI memory map!\n"); 563 memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size); 564 565 if (memmap.desc_size != sizeof(efi_memory_desc_t)) 566 printk(KERN_WARNING 567 "Kernel-defined memdesc doesn't match the one from EFI!\n"); 568 569 if (add_efi_memmap) 570 do_add_efi_memmap(); 571 572 #ifdef CONFIG_X86_32 573 x86_platform.get_wallclock = efi_get_time; 574 x86_platform.set_wallclock = efi_set_rtc_mmss; 575 #endif 576 577 #if EFI_DEBUG 578 print_efi_memmap(); 579 #endif 580 } 581 582 void __init efi_set_executable(efi_memory_desc_t *md, bool executable) 583 { 584 u64 addr, npages; 585 586 addr = md->virt_addr; 587 npages = md->num_pages; 588 589 memrange_efi_to_native(&addr, &npages); 590 591 if (executable) 592 set_memory_x(addr, npages); 593 else 594 set_memory_nx(addr, npages); 595 } 596 597 static void __init runtime_code_page_mkexec(void) 598 { 599 efi_memory_desc_t *md; 600 void *p; 601 602 /* Make EFI runtime service code area executable */ 603 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 604 md = p; 605 606 if (md->type != EFI_RUNTIME_SERVICES_CODE) 607 continue; 608 609 efi_set_executable(md, true); 610 } 611 } 612 613 /* 614 * This function will switch the EFI runtime services to virtual mode. 615 * Essentially, look through the EFI memmap and map every region that 616 * has the runtime attribute bit set in its memory descriptor and update 617 * that memory descriptor with the virtual address obtained from ioremap(). 618 * This enables the runtime services to be called without having to 619 * thunk back into physical mode for every invocation. 620 */ 621 void __init efi_enter_virtual_mode(void) 622 { 623 efi_memory_desc_t *md, *prev_md = NULL; 624 efi_status_t status; 625 unsigned long size; 626 u64 end, systab, addr, npages, end_pfn; 627 void *p, *va, *new_memmap = NULL; 628 int count = 0; 629 630 efi.systab = NULL; 631 632 /* Merge contiguous regions of the same type and attribute */ 633 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 634 u64 prev_size; 635 md = p; 636 637 if (!prev_md) { 638 prev_md = md; 639 continue; 640 } 641 642 if (prev_md->type != md->type || 643 prev_md->attribute != md->attribute) { 644 prev_md = md; 645 continue; 646 } 647 648 prev_size = prev_md->num_pages << EFI_PAGE_SHIFT; 649 650 if (md->phys_addr == (prev_md->phys_addr + prev_size)) { 651 prev_md->num_pages += md->num_pages; 652 md->type = EFI_RESERVED_TYPE; 653 md->attribute = 0; 654 continue; 655 } 656 prev_md = md; 657 } 658 659 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 660 md = p; 661 if (!(md->attribute & EFI_MEMORY_RUNTIME) && 662 md->type != EFI_BOOT_SERVICES_CODE && 663 md->type != EFI_BOOT_SERVICES_DATA) 664 continue; 665 666 size = md->num_pages << EFI_PAGE_SHIFT; 667 end = md->phys_addr + size; 668 669 end_pfn = PFN_UP(end); 670 if (end_pfn <= max_low_pfn_mapped 671 || (end_pfn > (1UL << (32 - PAGE_SHIFT)) 672 && end_pfn <= max_pfn_mapped)) 673 va = __va(md->phys_addr); 674 else 675 va = efi_ioremap(md->phys_addr, size, md->type); 676 677 md->virt_addr = (u64) (unsigned long) va; 678 679 if (!va) { 680 printk(KERN_ERR PFX "ioremap of 0x%llX failed!\n", 681 (unsigned long long)md->phys_addr); 682 continue; 683 } 684 685 if (!(md->attribute & EFI_MEMORY_WB)) { 686 addr = md->virt_addr; 687 npages = md->num_pages; 688 memrange_efi_to_native(&addr, &npages); 689 set_memory_uc(addr, npages); 690 } 691 692 systab = (u64) (unsigned long) efi_phys.systab; 693 if (md->phys_addr <= systab && systab < end) { 694 systab += md->virt_addr - md->phys_addr; 695 efi.systab = (efi_system_table_t *) (unsigned long) systab; 696 } 697 new_memmap = krealloc(new_memmap, 698 (count + 1) * memmap.desc_size, 699 GFP_KERNEL); 700 memcpy(new_memmap + (count * memmap.desc_size), md, 701 memmap.desc_size); 702 count++; 703 } 704 705 BUG_ON(!efi.systab); 706 707 status = phys_efi_set_virtual_address_map( 708 memmap.desc_size * count, 709 memmap.desc_size, 710 memmap.desc_version, 711 (efi_memory_desc_t *)__pa(new_memmap)); 712 713 if (status != EFI_SUCCESS) { 714 printk(KERN_ALERT "Unable to switch EFI into virtual mode " 715 "(status=%lx)!\n", status); 716 panic("EFI call to SetVirtualAddressMap() failed!"); 717 } 718 719 /* 720 * Thankfully, it does seem that no runtime services other than 721 * SetVirtualAddressMap() will touch boot services code, so we can 722 * get rid of it all at this point 723 */ 724 efi_free_boot_services(); 725 726 /* 727 * Now that EFI is in virtual mode, update the function 728 * pointers in the runtime service table to the new virtual addresses. 729 * 730 * Call EFI services through wrapper functions. 731 */ 732 efi.get_time = virt_efi_get_time; 733 efi.set_time = virt_efi_set_time; 734 efi.get_wakeup_time = virt_efi_get_wakeup_time; 735 efi.set_wakeup_time = virt_efi_set_wakeup_time; 736 efi.get_variable = virt_efi_get_variable; 737 efi.get_next_variable = virt_efi_get_next_variable; 738 efi.set_variable = virt_efi_set_variable; 739 efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count; 740 efi.reset_system = virt_efi_reset_system; 741 efi.set_virtual_address_map = NULL; 742 efi.query_variable_info = virt_efi_query_variable_info; 743 efi.update_capsule = virt_efi_update_capsule; 744 efi.query_capsule_caps = virt_efi_query_capsule_caps; 745 if (__supported_pte_mask & _PAGE_NX) 746 runtime_code_page_mkexec(); 747 early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size); 748 memmap.map = NULL; 749 kfree(new_memmap); 750 } 751 752 /* 753 * Convenience functions to obtain memory types and attributes 754 */ 755 u32 efi_mem_type(unsigned long phys_addr) 756 { 757 efi_memory_desc_t *md; 758 void *p; 759 760 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 761 md = p; 762 if ((md->phys_addr <= phys_addr) && 763 (phys_addr < (md->phys_addr + 764 (md->num_pages << EFI_PAGE_SHIFT)))) 765 return md->type; 766 } 767 return 0; 768 } 769 770 u64 efi_mem_attributes(unsigned long phys_addr) 771 { 772 efi_memory_desc_t *md; 773 void *p; 774 775 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) { 776 md = p; 777 if ((md->phys_addr <= phys_addr) && 778 (phys_addr < (md->phys_addr + 779 (md->num_pages << EFI_PAGE_SHIFT)))) 780 return md->attribute; 781 } 782 return 0; 783 } 784