drivers/firmware/efi/efi.c

   1 /*
   2  * efi.c - EFI subsystem
   3  *
   4  * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
   5  * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
   6  * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
   7  *
   8  * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
   9  * allowing the efivarfs to be mounted or the efivars module to be loaded.
  10  * The existance of /sys/firmware/efi may also be used by userspace to
  11  * determine that the system supports EFI.
  12  *
  13  * This file is released under the GPLv2.
  14  */
  15
  16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  17
  18 #include <linux/kobject.h>
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/device.h>
  22 #include <linux/efi.h>
  23 #include <linux/of.h>
  24 #include <linux/of_fdt.h>
  25 #include <linux/io.h>
  26 #include <linux/platform_device.h>
  27
  28 struct efi __read_mostly efi = {
  29         .mps                    = EFI_INVALID_TABLE_ADDR,
  30         .acpi                   = EFI_INVALID_TABLE_ADDR,
  31         .acpi20                 = EFI_INVALID_TABLE_ADDR,
  32         .smbios                 = EFI_INVALID_TABLE_ADDR,
  33         .smbios3                = EFI_INVALID_TABLE_ADDR,
  34         .sal_systab             = EFI_INVALID_TABLE_ADDR,
  35         .boot_info              = EFI_INVALID_TABLE_ADDR,
  36         .hcdp                   = EFI_INVALID_TABLE_ADDR,
  37         .uga                    = EFI_INVALID_TABLE_ADDR,
  38         .uv_systab              = EFI_INVALID_TABLE_ADDR,
  39         .fw_vendor              = EFI_INVALID_TABLE_ADDR,
  40         .runtime                = EFI_INVALID_TABLE_ADDR,
  41         .config_table           = EFI_INVALID_TABLE_ADDR,
  42         .esrt                   = EFI_INVALID_TABLE_ADDR,
  43         .properties_table       = EFI_INVALID_TABLE_ADDR,
  44 };
  45 EXPORT_SYMBOL(efi);
  46
  47 static bool disable_runtime;
  48 static int __init setup_noefi(char *arg)
  49 {
  50         disable_runtime = true;
  51         return 0;
  52 }
  53 early_param("noefi", setup_noefi);
  54
  55 bool efi_runtime_disabled(void)
  56 {
  57         return disable_runtime;
  58 }
  59
  60 static int __init parse_efi_cmdline(char *str)
  61 {
  62         if (!str) {
  63                 pr_warn("need at least one option\n");
  64                 return -EINVAL;
  65         }
  66
  67         if (parse_option_str(str, "debug"))
  68                 set_bit(EFI_DBG, &efi.flags);
  69
  70         if (parse_option_str(str, "noruntime"))
  71                 disable_runtime = true;
  72
  73         return 0;
  74 }
  75 early_param("efi", parse_efi_cmdline);
  76
  77 struct kobject *efi_kobj;
  78
  79 /*
  80  * Let's not leave out systab information that snuck into
  81  * the efivars driver
  82  */
  83 static ssize_t systab_show(struct kobject *kobj,
  84                            struct kobj_attribute *attr, char *buf)
  85 {
  86         char *str = buf;
  87
  88         if (!kobj || !buf)
  89                 return -EINVAL;
  90
  91         if (efi.mps != EFI_INVALID_TABLE_ADDR)
  92                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
  93         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
  94                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
  95         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
  96                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
  97         /*
  98          * If both SMBIOS and SMBIOS3 entry points are implemented, the
  99          * SMBIOS3 entry point shall be preferred, so we list it first to
 100          * let applications stop parsing after the first match.
 101          */
 102         if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
 103                 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
 104         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
 105                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
 106         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
 107                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
 108         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
 109                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
 110         if (efi.uga != EFI_INVALID_TABLE_ADDR)
 111                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
 112
 113         return str - buf;
 114 }
 115
 116 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400);
 117
 118 #define EFI_FIELD(var) efi.var
 119
 120 #define EFI_ATTR_SHOW(name) \
 121 static ssize_t name##_show(struct kobject *kobj, \
 122                                 struct kobj_attribute *attr, char *buf) \
 123 { \
 124         return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
 125 }
 126
 127 EFI_ATTR_SHOW(fw_vendor);
 128 EFI_ATTR_SHOW(runtime);
 129 EFI_ATTR_SHOW(config_table);
 130
 131 static ssize_t fw_platform_size_show(struct kobject *kobj,
 132                                      struct kobj_attribute *attr, char *buf)
 133 {
 134         return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
 135 }
 136
 137 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
 138 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
 139 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
 140 static struct kobj_attribute efi_attr_fw_platform_size =
 141         __ATTR_RO(fw_platform_size);
 142
 143 static struct attribute *efi_subsys_attrs[] = {
 144         &efi_attr_systab.attr,
 145         &efi_attr_fw_vendor.attr,
 146         &efi_attr_runtime.attr,
 147         &efi_attr_config_table.attr,
 148         &efi_attr_fw_platform_size.attr,
 149         NULL,
 150 };
 151
 152 static umode_t efi_attr_is_visible(struct kobject *kobj,
 153                                    struct attribute *attr, int n)
 154 {
 155         if (attr == &efi_attr_fw_vendor.attr) {
 156                 if (efi_enabled(EFI_PARAVIRT) ||
 157                                 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
 158                         return 0;
 159         } else if (attr == &efi_attr_runtime.attr) {
 160                 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
 161                         return 0;
 162         } else if (attr == &efi_attr_config_table.attr) {
 163                 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
 164                         return 0;
 165         }
 166
 167         return attr->mode;
 168 }
 169
 170 static struct attribute_group efi_subsys_attr_group = {
 171         .attrs = efi_subsys_attrs,
 172         .is_visible = efi_attr_is_visible,
 173 };
 174
 175 static struct efivars generic_efivars;
 176 static struct efivar_operations generic_ops;
 177
 178 static int generic_ops_register(void)
 179 {
 180         generic_ops.get_variable = efi.get_variable;
 181         generic_ops.set_variable = efi.set_variable;
 182         generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
 183         generic_ops.get_next_variable = efi.get_next_variable;
 184         generic_ops.query_variable_store = efi_query_variable_store;
 185
 186         return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
 187 }
 188
 189 static void generic_ops_unregister(void)
 190 {
 191         efivars_unregister(&generic_efivars);
 192 }
 193
 194 /*
 195  * We register the efi subsystem with the firmware subsystem and the
 196  * efivars subsystem with the efi subsystem, if the system was booted with
 197  * EFI.
 198  */
 199 static int __init efisubsys_init(void)
 200 {
 201         int error;
 202
 203         if (!efi_enabled(EFI_BOOT))
 204                 return 0;
 205
 206         /* We register the efi directory at /sys/firmware/efi */
 207         efi_kobj = kobject_create_and_add("efi", firmware_kobj);
 208         if (!efi_kobj) {
 209                 pr_err("efi: Firmware registration failed.\n");
 210                 return -ENOMEM;
 211         }
 212
 213         error = generic_ops_register();
 214         if (error)
 215                 goto err_put;
 216
 217         error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
 218         if (error) {
 219                 pr_err("efi: Sysfs attribute export failed with error %d.\n",
 220                        error);
 221                 goto err_unregister;
 222         }
 223
 224         error = efi_runtime_map_init(efi_kobj);
 225         if (error)
 226                 goto err_remove_group;
 227
 228         /* and the standard mountpoint for efivarfs */
 229         error = sysfs_create_mount_point(efi_kobj, "efivars");
 230         if (error) {
 231                 pr_err("efivars: Subsystem registration failed.\n");
 232                 goto err_remove_group;
 233         }
 234
 235         return 0;
 236
 237 err_remove_group:
 238         sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
 239 err_unregister:
 240         generic_ops_unregister();
 241 err_put:
 242         kobject_put(efi_kobj);
 243         return error;
 244 }
 245
 246 subsys_initcall(efisubsys_init);
 247
 248 /*
 249  * Find the efi memory descriptor for a given physical address.  Given a
 250  * physicall address, determine if it exists within an EFI Memory Map entry,
 251  * and if so, populate the supplied memory descriptor with the appropriate
 252  * data.
 253  */
 254 int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
 255 {
 256         struct efi_memory_map *map = efi.memmap;
 257         phys_addr_t p, e;
 258
 259         if (!efi_enabled(EFI_MEMMAP)) {
 260                 pr_err_once("EFI_MEMMAP is not enabled.\n");
 261                 return -EINVAL;
 262         }
 263
 264         if (!map) {
 265                 pr_err_once("efi.memmap is not set.\n");
 266                 return -EINVAL;
 267         }
 268         if (!out_md) {
 269                 pr_err_once("out_md is null.\n");
 270                 return -EINVAL;
 271         }
 272         if (WARN_ON_ONCE(!map->phys_map))
 273                 return -EINVAL;
 274         if (WARN_ON_ONCE(map->nr_map == 0) || WARN_ON_ONCE(map->desc_size == 0))
 275                 return -EINVAL;
 276
 277         e = map->phys_map + map->nr_map * map->desc_size;
 278         for (p = map->phys_map; p < e; p += map->desc_size) {
 279                 efi_memory_desc_t *md;
 280                 u64 size;
 281                 u64 end;
 282
 283                 /*
 284                  * If a driver calls this after efi_free_boot_services,
 285                  * ->map will be NULL, and the target may also not be mapped.
 286                  * So just always get our own virtual map on the CPU.
 287                  *
 288                  */
 289                 md = early_memremap(p, sizeof (*md));
 290                 if (!md) {
 291                         pr_err_once("early_memremap(%pa, %zu) failed.\n",
 292                                     &p, sizeof (*md));
 293                         return -ENOMEM;
 294                 }
 295
 296                 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
 297                     md->type != EFI_BOOT_SERVICES_DATA &&
 298                     md->type != EFI_RUNTIME_SERVICES_DATA) {
 299                         early_memunmap(md, sizeof (*md));
 300                         continue;
 301                 }
 302
 303                 size = md->num_pages << EFI_PAGE_SHIFT;
 304                 end = md->phys_addr + size;
 305                 if (phys_addr >= md->phys_addr && phys_addr < end) {
 306                         memcpy(out_md, md, sizeof(*out_md));
 307                         early_memunmap(md, sizeof (*md));
 308                         return 0;
 309                 }
 310
 311                 early_memunmap(md, sizeof (*md));
 312         }
 313         pr_err_once("requested map not found.\n");
 314         return -ENOENT;
 315 }
 316
 317 /*
 318  * Calculate the highest address of an efi memory descriptor.
 319  */
 320 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
 321 {
 322         u64 size = md->num_pages << EFI_PAGE_SHIFT;
 323         u64 end = md->phys_addr + size;
 324         return end;
 325 }
 326
 327 static __initdata efi_config_table_type_t common_tables[] = {
 328         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
 329         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
 330         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
 331         {MPS_TABLE_GUID, "MPS", &efi.mps},
 332         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
 333         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
 334         {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
 335         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
 336         {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
 337         {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
 338         {NULL_GUID, NULL, NULL},
 339 };
 340
 341 static __init int match_config_table(efi_guid_t *guid,
 342                                      unsigned long table,
 343                                      efi_config_table_type_t *table_types)
 344 {
 345         int i;
 346
 347         if (table_types) {
 348                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
 349                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
 350                                 *(table_types[i].ptr) = table;
 351                                 pr_cont(" %s=0x%lx ",
 352                                         table_types[i].name, table);
 353                                 return 1;
 354                         }
 355                 }
 356         }
 357
 358         return 0;
 359 }
 360
 361 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
 362                                    efi_config_table_type_t *arch_tables)
 363 {
 364         void *tablep;
 365         int i;
 366
 367         tablep = config_tables;
 368         pr_info("");
 369         for (i = 0; i < count; i++) {
 370                 efi_guid_t guid;
 371                 unsigned long table;
 372
 373                 if (efi_enabled(EFI_64BIT)) {
 374                         u64 table64;
 375                         guid = ((efi_config_table_64_t *)tablep)->guid;
 376                         table64 = ((efi_config_table_64_t *)tablep)->table;
 377                         table = table64;
 378 #ifndef CONFIG_64BIT
 379                         if (table64 >> 32) {
 380                                 pr_cont("\n");
 381                                 pr_err("Table located above 4GB, disabling EFI.\n");
 382                                 return -EINVAL;
 383                         }
 384 #endif
 385                 } else {
 386                         guid = ((efi_config_table_32_t *)tablep)->guid;
 387                         table = ((efi_config_table_32_t *)tablep)->table;
 388                 }
 389
 390                 if (!match_config_table(&guid, table, common_tables))
 391                         match_config_table(&guid, table, arch_tables);
 392
 393                 tablep += sz;
 394         }
 395         pr_cont("\n");
 396         set_bit(EFI_CONFIG_TABLES, &efi.flags);
 397
 398         /* Parse the EFI Properties table if it exists */
 399         if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
 400                 efi_properties_table_t *tbl;
 401
 402                 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
 403                 if (tbl == NULL) {
 404                         pr_err("Could not map Properties table!\n");
 405                         return -ENOMEM;
 406                 }
 407
 408                 if (tbl->memory_protection_attribute &
 409                     EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
 410                         set_bit(EFI_NX_PE_DATA, &efi.flags);
 411
 412                 early_memunmap(tbl, sizeof(*tbl));
 413         }
 414
 415         return 0;
 416 }
 417
 418 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 419 {
 420         void *config_tables;
 421         int sz, ret;
 422
 423         if (efi_enabled(EFI_64BIT))
 424                 sz = sizeof(efi_config_table_64_t);
 425         else
 426                 sz = sizeof(efi_config_table_32_t);
 427
 428         /*
 429          * Let's see what config tables the firmware passed to us.
 430          */
 431         config_tables = early_memremap(efi.systab->tables,
 432                                        efi.systab->nr_tables * sz);
 433         if (config_tables == NULL) {
 434                 pr_err("Could not map Configuration table!\n");
 435                 return -ENOMEM;
 436         }
 437
 438         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
 439                                       arch_tables);
 440
 441         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 442         return ret;
 443 }
 444
 445 #ifdef CONFIG_EFI_VARS_MODULE
 446 static int __init efi_load_efivars(void)
 447 {
 448         struct platform_device *pdev;
 449
 450         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 451                 return 0;
 452
 453         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 454         return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
 455 }
 456 device_initcall(efi_load_efivars);
 457 #endif
 458
 459 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 460
 461 #define UEFI_PARAM(name, prop, field)                      \
 462         {                                                  \
 463                 { name },                                  \
 464                 { prop },                                  \
 465                 offsetof(struct efi_fdt_params, field),    \
 466                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 467         }
 468
 469 static __initdata struct {
 470         const char name[32];
 471         const char propname[32];
 472         int offset;
 473         int size;
 474 } dt_params[] = {
 475         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 476         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 477         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 478         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 479         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 480 };
 481
 482 struct param_info {
 483         int found;
 484         void *params;
 485 };
 486
 487 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 488                                        int depth, void *data)
 489 {
 490         struct param_info *info = data;
 491         const void *prop;
 492         void *dest;
 493         u64 val;
 494         int i, len;
 495
 496         if (depth != 1 || strcmp(uname, "chosen") != 0)
 497                 return 0;
 498
 499         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 500                 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len);
 501                 if (!prop)
 502                         return 0;
 503                 dest = info->params + dt_params[i].offset;
 504                 info->found++;
 505
 506                 val = of_read_number(prop, len / sizeof(u32));
 507
 508                 if (dt_params[i].size == sizeof(u32))
 509                         *(u32 *)dest = val;
 510                 else
 511                         *(u64 *)dest = val;
 512
 513                 if (efi_enabled(EFI_DBG))
 514                         pr_info("  %s: 0x%0*llx\n", dt_params[i].name,
 515                                 dt_params[i].size * 2, val);
 516         }
 517         return 1;
 518 }
 519
 520 int __init efi_get_fdt_params(struct efi_fdt_params *params)
 521 {
 522         struct param_info info;
 523         int ret;
 524
 525         pr_info("Getting EFI parameters from FDT:\n");
 526
 527         info.found = 0;
 528         info.params = params;
 529
 530         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 531         if (!info.found)
 532                 pr_info("UEFI not found.\n");
 533         else if (!ret)
 534                 pr_err("Can't find '%s' in device tree!\n",
 535                        dt_params[info.found].name);
 536
 537         return ret;
 538 }
 539 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 540
 541 static __initdata char memory_type_name[][20] = {
 542         "Reserved",
 543         "Loader Code",
 544         "Loader Data",
 545         "Boot Code",
 546         "Boot Data",
 547         "Runtime Code",
 548         "Runtime Data",
 549         "Conventional Memory",
 550         "Unusable Memory",
 551         "ACPI Reclaim Memory",
 552         "ACPI Memory NVS",
 553         "Memory Mapped I/O",
 554         "MMIO Port Space",
 555         "PAL Code"
 556 };
 557
 558 char * __init efi_md_typeattr_format(char *buf, size_t size,
 559                                      const efi_memory_desc_t *md)
 560 {
 561         char *pos;
 562         int type_len;
 563         u64 attr;
 564
 565         pos = buf;
 566         if (md->type >= ARRAY_SIZE(memory_type_name))
 567                 type_len = snprintf(pos, size, "[type=%u", md->type);
 568         else
 569                 type_len = snprintf(pos, size, "[%-*s",
 570                                     (int)(sizeof(memory_type_name[0]) - 1),
 571                                     memory_type_name[md->type]);
 572         if (type_len >= size)
 573                 return buf;
 574
 575         pos += type_len;
 576         size -= type_len;
 577
 578         attr = md->attribute;
 579         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 580                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
 581                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
 582                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
 583                 snprintf(pos, size, "|attr=0x%016llx]",
 584                          (unsigned long long)attr);
 585         else
 586                 snprintf(pos, size, "|%3s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 587                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 588                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
 589                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 590                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 591                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 592                          attr & EFI_MEMORY_RO      ? "RO"  : "",
 593                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 594                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 595                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 596                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 597                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 598         return buf;
 599 }
 600
 601 /*
 602  * efi_mem_attributes - lookup memmap attributes for physical address
 603  * @phys_addr: the physical address to lookup
 604  *
 605  * Search in the EFI memory map for the region covering
 606  * @phys_addr. Returns the EFI memory attributes if the region
 607  * was found in the memory map, 0 otherwise.
 608  *
 609  * Despite being marked __weak, most architectures should *not*
 610  * override this function. It is __weak solely for the benefit
 611  * of ia64 which has a funky EFI memory map that doesn't work
 612  * the same way as other architectures.
 613  */
 614 u64 __weak efi_mem_attributes(unsigned long phys_addr)
 615 {
 616         struct efi_memory_map *map;
 617         efi_memory_desc_t *md;
 618         void *p;
 619
 620         if (!efi_enabled(EFI_MEMMAP))
 621                 return 0;
 622
 623         map = efi.memmap;
 624         for (p = map->map; p < map->map_end; p += map->desc_size) {
 625                 md = p;
 626                 if ((md->phys_addr <= phys_addr) &&
 627                     (phys_addr < (md->phys_addr +
 628                     (md->num_pages << EFI_PAGE_SHIFT))))
 629                         return md->attribute;
 630         }
 631         return 0;
 632 }