efi.c 21.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7
/*
 * Extensible Firmware Interface
 *
 * Based on Extensible Firmware Interface Specification version 0.9 April 30, 1999
 *
 * Copyright (C) 1999 VA Linux Systems
 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
8
 * Copyright (C) 1999-2003 Hewlett-Packard Co.
Linus Torvalds's avatar
Linus Torvalds committed
9 10
 *	David Mosberger-Tang <davidm@hpl.hp.com>
 *	Stephane Eranian <eranian@hpl.hp.com>
Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16 17 18
 *
 * 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>
Linus Torvalds's avatar
Linus Torvalds committed
19
 *	Skip non-WB memory and ignore empty memory ranges.
Linus Torvalds's avatar
Linus Torvalds committed
20
 */
Linus Torvalds's avatar
Linus Torvalds committed
21
#include <linux/config.h>
Linus Torvalds's avatar
Linus Torvalds committed
22 23 24 25
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/time.h>
Linus Torvalds's avatar
Linus Torvalds committed
26
#include <linux/proc_fs.h>
27
#include <linux/efi.h>
Linus Torvalds's avatar
Linus Torvalds committed
28 29

#include <asm/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
30
#include <asm/kregs.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35 36 37 38 39 40
#include <asm/pgtable.h>
#include <asm/processor.h>

#define EFI_DEBUG	0

extern efi_status_t efi_call_phys (void *, ...);

struct efi efi;
static efi_runtime_services_t *runtime;

Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45 46 47 48
/*
 * efi_dir is allocated here, but the directory isn't created
 * here, as proc_mkdir() doesn't work this early in the bootup
 * process.  Therefore, each module, like efivars, must test for
 *    if (!efi_dir)  efi_dir = proc_mkdir("efi", NULL);
 * prior to creating their own entries under /proc/efi.
 */
#ifdef CONFIG_PROC_FS
49
struct proc_dir_entry *efi_dir;
Linus Torvalds's avatar
Linus Torvalds committed
50 51
#endif

Linus Torvalds's avatar
Linus Torvalds committed
52 53
static unsigned long mem_limit = ~0UL;

54 55 56 57 58 59 60 61 62 63 64 65 66 67
#define efi_call_virt(f, args...)	(*(f))(args)

#define STUB_GET_TIME(prefix, adjust_arg)							\
static efi_status_t										\
prefix##_get_time (efi_time_t *tm, efi_time_cap_t *tc)						\
{												\
	struct ia64_fpreg fr[6];								\
	efi_status_t ret;									\
												\
	ia64_save_scratch_fpregs(fr);								\
	ret = efi_call_##prefix((efi_get_time_t *) __va(runtime->get_time), adjust_arg(tm),	\
				adjust_arg(tc));						\
	ia64_load_scratch_fpregs(fr);								\
	return ret;										\
Linus Torvalds's avatar
Linus Torvalds committed
68 69
}

70 71 72 73 74 75 76 77 78 79 80
#define STUB_SET_TIME(prefix, adjust_arg)							\
static efi_status_t										\
prefix##_set_time (efi_time_t *tm)								\
{												\
	struct ia64_fpreg fr[6];								\
	efi_status_t ret;									\
												\
	ia64_save_scratch_fpregs(fr);								\
	ret = efi_call_##prefix((efi_set_time_t *) __va(runtime->set_time), adjust_arg(tm));	\
	ia64_load_scratch_fpregs(fr);								\
	return ret;										\
Linus Torvalds's avatar
Linus Torvalds committed
81 82
}

83 84 85 86 87 88 89 90 91 92 93 94
#define STUB_GET_WAKEUP_TIME(prefix, adjust_arg)						\
static efi_status_t										\
prefix##_get_wakeup_time (efi_bool_t *enabled, efi_bool_t *pending, efi_time_t *tm)		\
{												\
	struct ia64_fpreg fr[6];								\
	efi_status_t ret;									\
												\
	ia64_save_scratch_fpregs(fr);								\
	ret = efi_call_##prefix((efi_get_wakeup_time_t *) __va(runtime->get_wakeup_time),	\
				adjust_arg(enabled), adjust_arg(pending), adjust_arg(tm));	\
	ia64_load_scratch_fpregs(fr);								\
	return ret;										\
