1/* 2 * Extensible Firmware Interface 3 * 4 * Based on Extensible Firmware Interface Specification version 0.9 April 30, 1999 5 * 6 * Copyright (C) 1999 VA Linux Systems 7 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com> 8 * Copyright (C) 1999-2003 Hewlett-Packard Co. 9 * David Mosberger-Tang <davidm@hpl.hp.com> 10 * Stephane Eranian <eranian@hpl.hp.com> 11 * (c) Copyright 2006 Hewlett-Packard Development Company, L.P. 12 * Bjorn Helgaas <bjorn.helgaas@hp.com> 13 * 14 * All EFI Runtime Services are not implemented yet as EFI only 15 * supports physical mode addressing on SoftSDV. This is to be fixed 16 * in a future version. --drummond 1999-07-20 17 * 18 * Implemented EFI runtime services and virtual mode calls. --davidm 19 * 20 * Goutham Rao: <goutham.rao@intel.com> 21 * Skip non-WB memory and ignore empty memory ranges. 22 */ 23#include <linux/module.h> 24#include <linux/bootmem.h> 25#include <linux/kernel.h> 26#include <linux/init.h> 27#include <linux/types.h> 28#include <linux/time.h> 29#include <linux/efi.h> 30#include <linux/kexec.h> 31 32#include <asm/io.h> 33#include <asm/kregs.h> 34#include <asm/meminit.h> 35#include <asm/pgtable.h> 36#include <asm/processor.h> 37#include <asm/mca.h> 38 39#define EFI_DEBUG 0 40 41extern efi_status_t efi_call_phys (void *, ...); 42 43struct efi efi; 44EXPORT_SYMBOL(efi); 45static efi_runtime_services_t *runtime; 46static unsigned long mem_limit = ~0UL, max_addr = ~0UL, min_addr = 0UL; 47 48#define efi_call_virt(f, args...) (*(f))(args) 49 50#define STUB_GET_TIME(prefix, adjust_arg) \ 51static efi_status_t \ 52prefix##_get_time (efi_time_t *tm, efi_time_cap_t *tc) \ 53{ \ 54 struct ia64_fpreg fr[6]; \ 55 efi_time_cap_t *atc = NULL; \ 56 efi_status_t ret; \ 57 \ 58 if (tc) \ 59 atc = adjust_arg(tc); \ 60 ia64_save_scratch_fpregs(fr); \ 61 ret = efi_call_##prefix((efi_get_time_t *) __va(runtime->get_time), adjust_arg(tm), atc); \ 62 ia64_load_scratch_fpregs(fr); \ 63 return ret; \ 64} 65 66#define STUB_SET_TIME(prefix, adjust_arg) \ 67static efi_status_t \ 68prefix##_set_time (efi_time_t *tm) \ 69{ \ 70 struct ia64_fpreg fr[6]; \ 71 efi_status_t ret; \ 72 \ 73 ia64_save_scratch_fpregs(fr); \ 74 ret = efi_call_##prefix((efi_set_time_t *) __va(runtime->set_time), adjust_arg(tm)); \ 75 ia64_load_scratch_fpregs(fr); \ 76 return ret; \ 77} 78 79#define STUB_GET_WAKEUP_TIME(prefix, adjust_arg) \ 80static efi_status_t \ 81prefix##_get_wakeup_time (efi_bool_t *enabled, efi_bool_t *pending, efi_time_t *tm) \ 82{ \ 83 struct ia64_fpreg fr[6]; \ 84 efi_status_t ret; \ 85 \ 86 ia64_save_scratch_fpregs(fr); \ 87 ret = efi_call_##prefix((efi_get_wakeup_time_t *) __va(runtime->get_wakeup_time), \ 88 adjust_arg(enabled), adjust_arg(pending), adjust_arg(tm)); \ 89 ia64_load_scratch_fpregs(fr); \ 90 return ret; \ 91} 92 93#define STUB_SET_WAKEUP_TIME(prefix, adjust_arg) \ 94static efi_status_t \ 95prefix##_set_wakeup_time (efi_bool_t enabled, efi_time_t *tm) \ 96{ \ 97 struct ia64_fpreg fr[6]; \ 98 efi_time_t *atm = NULL; \ 99 efi_status_t ret; \ 100 \ 101 if (tm) \ 102 atm = adjust_arg(tm); \ 103 ia64_save_scratch_fpregs(fr); \ 104 ret = efi_call_##prefix((efi_set_wakeup_time_t *) __va(runtime->set_wakeup_time), \ 105 enabled, atm); \ 106 ia64_load_scratch_fpregs(fr); \ 107 return ret; \ 108} 109 110#define STUB_GET_VARIABLE(prefix, adjust_arg) \ 111static efi_status_t \ 112prefix##_get_variable (efi_char16_t *name, efi_guid_t *vendor, u32 *attr, \ 113 unsigned long *data_size, void *data) \ 114{ \ 115 struct ia64_fpreg fr[6]; \ 116 u32 *aattr = NULL; \ 117 efi_status_t ret; \ 118 \ 119 if (attr) \ 120 aattr = adjust_arg(attr); \ 121 ia64_save_scratch_fpregs(fr); \ 122 ret = efi_call_##prefix((efi_get_variable_t *) __va(runtime->get_variable), \ 123 adjust_arg(name), adjust_arg(vendor), aattr, \ 124 adjust_arg(data_size), adjust_arg(data)); \ 125 ia64_load_scratch_fpregs(fr); \ 126 return ret; \ 127} 128 129#define STUB_GET_NEXT_VARIABLE(prefix, adjust_arg) \ 130static efi_status_t \ 131prefix##_get_next_variable (unsigned long *name_size, efi_char16_t *name, efi_guid_t *vendor) \ 132{ \ 133 struct ia64_fpreg fr[6]; \ 134 efi_status_t ret; \ 135 \ 136 ia64_save_scratch_fpregs(fr); \ 137 ret = efi_call_##prefix((efi_get_next_variable_t *) __va(runtime->get_next_variable), \ 138 adjust_arg(name_size), adjust_arg(name), adjust_arg(vendor)); \ 139 ia64_load_scratch_fpregs(fr); \ 140 return ret; \ 141} 142 143#define STUB_SET_VARIABLE(prefix, adjust_arg) \ 144static efi_status_t \ 145prefix##_set_variable (efi_char16_t *name, efi_guid_t *vendor, unsigned long attr, \ 146 unsigned long data_size, void *data) \ 147{ \ 148 struct ia64_fpreg fr[6]; \ 149 efi_status_t ret; \ 150 \ 151 ia64_save_scratch_fpregs(fr); \ 152 ret = efi_call_##prefix((efi_set_variable_t *) __va(runtime->set_variable), \ 153 adjust_arg(name), adjust_arg(vendor), attr, data_size, \ 154 adjust_arg(data)); \ 155 ia64_load_scratch_fpregs(fr); \ 156 return ret; \ 157} 158 159#define STUB_GET_NEXT_HIGH_MONO_COUNT(prefix, adjust_arg) \ 160static efi_status_t \ 161prefix##_get_next_high_mono_count (u32 *count) \ 162{ \ 163 struct ia64_fpreg fr[6]; \ 164 efi_status_t ret; \ 165 \ 166 ia64_save_scratch_fpregs(fr); \ 167 ret = efi_call_##prefix((efi_get_next_high_mono_count_t *) \ 168 __va(runtime->get_next_high_mono_count), adjust_arg(count)); \ 169 ia64_load_scratch_fpregs(fr); \ 170 return ret; \ 171} 172 173#define STUB_RESET_SYSTEM(prefix, adjust_arg) \ 174static void \ 175prefix##_reset_system (int reset_type, efi_status_t status, \ 176 unsigned long data_size, efi_char16_t *data) \ 177{ \ 178 struct ia64_fpreg fr[6]; \ 179 efi_char16_t *adata = NULL; \ 180 \ 181 if (data) \ 182 adata = adjust_arg(data); \ 183 \ 184 ia64_save_scratch_fpregs(fr); \ 185 efi_call_##prefix((efi_reset_system_t *) __va(runtime->reset_system), \ 186 reset_type, status, data_size, adata); \ 187 /* should not return, but just in case... */ \ 188 ia64_load_scratch_fpregs(fr); \ 189} 190 191#define phys_ptr(arg) ((__typeof__(arg)) ia64_tpa(arg)) 192 193STUB_GET_TIME(phys, phys_ptr) 194STUB_SET_TIME(phys, phys_ptr) 195STUB_GET_WAKEUP_TIME(phys, phys_ptr) 196STUB_SET_WAKEUP_TIME(phys, phys_ptr) 197STUB_GET_VARIABLE(phys, phys_ptr) 198STUB_GET_NEXT_VARIABLE(phys, phys_ptr) 199STUB_SET_VARIABLE(phys, phys_ptr) 200STUB_GET_NEXT_HIGH_MONO_COUNT(phys, phys_ptr) 201STUB_RESET_SYSTEM(phys, phys_ptr) 202 203#define id(arg) arg 204 205STUB_GET_TIME(virt, id) 206STUB_SET_TIME(virt, id) 207STUB_GET_WAKEUP_TIME(virt, id) 208STUB_SET_WAKEUP_TIME(virt, id) 209STUB_GET_VARIABLE(virt, id) 210STUB_GET_NEXT_VARIABLE(virt, id) 211STUB_SET_VARIABLE(virt, id) 212STUB_GET_NEXT_HIGH_MONO_COUNT(virt, id) 213STUB_RESET_SYSTEM(virt, id) 214 215void 216efi_gettimeofday (struct timespec *ts) 217{ 218 efi_time_t tm; 219 220 memset(ts, 0, sizeof(ts)); 221 if ((*efi.get_time)(&tm, NULL) != EFI_SUCCESS) 222 return; 223 224 ts->tv_sec = mktime(tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second); 225 ts->tv_nsec = tm.nanosecond; 226} 227 228static int 229is_memory_available (efi_memory_desc_t *md) 230{ 231 if (!(md->attribute & EFI_MEMORY_WB)) 232 return 0; 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 return 1; 241 } 242 return 0; 243} 244 245typedef struct kern_memdesc { 246 u64 attribute; 247 u64 start; 248 u64 num_pages; 249} kern_memdesc_t; 250 251static kern_memdesc_t *kern_memmap; 252 253#define efi_md_size(md) (md->num_pages << EFI_PAGE_SHIFT) 254 255static inline u64 256kmd_end(kern_memdesc_t *kmd) 257{ 258 return (kmd->start + (kmd->num_pages << EFI_PAGE_SHIFT)); 259} 260 261static inline u64 262efi_md_end(efi_memory_desc_t *md) 263{ 264 return (md->phys_addr + efi_md_size(md)); 265} 266 267static inline int 268efi_wb(efi_memory_desc_t *md) 269{ 270 return (md->attribute & EFI_MEMORY_WB); 271} 272 273static inline int 274efi_uc(efi_memory_desc_t *md) 275{ 276 return (md->attribute & EFI_MEMORY_UC); 277} 278 279static void 280walk (efi_freemem_callback_t callback, void *arg, u64 attr) 281{ 282 kern_memdesc_t *k; 283 u64 start, end, voff; 284 285 voff = (attr == EFI_MEMORY_WB) ? PAGE_OFFSET : __IA64_UNCACHED_OFFSET; 286 for (k = kern_memmap; k->start != ~0UL; k++) { 287 if (k->attribute != attr) 288 continue; 289 start = PAGE_ALIGN(k->start); 290 end = (k->start + (k->num_pages << EFI_PAGE_SHIFT)) & PAGE_MASK; 291 if (start < end) 292 if ((*callback)(start + voff, end + voff, arg) < 0) 293 return; 294 } 295} 296 297/* 298 * Walks the EFI memory map and calls CALLBACK once for each EFI memory descriptor that 299 * has memory that is available for OS use. 300 */ 301void 302efi_memmap_walk (efi_freemem_callback_t callback, void *arg) 303{ 304 walk(callback, arg, EFI_MEMORY_WB); 305} 306 307/* 308 * Walks the EFI memory map and calls CALLBACK once for each EFI memory descriptor that 309 * has memory that is available for uncached allocator. 310 */ 311void 312efi_memmap_walk_uc (efi_freemem_callback_t callback, void *arg) 313{ 314 walk(callback, arg, EFI_MEMORY_UC); 315} 316 317/* 318 * Look for the PAL_CODE region reported by EFI and maps it using an 319 * ITR to enable safe PAL calls in virtual mode. See IA-64 Processor 320 * Abstraction Layer chapter 11 in ADAG 321 */ 322 323void * 324efi_get_pal_addr (void) 325{ 326 void *efi_map_start, *efi_map_end, *p; 327 efi_memory_desc_t *md; 328 u64 efi_desc_size; 329 int pal_code_count = 0; 330 u64 vaddr, mask; 331 332 efi_map_start = __va(ia64_boot_param->efi_memmap); 333 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 334 efi_desc_size = ia64_boot_param->efi_memdesc_size; 335 336 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 337 md = p; 338 if (md->type != EFI_PAL_CODE) 339 continue; 340 341 if (++pal_code_count > 1) { 342 printk(KERN_ERR "Too many EFI Pal Code memory ranges, dropped @ %lx\n", 343 md->phys_addr); 344 continue; 345 } 346 /* 347 * The only ITLB entry in region 7 that is used is the one installed by 348 * __start(). That entry covers a 64MB range. 349 */ 350 mask = ~((1 << KERNEL_TR_PAGE_SHIFT) - 1); 351 vaddr = PAGE_OFFSET + md->phys_addr; 352 353 /* 354 * We must check that the PAL mapping won't overlap with the kernel 355 * mapping. 356 * 357 * PAL code is guaranteed to be aligned on a power of 2 between 4k and 358 * 256KB and that only one ITR is needed to map it. This implies that the 359 * PAL code is always aligned on its size, i.e., the closest matching page 360 * size supported by the TLB. Therefore PAL code is guaranteed never to 361 * cross a 64MB unless it is bigger than 64MB (very unlikely!). So for 362 * now the following test is enough to determine whether or not we need a 363 * dedicated ITR for the PAL code. 364 */ 365 if ((vaddr & mask) == (KERNEL_START & mask)) { 366 printk(KERN_INFO "%s: no need to install ITR for PAL code\n", 367 __FUNCTION__); 368 continue; 369 } 370 371 if (md->num_pages << EFI_PAGE_SHIFT > IA64_GRANULE_SIZE) 372 panic("Woah! PAL code size bigger than a granule!"); 373 374#if EFI_DEBUG 375 mask = ~((1 << IA64_GRANULE_SHIFT) - 1); 376 377 printk(KERN_INFO "CPU %d: mapping PAL code [0x%lx-0x%lx) into [0x%lx-0x%lx)\n", 378 smp_processor_id(), md->phys_addr, 379 md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT), 380 vaddr & mask, (vaddr & mask) + IA64_GRANULE_SIZE); 381#endif 382 return __va(md->phys_addr); 383 } 384 printk(KERN_WARNING "%s: no PAL-code memory-descriptor found\n", 385 __FUNCTION__); 386 return NULL; 387} 388 389void 390efi_map_pal_code (void) 391{ 392 void *pal_vaddr = efi_get_pal_addr (); 393 u64 psr; 394 395 if (!pal_vaddr) 396 return; 397 398 /* 399 * Cannot write to CRx with PSR.ic=1 400 */ 401 psr = ia64_clear_ic(); 402 ia64_itr(0x1, IA64_TR_PALCODE, GRANULEROUNDDOWN((unsigned long) pal_vaddr), 403 pte_val(pfn_pte(__pa(pal_vaddr) >> PAGE_SHIFT, PAGE_KERNEL)), 404 IA64_GRANULE_SHIFT); 405 ia64_set_psr(psr); /* restore psr */ 406 ia64_srlz_i(); 407} 408 409void __init 410efi_init (void) 411{ 412 void *efi_map_start, *efi_map_end; 413 efi_config_table_t *config_tables; 414 efi_char16_t *c16; 415 u64 efi_desc_size; 416 char *cp, vendor[100] = "unknown"; 417 int i; 418 419 /* it's too early to be able to use the standard kernel command line support... */ 420 for (cp = boot_command_line; *cp; ) { 421 if (memcmp(cp, "mem=", 4) == 0) { 422 mem_limit = memparse(cp + 4, &cp); 423 } else if (memcmp(cp, "max_addr=", 9) == 0) { 424 max_addr = GRANULEROUNDDOWN(memparse(cp + 9, &cp)); 425 } else if (memcmp(cp, "min_addr=", 9) == 0) { 426 min_addr = GRANULEROUNDDOWN(memparse(cp + 9, &cp)); 427 } else { 428 while (*cp != ' ' && *cp) 429 ++cp; 430 while (*cp == ' ') 431 ++cp; 432 } 433 } 434 if (min_addr != 0UL) 435 printk(KERN_INFO "Ignoring memory below %luMB\n", min_addr >> 20); 436 if (max_addr != ~0UL) 437 printk(KERN_INFO "Ignoring memory above %luMB\n", max_addr >> 20); 438 439 efi.systab = __va(ia64_boot_param->efi_systab); 440 441 /* 442 * Verify the EFI Table 443 */ 444 if (efi.systab == NULL) 445 panic("Woah! Can't find EFI system table.\n"); 446 if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) 447 panic("Woah! EFI system table signature incorrect\n"); 448 if ((efi.systab->hdr.revision >> 16) == 0) 449 printk(KERN_WARNING "Warning: EFI system table version " 450 "%d.%02d, expected 1.00 or greater\n", 451 efi.systab->hdr.revision >> 16, 452 efi.systab->hdr.revision & 0xffff); 453 454 config_tables = __va(efi.systab->tables); 455 456 /* Show what we know for posterity */ 457 c16 = __va(efi.systab->fw_vendor); 458 if (c16) { 459 for (i = 0;i < (int) sizeof(vendor) - 1 && *c16; ++i) 460 vendor[i] = *c16++; 461 vendor[i] = '\0'; 462 } 463 464 printk(KERN_INFO "EFI v%u.%.02u by %s:", 465 efi.systab->hdr.revision >> 16, efi.systab->hdr.revision & 0xffff, vendor); 466 467 efi.mps = EFI_INVALID_TABLE_ADDR; 468 efi.acpi = EFI_INVALID_TABLE_ADDR; 469 efi.acpi20 = EFI_INVALID_TABLE_ADDR; 470 efi.smbios = EFI_INVALID_TABLE_ADDR; 471 efi.sal_systab = EFI_INVALID_TABLE_ADDR; 472 efi.boot_info = EFI_INVALID_TABLE_ADDR; 473 efi.hcdp = EFI_INVALID_TABLE_ADDR; 474 efi.uga = EFI_INVALID_TABLE_ADDR; 475 476 for (i = 0; i < (int) efi.systab->nr_tables; i++) { 477 if (efi_guidcmp(config_tables[i].guid, MPS_TABLE_GUID) == 0) { 478 efi.mps = config_tables[i].table; 479 printk(" MPS=0x%lx", config_tables[i].table); 480 } else if (efi_guidcmp(config_tables[i].guid, ACPI_20_TABLE_GUID) == 0) { 481 efi.acpi20 = config_tables[i].table; 482 printk(" ACPI 2.0=0x%lx", config_tables[i].table); 483 } else if (efi_guidcmp(config_tables[i].guid, ACPI_TABLE_GUID) == 0) { 484 efi.acpi = config_tables[i].table; 485 printk(" ACPI=0x%lx", config_tables[i].table); 486 } else if (efi_guidcmp(config_tables[i].guid, SMBIOS_TABLE_GUID) == 0) { 487 efi.smbios = config_tables[i].table; 488 printk(" SMBIOS=0x%lx", config_tables[i].table); 489 } else if (efi_guidcmp(config_tables[i].guid, SAL_SYSTEM_TABLE_GUID) == 0) { 490 efi.sal_systab = config_tables[i].table; 491 printk(" SALsystab=0x%lx", config_tables[i].table); 492 } else if (efi_guidcmp(config_tables[i].guid, HCDP_TABLE_GUID) == 0) { 493 efi.hcdp = config_tables[i].table; 494 printk(" HCDP=0x%lx", config_tables[i].table); 495 } 496 } 497 printk("\n"); 498 499 runtime = __va(efi.systab->runtime); 500 efi.get_time = phys_get_time; 501 efi.set_time = phys_set_time; 502 efi.get_wakeup_time = phys_get_wakeup_time; 503 efi.set_wakeup_time = phys_set_wakeup_time; 504 efi.get_variable = phys_get_variable; 505 efi.get_next_variable = phys_get_next_variable; 506 efi.set_variable = phys_set_variable; 507 efi.get_next_high_mono_count = phys_get_next_high_mono_count; 508 efi.reset_system = phys_reset_system; 509 510 efi_map_start = __va(ia64_boot_param->efi_memmap); 511 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 512 efi_desc_size = ia64_boot_param->efi_memdesc_size; 513 514#if EFI_DEBUG 515 /* print EFI memory map: */ 516 { 517 efi_memory_desc_t *md; 518 void *p; 519 520 for (i = 0, p = efi_map_start; p < efi_map_end; ++i, p += efi_desc_size) { 521 md = p; 522 printk("mem%02u: type=%u, attr=0x%lx, range=[0x%016lx-0x%016lx) (%luMB)\n", 523 i, md->type, md->attribute, md->phys_addr, 524 md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT), 525 md->num_pages >> (20 - EFI_PAGE_SHIFT)); 526 } 527 } 528#endif 529 530 efi_map_pal_code(); 531 efi_enter_virtual_mode(); 532} 533 534void 535efi_enter_virtual_mode (void) 536{ 537 void *efi_map_start, *efi_map_end, *p; 538 efi_memory_desc_t *md; 539 efi_status_t status; 540 u64 efi_desc_size; 541 542 efi_map_start = __va(ia64_boot_param->efi_memmap); 543 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 544 efi_desc_size = ia64_boot_param->efi_memdesc_size; 545 546 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 547 md = p; 548 if (md->attribute & EFI_MEMORY_RUNTIME) { 549 /* 550 * Some descriptors have multiple bits set, so the order of 551 * the tests is relevant. 552 */ 553 if (md->attribute & EFI_MEMORY_WB) { 554 md->virt_addr = (u64) __va(md->phys_addr); 555 } else if (md->attribute & EFI_MEMORY_UC) { 556 md->virt_addr = (u64) ioremap(md->phys_addr, 0); 557 } else if (md->attribute & EFI_MEMORY_WC) { 558 printk(KERN_INFO "EFI_MEMORY_WC mapping\n"); 559 md->virt_addr = (u64) ioremap(md->phys_addr, 0); 560 } else if (md->attribute & EFI_MEMORY_WT) { 561 printk(KERN_INFO "EFI_MEMORY_WT mapping\n"); 562 md->virt_addr = (u64) ioremap(md->phys_addr, 0); 563 } 564 } 565 } 566 567 status = efi_call_phys(__va(runtime->set_virtual_address_map), 568 ia64_boot_param->efi_memmap_size, 569 efi_desc_size, ia64_boot_param->efi_memdesc_version, 570 ia64_boot_param->efi_memmap); 571 if (status != EFI_SUCCESS) { 572 printk(KERN_WARNING "warning: unable to switch EFI into virtual mode " 573 "(status=%lu)\n", status); 574 return; 575 } 576 577 /* 578 * Now that EFI is in virtual mode, we call the EFI functions more efficiently: 579 */ 580 efi.get_time = virt_get_time; 581 efi.set_time = virt_set_time; 582 efi.get_wakeup_time = virt_get_wakeup_time; 583 efi.set_wakeup_time = virt_set_wakeup_time; 584 efi.get_variable = virt_get_variable; 585 efi.get_next_variable = virt_get_next_variable; 586 efi.set_variable = virt_set_variable; 587 efi.get_next_high_mono_count = virt_get_next_high_mono_count; 588 efi.reset_system = virt_reset_system; 589} 590 591/* 592 * Walk the EFI memory map looking for the I/O port range. There can only be one entry of 593 * this type, other I/O port ranges should be described via ACPI. 594 */ 595u64 596efi_get_iobase (void) 597{ 598 void *efi_map_start, *efi_map_end, *p; 599 efi_memory_desc_t *md; 600 u64 efi_desc_size; 601 602 efi_map_start = __va(ia64_boot_param->efi_memmap); 603 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 604 efi_desc_size = ia64_boot_param->efi_memdesc_size; 605 606 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 607 md = p; 608 if (md->type == EFI_MEMORY_MAPPED_IO_PORT_SPACE) { 609 if (md->attribute & EFI_MEMORY_UC) 610 return md->phys_addr; 611 } 612 } 613 return 0; 614} 615 616static struct kern_memdesc * 617kern_memory_descriptor (unsigned long phys_addr) 618{ 619 struct kern_memdesc *md; 620 621 for (md = kern_memmap; md->start != ~0UL; md++) { 622 if (phys_addr - md->start < (md->num_pages << EFI_PAGE_SHIFT)) 623 return md; 624 } 625 return NULL; 626} 627 628static efi_memory_desc_t * 629efi_memory_descriptor (unsigned long phys_addr) 630{ 631 void *efi_map_start, *efi_map_end, *p; 632 efi_memory_desc_t *md; 633 u64 efi_desc_size; 634 635 efi_map_start = __va(ia64_boot_param->efi_memmap); 636 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 637 efi_desc_size = ia64_boot_param->efi_memdesc_size; 638 639 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 640 md = p; 641 642 if (phys_addr - md->phys_addr < (md->num_pages << EFI_PAGE_SHIFT)) 643 return md; 644 } 645 return NULL; 646} 647 648static int 649efi_memmap_intersects (unsigned long phys_addr, unsigned long size) 650{ 651 void *efi_map_start, *efi_map_end, *p; 652 efi_memory_desc_t *md; 653 u64 efi_desc_size; 654 unsigned long end; 655 656 efi_map_start = __va(ia64_boot_param->efi_memmap); 657 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 658 efi_desc_size = ia64_boot_param->efi_memdesc_size; 659 660 end = phys_addr + size; 661 662 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 663 md = p; 664 665 if (md->phys_addr < end && efi_md_end(md) > phys_addr) 666 return 1; 667 } 668 return 0; 669} 670 671u32 672efi_mem_type (unsigned long phys_addr) 673{ 674 efi_memory_desc_t *md = efi_memory_descriptor(phys_addr); 675 676 if (md) 677 return md->type; 678 return 0; 679} 680 681u64 682efi_mem_attributes (unsigned long phys_addr) 683{ 684 efi_memory_desc_t *md = efi_memory_descriptor(phys_addr); 685 686 if (md) 687 return md->attribute; 688 return 0; 689} 690EXPORT_SYMBOL(efi_mem_attributes); 691 692u64 693efi_mem_attribute (unsigned long phys_addr, unsigned long size) 694{ 695 unsigned long end = phys_addr + size; 696 efi_memory_desc_t *md = efi_memory_descriptor(phys_addr); 697 u64 attr; 698 699 if (!md) 700 return 0; 701 702 /* 703 * EFI_MEMORY_RUNTIME is not a memory attribute; it just tells 704 * the kernel that firmware needs this region mapped. 705 */ 706 attr = md->attribute & ~EFI_MEMORY_RUNTIME; 707 do { 708 unsigned long md_end = efi_md_end(md); 709 710 if (end <= md_end) 711 return attr; 712 713 md = efi_memory_descriptor(md_end); 714 if (!md || (md->attribute & ~EFI_MEMORY_RUNTIME) != attr) 715 return 0; 716 } while (md); 717 return 0; 718} 719 720u64 721kern_mem_attribute (unsigned long phys_addr, unsigned long size) 722{ 723 unsigned long end = phys_addr + size; 724 struct kern_memdesc *md; 725 u64 attr; 726 727 /* 728 * This is a hack for ioremap calls before we set up kern_memmap. 729 * Maybe we should do efi_memmap_init() earlier instead. 730 */ 731 if (!kern_memmap) { 732 attr = efi_mem_attribute(phys_addr, size); 733 if (attr & EFI_MEMORY_WB) 734 return EFI_MEMORY_WB; 735 return 0; 736 } 737 738 md = kern_memory_descriptor(phys_addr); 739 if (!md) 740 return 0; 741 742 attr = md->attribute; 743 do { 744 unsigned long md_end = kmd_end(md); 745 746 if (end <= md_end) 747 return attr; 748 749 md = kern_memory_descriptor(md_end); 750 if (!md || md->attribute != attr) 751 return 0; 752 } while (md); 753 return 0; 754} 755EXPORT_SYMBOL(kern_mem_attribute); 756 757int 758valid_phys_addr_range (unsigned long phys_addr, unsigned long size) 759{ 760 u64 attr; 761 762 /* 763 * /dev/mem reads and writes use copy_to_user(), which implicitly 764 * uses a granule-sized kernel identity mapping. It's really 765 * only safe to do this for regions in kern_memmap. For more 766 * details, see Documentation/ia64/aliasing.txt. 767 */ 768 attr = kern_mem_attribute(phys_addr, size); 769 if (attr & EFI_MEMORY_WB || attr & EFI_MEMORY_UC) 770 return 1; 771 return 0; 772} 773 774int 775valid_mmap_phys_addr_range (unsigned long pfn, unsigned long size) 776{ 777 unsigned long phys_addr = pfn << PAGE_SHIFT; 778 u64 attr; 779 780 attr = efi_mem_attribute(phys_addr, size); 781 782 /* 783 * /dev/mem mmap uses normal user pages, so we don't need the entire 784 * granule, but the entire region we're mapping must support the same 785 * attribute. 786 */ 787 if (attr & EFI_MEMORY_WB || attr & EFI_MEMORY_UC) 788 return 1; 789 790 /* 791 * Intel firmware doesn't tell us about all the MMIO regions, so 792 * in general we have to allow mmap requests. But if EFI *does* 793 * tell us about anything inside this region, we should deny it. 794 * The user can always map a smaller region to avoid the overlap. 795 */ 796 if (efi_memmap_intersects(phys_addr, size)) 797 return 0; 798 799 return 1; 800} 801 802pgprot_t 803phys_mem_access_prot(struct file *file, unsigned long pfn, unsigned long size, 804 pgprot_t vma_prot) 805{ 806 unsigned long phys_addr = pfn << PAGE_SHIFT; 807 u64 attr; 808 809 /* 810 * For /dev/mem mmap, we use user mappings, but if the region is 811 * in kern_memmap (and hence may be covered by a kernel mapping), 812 * we must use the same attribute as the kernel mapping. 813 */ 814 attr = kern_mem_attribute(phys_addr, size); 815 if (attr & EFI_MEMORY_WB) 816 return pgprot_cacheable(vma_prot); 817 else if (attr & EFI_MEMORY_UC) 818 return pgprot_noncached(vma_prot); 819 820 /* 821 * Some chipsets don't support UC access to memory. If 822 * WB is supported, we prefer that. 823 */ 824 if (efi_mem_attribute(phys_addr, size) & EFI_MEMORY_WB) 825 return pgprot_cacheable(vma_prot); 826 827 return pgprot_noncached(vma_prot); 828} 829 830int __init 831efi_uart_console_only(void) 832{ 833 efi_status_t status; 834 char *s, name[] = "ConOut"; 835 efi_guid_t guid = EFI_GLOBAL_VARIABLE_GUID; 836 efi_char16_t *utf16, name_utf16[32]; 837 unsigned char data[1024]; 838 unsigned long size = sizeof(data); 839 struct efi_generic_dev_path *hdr, *end_addr; 840 int uart = 0; 841 842 /* Convert to UTF-16 */ 843 utf16 = name_utf16; 844 s = name; 845 while (*s) 846 *utf16++ = *s++ & 0x7f; 847 *utf16 = 0; 848 849 status = efi.get_variable(name_utf16, &guid, NULL, &size, data); 850 if (status != EFI_SUCCESS) { 851 printk(KERN_ERR "No EFI %s variable?\n", name); 852 return 0; 853 } 854 855 hdr = (struct efi_generic_dev_path *) data; 856 end_addr = (struct efi_generic_dev_path *) ((u8 *) data + size); 857 while (hdr < end_addr) { 858 if (hdr->type == EFI_DEV_MSG && 859 hdr->sub_type == EFI_DEV_MSG_UART) 860 uart = 1; 861 else if (hdr->type == EFI_DEV_END_PATH || 862 hdr->type == EFI_DEV_END_PATH2) { 863 if (!uart) 864 return 0; 865 if (hdr->sub_type == EFI_DEV_END_ENTIRE) 866 return 1; 867 uart = 0; 868 } 869 hdr = (struct efi_generic_dev_path *) ((u8 *) hdr + hdr->length); 870 } 871 printk(KERN_ERR "Malformed %s value\n", name); 872 return 0; 873} 874 875/* 876 * Look for the first granule aligned memory descriptor memory 877 * that is big enough to hold EFI memory map. Make sure this 878 * descriptor is atleast granule sized so it does not get trimmed 879 */ 880struct kern_memdesc * 881find_memmap_space (void) 882{ 883 u64 contig_low=0, contig_high=0; 884 u64 as = 0, ae; 885 void *efi_map_start, *efi_map_end, *p, *q; 886 efi_memory_desc_t *md, *pmd = NULL, *check_md; 887 u64 space_needed, efi_desc_size; 888 unsigned long total_mem = 0; 889 890 efi_map_start = __va(ia64_boot_param->efi_memmap); 891 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 892 efi_desc_size = ia64_boot_param->efi_memdesc_size; 893 894 /* 895 * Worst case: we need 3 kernel descriptors for each efi descriptor 896 * (if every entry has a WB part in the middle, and UC head and tail), 897 * plus one for the end marker. 898 */ 899 space_needed = sizeof(kern_memdesc_t) * 900 (3 * (ia64_boot_param->efi_memmap_size/efi_desc_size) + 1); 901 902 for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) { 903 md = p; 904 if (!efi_wb(md)) { 905 continue; 906 } 907 if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) { 908 contig_low = GRANULEROUNDUP(md->phys_addr); 909 contig_high = efi_md_end(md); 910 for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) { 911 check_md = q; 912 if (!efi_wb(check_md)) 913 break; 914 if (contig_high != check_md->phys_addr) 915 break; 916 contig_high = efi_md_end(check_md); 917 } 918 contig_high = GRANULEROUNDDOWN(contig_high); 919 } 920 if (!is_memory_available(md) || md->type == EFI_LOADER_DATA) 921 continue; 922 923 /* Round ends inward to granule boundaries */ 924 as = max(contig_low, md->phys_addr); 925 ae = min(contig_high, efi_md_end(md)); 926 927 /* keep within max_addr= and min_addr= command line arg */ 928 as = max(as, min_addr); 929 ae = min(ae, max_addr); 930 if (ae <= as) 931 continue; 932 933 /* avoid going over mem= command line arg */ 934 if (total_mem + (ae - as) > mem_limit) 935 ae -= total_mem + (ae - as) - mem_limit; 936 937 if (ae <= as) 938 continue; 939 940 if (ae - as > space_needed) 941 break; 942 } 943 if (p >= efi_map_end) 944 panic("Can't allocate space for kernel memory descriptors"); 945 946 return __va(as); 947} 948 949/* 950 * Walk the EFI memory map and gather all memory available for kernel 951 * to use. We can allocate partial granules only if the unavailable 952 * parts exist, and are WB. 953 */ 954void 955efi_memmap_init(unsigned long *s, unsigned long *e) 956{ 957 struct kern_memdesc *k, *prev = NULL; 958 u64 contig_low=0, contig_high=0; 959 u64 as, ae, lim; 960 void *efi_map_start, *efi_map_end, *p, *q; 961 efi_memory_desc_t *md, *pmd = NULL, *check_md; 962 u64 efi_desc_size; 963 unsigned long total_mem = 0; 964 965 k = kern_memmap = find_memmap_space(); 966 967 efi_map_start = __va(ia64_boot_param->efi_memmap); 968 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 969 efi_desc_size = ia64_boot_param->efi_memdesc_size; 970 971 for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) { 972 md = p; 973 if (!efi_wb(md)) { 974 if (efi_uc(md) && (md->type == EFI_CONVENTIONAL_MEMORY || 975 md->type == EFI_BOOT_SERVICES_DATA)) { 976 k->attribute = EFI_MEMORY_UC; 977 k->start = md->phys_addr; 978 k->num_pages = md->num_pages; 979 k++; 980 } 981 continue; 982 } 983 if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) { 984 contig_low = GRANULEROUNDUP(md->phys_addr); 985 contig_high = efi_md_end(md); 986 for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) { 987 check_md = q; 988 if (!efi_wb(check_md)) 989 break; 990 if (contig_high != check_md->phys_addr) 991 break; 992 contig_high = efi_md_end(check_md); 993 } 994 contig_high = GRANULEROUNDDOWN(contig_high); 995 } 996 if (!is_memory_available(md)) 997 continue; 998 999#ifdef CONFIG_CRASH_DUMP 1000 /* saved_max_pfn should ignore max_addr= command line arg */ 1001 if (saved_max_pfn < (efi_md_end(md) >> PAGE_SHIFT)) 1002 saved_max_pfn = (efi_md_end(md) >> PAGE_SHIFT); 1003#endif 1004 /* 1005 * Round ends inward to granule boundaries 1006 * Give trimmings to uncached allocator 1007 */ 1008 if (md->phys_addr < contig_low) { 1009 lim = min(efi_md_end(md), contig_low); 1010 if (efi_uc(md)) { 1011 if (k > kern_memmap && (k-1)->attribute == EFI_MEMORY_UC && 1012 kmd_end(k-1) == md->phys_addr) { 1013 (k-1)->num_pages += (lim - md->phys_addr) >> EFI_PAGE_SHIFT; 1014 } else { 1015 k->attribute = EFI_MEMORY_UC; 1016 k->start = md->phys_addr; 1017 k->num_pages = (lim - md->phys_addr) >> EFI_PAGE_SHIFT; 1018 k++; 1019 } 1020 } 1021 as = contig_low; 1022 } else 1023 as = md->phys_addr; 1024 1025 if (efi_md_end(md) > contig_high) { 1026 lim = max(md->phys_addr, contig_high); 1027 if (efi_uc(md)) { 1028 if (lim == md->phys_addr && k > kern_memmap && 1029 (k-1)->attribute == EFI_MEMORY_UC && 1030 kmd_end(k-1) == md->phys_addr) { 1031 (k-1)->num_pages += md->num_pages; 1032 } else { 1033 k->attribute = EFI_MEMORY_UC; 1034 k->start = lim; 1035 k->num_pages = (efi_md_end(md) - lim) >> EFI_PAGE_SHIFT; 1036 k++; 1037 } 1038 } 1039 ae = contig_high; 1040 } else 1041 ae = efi_md_end(md); 1042 1043 /* keep within max_addr= and min_addr= command line arg */ 1044 as = max(as, min_addr); 1045 ae = min(ae, max_addr); 1046 if (ae <= as) 1047 continue; 1048 1049 /* avoid going over mem= command line arg */ 1050 if (total_mem + (ae - as) > mem_limit) 1051 ae -= total_mem + (ae - as) - mem_limit; 1052 1053 if (ae <= as) 1054 continue; 1055 if (prev && kmd_end(prev) == md->phys_addr) { 1056 prev->num_pages += (ae - as) >> EFI_PAGE_SHIFT; 1057 total_mem += ae - as; 1058 continue; 1059 } 1060 k->attribute = EFI_MEMORY_WB; 1061 k->start = as; 1062 k->num_pages = (ae - as) >> EFI_PAGE_SHIFT; 1063 total_mem += ae - as; 1064 prev = k++; 1065 } 1066 k->start = ~0L; /* end-marker */ 1067 1068 /* reserve the memory we are using for kern_memmap */ 1069 *s = (u64)kern_memmap; 1070 *e = (u64)++k; 1071} 1072 1073void 1074efi_initialize_iomem_resources(struct resource *code_resource, 1075 struct resource *data_resource) 1076{ 1077 struct resource *res; 1078 void *efi_map_start, *efi_map_end, *p; 1079 efi_memory_desc_t *md; 1080 u64 efi_desc_size; 1081 char *name; 1082 unsigned long flags; 1083 1084 efi_map_start = __va(ia64_boot_param->efi_memmap); 1085 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 1086 efi_desc_size = ia64_boot_param->efi_memdesc_size; 1087 1088 res = NULL; 1089 1090 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 1091 md = p; 1092 1093 if (md->num_pages == 0) /* should not happen */ 1094 continue; 1095 1096 flags = IORESOURCE_MEM; 1097 switch (md->type) { 1098 1099 case EFI_MEMORY_MAPPED_IO: 1100 case EFI_MEMORY_MAPPED_IO_PORT_SPACE: 1101 continue; 1102 1103 case EFI_LOADER_CODE: 1104 case EFI_LOADER_DATA: 1105 case EFI_BOOT_SERVICES_DATA: 1106 case EFI_BOOT_SERVICES_CODE: 1107 case EFI_CONVENTIONAL_MEMORY: 1108 if (md->attribute & EFI_MEMORY_WP) { 1109 name = "System ROM"; 1110 flags |= IORESOURCE_READONLY; 1111 } else { 1112 name = "System RAM"; 1113 } 1114 break; 1115 1116 case EFI_ACPI_MEMORY_NVS: 1117 name = "ACPI Non-volatile Storage"; 1118 flags |= IORESOURCE_BUSY; 1119 break; 1120 1121 case EFI_UNUSABLE_MEMORY: 1122 name = "reserved"; 1123 flags |= IORESOURCE_BUSY | IORESOURCE_DISABLED; 1124 break; 1125 1126 case EFI_RESERVED_TYPE: 1127 case EFI_RUNTIME_SERVICES_CODE: 1128 case EFI_RUNTIME_SERVICES_DATA: 1129 case EFI_ACPI_RECLAIM_MEMORY: 1130 default: 1131 name = "reserved"; 1132 flags |= IORESOURCE_BUSY; 1133 break; 1134 } 1135 1136 if ((res = kzalloc(sizeof(struct resource), GFP_KERNEL)) == NULL) { 1137 printk(KERN_ERR "failed to alocate resource for iomem\n"); 1138 return; 1139 } 1140 1141 res->name = name; 1142 res->start = md->phys_addr; 1143 res->end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1; 1144 res->flags = flags; 1145 1146 if (insert_resource(&iomem_resource, res) < 0) 1147 kfree(res); 1148 else { 1149 /* 1150 * We don't know which region contains 1151 * kernel data so we try it repeatedly and 1152 * let the resource manager test it. 1153 */ 1154 insert_resource(res, code_resource); 1155 insert_resource(res, data_resource); 1156#ifdef CONFIG_KEXEC 1157 insert_resource(res, &efi_memmap_res); 1158 insert_resource(res, &boot_param_res); 1159 if (crashk_res.end > crashk_res.start) 1160 insert_resource(res, &crashk_res); 1161#endif 1162 } 1163 } 1164} 1165 1166#ifdef CONFIG_KEXEC 1167/* find a block of memory aligned to 64M exclude reserved regions 1168 rsvd_regions are sorted 1169 */ 1170unsigned long __init 1171kdump_find_rsvd_region (unsigned long size, 1172 struct rsvd_region *r, int n) 1173{ 1174 int i; 1175 u64 start, end; 1176 u64 alignment = 1UL << _PAGE_SIZE_64M; 1177 void *efi_map_start, *efi_map_end, *p; 1178 efi_memory_desc_t *md; 1179 u64 efi_desc_size; 1180 1181 efi_map_start = __va(ia64_boot_param->efi_memmap); 1182 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 1183 efi_desc_size = ia64_boot_param->efi_memdesc_size; 1184 1185 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 1186 md = p; 1187 if (!efi_wb(md)) 1188 continue; 1189 start = ALIGN(md->phys_addr, alignment); 1190 end = efi_md_end(md); 1191 for (i = 0; i < n; i++) { 1192 if (__pa(r[i].start) >= start && __pa(r[i].end) < end) { 1193 if (__pa(r[i].start) > start + size) 1194 return start; 1195 start = ALIGN(__pa(r[i].end), alignment); 1196 if (i < n-1 && __pa(r[i+1].start) < start + size) 1197 continue; 1198 else 1199 break; 1200 } 1201 } 1202 if (end > start + size) 1203 return start; 1204 } 1205 1206 printk(KERN_WARNING "Cannot reserve 0x%lx byte of memory for crashdump\n", 1207 size); 1208 return ~0UL; 1209} 1210#endif 1211 1212#ifdef CONFIG_PROC_VMCORE 1213/* locate the size find a the descriptor at a certain address */ 1214unsigned long 1215vmcore_find_descriptor_size (unsigned long address) 1216{ 1217 void *efi_map_start, *efi_map_end, *p; 1218 efi_memory_desc_t *md; 1219 u64 efi_desc_size; 1220 unsigned long ret = 0; 1221 1222 efi_map_start = __va(ia64_boot_param->efi_memmap); 1223 efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size; 1224 efi_desc_size = ia64_boot_param->efi_memdesc_size; 1225 1226 for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) { 1227 md = p; 1228 if (efi_wb(md) && md->type == EFI_LOADER_DATA 1229 && md->phys_addr == address) { 1230 ret = efi_md_size(md); 1231 break; 1232 } 1233 } 1234 1235 if (ret == 0) 1236 printk(KERN_WARNING "Cannot locate EFI vmcore descriptor\n"); 1237 1238 return ret; 1239} 1240#endif 1241