开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
efi.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：14k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

efi.c：源码内容
  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-2001 Hewlett-Packard Co.
  9.  * David Mosberger-Tang <davidm@hpl.hp.com>
  10.  * Stephane Eranian <eranian@hpl.hp.com>
  11.  *
  12.  * All EFI Runtime Services are not implemented yet as EFI only
  13.  * supports physical mode addressing on SoftSDV. This is to be fixed
  14.  * in a future version.  --drummond 1999-07-20
  15.  *
  16.  * Implemented EFI runtime services and virtual mode calls.  --davidm
  17.  *
  18.  * Goutham Rao: <goutham.rao@intel.com>
  19.  * Skip non-WB memory and ignore empty memory ranges.
  20.  */
  21. #include <linux/config.h>
  22. #include <linux/kernel.h>
  23. #include <linux/init.h>
  24. #include <linux/types.h>
  25. #include <linux/time.h>
  26. #include <linux/proc_fs.h>
  28. #include <asm/efi.h>
  29. #include <asm/io.h>
  30. #include <asm/kregs.h>
  31. #include <asm/pgtable.h>
  32. #include <asm/processor.h>
  34. #define EFI_DEBUG 0
  36. extern efi_status_t efi_call_phys (void *, ...);
  38. struct efi efi;
  39. static efi_runtime_services_t *runtime;
  41. /*
  42.  * efi_dir is allocated here, but the directory isn't created
  43.  * here, as proc_mkdir() doesn't work this early in the bootup
  44.  * process.  Therefore, each module, like efivars, must test for
  45.  *    if (!efi_dir)  efi_dir = proc_mkdir("efi", NULL);
  46.  * prior to creating their own entries under /proc/efi.
  47.  */
  48. #ifdef CONFIG_PROC_FS
  49. struct proc_dir_entry *efi_dir = NULL;
  50. #endif
  52. static unsigned long mem_limit = ~0UL;
  54. static efi_status_t
  55. phys_get_time (efi_time_t *tm, efi_time_cap_t *tc)
  56. {
  57. return efi_call_phys(__va(runtime->get_time), __pa(tm), __pa(tc));
  58. }
  60. static efi_status_t
  61. phys_set_time (efi_time_t *tm)
  62. {
  63. return efi_call_phys(__va(runtime->set_time), __pa(tm));
  64. }
  66. static efi_status_t
  67. phys_get_wakeup_time (efi_bool_t *enabled, efi_bool_t *pending, efi_time_t *tm)
  68. {
  69. return efi_call_phys(__va(runtime->get_wakeup_time), __pa(enabled), __pa(pending),
  70.      __pa(tm));
  71. }
  73. static efi_status_t
  74. phys_set_wakeup_time (efi_bool_t enabled, efi_time_t *tm)
  75. {
  76. return efi_call_phys(__va(runtime->set_wakeup_time), enabled, __pa(tm));
  77. }
  79. static efi_status_t
  80. phys_get_variable (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,
  81.    unsigned long *data_size, void *data)
  82. {
  83. return efi_call_phys(__va(runtime->get_variable), __pa(name), __pa(vendor), __pa(attr),
  84.      __pa(data_size), __pa(data));
  85. }
  87. static efi_status_t
  88. phys_get_next_variable (unsigned long *name_size, efi_char16_t *name, efi_guid_t *vendor)
  89. {
  90. return efi_call_phys(__va(runtime->get_next_variable), __pa(name_size), __pa(name),
  91.      __pa(vendor));
  92. }
  94. static efi_status_t
  95. phys_set_variable (efi_char16_t *name, efi_guid_t *vendor, u32 attr,
  96.    unsigned long data_size, void *data)
  97. {
  98. return efi_call_phys(__va(runtime->set_variable), __pa(name), __pa(vendor), attr,
  99.      data_size, __pa(data));
  100. }
  102. static efi_status_t
  103. phys_get_next_high_mono_count (u64 *count)
  104. {
  105. return efi_call_phys(__va(runtime->get_next_high_mono_count), __pa(count));
  106. }
  108. static void
  109. phys_reset_system (int reset_type, efi_status_t status,
  110.    unsigned long data_size, efi_char16_t *data)
  111. {
  112. efi_call_phys(__va(runtime->reset_system), status, data_size, __pa(data));
  113. }
  115. void
  116. efi_gettimeofday (struct timeval *tv)
  117. {
  118. efi_time_t tm;
  120. memset(tv, 0, sizeof(tv));
  121. if ((*efi.get_time)(&tm, 0) != EFI_SUCCESS)
  122. return;
  124. tv->tv_sec = mktime(tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
  125. tv->tv_usec = tm.nanosecond / 1000;
  126. }
  128. /*
  129.  * Walks the EFI memory map and calls CALLBACK once for each EFI
  130.  * memory descriptor that has memory that is available for OS use.
  131.  */
  132. void
  133. efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
  134. {
  135. int prev_valid = 0;
  136. struct range {
  137. u64 start;
  138. u64 end;
  139. } prev, curr;
  140. void *efi_map_start, *efi_map_end, *p;
  141. efi_memory_desc_t *md;
  142. u64 efi_desc_size, start, end;
  144. efi_map_start = __va(ia64_boot_param->efi_memmap);
  145. efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
  146. efi_desc_size = ia64_boot_param->efi_memdesc_size;
  148. for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
  149. md = p;
  150. switch (md->type) {
  151.       case EFI_LOADER_CODE:
  152.       case EFI_LOADER_DATA:
  153.       case EFI_BOOT_SERVICES_CODE:
  154.       case EFI_BOOT_SERVICES_DATA:
  155.       case EFI_CONVENTIONAL_MEMORY:
  156. if (!(md->attribute & EFI_MEMORY_WB))
  157. continue;
  158. if (md->phys_addr + (md->num_pages << 12) > mem_limit) {
  159. if (md->phys_addr > mem_limit)
  160. continue;
  161. md->num_pages = (mem_limit - md->phys_addr) >> 12;
  162. }
  163. if (md->num_pages == 0) {
  164. printk("efi_memmap_walk: ignoring empty region at 0x%lx",
  165.        md->phys_addr);
  166. continue;
  167. }
  169. curr.start = PAGE_OFFSET + md->phys_addr;
  170. curr.end   = curr.start + (md->num_pages << 12);
  172. if (!prev_valid) {
  173. prev = curr;
  174. prev_valid = 1;
  175. } else {
  176. if (curr.start < prev.start)
  177. printk("Oops: EFI memory table not ordered!n");
  179. if (prev.end == curr.start) {
  180. /* merge two consecutive memory ranges */
  181. prev.end = curr.end;
  182. } else {
  183. start = PAGE_ALIGN(prev.start);
  184. end = prev.end & PAGE_MASK;
  185. if ((end > start) && (*callback)(start, end, arg) < 0)
  186. return;
  187. prev = curr;
  188. }
  189. }
  190. break;
  192.       default:
  193. continue;
  194. }
  195. }
  196. if (prev_valid) {
  197. start = PAGE_ALIGN(prev.start);
  198. end = prev.end & PAGE_MASK;
  199. if (end > start)
  200. (*callback)(start, end, arg);
  201. }
  202. }
  204. /*
  205.  * Look for the PAL_CODE region reported by EFI and maps it using an
  206.  * ITR to enable safe PAL calls in virtual mode.  See IA-64 Processor
  207.  * Abstraction Layer chapter 11 in ADAG
  208.  */
  209. void
  210. efi_map_pal_code (void)
  211. {
  212. void *efi_map_start, *efi_map_end, *p;
  213. efi_memory_desc_t *md;
  214. u64 efi_desc_size;
  215. int pal_code_count=0;
  216. u64 mask, flags;
  217. u64 vaddr;
  219. efi_map_start = __va(ia64_boot_param->efi_memmap);
  220. efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
  221. efi_desc_size = ia64_boot_param->efi_memdesc_size;
  223. for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
  224. md = p;
  225. if (md->type != EFI_PAL_CODE)
  226. continue;
  228. if (++pal_code_count > 1) {
  229. printk(KERN_ERR "Too many EFI Pal Code memory ranges, dropped @ %lxn",
  230.        md->phys_addr);
  231. continue;
  232. }
  233. /*
  234.  * The only ITLB entry in region 7 that is used is the one installed by
  235.  * __start().  That entry covers a 64MB range.
  236.  */
  237. mask  = ~((1 << KERNEL_TR_PAGE_SHIFT) - 1);
  238. vaddr = PAGE_OFFSET + md->phys_addr;
  240. /*
  241.  * We must check that the PAL mapping won't overlap with the kernel
  242.  * mapping.
  243.  *
  244.  * PAL code is guaranteed to be aligned on a power of 2 between 4k and
  245.  * 256KB and that only one ITR is needed to map it. This implies that the
  246.  * PAL code is always aligned on its size, i.e., the closest matching page
  247.  * size supported by the TLB. Therefore PAL code is guaranteed never to
  248.  * cross a 64MB unless it is bigger than 64MB (very unlikely!).  So for
  249.  * now the following test is enough to determine whether or not we need a
  250.  * dedicated ITR for the PAL code.
  251.  */
  252. if ((vaddr & mask) == (KERNEL_START & mask)) {
  253. printk(__FUNCTION__ ": no need to install ITR for PAL coden");
  254. continue;
  255. }
  257. if (md->num_pages << 12 > IA64_GRANULE_SIZE)
  258. panic("Woah!  PAL code size bigger than a granule!");
  260. mask  = ~((1 << IA64_GRANULE_SHIFT) - 1);
  261. printk("CPU %d: mapping PAL code [0x%lx-0x%lx) into [0x%lx-0x%lx)n",
  262.        smp_processor_id(), md->phys_addr, md->phys_addr + (md->num_pages << 12),
  263.        vaddr & mask, (vaddr & mask) + IA64_GRANULE_SIZE);
  265. /*
  266.  * Cannot write to CRx with PSR.ic=1
  267.  */
  268. ia64_clear_ic(flags);
  269. ia64_itr(0x1, IA64_TR_PALCODE, vaddr & mask,
  270.  pte_val(mk_pte_phys(md->phys_addr, PAGE_KERNEL)), IA64_GRANULE_SHIFT);
  271. local_irq_restore(flags);
  272. ia64_srlz_i();
  273. }
  274. }
  276. void __init
  277. efi_init (void)
  278. {
  279. void *efi_map_start, *efi_map_end;
  280. efi_config_table_t *config_tables;
  281. efi_char16_t *c16;
  282. u64 efi_desc_size;
  283. char *cp, *end, vendor[100] = "unknown";
  284. extern char saved_command_line[];
  285. int i;
  287. /* it's too early to be able to use the standard kernel command line support... */
  288. for (cp = saved_command_line; *cp; ) {
  289. if (memcmp(cp, "mem=", 4) == 0) {
  290. cp += 4;
  291. mem_limit = memparse(cp, &end) - 1;
  292. if (end != cp)
  293. break;
  294. cp = end;
  295. } else {
  296. while (*cp != ' ' && *cp)
  297. ++cp;
  298. while (*cp == ' ')
  299. ++cp;
  300. }
  301. }
  302. if (mem_limit != ~0UL)
  303. printk("Ignoring memory above %luMBn", mem_limit >> 20);
  305. efi.systab = __va(ia64_boot_param->efi_systab);
  307. /*
  308.  * Verify the EFI Table
  309.  */
  310. if (efi.systab == NULL)
  311. panic("Woah! Can't find EFI system table.n");
  312. if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
  313. panic("Woah! EFI system table signature incorrectn");
  314. if ((efi.systab->hdr.revision ^ EFI_SYSTEM_TABLE_REVISION) >> 16 != 0)
  315. printk("Warning: EFI system table major version mismatch: "
  316.        "got %d.%02d, expected %d.%02dn",
  317.        efi.systab->hdr.revision >> 16, efi.systab->hdr.revision & 0xffff,
  318.        EFI_SYSTEM_TABLE_REVISION >> 16, EFI_SYSTEM_TABLE_REVISION & 0xffff);
  320. config_tables = __va(efi.systab->tables);
  322. /* Show what we know for posterity */
  323. c16 = __va(efi.systab->fw_vendor);
  324. if (c16) {
  325. for (i = 0;i < sizeof(vendor) && *c16; ++i)
  326. vendor[i] = *c16++;
  327. vendor[i] = '';
  328. }
  330. printk("EFI v%u.%.02u by %s:",
  331.        efi.systab->hdr.revision >> 16, efi.systab->hdr.revision & 0xffff, vendor);
  333. for (i = 0; i < efi.systab->nr_tables; i++) {
  334. if (efi_guidcmp(config_tables[i].guid, MPS_TABLE_GUID) == 0) {
  335. efi.mps = __va(config_tables[i].table);
  336. printk(" MPS=0x%lx", config_tables[i].table);
  337. } else if (efi_guidcmp(config_tables[i].guid, ACPI_20_TABLE_GUID) == 0) {
  338. efi.acpi20 = __va(config_tables[i].table);
  339. printk(" ACPI 2.0=0x%lx", config_tables[i].table);
  340. } else if (efi_guidcmp(config_tables[i].guid, ACPI_TABLE_GUID) == 0) {
  341. efi.acpi = __va(config_tables[i].table);
  342. printk(" ACPI=0x%lx", config_tables[i].table);
  343. } else if (efi_guidcmp(config_tables[i].guid, SMBIOS_TABLE_GUID) == 0) {
  344. efi.smbios = __va(config_tables[i].table);
  345. printk(" SMBIOS=0x%lx", config_tables[i].table);
  346. } else if (efi_guidcmp(config_tables[i].guid, SAL_SYSTEM_TABLE_GUID) == 0) {
  347. efi.sal_systab = __va(config_tables[i].table);
  348. printk(" SALsystab=0x%lx", config_tables[i].table);
  349. }
  350. }
  351. printk("n");
  353. runtime = __va(efi.systab->runtime);
  354. efi.get_time = phys_get_time;
  355. efi.set_time = phys_set_time;
  356. efi.get_wakeup_time = phys_get_wakeup_time;
  357. efi.set_wakeup_time = phys_set_wakeup_time;
  358. efi.get_variable = phys_get_variable;
  359. efi.get_next_variable = phys_get_next_variable;
  360. efi.set_variable = phys_set_variable;
  361. efi.get_next_high_mono_count = phys_get_next_high_mono_count;
  362. efi.reset_system = phys_reset_system;
  364. efi_map_start = __va(ia64_boot_param->efi_memmap);
  365. efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
  366. efi_desc_size = ia64_boot_param->efi_memdesc_size;
  368. #if EFI_DEBUG
  369. /* print EFI memory map: */
  370. {
  371. efi_memory_desc_t *md;
  372. void *p;
  374. for (i = 0, p = efi_map_start; p < efi_map_end; ++i, p += efi_desc_size) {
  375. md = p;
  376. printk("mem%02u: type=%u, attr=0x%lx, range=[0x%016lx-0x%016lx) (%luMB)n",
  377.        i, md->type, md->attribute, md->phys_addr,
  378.        md->phys_addr + (md->num_pages<<12) - 1, md->num_pages >> 8);
  379. }
  380. }
  381. #endif
  383. efi_map_pal_code();
  384. efi_enter_virtual_mode();
  385. }
  387. void
  388. efi_enter_virtual_mode (void)
  389. {
  390. void *efi_map_start, *efi_map_end, *p;
  391. efi_memory_desc_t *md;
  392. efi_status_t status;
  393. u64 efi_desc_size;
  395. efi_map_start = __va(ia64_boot_param->efi_memmap);
  396. efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
  397. efi_desc_size = ia64_boot_param->efi_memdesc_size;
  399. for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
  400. md = p;
  401. if (md->attribute & EFI_MEMORY_RUNTIME) {
  402. /*
  403.  * Some descriptors have multiple bits set, so the order of
  404.  * the tests is relevant.
  405.  */
  406. if (md->attribute & EFI_MEMORY_WB) {
  407. md->virt_addr = (u64) __va(md->phys_addr);
  408. } else if (md->attribute & EFI_MEMORY_UC) {
  409. md->virt_addr = (u64) ioremap(md->phys_addr, 0);
  410. } else if (md->attribute & EFI_MEMORY_WC) {
  411. #if 0
  412. md->virt_addr = ia64_remap(md->phys_addr, (_PAGE_A | _PAGE_P
  413.    | _PAGE_D
  414.    | _PAGE_MA_WC
  415.    | _PAGE_PL_0
  416.    | _PAGE_AR_RW));
  417. #else
  418. printk("EFI_MEMORY_WC mappingn");
  419. md->virt_addr = (u64) ioremap(md->phys_addr, 0);
  420. #endif
  421. } else if (md->attribute & EFI_MEMORY_WT) {
  422. #if 0
  423. md->virt_addr = ia64_remap(md->phys_addr, (_PAGE_A | _PAGE_P
  424.    | _PAGE_D | _PAGE_MA_WT
  425.    | _PAGE_PL_0
  426.    | _PAGE_AR_RW));
  427. #else
  428. printk("EFI_MEMORY_WT mappingn");
  429. md->virt_addr = (u64) ioremap(md->phys_addr, 0);
  430. #endif
  431. }
  432. }
  433. }
  435. status = efi_call_phys(__va(runtime->set_virtual_address_map),
  436.        ia64_boot_param->efi_memmap_size,
  437.        efi_desc_size, ia64_boot_param->efi_memdesc_version,
  438.        ia64_boot_param->efi_memmap);
  439. if (status != EFI_SUCCESS) {
  440. printk("Warning: unable to switch EFI into virtual mode (status=%lu)n", status);
  441. return;
  442. }
  444. /*
  445.  * Now that EFI is in virtual mode, we arrange for EFI functions to be
  446.  * called directly:
  447.  */
  448. efi.get_time = __va(runtime->get_time);
  449. efi.set_time = __va(runtime->set_time);
  450. efi.get_wakeup_time = __va(runtime->get_wakeup_time);
  451. efi.set_wakeup_time = __va(runtime->set_wakeup_time);
  452. efi.get_variable = __va(runtime->get_variable);
  453. efi.get_next_variable = __va(runtime->get_next_variable);
  454. efi.set_variable = __va(runtime->set_variable);
  455. efi.get_next_high_mono_count = __va(runtime->get_next_high_mono_count);
  456. efi.reset_system = __va(runtime->reset_system);
  457. }
  459. /*
  460.  * Walk the EFI memory map looking for the I/O port range.  There can only be one entry of
  461.  * this type, other I/O port ranges should be described via ACPI.
  462.  */
  463. u64
  464. efi_get_iobase (void)
  465. {
  466. void *efi_map_start, *efi_map_end, *p;
  467. efi_memory_desc_t *md;
  468. u64 efi_desc_size;
  470. efi_map_start = __va(ia64_boot_param->efi_memmap);
  471. efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
  472. efi_desc_size = ia64_boot_param->efi_memdesc_size;
  474. for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
  475. md = p;
  476. if (md->type == EFI_MEMORY_MAPPED_IO_PORT_SPACE) {
  477. /* paranoia attribute checking */
  478. if (md->attribute == (EFI_MEMORY_UC | EFI_MEMORY_RUNTIME))
  479. return md->phys_addr;
  480. }
  481. }
  482. return 0;
  483. }
  485. static void __exit
  486. efivars_exit(void)
  487. {
  488. #ifdef CONFIG_PROC_FS
  489.   remove_proc_entry(efi_dir->name, NULL);
  490. #endif
  491. }