Linus Torvalds's avatar
Linus Torvalds committed
95 96
}

97 98 99 100 101 102 103 104 105 106 107 108
#define STUB_SET_WAKEUP_TIME(prefix, adjust_arg)						\
static efi_status_t										\
prefix##_set_wakeup_time (efi_bool_t enabled, efi_time_t *tm)					\
{												\
	struct ia64_fpreg fr[6];								\
	efi_status_t ret;									\
												\
	ia64_save_scratch_fpregs(fr);								\
	ret = efi_call_##prefix((efi_set_wakeup_time_t *) __va(runtime->set_wakeup_time),	\
				enabled, adjust_arg(tm));					\
	ia64_load_scratch_fpregs(fr);								\
	return ret;										\
Linus Torvalds's avatar
Linus Torvalds committed
109 110
}

111 112 113 114 115 116 117 118 119 120 121 122 123 124
#define STUB_GET_VARIABLE(prefix, adjust_arg)						\
static efi_status_t									\
prefix##_get_variable (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,		\
		       unsigned long *data_size, void *data)				\
{											\
	struct ia64_fpreg fr[6];							\
	efi_status_t ret;								\
											\
	ia64_save_scratch_fpregs(fr);							\
	ret = efi_call_##prefix((efi_get_variable_t *) __va(runtime->get_variable),	\
				adjust_arg(name), adjust_arg(vendor), adjust_arg(attr),	\
				adjust_arg(data_size), adjust_arg(data));		\
	ia64_load_scratch_fpregs(fr);							\
	return ret;									\
Linus Torvalds's avatar
Linus Torvalds committed
125 126
}

127 128 129 130 131 132 133 134 135 136 137 138
#define STUB_GET_NEXT_VARIABLE(prefix, adjust_arg)						\
static efi_status_t										\
prefix##_get_next_variable (unsigned long *name_size, efi_char16_t *name, efi_guid_t *vendor)	\
{												\
	struct ia64_fpreg fr[6];								\
	efi_status_t ret;									\
												\
	ia64_save_scratch_fpregs(fr);								\
	ret = efi_call_##prefix((efi_get_next_variable_t *) __va(runtime->get_next_variable),	\
				adjust_arg(name_size), adjust_arg(name), adjust_arg(vendor));	\
	ia64_load_scratch_fpregs(fr);								\
	return ret;										\
Linus Torvalds's avatar
Linus Torvalds committed
139 140
}

141 142
#define STUB_SET_VARIABLE(prefix, adjust_arg)						\
static efi_status_t									\
143
prefix##_set_variable (efi_char16_t *name, efi_guid_t *vendor, unsigned long attr,	\
144 145 146 147 148 149 150 151 152 153 154
		       unsigned long data_size, void *data)				\
{											\
	struct ia64_fpreg fr[6];							\
	efi_status_t ret;								\
											\
	ia64_save_scratch_fpregs(fr);							\
	ret = efi_call_##prefix((efi_set_variable_t *) __va(runtime->set_variable),	\
				adjust_arg(name), adjust_arg(vendor), attr, data_size,	\
				adjust_arg(data));					\
	ia64_load_scratch_fpregs(fr);							\
	return ret;									\
Linus Torvalds's avatar
Linus Torvalds committed
155 156
}

157 158
#define STUB_GET_NEXT_HIGH_MONO_COUNT(prefix, adjust_arg)					\
static efi_status_t										\
159
prefix##_get_next_high_mono_count (u32 *count)							\
160 161 162 163 164 165 166 167 168
{												\
	struct ia64_fpreg fr[6];								\
	efi_status_t ret;									\
												\
	ia64_save_scratch_fpregs(fr);								\
	ret = efi_call_##prefix((efi_get_next_high_mono_count_t *)				\
				__va(runtime->get_next_high_mono_count), adjust_arg(count));	\
	ia64_load_scratch_fpregs(fr);								\
	return ret;										\
Linus Torvalds's avatar
Linus Torvalds committed
169 170
}

