efi.c 25.4 KB
Newer Older
Huang, Ying's avatar
Huang, Ying committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
 * Common EFI (Extensible Firmware Interface) support functions
 * Based on Extensible Firmware Interface Specification version 1.0
 *
 * Copyright (C) 1999 VA Linux Systems
 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
 * Copyright (C) 1999-2002 Hewlett-Packard Co.
 *	David Mosberger-Tang <davidm@hpl.hp.com>
 *	Stephane Eranian <eranian@hpl.hp.com>
 * Copyright (C) 2005-2008 Intel Co.
 *	Fenghua Yu <fenghua.yu@intel.com>
 *	Bibo Mao <bibo.mao@intel.com>
 *	Chandramouli Narayanan <mouli@linux.intel.com>
 *	Huang Ying <ying.huang@intel.com>
 *
 * Copied from efi_32.c to eliminate the duplicated code between EFI
 * 32/64 support code. --ying 2007-10-26
 *
 * All EFI Runtime Services are not implemented yet as EFI only
 * supports physical mode addressing on SoftSDV. This is to be fixed
 * in a future version.  --drummond 1999-07-20
 *
 * Implemented EFI runtime services and virtual mode calls.  --davidm
 *
 * Goutham Rao: <goutham.rao@intel.com>
 *	Skip non-WB memory and ignore empty memory ranges.
 */

29
30
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Huang, Ying's avatar
Huang, Ying committed
31
32
33
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/efi.h>
34
#include <linux/efi-bgrt.h>
35
#include <linux/export.h>
Huang, Ying's avatar
Huang, Ying committed
36
#include <linux/bootmem.h>
37
#include <linux/memblock.h>
Huang, Ying's avatar
Huang, Ying committed
38
39
40
41
42
43
44
45
46
47
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/time.h>
#include <linux/io.h>
#include <linux/reboot.h>
#include <linux/bcd.h>

#include <asm/setup.h>
#include <asm/efi.h>
#include <asm/time.h>
48
49
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
50
#include <asm/x86_init.h>
Huang, Ying's avatar
Huang, Ying committed
51
52
53

#define EFI_DEBUG	1

54
55
56
57
58
59
60
61
62
63
64
struct efi __read_mostly efi = {
	.mps        = EFI_INVALID_TABLE_ADDR,
	.acpi       = EFI_INVALID_TABLE_ADDR,
	.acpi20     = EFI_INVALID_TABLE_ADDR,
	.smbios     = EFI_INVALID_TABLE_ADDR,
	.sal_systab = EFI_INVALID_TABLE_ADDR,
	.boot_info  = EFI_INVALID_TABLE_ADDR,
	.hcdp       = EFI_INVALID_TABLE_ADDR,
	.uga        = EFI_INVALID_TABLE_ADDR,
	.uv_systab  = EFI_INVALID_TABLE_ADDR,
};
Huang, Ying's avatar
Huang, Ying committed
65
66
67
68
EXPORT_SYMBOL(efi);

struct efi_memory_map memmap;

Harvey Harrison's avatar
Harvey Harrison committed
69
static struct efi efi_phys __initdata;
Huang, Ying's avatar
Huang, Ying committed
70
71
static efi_system_table_t efi_systab __initdata;

72
73
static inline bool efi_is_native(void)
{
74
75
76
77
78
79
80
81
82
83
84
	return IS_ENABLED(CONFIG_X86_64) == efi_enabled(EFI_64BIT);
}

unsigned long x86_efi_facility;

/*
 * Returns 1 if 'facility' is enabled, 0 otherwise.
 */
int efi_enabled(int facility)
{
	return test_bit(facility, &x86_efi_facility) != 0;
85
}
86
EXPORT_SYMBOL(efi_enabled);
87

88
89
static int __init setup_noefi(char *arg)
{
90
	clear_bit(EFI_RUNTIME_SERVICES, &x86_efi_facility);
91
92
93
94
	return 0;
}
early_param("noefi", setup_noefi);

95
96
97
98
99
100
101
102
103
104
105
int add_efi_memmap;
EXPORT_SYMBOL(add_efi_memmap);

static int __init setup_add_efi_memmap(char *arg)
{
	add_efi_memmap = 1;
	return 0;
}
early_param("add_efi_memmap", setup_add_efi_memmap);


Huang, Ying's avatar
Huang, Ying committed
106
107
static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
{
108
109
110
111
112
113
114
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt2(get_time, tm, tc);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
115
116
117
118
}

