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