171 172 173 174 175 176 177 178 179 180 181 182
#define STUB_RESET_SYSTEM(prefix, adjust_arg)					\
static void									\
prefix##_reset_system (int reset_type, efi_status_t status,			\
		       unsigned long data_size, efi_char16_t *data)		\
{										\
	struct ia64_fpreg fr[6];						\
										\
	ia64_save_scratch_fpregs(fr);						\
	efi_call_##prefix((efi_reset_system_t *) __va(runtime->reset_system),	\
			  reset_type, status, data_size, adjust_arg(data));	\
	/* should not return, but just in case... */				\
	ia64_load_scratch_fpregs(fr);						\
Linus Torvalds's avatar
Linus Torvalds committed
183 184
}

185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
STUB_GET_TIME(phys, __pa)
STUB_SET_TIME(phys, __pa)
STUB_GET_WAKEUP_TIME(phys, __pa)
STUB_SET_WAKEUP_TIME(phys, __pa)
STUB_GET_VARIABLE(phys, __pa)
STUB_GET_NEXT_VARIABLE(phys, __pa)
STUB_SET_VARIABLE(phys, __pa)
STUB_GET_NEXT_HIGH_MONO_COUNT(phys, __pa)
STUB_RESET_SYSTEM(phys, __pa)

STUB_GET_TIME(virt, )
STUB_SET_TIME(virt, )
STUB_GET_WAKEUP_TIME(virt, )
STUB_SET_WAKEUP_TIME(virt, )
STUB_GET_VARIABLE(virt, )
STUB_GET_NEXT_VARIABLE(virt, )
STUB_SET_VARIABLE(virt, )
STUB_GET_NEXT_HIGH_MONO_COUNT(virt, )
STUB_RESET_SYSTEM(virt, )

Linus Torvalds's avatar
Linus Torvalds committed
205
void
206
efi_gettimeofday (struct timespec *ts)
Linus Torvalds's avatar
Linus Torvalds committed
207 208 209
{
	efi_time_t tm;

210
	memset(ts, 0, sizeof(ts));
Linus Torvalds's avatar
Linus Torvalds committed
211 212 213
	if ((*efi.get_time)(&tm, 0) != EFI_SUCCESS)
		return;

214 215
	ts->tv_sec = mktime(tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
	ts->tv_nsec = tm.nanosecond;
Linus Torvalds's avatar
Linus Torvalds committed
216 217
}

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
static int
is_available_memory (efi_memory_desc_t *md)
{
	if (!(md->attribute & EFI_MEMORY_WB))
		return 0;

	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:
		return 1;
	}
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
235
/*
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
 * Trim descriptor MD so its starts at address START_ADDR.  If the descriptor covers
 * memory that is normally available to the kernel, issue a warning that some memory
 * is being ignored.
 */
static void
trim_bottom (efi_memory_desc_t *md, u64 start_addr)
{
	u64 num_skipped_pages;

	if (md->phys_addr >= start_addr || !md->num_pages)
		return;

	num_skipped_pages = (start_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
	if (num_skipped_pages > md->num_pages)
		num_skipped_pages = md->num_pages;

	if (is_available_memory(md))
		printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
		       "at 0x%lx\n", __FUNCTION__,
		       (num_skipped_pages << EFI_PAGE_SHIFT) >> 10,
		       md->phys_addr, start_addr - IA64_GRANULE_SIZE);
	/*
	 * NOTE: Don't set md->phys_addr to START_ADDR because that could cause the memory
	 * descriptor list to become unsorted.  In such a case, md->num_pages will be
	 * zero, so the Right Thing will happen.
	 */
	md->phys_addr += num_skipped_pages << EFI_PAGE_SHIFT;
	md->num_pages -= num_skipped_pages;
}

static void
trim_top (efi_memory_desc_t *md, u64 end_addr)
{
	u64 num_dropped_pages, md_end_addr;

	md_end_addr = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);

	if (md_end_addr <= end_addr || !md->num_pages)
		return;

	num_dropped_pages = (md_end_addr - end_addr) >> EFI_PAGE_SHIFT;
	if (num_dropped_pages > md->num_pages)
		num_dropped_pages = md->num_pages;

	if (is_available_memory(md))
		printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
		       "at 0x%lx\n", __FUNCTION__,
		       (num_dropped_pages << EFI_PAGE_SHIFT) >> 10,
		       md->phys_addr, end_addr);
	md->num_pages -= num_dropped_pages;
}

