1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * x86_64 specific EFI support functions 4 * Based on Extensible Firmware Interface Specification version 1.0 5 * 6 * Copyright (C) 2005-2008 Intel Co. 7 * Fenghua Yu <fenghua.yu@intel.com> 8 * Bibo Mao <bibo.mao@intel.com> 9 * Chandramouli Narayanan <mouli@linux.intel.com> 10 * Huang Ying <ying.huang@intel.com> 11 * 12 * Code to convert EFI to E820 map has been implemented in elilo bootloader 13 * based on a EFI patch by Edgar Hucek. Based on the E820 map, the page table 14 * is setup appropriately for EFI runtime code. 15 * - mouli 06/14/2007. 16 * 17 */ 18 19 #define pr_fmt(fmt) "efi: " fmt 20 21 #include <linux/kernel.h> 22 #include <linux/init.h> 23 #include <linux/mm.h> 24 #include <linux/types.h> 25 #include <linux/spinlock.h> 26 #include <linux/bootmem.h> 27 #include <linux/ioport.h> 28 #include <linux/init.h> 29 #include <linux/mc146818rtc.h> 30 #include <linux/efi.h> 31 #include <linux/uaccess.h> 32 #include <linux/io.h> 33 #include <linux/reboot.h> 34 #include <linux/slab.h> 35 #include <linux/ucs2_string.h> 36 37 #include <asm/setup.h> 38 #include <asm/page.h> 39 #include <asm/e820/api.h> 40 #include <asm/pgtable.h> 41 #include <asm/tlbflush.h> 42 #include <asm/proto.h> 43 #include <asm/efi.h> 44 #include <asm/cacheflush.h> 45 #include <asm/fixmap.h> 46 #include <asm/realmode.h> 47 #include <asm/time.h> 48 #include <asm/pgalloc.h> 49 50 /* 51 * We allocate runtime services regions top-down, starting from -4G, i.e. 52 * 0xffff_ffff_0000_0000 and limit EFI VA mapping space to 64G. 53 */ 54 static u64 efi_va = EFI_VA_START; 55 56 struct efi_scratch efi_scratch; 57 58 static void __init early_code_mapping_set_exec(int executable) 59 { 60 efi_memory_desc_t *md; 61 62 if (!(__supported_pte_mask & _PAGE_NX)) 63 return; 64 65 /* Make EFI service code area executable */ 66 for_each_efi_memory_desc(md) { 67 if (md->type == EFI_RUNTIME_SERVICES_CODE || 68 md->type == EFI_BOOT_SERVICES_CODE) 69 efi_set_executable(md, executable); 70 } 71 } 72 73 pgd_t * __init efi_call_phys_prolog(void) 74 { 75 unsigned long vaddr, addr_pgd, addr_p4d, addr_pud; 76 pgd_t *save_pgd, *pgd_k, *pgd_efi; 77 p4d_t *p4d, *p4d_k, *p4d_efi; 78 pud_t *pud; 79 80 int pgd; 81 int n_pgds, i, j; 82 83 if (!efi_enabled(EFI_OLD_MEMMAP)) { 84 save_pgd = (pgd_t *)__read_cr3(); 85 write_cr3((unsigned long)efi_scratch.efi_pgt); 86 goto out; 87 } 88 89 early_code_mapping_set_exec(1); 90 91 n_pgds = DIV_ROUND_UP((max_pfn << PAGE_SHIFT), PGDIR_SIZE); 92 save_pgd = kmalloc_array(n_pgds, sizeof(*save_pgd), GFP_KERNEL); 93 94 /* 95 * Build 1:1 identity mapping for efi=old_map usage. Note that 96 * PAGE_OFFSET is PGDIR_SIZE aligned when KASLR is disabled, while 97 * it is PUD_SIZE ALIGNED with KASLR enabled. So for a given physical 98 * address X, the pud_index(X) != pud_index(__va(X)), we can only copy 99 * PUD entry of __va(X) to fill in pud entry of X to build 1:1 mapping. 100 * This means here we can only reuse the PMD tables of the direct mapping. 101 */ 102 for (pgd = 0; pgd < n_pgds; pgd++) { 103 addr_pgd = (unsigned long)(pgd * PGDIR_SIZE); 104 vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); 105 pgd_efi = pgd_offset_k(addr_pgd); 106 save_pgd[pgd] = *pgd_efi; 107 108 p4d = p4d_alloc(&init_mm, pgd_efi, addr_pgd); 109 if (!p4d) { 110 pr_err("Failed to allocate p4d table!\n"); 111 goto out; 112 } 113 114 for (i = 0; i < PTRS_PER_P4D; i++) { 115 addr_p4d = addr_pgd + i * P4D_SIZE; 116 p4d_efi = p4d + p4d_index(addr_p4d); 117 118 pud = pud_alloc(&init_mm, p4d_efi, addr_p4d); 119 if (!pud) { 120 pr_err("Failed to allocate pud table!\n"); 121 goto out; 122 } 123 124 for (j = 0; j < PTRS_PER_PUD; j++) { 125 addr_pud = addr_p4d + j * PUD_SIZE; 126 127 if (addr_pud > (max_pfn << PAGE_SHIFT)) 128 break; 129 130 vaddr = (unsigned long)__va(addr_pud); 131 132 pgd_k = pgd_offset_k(vaddr); 133 p4d_k = p4d_offset(pgd_k, vaddr); 134 pud[j] = *pud_offset(p4d_k, vaddr); 135 } 136 } 137 } 138 out: 139 __flush_tlb_all(); 140 141 return save_pgd; 142 } 143 144 void __init efi_call_phys_epilog(pgd_t *save_pgd) 145 { 146 /* 147 * After the lock is released, the original page table is restored. 148 */ 149 int pgd_idx, i; 150 int nr_pgds; 151 pgd_t *pgd; 152 p4d_t *p4d; 153 pud_t *pud; 154 155 if (!efi_enabled(EFI_OLD_MEMMAP)) { 156 write_cr3((unsigned long)save_pgd); 157 __flush_tlb_all(); 158 return; 159 } 160 161 nr_pgds = DIV_ROUND_UP((max_pfn << PAGE_SHIFT) , PGDIR_SIZE); 162 163 for (pgd_idx = 0; pgd_idx < nr_pgds; pgd_idx++) { 164 pgd = pgd_offset_k(pgd_idx * PGDIR_SIZE); 165 set_pgd(pgd_offset_k(pgd_idx * PGDIR_SIZE), save_pgd[pgd_idx]); 166 167 if (!(pgd_val(*pgd) & _PAGE_PRESENT)) 168 continue; 169 170 for (i = 0; i < PTRS_PER_P4D; i++) { 171 p4d = p4d_offset(pgd, 172 pgd_idx * PGDIR_SIZE + i * P4D_SIZE); 173 174 if (!(p4d_val(*p4d) & _PAGE_PRESENT)) 175 continue; 176 177 pud = (pud_t *)p4d_page_vaddr(*p4d); 178 pud_free(&init_mm, pud); 179 } 180 181 p4d = (p4d_t *)pgd_page_vaddr(*pgd); 182 p4d_free(&init_mm, p4d); 183 } 184 185 kfree(save_pgd); 186 187 __flush_tlb_all(); 188 early_code_mapping_set_exec(0); 189 } 190 191 static pgd_t *efi_pgd; 192 193 /* 194 * We need our own copy of the higher levels of the page tables 195 * because we want to avoid inserting EFI region mappings (EFI_VA_END 196 * to EFI_VA_START) into the standard kernel page tables. Everything 197 * else can be shared, see efi_sync_low_kernel_mappings(). 198 */ 199 int __init efi_alloc_page_tables(void) 200 { 201 pgd_t *pgd; 202 p4d_t *p4d; 203 pud_t *pud; 204 gfp_t gfp_mask; 205 206 if (efi_enabled(EFI_OLD_MEMMAP)) 207 return 0; 208 209 gfp_mask = GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO; 210 efi_pgd = (pgd_t *)__get_free_page(gfp_mask); 211 if (!efi_pgd) 212 return -ENOMEM; 213 214 pgd = efi_pgd + pgd_index(EFI_VA_END); 215 p4d = p4d_alloc(&init_mm, pgd, EFI_VA_END); 216 if (!p4d) { 217 free_page((unsigned long)efi_pgd); 218 return -ENOMEM; 219 } 220 221 pud = pud_alloc(&init_mm, p4d, EFI_VA_END); 222 if (!pud) { 223 if (CONFIG_PGTABLE_LEVELS > 4) 224 free_page((unsigned long) pgd_page_vaddr(*pgd)); 225 free_page((unsigned long)efi_pgd); 226 return -ENOMEM; 227 } 228 229 return 0; 230 } 231 232 /* 233 * Add low kernel mappings for passing arguments to EFI functions. 234 */ 235 void efi_sync_low_kernel_mappings(void) 236 { 237 unsigned num_entries; 238 pgd_t *pgd_k, *pgd_efi; 239 p4d_t *p4d_k, *p4d_efi; 240 pud_t *pud_k, *pud_efi; 241 242 if (efi_enabled(EFI_OLD_MEMMAP)) 243 return; 244 245 /* 246 * We can share all PGD entries apart from the one entry that 247 * covers the EFI runtime mapping space. 248 * 249 * Make sure the EFI runtime region mappings are guaranteed to 250 * only span a single PGD entry and that the entry also maps 251 * other important kernel regions. 252 */ 253 BUILD_BUG_ON(pgd_index(EFI_VA_END) != pgd_index(MODULES_END)); 254 BUILD_BUG_ON((EFI_VA_START & PGDIR_MASK) != 255 (EFI_VA_END & PGDIR_MASK)); 256 257 pgd_efi = efi_pgd + pgd_index(PAGE_OFFSET); 258 pgd_k = pgd_offset_k(PAGE_OFFSET); 259 260 num_entries = pgd_index(EFI_VA_END) - pgd_index(PAGE_OFFSET); 261 memcpy(pgd_efi, pgd_k, sizeof(pgd_t) * num_entries); 262 263 /* 264 * As with PGDs, we share all P4D entries apart from the one entry 265 * that covers the EFI runtime mapping space. 266 */ 267 BUILD_BUG_ON(p4d_index(EFI_VA_END) != p4d_index(MODULES_END)); 268 BUILD_BUG_ON((EFI_VA_START & P4D_MASK) != (EFI_VA_END & P4D_MASK)); 269 270 pgd_efi = efi_pgd + pgd_index(EFI_VA_END); 271 pgd_k = pgd_offset_k(EFI_VA_END); 272 p4d_efi = p4d_offset(pgd_efi, 0); 273 p4d_k = p4d_offset(pgd_k, 0); 274 275 num_entries = p4d_index(EFI_VA_END); 276 memcpy(p4d_efi, p4d_k, sizeof(p4d_t) * num_entries); 277 278 /* 279 * We share all the PUD entries apart from those that map the 280 * EFI regions. Copy around them. 281 */ 282 BUILD_BUG_ON((EFI_VA_START & ~PUD_MASK) != 0); 283 BUILD_BUG_ON((EFI_VA_END & ~PUD_MASK) != 0); 284 285 p4d_efi = p4d_offset(pgd_efi, EFI_VA_END); 286 p4d_k = p4d_offset(pgd_k, EFI_VA_END); 287 pud_efi = pud_offset(p4d_efi, 0); 288 pud_k = pud_offset(p4d_k, 0); 289 290 num_entries = pud_index(EFI_VA_END); 291 memcpy(pud_efi, pud_k, sizeof(pud_t) * num_entries); 292 293 pud_efi = pud_offset(p4d_efi, EFI_VA_START); 294 pud_k = pud_offset(p4d_k, EFI_VA_START); 295 296 num_entries = PTRS_PER_PUD - pud_index(EFI_VA_START); 297 memcpy(pud_efi, pud_k, sizeof(pud_t) * num_entries); 298 } 299 300 /* 301 * Wrapper for slow_virt_to_phys() that handles NULL addresses. 302 */ 303 static inline phys_addr_t 304 virt_to_phys_or_null_size(void *va, unsigned long size) 305 { 306 bool bad_size; 307 308 if (!va) 309 return 0; 310 311 if (virt_addr_valid(va)) 312 return virt_to_phys(va); 313 314 /* 315 * A fully aligned variable on the stack is guaranteed not to 316 * cross a page bounary. Try to catch strings on the stack by 317 * checking that 'size' is a power of two. 318 */ 319 bad_size = size > PAGE_SIZE || !is_power_of_2(size); 320 321 WARN_ON(!IS_ALIGNED((unsigned long)va, size) || bad_size); 322 323 return slow_virt_to_phys(va); 324 } 325 326 #define virt_to_phys_or_null(addr) \ 327 virt_to_phys_or_null_size((addr), sizeof(*(addr))) 328 329 int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages) 330 { 331 unsigned long pfn, text, pf; 332 struct page *page; 333 unsigned npages; 334 pgd_t *pgd; 335 336 if (efi_enabled(EFI_OLD_MEMMAP)) 337 return 0; 338 339 /* 340 * Since the PGD is encrypted, set the encryption mask so that when 341 * this value is loaded into cr3 the PGD will be decrypted during 342 * the pagetable walk. 343 */ 344 efi_scratch.efi_pgt = (pgd_t *)__sme_pa(efi_pgd); 345 pgd = efi_pgd; 346 347 /* 348 * It can happen that the physical address of new_memmap lands in memory 349 * which is not mapped in the EFI page table. Therefore we need to go 350 * and ident-map those pages containing the map before calling 351 * phys_efi_set_virtual_address_map(). 352 */ 353 pfn = pa_memmap >> PAGE_SHIFT; 354 pf = _PAGE_NX | _PAGE_RW | _PAGE_ENC; 355 if (kernel_map_pages_in_pgd(pgd, pfn, pa_memmap, num_pages, pf)) { 356 pr_err("Error ident-mapping new memmap (0x%lx)!\n", pa_memmap); 357 return 1; 358 } 359 360 efi_scratch.use_pgd = true; 361 362 /* 363 * Certain firmware versions are way too sentimential and still believe 364 * they are exclusive and unquestionable owners of the first physical page, 365 * even though they explicitly mark it as EFI_CONVENTIONAL_MEMORY 366 * (but then write-access it later during SetVirtualAddressMap()). 367 * 368 * Create a 1:1 mapping for this page, to avoid triple faults during early 369 * boot with such firmware. We are free to hand this page to the BIOS, 370 * as trim_bios_range() will reserve the first page and isolate it away 371 * from memory allocators anyway. 372 */ 373 if (kernel_map_pages_in_pgd(pgd, 0x0, 0x0, 1, _PAGE_RW)) { 374 pr_err("Failed to create 1:1 mapping for the first page!\n"); 375 return 1; 376 } 377 378 /* 379 * When making calls to the firmware everything needs to be 1:1 380 * mapped and addressable with 32-bit pointers. Map the kernel 381 * text and allocate a new stack because we can't rely on the 382 * stack pointer being < 4GB. 383 */ 384 if (!IS_ENABLED(CONFIG_EFI_MIXED) || efi_is_native()) 385 return 0; 386 387 page = alloc_page(GFP_KERNEL|__GFP_DMA32); 388 if (!page) 389 panic("Unable to allocate EFI runtime stack < 4GB\n"); 390 391 efi_scratch.phys_stack = virt_to_phys(page_address(page)); 392 efi_scratch.phys_stack += PAGE_SIZE; /* stack grows down */ 393 394 npages = (_etext - _text) >> PAGE_SHIFT; 395 text = __pa(_text); 396 pfn = text >> PAGE_SHIFT; 397 398 pf = _PAGE_RW | _PAGE_ENC; 399 if (kernel_map_pages_in_pgd(pgd, pfn, text, npages, pf)) { 400 pr_err("Failed to map kernel text 1:1\n"); 401 return 1; 402 } 403 404 return 0; 405 } 406 407 static void __init __map_region(efi_memory_desc_t *md, u64 va) 408 { 409 unsigned long flags = _PAGE_RW; 410 unsigned long pfn; 411 pgd_t *pgd = efi_pgd; 412 413 if (!(md->attribute & EFI_MEMORY_WB)) 414 flags |= _PAGE_PCD; 415 416 pfn = md->phys_addr >> PAGE_SHIFT; 417 if (kernel_map_pages_in_pgd(pgd, pfn, va, md->num_pages, flags)) 418 pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n", 419 md->phys_addr, va); 420 } 421 422 void __init efi_map_region(efi_memory_desc_t *md) 423 { 424 unsigned long size = md->num_pages << PAGE_SHIFT; 425 u64 pa = md->phys_addr; 426 427 if (efi_enabled(EFI_OLD_MEMMAP)) 428 return old_map_region(md); 429 430 /* 431 * Make sure the 1:1 mappings are present as a catch-all for b0rked 432 * firmware which doesn't update all internal pointers after switching 433 * to virtual mode and would otherwise crap on us. 434 */ 435 __map_region(md, md->phys_addr); 436 437 /* 438 * Enforce the 1:1 mapping as the default virtual address when 439 * booting in EFI mixed mode, because even though we may be 440 * running a 64-bit kernel, the firmware may only be 32-bit. 441 */ 442 if (!efi_is_native () && IS_ENABLED(CONFIG_EFI_MIXED)) { 443 md->virt_addr = md->phys_addr; 444 return; 445 } 446 447 efi_va -= size; 448 449 /* Is PA 2M-aligned? */ 450 if (!(pa & (PMD_SIZE - 1))) { 451 efi_va &= PMD_MASK; 452 } else { 453 u64 pa_offset = pa & (PMD_SIZE - 1); 454 u64 prev_va = efi_va; 455 456 /* get us the same offset within this 2M page */ 457 efi_va = (efi_va & PMD_MASK) + pa_offset; 458 459 if (efi_va > prev_va) 460 efi_va -= PMD_SIZE; 461 } 462 463 if (efi_va < EFI_VA_END) { 464 pr_warn(FW_WARN "VA address range overflow!\n"); 465 return; 466 } 467 468 /* Do the VA map */ 469 __map_region(md, efi_va); 470 md->virt_addr = efi_va; 471 } 472 473 /* 474 * kexec kernel will use efi_map_region_fixed to map efi runtime memory ranges. 475 * md->virt_addr is the original virtual address which had been mapped in kexec 476 * 1st kernel. 477 */ 478 void __init efi_map_region_fixed(efi_memory_desc_t *md) 479 { 480 __map_region(md, md->phys_addr); 481 __map_region(md, md->virt_addr); 482 } 483 484 void __iomem *__init efi_ioremap(unsigned long phys_addr, unsigned long size, 485 u32 type, u64 attribute) 486 { 487 unsigned long last_map_pfn; 488 489 if (type == EFI_MEMORY_MAPPED_IO) 490 return ioremap(phys_addr, size); 491 492 last_map_pfn = init_memory_mapping(phys_addr, phys_addr + size); 493 if ((last_map_pfn << PAGE_SHIFT) < phys_addr + size) { 494 unsigned long top = last_map_pfn << PAGE_SHIFT; 495 efi_ioremap(top, size - (top - phys_addr), type, attribute); 496 } 497 498 if (!(attribute & EFI_MEMORY_WB)) 499 efi_memory_uc((u64)(unsigned long)__va(phys_addr), size); 500 501 return (void __iomem *)__va(phys_addr); 502 } 503 504 void __init parse_efi_setup(u64 phys_addr, u32 data_len) 505 { 506 efi_setup = phys_addr + sizeof(struct setup_data); 507 } 508 509 static int __init efi_update_mappings(efi_memory_desc_t *md, unsigned long pf) 510 { 511 unsigned long pfn; 512 pgd_t *pgd = efi_pgd; 513 int err1, err2; 514 515 /* Update the 1:1 mapping */ 516 pfn = md->phys_addr >> PAGE_SHIFT; 517 err1 = kernel_map_pages_in_pgd(pgd, pfn, md->phys_addr, md->num_pages, pf); 518 if (err1) { 519 pr_err("Error while updating 1:1 mapping PA 0x%llx -> VA 0x%llx!\n", 520 md->phys_addr, md->virt_addr); 521 } 522 523 err2 = kernel_map_pages_in_pgd(pgd, pfn, md->virt_addr, md->num_pages, pf); 524 if (err2) { 525 pr_err("Error while updating VA mapping PA 0x%llx -> VA 0x%llx!\n", 526 md->phys_addr, md->virt_addr); 527 } 528 529 return err1 || err2; 530 } 531 532 static int __init efi_update_mem_attr(struct mm_struct *mm, efi_memory_desc_t *md) 533 { 534 unsigned long pf = 0; 535 536 if (md->attribute & EFI_MEMORY_XP) 537 pf |= _PAGE_NX; 538 539 if (!(md->attribute & EFI_MEMORY_RO)) 540 pf |= _PAGE_RW; 541 542 return efi_update_mappings(md, pf); 543 } 544 545 void __init efi_runtime_update_mappings(void) 546 { 547 efi_memory_desc_t *md; 548 549 if (efi_enabled(EFI_OLD_MEMMAP)) { 550 if (__supported_pte_mask & _PAGE_NX) 551 runtime_code_page_mkexec(); 552 return; 553 } 554 555 /* 556 * Use the EFI Memory Attribute Table for mapping permissions if it 557 * exists, since it is intended to supersede EFI_PROPERTIES_TABLE. 558 */ 559 if (efi_enabled(EFI_MEM_ATTR)) { 560 efi_memattr_apply_permissions(NULL, efi_update_mem_attr); 561 return; 562 } 563 564 /* 565 * EFI_MEMORY_ATTRIBUTES_TABLE is intended to replace 566 * EFI_PROPERTIES_TABLE. So, use EFI_PROPERTIES_TABLE to update 567 * permissions only if EFI_MEMORY_ATTRIBUTES_TABLE is not 568 * published by the firmware. Even if we find a buggy implementation of 569 * EFI_MEMORY_ATTRIBUTES_TABLE, don't fall back to 570 * EFI_PROPERTIES_TABLE, because of the same reason. 571 */ 572 573 if (!efi_enabled(EFI_NX_PE_DATA)) 574 return; 575 576 for_each_efi_memory_desc(md) { 577 unsigned long pf = 0; 578 579 if (!(md->attribute & EFI_MEMORY_RUNTIME)) 580 continue; 581 582 if (!(md->attribute & EFI_MEMORY_WB)) 583 pf |= _PAGE_PCD; 584 585 if ((md->attribute & EFI_MEMORY_XP) || 586 (md->type == EFI_RUNTIME_SERVICES_DATA)) 587 pf |= _PAGE_NX; 588 589 if (!(md->attribute & EFI_MEMORY_RO) && 590 (md->type != EFI_RUNTIME_SERVICES_CODE)) 591 pf |= _PAGE_RW; 592 593 efi_update_mappings(md, pf); 594 } 595 } 596 597 void __init efi_dump_pagetable(void) 598 { 599 #ifdef CONFIG_EFI_PGT_DUMP 600 if (efi_enabled(EFI_OLD_MEMMAP)) 601 ptdump_walk_pgd_level(NULL, swapper_pg_dir); 602 else 603 ptdump_walk_pgd_level(NULL, efi_pgd); 604 #endif 605 } 606 607 #ifdef CONFIG_EFI_MIXED 608 extern efi_status_t efi64_thunk(u32, ...); 609 610 #define runtime_service32(func) \ 611 ({ \ 612 u32 table = (u32)(unsigned long)efi.systab; \ 613 u32 *rt, *___f; \ 614 \ 615 rt = (u32 *)(table + offsetof(efi_system_table_32_t, runtime)); \ 616 ___f = (u32 *)(*rt + offsetof(efi_runtime_services_32_t, func)); \ 617 *___f; \ 618 }) 619 620 /* 621 * Switch to the EFI page tables early so that we can access the 1:1 622 * runtime services mappings which are not mapped in any other page 623 * tables. This function must be called before runtime_service32(). 624 * 625 * Also, disable interrupts because the IDT points to 64-bit handlers, 626 * which aren't going to function correctly when we switch to 32-bit. 627 */ 628 #define efi_thunk(f, ...) \ 629 ({ \ 630 efi_status_t __s; \ 631 unsigned long __flags; \ 632 u32 __func; \ 633 \ 634 local_irq_save(__flags); \ 635 arch_efi_call_virt_setup(); \ 636 \ 637 __func = runtime_service32(f); \ 638 __s = efi64_thunk(__func, __VA_ARGS__); \ 639 \ 640 arch_efi_call_virt_teardown(); \ 641 local_irq_restore(__flags); \ 642 \ 643 __s; \ 644 }) 645 646 efi_status_t efi_thunk_set_virtual_address_map( 647 void *phys_set_virtual_address_map, 648 unsigned long memory_map_size, 649 unsigned long descriptor_size, 650 u32 descriptor_version, 651 efi_memory_desc_t *virtual_map) 652 { 653 efi_status_t status; 654 unsigned long flags; 655 u32 func; 656 657 efi_sync_low_kernel_mappings(); 658 local_irq_save(flags); 659 660 efi_scratch.prev_cr3 = __read_cr3(); 661 write_cr3((unsigned long)efi_scratch.efi_pgt); 662 __flush_tlb_all(); 663 664 func = (u32)(unsigned long)phys_set_virtual_address_map; 665 status = efi64_thunk(func, memory_map_size, descriptor_size, 666 descriptor_version, virtual_map); 667 668 write_cr3(efi_scratch.prev_cr3); 669 __flush_tlb_all(); 670 local_irq_restore(flags); 671 672 return status; 673 } 674 675 static efi_status_t efi_thunk_get_time(efi_time_t *tm, efi_time_cap_t *tc) 676 { 677 efi_status_t status; 678 u32 phys_tm, phys_tc; 679 680 spin_lock(&rtc_lock); 681 682 phys_tm = virt_to_phys_or_null(tm); 683 phys_tc = virt_to_phys_or_null(tc); 684 685 status = efi_thunk(get_time, phys_tm, phys_tc); 686 687 spin_unlock(&rtc_lock); 688 689 return status; 690 } 691 692 static efi_status_t efi_thunk_set_time(efi_time_t *tm) 693 { 694 efi_status_t status; 695 u32 phys_tm; 696 697 spin_lock(&rtc_lock); 698 699 phys_tm = virt_to_phys_or_null(tm); 700 701 status = efi_thunk(set_time, phys_tm); 702 703 spin_unlock(&rtc_lock); 704 705 return status; 706 } 707 708 static efi_status_t 709 efi_thunk_get_wakeup_time(efi_bool_t *enabled, efi_bool_t *pending, 710 efi_time_t *tm) 711 { 712 efi_status_t status; 713 u32 phys_enabled, phys_pending, phys_tm; 714 715 spin_lock(&rtc_lock); 716 717 phys_enabled = virt_to_phys_or_null(enabled); 718 phys_pending = virt_to_phys_or_null(pending); 719 phys_tm = virt_to_phys_or_null(tm); 720 721 status = efi_thunk(get_wakeup_time, phys_enabled, 722 phys_pending, phys_tm); 723 724 spin_unlock(&rtc_lock); 725 726 return status; 727 } 728 729 static efi_status_t 730 efi_thunk_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm) 731 { 732 efi_status_t status; 733 u32 phys_tm; 734 735 spin_lock(&rtc_lock); 736 737 phys_tm = virt_to_phys_or_null(tm); 738 739 status = efi_thunk(set_wakeup_time, enabled, phys_tm); 740 741 spin_unlock(&rtc_lock); 742 743 return status; 744 } 745 746 static unsigned long efi_name_size(efi_char16_t *name) 747 { 748 return ucs2_strsize(name, EFI_VAR_NAME_LEN) + 1; 749 } 750 751 static efi_status_t 752 efi_thunk_get_variable(efi_char16_t *name, efi_guid_t *vendor, 753 u32 *attr, unsigned long *data_size, void *data) 754 { 755 efi_status_t status; 756 u32 phys_name, phys_vendor, phys_attr; 757 u32 phys_data_size, phys_data; 758 759 phys_data_size = virt_to_phys_or_null(data_size); 760 phys_vendor = virt_to_phys_or_null(vendor); 761 phys_name = virt_to_phys_or_null_size(name, efi_name_size(name)); 762 phys_attr = virt_to_phys_or_null(attr); 763 phys_data = virt_to_phys_or_null_size(data, *data_size); 764 765 status = efi_thunk(get_variable, phys_name, phys_vendor, 766 phys_attr, phys_data_size, phys_data); 767 768 return status; 769 } 770 771 static efi_status_t 772 efi_thunk_set_variable(efi_char16_t *name, efi_guid_t *vendor, 773 u32 attr, unsigned long data_size, void *data) 774 { 775 u32 phys_name, phys_vendor, phys_data; 776 efi_status_t status; 777 778 phys_name = virt_to_phys_or_null_size(name, efi_name_size(name)); 779 phys_vendor = virt_to_phys_or_null(vendor); 780 phys_data = virt_to_phys_or_null_size(data, data_size); 781 782 /* If data_size is > sizeof(u32) we've got problems */ 783 status = efi_thunk(set_variable, phys_name, phys_vendor, 784 attr, data_size, phys_data); 785 786 return status; 787 } 788 789 static efi_status_t 790 efi_thunk_get_next_variable(unsigned long *name_size, 791 efi_char16_t *name, 792 efi_guid_t *vendor) 793 { 794 efi_status_t status; 795 u32 phys_name_size, phys_name, phys_vendor; 796 797 phys_name_size = virt_to_phys_or_null(name_size); 798 phys_vendor = virt_to_phys_or_null(vendor); 799 phys_name = virt_to_phys_or_null_size(name, *name_size); 800 801 status = efi_thunk(get_next_variable, phys_name_size, 802 phys_name, phys_vendor); 803 804 return status; 805 } 806 807 static efi_status_t 808 efi_thunk_get_next_high_mono_count(u32 *count) 809 { 810 efi_status_t status; 811 u32 phys_count; 812 813 phys_count = virt_to_phys_or_null(count); 814 status = efi_thunk(get_next_high_mono_count, phys_count); 815 816 return status; 817 } 818 819 static void 820 efi_thunk_reset_system(int reset_type, efi_status_t status, 821 unsigned long data_size, efi_char16_t *data) 822 { 823 u32 phys_data; 824 825 phys_data = virt_to_phys_or_null_size(data, data_size); 826 827 efi_thunk(reset_system, reset_type, status, data_size, phys_data); 828 } 829 830 static efi_status_t 831 efi_thunk_update_capsule(efi_capsule_header_t **capsules, 832 unsigned long count, unsigned long sg_list) 833 { 834 /* 835 * To properly support this function we would need to repackage 836 * 'capsules' because the firmware doesn't understand 64-bit 837 * pointers. 838 */ 839 return EFI_UNSUPPORTED; 840 } 841 842 static efi_status_t 843 efi_thunk_query_variable_info(u32 attr, u64 *storage_space, 844 u64 *remaining_space, 845 u64 *max_variable_size) 846 { 847 efi_status_t status; 848 u32 phys_storage, phys_remaining, phys_max; 849 850 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 851 return EFI_UNSUPPORTED; 852 853 phys_storage = virt_to_phys_or_null(storage_space); 854 phys_remaining = virt_to_phys_or_null(remaining_space); 855 phys_max = virt_to_phys_or_null(max_variable_size); 856 857 status = efi_thunk(query_variable_info, attr, phys_storage, 858 phys_remaining, phys_max); 859 860 return status; 861 } 862 863 static efi_status_t 864 efi_thunk_query_capsule_caps(efi_capsule_header_t **capsules, 865 unsigned long count, u64 *max_size, 866 int *reset_type) 867 { 868 /* 869 * To properly support this function we would need to repackage 870 * 'capsules' because the firmware doesn't understand 64-bit 871 * pointers. 872 */ 873 return EFI_UNSUPPORTED; 874 } 875 876 void efi_thunk_runtime_setup(void) 877 { 878 efi.get_time = efi_thunk_get_time; 879 efi.set_time = efi_thunk_set_time; 880 efi.get_wakeup_time = efi_thunk_get_wakeup_time; 881 efi.set_wakeup_time = efi_thunk_set_wakeup_time; 882 efi.get_variable = efi_thunk_get_variable; 883 efi.get_next_variable = efi_thunk_get_next_variable; 884 efi.set_variable = efi_thunk_set_variable; 885 efi.get_next_high_mono_count = efi_thunk_get_next_high_mono_count; 886 efi.reset_system = efi_thunk_reset_system; 887 efi.query_variable_info = efi_thunk_query_variable_info; 888 efi.update_capsule = efi_thunk_update_capsule; 889 efi.query_capsule_caps = efi_thunk_query_capsule_caps; 890 } 891 #endif /* CONFIG_EFI_MIXED */ 892