static efi_status_t virt_efi_set_time(efi_time_t *tm)
{
119
120
121
122
123
124
125
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt1(set_time, tm);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
126
127
128
129
130
131
}

static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
					     efi_bool_t *pending,
					     efi_time_t *tm)
{
132
133
134
135
136
137
138
139
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt3(get_wakeup_time,
				enabled, pending, tm);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
140
141
142
143
}

static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
{
144
145
146
147
148
149
150
151
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	status = efi_call_virt2(set_wakeup_time,
				enabled, tm);
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
Huang, Ying's avatar
Huang, Ying committed
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
}

static efi_status_t virt_efi_get_variable(efi_char16_t *name,
					  efi_guid_t *vendor,
					  u32 *attr,
					  unsigned long *data_size,
					  void *data)
{
	return efi_call_virt5(get_variable,
			      name, vendor, attr,
			      data_size, data);
}

static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
					       efi_char16_t *name,
					       efi_guid_t *vendor)
{
	return efi_call_virt3(get_next_variable,
			      name_size, name, vendor);
}

static efi_status_t virt_efi_set_variable(efi_char16_t *name,
					  efi_guid_t *vendor,
175
					  u32 attr,
Huang, Ying's avatar
Huang, Ying committed
176
177
178
179
180
181
182
183
					  unsigned long data_size,
					  void *data)
{
	return efi_call_virt5(set_variable,
			      name, vendor, attr,
			      data_size, data);
}

184
185
186
187
188
189
190
191
192
193
194
195
static efi_status_t virt_efi_query_variable_info(u32 attr,
						 u64 *storage_space,
						 u64 *remaining_space,
						 u64 *max_variable_size)
{
	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

	return efi_call_virt4(query_variable_info, attr, storage_space,
			      remaining_space, max_variable_size);
}

Huang, Ying's avatar
Huang, Ying committed
196
197
198
199
200
201
202
203
204
205
206
207
208
209
static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
{
	return efi_call_virt1(get_next_high_mono_count, count);
}

static void virt_efi_reset_system(int reset_type,
				  efi_status_t status,
				  unsigned long data_size,
				  efi_char16_t *data)
{
	efi_call_virt4(reset_system, reset_type, status,
		       data_size, data);
}

210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
					    unsigned long count,
					    unsigned long sg_list)
{
	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

	return efi_call_virt3(update_capsule, capsules, count, sg_list);
}

static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
						unsigned long count,
						u64 *max_size,
						int *reset_type)
{
	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
		return EFI_UNSUPPORTED;

	return efi_call_virt4(query_capsule_caps, capsules, count, max_size,
			      reset_type);
}

Huang, Ying's avatar
Huang, Ying committed
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
static efi_status_t __init phys_efi_set_virtual_address_map(
	unsigned long memory_map_size,
	unsigned long descriptor_size,
	u32 descriptor_version,
	efi_memory_desc_t *virtual_map)
{
	efi_status_t status;

	efi_call_phys_prelog();
	status = efi_call_phys4(efi_phys.set_virtual_address_map,
				memory_map_size, descriptor_size,
				descriptor_version, virtual_map);
	efi_call_phys_epilog();
	return status;
}

248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
static efi_status_t __init phys_efi_get_time(efi_time_t *tm,
					     efi_time_cap_t *tc)
{
	unsigned long flags;
	efi_status_t status;

	spin_lock_irqsave(&rtc_lock, flags);
	efi_call_phys_prelog();
	status = efi_call_phys2(efi_phys.get_time, virt_to_phys(tm),
				virt_to_phys(tc));
	efi_call_phys_epilog();
	spin_unlock_irqrestore(&rtc_lock, flags);
	return status;
}

int efi_set_rtc_mmss(unsigned long nowtime)
Huang, Ying's avatar
Huang, Ying committed
264
265
266
267
268
269
270
271
{
	int real_seconds, real_minutes;
	efi_status_t 	status;
	efi_time_t 	eft;
	efi_time_cap_t 	cap;

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS) {
272
		pr_err("Oops: efitime: can't read time!\n");
Huang, Ying's avatar
Huang, Ying committed
273
274
275
276
277
278
279
280
281
282
283
284
285
		return -1;
	}

	real_seconds = nowtime % 60;
	real_minutes = nowtime / 60;
	if (((abs(real_minutes - eft.minute) + 15)/30) & 1)
		real_minutes += 30;
	real_minutes %= 60;
	eft.minute = real_minutes;
	eft.second = real_seconds;

	status = efi.set_time(&eft);
	if (status != EFI_SUCCESS) {
286
		pr_err("Oops: efitime: can't write time!\n");
Huang, Ying's avatar
Huang, Ying committed
287
288
289
290
291
		return -1;
	}
	return 0;
}