/*
 * Walks the EFI memory map and calls CALLBACK once for each EFI memory descriptor that
 * has memory that is available for OS use.
Linus Torvalds's avatar
Linus Torvalds committed
291 292 293 294 295 296 297 298 299
 */
void
efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
{
	int prev_valid = 0;
	struct range {
		u64 start;
		u64 end;
	} prev, curr;
300
	void *efi_map_start, *efi_map_end, *p, *q, *r;
301 302
	efi_memory_desc_t *md, *check_md;
	u64 efi_desc_size, start, end, granule_addr, first_non_wb_addr = 0;
Linus Torvalds's avatar
Linus Torvalds committed
303

Linus Torvalds's avatar
Linus Torvalds committed
304 305 306
	efi_map_start = __va(ia64_boot_param->efi_memmap);
	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
	efi_desc_size = ia64_boot_param->efi_memdesc_size;
Linus Torvalds's avatar
Linus Torvalds committed
307 308 309

	for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
		md = p;
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326

		/* skip over non-WB memory descriptors; that's all we're interested in... */
		if (!(md->attribute & EFI_MEMORY_WB))
			continue;

		if (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) > first_non_wb_addr) {
			/*
			 * Search for the next run of contiguous WB memory.  Start search
			 * at first granule boundary covered by md.
			 */
			granule_addr = ((md->phys_addr + IA64_GRANULE_SIZE - 1)
					& -IA64_GRANULE_SIZE);
			first_non_wb_addr = granule_addr;
			for (q = p; q < efi_map_end; q += efi_desc_size) {
				check_md = q;

				if (check_md->attribute & EFI_MEMORY_WB)
327
					trim_bottom(check_md, granule_addr);
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345

				if (check_md->phys_addr < granule_addr)
					continue;

				if (!(check_md->attribute & EFI_MEMORY_WB))
					break;	/* hit a non-WB region; stop search */

				if (check_md->phys_addr != first_non_wb_addr)
					break;	/* hit a memory hole; stop search */

				first_non_wb_addr += check_md->num_pages << EFI_PAGE_SHIFT;
			}
			/* round it down to the previous granule-boundary: */
			first_non_wb_addr &= -IA64_GRANULE_SIZE;

			if (!(first_non_wb_addr > granule_addr))
				continue;	/* couldn't find enough contiguous memory */

346 347 348
			for (r = p; r < q; r += efi_desc_size)
				trim_top(r, first_non_wb_addr);
		}
349 350

		if (is_available_memory(md)) {
351
			if (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) > mem_limit) {
Linus Torvalds's avatar
Linus Torvalds committed
352 353
				if (md->phys_addr > mem_limit)
					continue;
354
				md->num_pages = (mem_limit - md->phys_addr) >> EFI_PAGE_SHIFT;
Linus Torvalds's avatar
Linus Torvalds committed
355
			}
356 357

			if (md->num_pages == 0)
Linus Torvalds's avatar
Linus Torvalds committed
358 359 360
				continue;

			curr.start = PAGE_OFFSET + md->phys_addr;
361
			curr.end   = curr.start + (md->num_pages << EFI_PAGE_SHIFT);
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364 365 366 367

			if (!prev_valid) {
				prev = curr;
				prev_valid = 1;
			} else {
				if (curr.start < prev.start)
368
					printk(KERN_ERR "Oops: EFI memory table not ordered!\n");
Linus Torvalds's avatar
Linus Torvalds committed
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401

				if (prev.end == curr.start) {
					/* merge two consecutive memory ranges */
					prev.end = curr.end;
				} else {
					start = PAGE_ALIGN(prev.start);
					end = prev.end & PAGE_MASK;
					if ((end > start) && (*callback)(start, end, arg) < 0)
						return;
					prev = curr;
				}
			}
		}
	}
	if (prev_valid) {
		start = PAGE_ALIGN(prev.start);
		end = prev.end & PAGE_MASK;
		if (end > start)
			(*callback)(start, end, arg);
	}
}

/*
 * Look for the PAL_CODE region reported by EFI and maps it using an
 * ITR to enable safe PAL calls in virtual mode.  See IA-64 Processor
 * Abstraction Layer chapter 11 in ADAG
 */
