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