292
unsigned long efi_get_time(void)
Huang, Ying's avatar
Huang, Ying committed
293
294
295
296
297
298
299
{
	efi_status_t status;
	efi_time_t eft;
	efi_time_cap_t cap;

	status = efi.get_time(&eft, &cap);
	if (status != EFI_SUCCESS)
300
		pr_err("Oops: efitime: can't read time!\n");
Huang, Ying's avatar
Huang, Ying committed
301
302
303
304
305

	return mktime(eft.year, eft.month, eft.day, eft.hour,
		      eft.minute, eft.second);
}

306
307
308
309
310
311
/*
 * Tell the kernel about the EFI memory map.  This might include
 * more than the max 128 entries that can fit in the e820 legacy
 * (zeropage) memory map.
 */

312
static void __init do_add_efi_memmap(void)
313
314
315
316
317
318
319
320
321
{
	void *p;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
		unsigned long long start = md->phys_addr;
		unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
		int e820_type;

322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
		switch (md->type) {
		case EFI_LOADER_CODE:
		case EFI_LOADER_DATA:
		case EFI_BOOT_SERVICES_CODE:
		case EFI_BOOT_SERVICES_DATA:
		case EFI_CONVENTIONAL_MEMORY:
			if (md->attribute & EFI_MEMORY_WB)
				e820_type = E820_RAM;
			else
				e820_type = E820_RESERVED;
			break;
		case EFI_ACPI_RECLAIM_MEMORY:
			e820_type = E820_ACPI;
			break;
		case EFI_ACPI_MEMORY_NVS:
			e820_type = E820_NVS;
			break;
		case EFI_UNUSABLE_MEMORY:
			e820_type = E820_UNUSABLE;
			break;
		default:
			/*
			 * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE
			 * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
			 * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
			 */
348
			e820_type = E820_RESERVED;
349
350
			break;
		}
351
		e820_add_region(start, size, e820_type);
352
353
354
355
	}
	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
}

356
int __init efi_memblock_x86_reserve_range(void)
357
358
359
{
	unsigned long pmap;

360
#ifdef CONFIG_X86_32
361
362
363
364
365
	/* Can't handle data above 4GB at this time */
	if (boot_params.efi_info.efi_memmap_hi) {
		pr_err("Memory map is above 4GB, disabling EFI.\n");
		return -EINVAL;
	}
366
	pmap = boot_params.efi_info.efi_memmap;
367
368
369
#else
	pmap = (boot_params.efi_info.efi_memmap |
		((__u64)boot_params.efi_info.efi_memmap_hi<<32));
370
371
372
373
374
375
#endif
	memmap.phys_map = (void *)pmap;
	memmap.nr_map = boot_params.efi_info.efi_memmap_size /
		boot_params.efi_info.efi_memdesc_size;
	memmap.desc_version = boot_params.efi_info.efi_memdesc_version;
	memmap.desc_size = boot_params.efi_info.efi_memdesc_size;
376
	memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
377
378

	return 0;
379
380
}

Huang, Ying's avatar
Huang, Ying committed
381
382
383
384
385
386
387
388
389
390
391
#if EFI_DEBUG
static void __init print_efi_memmap(void)
{
	efi_memory_desc_t *md;
	void *p;
	int i;

	for (p = memmap.map, i = 0;
	     p < memmap.map_end;
	     p += memmap.desc_size, i++) {
		md = p;
392
		pr_info("mem%02u: type=%u, attr=0x%llx, "
Huang, Ying's avatar
Huang, Ying committed
393
394
395
396
397
398
399
400
			"range=[0x%016llx-0x%016llx) (%lluMB)\n",
			i, md->type, md->attribute, md->phys_addr,
			md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
			(md->num_pages >> (20 - EFI_PAGE_SHIFT)));
	}
}
#endif  /*  EFI_DEBUG  */