void
efi_map_pal_code (void)
{
	void *efi_map_start, *efi_map_end, *p;
	efi_memory_desc_t *md;
	u64 efi_desc_size;
402 403
	int pal_code_count = 0;
	u64 mask, psr;
Linus Torvalds's avatar
Linus Torvalds committed
404 405
	u64 vaddr;

Linus Torvalds's avatar
Linus Torvalds committed
406 407 408
	efi_map_start = __va(ia64_boot_param->efi_memmap);
	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
	efi_desc_size = ia64_boot_param->efi_memdesc_size;
Linus Torvalds's avatar
Linus Torvalds committed
409 410 411 412 413 414 415 416 417 418 419 420

	for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
		md = p;
		if (md->type != EFI_PAL_CODE)
			continue;

		if (++pal_code_count > 1) {
			printk(KERN_ERR "Too many EFI Pal Code memory ranges, dropped @ %lx\n",
			       md->phys_addr);
			continue;
		}
		/*
Linus Torvalds's avatar
Linus Torvalds committed
421 422
		 * The only ITLB entry in region 7 that is used is the one installed by
		 * __start().  That entry covers a 64MB range.
Linus Torvalds's avatar
Linus Torvalds committed
423
		 */
Linus Torvalds's avatar
Linus Torvalds committed
424
		mask  = ~((1 << KERNEL_TR_PAGE_SHIFT) - 1);
Linus Torvalds's avatar
Linus Torvalds committed
425 426 427
		vaddr = PAGE_OFFSET + md->phys_addr;

		/*
Linus Torvalds's avatar
Linus Torvalds committed
428 429
		 * We must check that the PAL mapping won't overlap with the kernel
		 * mapping.
Linus Torvalds's avatar
Linus Torvalds committed
430
		 *
Linus Torvalds's avatar
Linus Torvalds committed
431
		 * PAL code is guaranteed to be aligned on a power of 2 between 4k and
Linus Torvalds's avatar
Linus Torvalds committed
432 433 434 435
		 * 256KB and that only one ITR is needed to map it. This implies that the
		 * PAL code is always aligned on its size, i.e., the closest matching page
		 * size supported by the TLB. Therefore PAL code is guaranteed never to
		 * cross a 64MB unless it is bigger than 64MB (very unlikely!).  So for
Linus Torvalds's avatar
Linus Torvalds committed
436 437
		 * now the following test is enough to determine whether or not we need a
		 * dedicated ITR for the PAL code.
Linus Torvalds's avatar
Linus Torvalds committed
438
		 */
Linus Torvalds's avatar
Linus Torvalds committed
439
		if ((vaddr & mask) == (KERNEL_START & mask)) {
440 441
			printk(KERN_INFO "%s: no need to install ITR for PAL code\n",
			       __FUNCTION__);
Linus Torvalds's avatar
Linus Torvalds committed
442 443 444
			continue;
		}

445
		if (md->num_pages << EFI_PAGE_SHIFT > IA64_GRANULE_SIZE)
Linus Torvalds's avatar
Linus Torvalds committed
446 447 448
			panic("Woah!  PAL code size bigger than a granule!");

		mask  = ~((1 << IA64_GRANULE_SHIFT) - 1);
449
#if EFI_DEBUG
450
		printk(KERN_INFO "CPU %d: mapping PAL code [0x%lx-0x%lx) into [0x%lx-0x%lx)\n",
David Mosberger's avatar
David Mosberger committed
451 452
		       smp_processor_id(), md->phys_addr,
		       md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
Linus Torvalds's avatar
Linus Torvalds committed
453
		       vaddr & mask, (vaddr & mask) + IA64_GRANULE_SIZE);
454
#endif
Linus Torvalds's avatar
Linus Torvalds committed
455 456 457 458

		/*
		 * Cannot write to CRx with PSR.ic=1
		 */
459
		psr = ia64_clear_ic();
Linus Torvalds's avatar
Linus Torvalds committed
460
		ia64_itr(0x1, IA64_TR_PALCODE, vaddr & mask,
461 462 463
			 pte_val(pfn_pte(md->phys_addr >> PAGE_SHIFT, PAGE_KERNEL)),
			 IA64_GRANULE_SHIFT);
		ia64_set_psr(psr);		/* restore psr */
Linus Torvalds's avatar
Linus Torvalds committed
464
		ia64_srlz_i();
Linus Torvalds's avatar
Linus Torvalds committed
465 466 467
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
468
void __init
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
efi_init (void)
{
	void *efi_map_start, *efi_map_end;
	efi_config_table_t *config_tables;
	efi_char16_t *c16;
	u64 efi_desc_size;
	char *cp, *end, vendor[100] = "unknown";
	extern char saved_command_line[];
	int i;

	/* it's too early to be able to use the standard kernel command line support... */
	for (cp = saved_command_line; *cp; ) {
		if (memcmp(cp, "mem=", 4) == 0) {
			cp += 4;
			mem_limit = memparse(cp, &end) - 1;
			if (end != cp)
				break;
			cp = end;
		} else {
			while (*cp != ' ' && *cp)
				++cp;
			while (*cp == ' ')
				++cp;
		}
	}
	if (mem_limit != ~0UL)
495
		printk(KERN_INFO "Ignoring memory above %luMB\n", mem_limit >> 20);
Linus Torvalds's avatar
Linus Torvalds committed
496

Linus Torvalds's avatar
Linus Torvalds committed
497
	efi.systab = __va(ia64_boot_param->efi_systab);
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500

	/*
	 * Verify the EFI Table
Linus Torvalds's avatar
Linus Torvalds committed
501 502
	 */
	if (efi.systab == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
503
		panic("Woah! Can't find EFI system table.\n");
Linus Torvalds's avatar
Linus Torvalds committed
504
	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
Linus Torvalds's avatar
Linus Torvalds committed
505 506
		panic("Woah! EFI system table signature incorrect\n");
	if ((efi.systab->hdr.revision ^ EFI_SYSTEM_TABLE_REVISION) >> 16 != 0)
507
		printk(KERN_WARNING "Warning: EFI system table major version mismatch: "
Linus Torvalds's avatar
Linus Torvalds committed
508 509 510 511 512 513 514 515 516
		       "got %d.%02d, expected %d.%02d\n",
		       efi.systab->hdr.revision >> 16, efi.systab->hdr.revision & 0xffff,
		       EFI_SYSTEM_TABLE_REVISION >> 16, EFI_SYSTEM_TABLE_REVISION & 0xffff);

	config_tables = __va(efi.systab->tables);

	/* Show what we know for posterity */
	c16 = __va(efi.systab->fw_vendor);
	if (c16) {
517
		for (i = 0;i < (int) sizeof(vendor) && *c16; ++i)
Linus Torvalds's avatar
Linus Torvalds committed
518 519 520 521
			vendor[i] = *c16++;
		vendor[i] = '\0';
	}

522
	printk(KERN_INFO "EFI v%u.%.02u by %s:",
Linus Torvalds's avatar
Linus Torvalds committed
523 524
	       efi.systab->hdr.revision >> 16, efi.systab->hdr.revision & 0xffff, vendor);

525
	for (i = 0; i < (int) efi.systab->nr_tables; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
		if (efi_guidcmp(config_tables[i].guid, MPS_TABLE_GUID) == 0) {
			efi.mps = __va(config_tables[i].table);
			printk(" MPS=0x%lx", config_tables[i].table);
		} else if (efi_guidcmp(config_tables[i].guid, ACPI_20_TABLE_GUID) == 0) {
			efi.acpi20 = __va(config_tables[i].table);
			printk(" ACPI 2.0=0x%lx", config_tables[i].table);
		} else if (efi_guidcmp(config_tables[i].guid, ACPI_TABLE_GUID) == 0) {
			efi.acpi = __va(config_tables[i].table);
			printk(" ACPI=0x%lx", config_tables[i].table);
		} else if (efi_guidcmp(config_tables[i].guid, SMBIOS_TABLE_GUID) == 0) {
			efi.smbios = __va(config_tables[i].table);
			printk(" SMBIOS=0x%lx", config_tables[i].table);
		} else if (efi_guidcmp(config_tables[i].guid, SAL_SYSTEM_TABLE_GUID) == 0) {
			efi.sal_systab = __va(config_tables[i].table);
			printk(" SALsystab=0x%lx", config_tables[i].table);
David Mosberger's avatar
David Mosberger committed
541 542 543
		} else if (efi_guidcmp(config_tables[i].guid, HCDP_TABLE_GUID) == 0) {
			efi.hcdp = __va(config_tables[i].table);
			printk(" HCDP=0x%lx", config_tables[i].table);
Linus Torvalds's avatar
Linus Torvalds committed
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
		}
	}
	printk("\n");

	runtime = __va(efi.systab->runtime);
	efi.get_time = phys_get_time;
	efi.set_time = phys_set_time;
	efi.get_wakeup_time = phys_get_wakeup_time;
	efi.set_wakeup_time = phys_set_wakeup_time;
	efi.get_variable = phys_get_variable;
	efi.get_next_variable = phys_get_next_variable;
	efi.set_variable = phys_set_variable;
	efi.get_next_high_mono_count = phys_get_next_high_mono_count;
	efi.reset_system = phys_reset_system;

Linus Torvalds's avatar
Linus Torvalds committed
559 560 561
	efi_map_start = __va(ia64_boot_param->efi_memmap);
	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
	efi_desc_size = ia64_boot_param->efi_memdesc_size;
Linus Torvalds's avatar
Linus Torvalds committed
562 563 564 565 566 567 568 569 570 571 572

#if EFI_DEBUG
	/* print EFI memory map: */
	{
		efi_memory_desc_t *md;
		void *p;

		for (i = 0, p = efi_map_start; p < efi_map_end; ++i, p += efi_desc_size) {
			md = p;
			printk("mem%02u: type=%u, attr=0x%lx, range=[0x%016lx-0x%016lx) (%luMB)\n",
			       i, md->type, md->attribute, md->phys_addr,
573
			       md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
David Mosberger's avatar
David Mosberger committed
574
			       md->num_pages >> (20 - EFI_PAGE_SHIFT));
Linus Torvalds's avatar
Linus Torvalds committed
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
		}
	}
#endif

	efi_map_pal_code();
	efi_enter_virtual_mode();
}

void
efi_enter_virtual_mode (void)
{
	void *efi_map_start, *efi_map_end, *p;
	efi_memory_desc_t *md;
	efi_status_t status;
	u64 efi_desc_size;

Linus Torvalds's avatar
Linus Torvalds committed
591 592 593
	efi_map_start = __va(ia64_boot_param->efi_memmap);
	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
	efi_desc_size = ia64_boot_param->efi_memdesc_size;
Linus Torvalds's avatar
Linus Torvalds committed
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613

	for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
		md = p;
		if (md->attribute & EFI_MEMORY_RUNTIME) {
			/*
			 * Some descriptors have multiple bits set, so the order of
			 * the tests is relevant.
			 */
			if (md->attribute & EFI_MEMORY_WB) {
				md->virt_addr = (u64) __va(md->phys_addr);
			} else if (md->attribute & EFI_MEMORY_UC) {
				md->virt_addr = (u64) ioremap(md->phys_addr, 0);
			} else if (md->attribute & EFI_MEMORY_WC) {
#if 0
				md->virt_addr = ia64_remap(md->phys_addr, (_PAGE_A | _PAGE_P
									   | _PAGE_D
									   | _PAGE_MA_WC
									   | _PAGE_PL_0
									   | _PAGE_AR_RW));
#else
614
				printk(KERN_INFO "EFI_MEMORY_WC mapping\n");
Linus Torvalds's avatar
Linus Torvalds committed
615 616 617 618 619 620 621 622 623
				md->virt_addr = (u64) ioremap(md->phys_addr, 0);
#endif
			} else if (md->attribute & EFI_MEMORY_WT) {
#if 0
				md->virt_addr = ia64_remap(md->phys_addr, (_PAGE_A | _PAGE_P
									   | _PAGE_D | _PAGE_MA_WT
									   | _PAGE_PL_0
									   | _PAGE_AR_RW));
#else
624
				printk(KERN_INFO "EFI_MEMORY_WT mapping\n");
Linus Torvalds's avatar
Linus Torvalds committed
625 626 627 628 629 630 631
				md->virt_addr = (u64) ioremap(md->phys_addr, 0);
#endif
			}
		}
	}

	status = efi_call_phys(__va(runtime->set_virtual_address_map),
Linus Torvalds's avatar
Linus Torvalds committed
632 633 634
			       ia64_boot_param->efi_memmap_size,
			       efi_desc_size, ia64_boot_param->efi_memdesc_version,
			       ia64_boot_param->efi_memmap);
Linus Torvalds's avatar
Linus Torvalds committed
635
	if (status != EFI_SUCCESS) {
636 637
		printk(KERN_WARNING "warning: unable to switch EFI into virtual mode "
		       "(status=%lu)\n", status);
Linus Torvalds's avatar
Linus Torvalds committed
638 639 640 641
		return;
	}

	/*
642
	 * Now that EFI is in virtual mode, we call the EFI functions more efficiently:
Linus Torvalds's avatar
Linus Torvalds committed
643
	 */
644 645 646 647 648 649 650 651 652
	efi.get_time = virt_get_time;
	efi.set_time = virt_set_time;
	efi.get_wakeup_time = virt_get_wakeup_time;
	efi.set_wakeup_time = virt_set_wakeup_time;
	efi.get_variable = virt_get_variable;
	efi.get_next_variable = virt_get_next_variable;
	efi.set_variable = virt_set_variable;
	efi.get_next_high_mono_count = virt_get_next_high_mono_count;
	efi.reset_system = virt_reset_system;
Linus Torvalds's avatar
Linus Torvalds committed
653
}
Linus Torvalds's avatar
Linus Torvalds committed
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680

/*
 * Walk the EFI memory map looking for the I/O port range.  There can only be one entry of
 * this type, other I/O port ranges should be described via ACPI.
 */
u64
efi_get_iobase (void)
{
	void *efi_map_start, *efi_map_end, *p;
	efi_memory_desc_t *md;
	u64 efi_desc_size;

	efi_map_start = __va(ia64_boot_param->efi_memmap);
	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
	efi_desc_size = ia64_boot_param->efi_memdesc_size;

	for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
		md = p;
		if (md->type == EFI_MEMORY_MAPPED_IO_PORT_SPACE) {
			/* paranoia attribute checking */
			if (md->attribute == (EFI_MEMORY_UC | EFI_MEMORY_RUNTIME))
				return md->phys_addr;
		}
	}
	return 0;
}

