Pileus Git - ~andy/linux/blob - arch/x86/platform/efi/efi.c

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