401
402
403
404
405
406
void __init efi_reserve_boot_services(void)
{
	void *p;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
407
408
		u64 start = md->phys_addr;
		u64 size = md->num_pages << EFI_PAGE_SHIFT;
409
410
411
412

		if (md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;
413
414
415
416
417
418
419
420
421
		/* Only reserve where possible:
		 * - Not within any already allocated areas
		 * - Not over any memory area (really needed, if above?)
		 * - Not within any part of the kernel
		 * - Not the bios reserved area
		*/
		if ((start+size >= virt_to_phys(_text)
				&& start <= virt_to_phys(_end)) ||
			!e820_all_mapped(start, start+size, E820_RAM) ||
422
			memblock_is_region_reserved(start, size)) {
423
424
			/* Could not reserve, skip it */
			md->num_pages = 0;
425
			memblock_dbg("Could not reserve boot range "
426
427
428
					"[0x%010llx-0x%010llx]\n",
						start, start+size-1);
		} else
429
			memblock_reserve(start, size);
430
431
432
	}
}

433
void __init efi_unmap_memmap(void)
434
{
435
	clear_bit(EFI_MEMMAP, &x86_efi_facility);
436
437
438
439
440
441
442
	if (memmap.map) {
		early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
		memmap.map = NULL;
	}
}

void __init efi_free_boot_services(void)
443
444
445
{
	void *p;

446
	if (!efi_is_native())
447
448
		return;

449
450
451
452
453
454
455
456
457
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
		unsigned long long start = md->phys_addr;
		unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;

		if (md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;

458
459
460
461
		/* Could not reserve boot area */
		if (!size)
			continue;

462
463
		free_bootmem_late(start, size);
	}
464
465

	efi_unmap_memmap();
466
467
}

468
static int __init efi_systab_init(void *phys)
Huang, Ying's avatar
Huang, Ying committed
469
{
470
	if (efi_enabled(EFI_64BIT)) {
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
		efi_system_table_64_t *systab64;
		u64 tmp = 0;

		systab64 = early_ioremap((unsigned long)phys,
					 sizeof(*systab64));
		if (systab64 == NULL) {
			pr_err("Couldn't map the system table!\n");
			return -ENOMEM;
		}

		efi_systab.hdr = systab64->hdr;
		efi_systab.fw_vendor = systab64->fw_vendor;
		tmp |= systab64->fw_vendor;
		efi_systab.fw_revision = systab64->fw_revision;
		efi_systab.con_in_handle = systab64->con_in_handle;
		tmp |= systab64->con_in_handle;
		efi_systab.con_in = systab64->con_in;
		tmp |= systab64->con_in;
		efi_systab.con_out_handle = systab64->con_out_handle;
		tmp |= systab64->con_out_handle;
		efi_systab.con_out = systab64->con_out;
		tmp |= systab64->con_out;
		efi_systab.stderr_handle = systab64->stderr_handle;
		tmp |= systab64->stderr_handle;
		efi_systab.stderr = systab64->stderr;
		tmp |= systab64->stderr;
		efi_systab.runtime = (void *)(unsigned long)systab64->runtime;
		tmp |= systab64->runtime;
		efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
		tmp |= systab64->boottime;
		efi_systab.nr_tables = systab64->nr_tables;
		efi_systab.tables = systab64->tables;
		tmp |= systab64->tables;

		early_iounmap(systab64, sizeof(*systab64));
#ifdef CONFIG_X86_32
		if (tmp >> 32) {
			pr_err("EFI data located above 4GB, disabling EFI.\n");
			return -EINVAL;
		}
#endif
	} else {
		efi_system_table_32_t *systab32;

		systab32 = early_ioremap((unsigned long)phys,
					 sizeof(*systab32));
		if (systab32 == NULL) {
			pr_err("Couldn't map the system table!\n");
			return -ENOMEM;
		}

		efi_systab.hdr = systab32->hdr;
		efi_systab.fw_vendor = systab32->fw_vendor;
		efi_systab.fw_revision = systab32->fw_revision;
		efi_systab.con_in_handle = systab32->con_in_handle;
		efi_systab.con_in = systab32->con_in;
		efi_systab.con_out_handle = systab32->con_out_handle;
		efi_systab.con_out = systab32->con_out;
		efi_systab.stderr_handle = systab32->stderr_handle;
		efi_systab.stderr = systab32->stderr;
		efi_systab.runtime = (void *)(unsigned long)systab32->runtime;
		efi_systab.boottime = (void *)(unsigned long)systab32->boottime;
		efi_systab.nr_tables = systab32->nr_tables;
		efi_systab.tables = systab32->tables;

		early_iounmap(systab32, sizeof(*systab32));
537
	}
538

Huang, Ying's avatar
Huang, Ying committed
539
540
541
542
543
	efi.systab = &efi_systab;

	/*
	 * Verify the EFI Table
	 */
544
	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
545
		pr_err("System table signature incorrect!\n");
546
547
		return -EINVAL;
	}