681
u32
682
efi_mem_type (unsigned long phys_addr)
683 684 685 686 687 688 689 690 691 692 693
{
	void *efi_map_start, *efi_map_end, *p;
	efi_memory_desc_t *md;
	u64 efi_desc_size;

	efi_map_start = __va(ia64_boot_param->efi_memmap);
	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
	efi_desc_size = ia64_boot_param->efi_memdesc_size;

	for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
		md = p;
David Mosberger's avatar
David Mosberger committed
694

695 696 697 698 699 700 701
		if ((md->phys_addr <= phys_addr) && (phys_addr <=
		    (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1)))
			 return md->type;
	}
	return 0;
}

David Mosberger's avatar
David Mosberger committed
702
u64
703
efi_mem_attributes (unsigned long phys_addr)
David Mosberger's avatar
David Mosberger committed
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
{
	void *efi_map_start, *efi_map_end, *p;
	efi_memory_desc_t *md;
	u64 efi_desc_size;

	efi_map_start = __va(ia64_boot_param->efi_memmap);
	efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
	efi_desc_size = ia64_boot_param->efi_memdesc_size;

	for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
		md = p;

		if ((md->phys_addr <= phys_addr) && (phys_addr <=
		    (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1)))
			return md->attribute;
	}
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
723
static void __exit
David Mosberger's avatar
David Mosberger committed
724
efivars_exit (void)
Linus Torvalds's avatar
Linus Torvalds committed
725
{
Linus Torvalds's avatar
Linus Torvalds committed
726
#ifdef CONFIG_PROC_FS
Linus Torvalds's avatar
Linus Torvalds committed
727
 	remove_proc_entry(efi_dir->name, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
728
#endif
Linus Torvalds's avatar
Linus Torvalds committed
729
}