Huang, Ying's avatar
Huang, Ying committed
548
	if ((efi.systab->hdr.revision >> 16) == 0)
549
		pr_err("Warning: System table version "
Huang, Ying's avatar
Huang, Ying committed
550
551
552
		       "%d.%02d, expected 1.00 or greater!\n",
		       efi.systab->hdr.revision >> 16,
		       efi.systab->hdr.revision & 0xffff);
553
554

	return 0;
555
}
Huang, Ying's avatar
Huang, Ying committed
556

557
static int __init efi_config_init(u64 tables, int nr_tables)
558
{
559
560
561
	void *config_tables, *tablep;
	int i, sz;

562
	if (efi_enabled(EFI_64BIT))
563
564
565
		sz = sizeof(efi_config_table_64_t);
	else
		sz = sizeof(efi_config_table_32_t);
Huang, Ying's avatar
Huang, Ying committed
566
567
568
569

	/*
	 * Let's see what config tables the firmware passed to us.
	 */
570
	config_tables = early_ioremap(tables, nr_tables * sz);
571
	if (config_tables == NULL) {
572
		pr_err("Could not map Configuration table!\n");
573
574
		return -ENOMEM;
	}
Huang, Ying's avatar
Huang, Ying committed
575

576
	tablep = config_tables;
577
	pr_info("");
Huang, Ying's avatar
Huang, Ying committed
578
	for (i = 0; i < efi.systab->nr_tables; i++) {
579
580
581
		efi_guid_t guid;
		unsigned long table;

582
		if (efi_enabled(EFI_64BIT)) {
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
			u64 table64;
			guid = ((efi_config_table_64_t *)tablep)->guid;
			table64 = ((efi_config_table_64_t *)tablep)->table;
			table = table64;
#ifdef CONFIG_X86_32
			if (table64 >> 32) {
				pr_cont("\n");
				pr_err("Table located above 4GB, disabling EFI.\n");
				early_iounmap(config_tables,
					      efi.systab->nr_tables * sz);
				return -EINVAL;
			}
#endif
		} else {
			guid = ((efi_config_table_32_t *)tablep)->guid;
			table = ((efi_config_table_32_t *)tablep)->table;
		}
600
601
602
603
604
605
606
607
608
609
610
611
		if (!efi_guidcmp(guid, MPS_TABLE_GUID)) {
			efi.mps = table;
			pr_cont(" MPS=0x%lx ", table);
		} else if (!efi_guidcmp(guid, ACPI_20_TABLE_GUID)) {
			efi.acpi20 = table;
			pr_cont(" ACPI 2.0=0x%lx ", table);
		} else if (!efi_guidcmp(guid, ACPI_TABLE_GUID)) {
			efi.acpi = table;
			pr_cont(" ACPI=0x%lx ", table);
		} else if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID)) {
			efi.smbios = table;
			pr_cont(" SMBIOS=0x%lx ", table);
612
#ifdef CONFIG_X86_UV
613
614
615
		} else if (!efi_guidcmp(guid, UV_SYSTEM_TABLE_GUID)) {
			efi.uv_systab = table;
			pr_cont(" UVsystab=0x%lx ", table);
616
#endif
617
618
619
620
621
622
		} else if (!efi_guidcmp(guid, HCDP_TABLE_GUID)) {
			efi.hcdp = table;
			pr_cont(" HCDP=0x%lx ", table);
		} else if (!efi_guidcmp(guid, UGA_IO_PROTOCOL_GUID)) {
			efi.uga = table;
			pr_cont(" UGA=0x%lx ", table);
Huang, Ying's avatar
Huang, Ying committed
623
		}
624
		tablep += sz;
Huang, Ying's avatar
Huang, Ying committed
625
	}
626
	pr_cont("\n");
627
	early_iounmap(config_tables, efi.systab->nr_tables * sz);
628
	return 0;
629
630
}

631
static int __init efi_runtime_init(void)
632
633
{
	efi_runtime_services_t *runtime;
Huang, Ying's avatar
Huang, Ying committed
634
635
636
637
638
639
640

	/*
	 * Check out the runtime services table. We need to map
	 * the runtime services table so that we can grab the physical
	 * address of several of the EFI runtime functions, needed to
	 * set the firmware into virtual mode.
	 */
641
642
	runtime = early_ioremap((unsigned long)efi.systab->runtime,
				sizeof(efi_runtime_services_t));
643
	if (!runtime) {
644
		pr_err("Could not map the runtime service table!\n");
645
646
647
648
		return -ENOMEM;
	}
	/*
	 * We will only need *early* access to the following
649
	 * two EFI runtime services before set_virtual_address_map
650
651
	 * is invoked.
	 */
652
	efi_phys.get_time = (efi_get_time_t *)runtime->get_time;
653
654
655
	efi_phys.set_virtual_address_map =
		(efi_set_virtual_address_map_t *)
		runtime->set_virtual_address_map;
656
657
658
659
660
	/*
	 * Make efi_get_time can be called before entering
	 * virtual mode.
	 */
	efi.get_time = phys_efi_get_time;
661
	early_iounmap(runtime, sizeof(efi_runtime_services_t));
662
663

	return 0;
664
}
Huang, Ying's avatar
Huang, Ying committed
665

666
static int __init efi_memmap_init(void)
667
{
Huang, Ying's avatar
Huang, Ying committed
668
	/* Map the EFI memory map */
669
670
	memmap.map = early_ioremap((unsigned long)memmap.phys_map,
				   memmap.nr_map * memmap.desc_size);
671
	if (memmap.map == NULL) {
672
		pr_err("Could not map the memory map!\n");
673
674
		return -ENOMEM;
	}
Huang, Ying's avatar
Huang, Ying committed
675
	memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
676

677
678
	if (add_efi_memmap)
		do_add_efi_memmap();
679
680

	return 0;
681
682
683
684
685
686
687
688
689
690
}

void __init efi_init(void)
{
	efi_char16_t *c16;
	char vendor[100] = "unknown";
	int i = 0;
	void *tmp;

#ifdef CONFIG_X86_32
691
692
693
694
695
	if (boot_params.efi_info.efi_systab_hi ||
	    boot_params.efi_info.efi_memmap_hi) {
		pr_info("Table located above 4GB, disabling EFI.\n");
		return;
	}
696
697
698
	efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
#else
	efi_phys.systab = (efi_system_table_t *)
699
700
			  (boot_params.efi_info.efi_systab |
			  ((__u64)boot_params.efi_info.efi_systab_hi<<32));
701
702
#endif

703
	if (efi_systab_init(efi_phys.systab))
704
		return;
705
706

	set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility);
707
708
709
710
711
712
713
714
715
716

	/*
	 * Show what we know for posterity
	 */
	c16 = tmp = early_ioremap(efi.systab->fw_vendor, 2);
	if (c16) {
		for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
			vendor[i] = *c16++;
		vendor[i] = '\0';
	} else
717
		pr_err("Could not map the firmware vendor!\n");
718
719
	early_iounmap(tmp, 2);

720
721
722
	pr_info("EFI v%u.%.02u by %s\n",
		efi.systab->hdr.revision >> 16,
		efi.systab->hdr.revision & 0xffff, vendor);
723

724
	if (efi_config_init(efi.systab->tables, efi.systab->nr_tables))
725
		return;
726
727

	set_bit(EFI_CONFIG_TABLES, &x86_efi_facility);
728

729
730
731
732
733
	/*
	 * Note: We currently don't support runtime services on an EFI
	 * that doesn't match the kernel 32/64-bit mode.
	 */

734
	if (!efi_is_native())
735
		pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
736
737
738
739
	else {
		if (efi_runtime_init())
			return;
		set_bit(EFI_RUNTIME_SERVICES, &x86_efi_facility);
740
	}
741

742
	if (efi_memmap_init())
743
		return;
744
745
746

	set_bit(EFI_MEMMAP, &x86_efi_facility);

747
#ifdef CONFIG_X86_32
748
	if (efi_is_native()) {
749
750
751
		x86_platform.get_wallclock = efi_get_time;
		x86_platform.set_wallclock = efi_set_rtc_mmss;
	}
752
#endif
753

Huang, Ying's avatar
Huang, Ying committed
754
755
756
757
758
#if EFI_DEBUG
	print_efi_memmap();
#endif
}

759
760
761
762
763
void __init efi_late_init(void)
{
	efi_bgrt_init();
}

764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
{
	u64 addr, npages;

	addr = md->virt_addr;
	npages = md->num_pages;

	memrange_efi_to_native(&addr, &npages);

	if (executable)
		set_memory_x(addr, npages);
	else
		set_memory_nx(addr, npages);
}

779
780
781
782
783
784
785
786
static void __init runtime_code_page_mkexec(void)
{
	efi_memory_desc_t *md;
	void *p;

	/* Make EFI runtime service code area executable */
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
Huang, Ying's avatar
Huang, Ying committed
787
788
789
790

		if (md->type != EFI_RUNTIME_SERVICES_CODE)
			continue;

791
		efi_set_executable(md, true);
792
793
794
	}
}

795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
/*
 * We can't ioremap data in EFI boot services RAM, because we've already mapped
 * it as RAM.  So, look it up in the existing EFI memory map instead.  Only
 * callable after efi_enter_virtual_mode and before efi_free_boot_services.
 */
void __iomem *efi_lookup_mapped_addr(u64 phys_addr)
{
	void *p;
	if (WARN_ON(!memmap.map))
		return NULL;
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		efi_memory_desc_t *md = p;
		u64 size = md->num_pages << EFI_PAGE_SHIFT;
		u64 end = md->phys_addr + size;
		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
		    md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
			continue;
		if (!md->virt_addr)
			continue;
		if (phys_addr >= md->phys_addr && phys_addr < end) {
			phys_addr += md->virt_addr - md->phys_addr;
			return (__force void __iomem *)(unsigned long)phys_addr;
		}
	}
	return NULL;
}

823
824
825
826
827
828
829
830
831
832
void efi_memory_uc(u64 addr, unsigned long size)
{
	unsigned long page_shift = 1UL << EFI_PAGE_SHIFT;
	u64 npages;

	npages = round_up(size, page_shift) / page_shift;
	memrange_efi_to_native(&addr, &npages);
	set_memory_uc(addr, npages);
}

Huang, Ying's avatar
Huang, Ying committed
833
834
835
836
837
838
839
840
841
842
/*
 * This function will switch the EFI runtime services to virtual mode.
 * Essentially, look through the EFI memmap and map every region that
 * has the runtime attribute bit set in its memory descriptor and update
 * that memory descriptor with the virtual address obtained from ioremap().
 * This enables the runtime services to be called without having to
 * thunk back into physical mode for every invocation.
 */
void __init efi_enter_virtual_mode(void)
{
843
	efi_memory_desc_t *md, *prev_md = NULL;
Huang, Ying's avatar
Huang, Ying committed
844
	efi_status_t status;
Huang, Ying's avatar
Huang, Ying committed
845
	unsigned long size;
846
	u64 end, systab, end_pfn;
847
848
	void *p, *va, *new_memmap = NULL;
	int count = 0;
Huang, Ying's avatar
Huang, Ying committed
849
850

	efi.systab = NULL;
851

852
853
854
855
856
	/*
	 * We don't do virtual mode, since we don't do runtime services, on
	 * non-native EFI
	 */

857
	if (!efi_is_native()) {
858
859
860
		efi_unmap_memmap();
		return;
	}
861

862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
	/* Merge contiguous regions of the same type and attribute */
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		u64 prev_size;
		md = p;

		if (!prev_md) {
			prev_md = md;
			continue;
		}

		if (prev_md->type != md->type ||
		    prev_md->attribute != md->attribute) {
			prev_md = md;
			continue;
		}

		prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;

		if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
			prev_md->num_pages += md->num_pages;
			md->type = EFI_RESERVED_TYPE;
			md->attribute = 0;
			continue;
		}
		prev_md = md;
	}

Huang, Ying's avatar
Huang, Ying committed
889
890
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
891
892
893
		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
		    md->type != EFI_BOOT_SERVICES_CODE &&
		    md->type != EFI_BOOT_SERVICES_DATA)
Huang, Ying's avatar
Huang, Ying committed
894
			continue;
Huang, Ying's avatar
Huang, Ying committed
895
896
897
898

		size = md->num_pages << EFI_PAGE_SHIFT;
		end = md->phys_addr + size;

899
900
901
		end_pfn = PFN_UP(end);
		if (end_pfn <= max_low_pfn_mapped
		    || (end_pfn > (1UL << (32 - PAGE_SHIFT))
902
			&& end_pfn <= max_pfn_mapped)) {
Huang, Ying's avatar
Huang, Ying committed
903
			va = __va(md->phys_addr);
904
905
906
907
908
909

			if (!(md->attribute & EFI_MEMORY_WB))
				efi_memory_uc((u64)(unsigned long)va, size);
		} else
			va = efi_ioremap(md->phys_addr, size,
					 md->type, md->attribute);
Huang, Ying's avatar
Huang, Ying committed
910
911
912
913

		md->virt_addr = (u64) (unsigned long) va;

		if (!va) {
914
			pr_err("ioremap of 0x%llX failed!\n",
Huang, Ying's avatar
Huang, Ying committed
915
			       (unsigned long long)md->phys_addr);
Huang, Ying's avatar
Huang, Ying committed
916
917
918
919
920
921
922
923
			continue;
		}

		systab = (u64) (unsigned long) efi_phys.systab;
		if (md->phys_addr <= systab && systab < end) {
			systab += md->virt_addr - md->phys_addr;
			efi.systab = (efi_system_table_t *) (unsigned long) systab;
		}
924
925
926
927
928
929
		new_memmap = krealloc(new_memmap,
				      (count + 1) * memmap.desc_size,
				      GFP_KERNEL);
		memcpy(new_memmap + (count * memmap.desc_size), md,
		       memmap.desc_size);
		count++;
Huang, Ying's avatar
Huang, Ying committed
930
931
932
933
934
	}

	BUG_ON(!efi.systab);

	status = phys_efi_set_virtual_address_map(
935
		memmap.desc_size * count,
Huang, Ying's avatar
Huang, Ying committed
936
937
		memmap.desc_size,
		memmap.desc_version,
938
		(efi_memory_desc_t *)__pa(new_memmap));
Huang, Ying's avatar
Huang, Ying committed
939
940

	if (status != EFI_SUCCESS) {
941
942
		pr_alert("Unable to switch EFI into virtual mode "
			 "(status=%lx)!\n", status);
Huang, Ying's avatar
Huang, Ying committed
943
944
945
946
947
948
949
950
951
		panic("EFI call to SetVirtualAddressMap() failed!");
	}

	/*
	 * Now that EFI is in virtual mode, update the function
	 * pointers in the runtime service table to the new virtual addresses.
	 *
	 * Call EFI services through wrapper functions.
	 */
952
	efi.runtime_version = efi_systab.hdr.revision;
Huang, Ying's avatar
Huang, Ying committed
953
954
955
956
957
958
959
960
961
	efi.get_time = virt_efi_get_time;
	efi.set_time = virt_efi_set_time;
	efi.get_wakeup_time = virt_efi_get_wakeup_time;
	efi.set_wakeup_time = virt_efi_set_wakeup_time;
	efi.get_variable = virt_efi_get_variable;
	efi.get_next_variable = virt_efi_get_next_variable;
	efi.set_variable = virt_efi_set_variable;
	efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
	efi.reset_system = virt_efi_reset_system;
962
	efi.set_virtual_address_map = NULL;
963
964
965
	efi.query_variable_info = virt_efi_query_variable_info;
	efi.update_capsule = virt_efi_update_capsule;
	efi.query_capsule_caps = virt_efi_query_capsule_caps;
966
967
	if (__supported_pte_mask & _PAGE_NX)
		runtime_code_page_mkexec();
968

969
	kfree(new_memmap);
Huang, Ying's avatar
Huang, Ying committed
970
971
972
973
974
975
976
977
978
979
}

/*
 * Convenience functions to obtain memory types and attributes
 */
u32 efi_mem_type(unsigned long phys_addr)
{
	efi_memory_desc_t *md;
	void *p;

980
981
982
	if (!efi_enabled(EFI_MEMMAP))
		return 0;

Huang, Ying's avatar
Huang, Ying committed
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
		if ((md->phys_addr <= phys_addr) &&
		    (phys_addr < (md->phys_addr +
				  (md->num_pages << EFI_PAGE_SHIFT))))
			return md->type;
	}
	return 0;
}

u64 efi_mem_attributes(unsigned long phys_addr)
{
	efi_memory_desc_t *md;
	void *p;

	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
		md = p;
		if ((md->phys_addr <= phys_addr) &&
		    (phys_addr < (md->phys_addr +
				  (md->num_pages << EFI_PAGE_SHIFT))))
			return md->attribute;
	}
	return 0;
}