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

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

嵌入式Linux

开发平台：

Unix_Linux

fw-emu.c：源码内容
  1. /*
  2.  * PAL & SAL emulation.
  3.  *
  4.  * Copyright (C) 1998-2000 Hewlett-Packard Co
  5.  * Copyright (C) 1998-2000 David Mosberger-Tang <davidm@hpl.hp.com>
  6.  *
  7.  *
  8.  * Copyright (C) 2000 Silicon Graphics, Inc.
  9.  * Copyright (C) 2000 by Jack Steiner (steiner@sgi.com)
  10.  */
  11. #include <asm/efi.h>
  12. #include <asm/pal.h>
  13. #include <asm/sal.h>
  14. #include <asm/processor.h>
  15. #include <asm/acpi-ext.h>
  16. #include "fpmem.h"
  18. #define MB (1024*1024UL)
  19. #define GB (MB*1024UL)
  21. #define FPROM_BUG() do {while (1);} while (0)
  22. #define MAX_NODES 128
  23. #define MAX_LSAPICS 512
  24. #define MAX_CPUS 512
  25. #define MAX_CPUS_NODE 4
  26. #define CPUS_PER_NODE 4
  27. #define CPUS_PER_FSB 2
  28. #define CPUS_PER_FSB_MASK (CPUS_PER_FSB-1)
  30. #define NUM_EFI_DESCS 2
  32. typedef union ia64_nasid_va {
  33.         struct {
  34.                 unsigned long off   : 33;       /* intra-region offset */
  35. unsigned long nasid :  7; /* NASID */
  36. unsigned long off2  : 21; /* fill */
  37.                 unsigned long reg   :  3;       /* region number */
  38.         } f;
  39.         unsigned long l;
  40.         void *p;
  41. } ia64_nasid_va;
  43. typedef struct {
  44. unsigned long pc;
  45. unsigned long gp;
  46. } func_ptr_t;
  47.  
  48. #define IS_VIRTUAL_MODE()   ({struct ia64_psr psr; asm("mov %0=psr" : "=r"(psr)); psr.dt;})
  49. #define ADDR_OF(p) (IS_VIRTUAL_MODE() ? ((void*)((long)(p)+PAGE_OFFSET)) : ((void*) (p)))
  50. #define __fwtab_pa(n,x) ({ia64_nasid_va _v; _v.l = (long) (x); _v.f.nasid = (x) ? (n) : 0; _v.f.reg = 0; _v.l;})
  52. /*
  53.  * The following variables are passed thru registersfrom the configuration file and
  54.  * are set via the _start function.
  55.  */
  56. long base_nasid;
  57. long num_cpus;
  58. long bsp_entry_pc=0;
  59. long num_nodes;
  60. long app_entry_pc;
  61. int bsp_lid;
  62. func_ptr_t ap_entry;
  65. static efi_runtime_services_t    *efi_runtime_p;
  66. static char fw_mem[(  sizeof(efi_system_table_t)
  67.     + sizeof(efi_runtime_services_t)
  68.     + NUM_EFI_DESCS*sizeof(efi_config_table_t)
  69.     + sizeof(struct ia64_sal_systab)
  70.     + sizeof(struct ia64_sal_desc_entry_point)
  71.     + sizeof(struct ia64_sal_desc_ap_wakeup)
  72.     + sizeof(acpi_rsdp_t)
  73.     + sizeof(acpi_rsdt_t)
  74.     + sizeof(acpi_sapic_t)
  75.     + MAX_LSAPICS*(sizeof(acpi_entry_lsapic_t))
  76.     + (1+8*MAX_NODES)*(sizeof(efi_memory_desc_t))
  77.     + sizeof(ia64_sal_desc_ptc_t) +
  78.     + MAX_NODES*sizeof(ia64_sal_ptc_domain_info_t) +
  79.     + MAX_CPUS*sizeof(ia64_sal_ptc_domain_proc_entry_t) +
  80.     + 1024)] __attribute__ ((aligned (8)));
  82. /*
  83.  * Very ugly, but we need this in the simulator only.  Once we run on
  84.  * real hw, this can all go away.
  85.  */
  86. extern void pal_emulator_static (void);
  88. asm ("
  89. .text
  90. .proc pal_emulator_static
  91. pal_emulator_static:
  92. mov r8=-1;;
  93. cmp.eq p6,p7=6,r28;; /* PAL_PTCE_INFO */
  94. (p7) br.cond.sptk.few 1f
  95. ;;
  96. mov r8=0 /* status = 0 */
  97. movl r9=0x500000000 /* tc.base */
  98. movl r10=0x0000000200000003 /* count[0], count[1] */
  99. movl r11=0x1000000000002000 /* stride[0], stride[1] */
  100. br.cond.sptk.few rp
  102. 1: cmp.eq p6,p7=14,r28;; /* PAL_FREQ_RATIOS */
  103. (p7) br.cond.sptk.few 1f;;
  104. mov r8=0 /* status = 0 */
  105. movl r9 =0x100000064 /* proc_ratio (1/100) */
  106. movl r10=0x100000100 /* bus_ratio<<32 (1/256) */
  107. movl r11=0x10000000a /* itc_ratio<<32 (1/100) */
  109. 1: cmp.eq p6,p7=22,r28;; /* PAL_MC_DRAIN */
  110. (p7) br.cond.sptk.few 1f;;
  111. mov r8=0
  112. br.cond.sptk.few rp
  114. 1: cmp.eq p6,p7=23,r28;; /* PAL_MC_EXPECTED */
  115. (p7) br.cond.sptk.few 1f;;
  116. mov r8=0
  117. br.cond.sptk.few rp
  119. 1: br.cond.sptk.few rp
  120. .endp pal_emulator_staticn");
  123. static efi_status_t
  124. efi_get_time (efi_time_t *tm, efi_time_cap_t *tc)
  125. {
  126. if (tm) {
  127. memset(tm, 0, sizeof(*tm));
  128. tm->year = 2000;
  129. tm->month = 2;
  130. tm->day = 13;
  131. tm->hour = 10;
  132. tm->minute = 11;
  133. tm->second = 12;
  134. }
  136. if (tc) {
  137. tc->resolution = 10;
  138. tc->accuracy = 12;
  139. tc->sets_to_zero = 1;
  140. }
  142. return EFI_SUCCESS;
  143. }
  145. static void
  146. efi_reset_system (int reset_type, efi_status_t status, unsigned long data_size, efi_char16_t *data)
  147. {
  148. while(1); /* Is there a pseudo-op to stop medusa */
  149. }
  151. static efi_status_t
  152. efi_success (void)
  153. {
  154. return EFI_SUCCESS;
  155. }
  157. static efi_status_t
  158. efi_unimplemented (void)
  159. {
  160. return EFI_UNSUPPORTED;
  161. }
  163. static long
  164. sal_emulator (long index, unsigned long in1, unsigned long in2,
  165.       unsigned long in3, unsigned long in4, unsigned long in5,
  166.       unsigned long in6, unsigned long in7)
  167. {
  168. register long r9 asm ("r9") = 0;
  169. register long r10 asm ("r10") = 0;
  170. register long r11 asm ("r11") = 0;
  171. long status;
  173. /*
  174.  * Don't do a "switch" here since that gives us code that
  175.  * isn't self-relocatable.
  176.  */
  177. status = 0;
  178. if (index == SAL_FREQ_BASE) {
  179. switch (in1) {
  180.       case SAL_FREQ_BASE_PLATFORM:
  181. r9 = 500000000;
  182. break;
  184.       case SAL_FREQ_BASE_INTERVAL_TIMER:
  185. /*
  186.  * Is this supposed to be the cr.itc frequency
  187.  * or something platform specific?  The SAL
  188.  * doc ain't exactly clear on this...
  189.  */
  190. r9 = 700000000;
  191. break;
  193.       case SAL_FREQ_BASE_REALTIME_CLOCK:
  194. r9 = 1;
  195. break;
  197.       default:
  198. status = -1;
  199. break;
  200. }
  201. } else if (index == SAL_SET_VECTORS) {
  202. if (in1 == SAL_VECTOR_OS_BOOT_RENDEZ) {
  203. func_ptr_t *fp;
  204. fp = ADDR_OF(&ap_entry);
  205. fp->pc = in2;
  206. fp->gp = in3;
  207. } else {
  208. status = -1;
  209. }
  210. ;
  211. } else if (index == SAL_GET_STATE_INFO) {
  212. ;
  213. } else if (index == SAL_GET_STATE_INFO_SIZE) {
  214. ;
  215. } else if (index == SAL_CLEAR_STATE_INFO) {
  216. ;
  217. } else if (index == SAL_MC_RENDEZ) {
  218. ;
  219. } else if (index == SAL_MC_SET_PARAMS) {
  220. ;
  221. } else if (index == SAL_CACHE_FLUSH) {
  222. ;
  223. } else if (index == SAL_CACHE_INIT) {
  224. ;
  225. } else if (index == SAL_UPDATE_PAL) {
  226. ;
  227. } else {
  228. status = -1;
  229. }
  230. asm volatile ("" :: "r"(r9), "r"(r10), "r"(r11));
  231. return status;
  232. }
  235. /*
  236.  * This is here to work around a bug in egcs-1.1.1b that causes the
  237.  * compiler to crash (seems like a bug in the new alias analysis code.
  238.  */
  239. void *
  240. id (long addr)
  241. {
  242. return (void *) addr;
  243. }
  246. /*
  247.  * Fix the addresses in a function pointer by adding base node address
  248.  * to pc & gp.
  249.  */
  250. void
  251. fix_function_pointer(void *fp)
  252. {
  253. func_ptr_t *_fp;
  255. _fp = fp;
  256. _fp->pc = __fwtab_pa(base_nasid, _fp->pc);
  257. _fp->gp = __fwtab_pa(base_nasid, _fp->gp);
  258. }
  260. void
  261. fix_virt_function_pointer(void *fptr)
  262. {
  263.         func_ptr_t      *fp;
  265.         fp = fptr;
  266.         fp->pc = fp->pc | PAGE_OFFSET;
  267.         fp->gp = fp->gp | PAGE_OFFSET;
  268. }
  271. int
  272. efi_set_virtual_address_map(void)
  273. {
  274.         efi_runtime_services_t            *runtime;
  276.         runtime = efi_runtime_p;
  277.         fix_virt_function_pointer((void*)runtime->get_time);
  278.         fix_virt_function_pointer((void*)runtime->set_time);
  279.         fix_virt_function_pointer((void*)runtime->get_wakeup_time);
  280.         fix_virt_function_pointer((void*)runtime->set_wakeup_time);
  281.         fix_virt_function_pointer((void*)runtime->set_virtual_address_map);
  282.         fix_virt_function_pointer((void*)runtime->get_variable);
  283.         fix_virt_function_pointer((void*)runtime->get_next_variable);
  284.         fix_virt_function_pointer((void*)runtime->set_variable);
  285.         fix_virt_function_pointer((void*)runtime->get_next_high_mono_count);
  286.         fix_virt_function_pointer((void*)runtime->reset_system);
  287.         return EFI_SUCCESS;;
  288. }
  291. void
  292. sys_fw_init (const char *args, int arglen, int bsp)
  293. {
  294. /*
  295.  * Use static variables to keep from overflowing the RSE stack
  296.  */
  297. static efi_system_table_t *efi_systab;
  298. static efi_runtime_services_t *efi_runtime;
  299. static efi_config_table_t *efi_tables;
  300. static ia64_sal_desc_ptc_t *sal_ptc;
  301. static ia64_sal_ptc_domain_info_t *sal_ptcdi;
  302. static ia64_sal_ptc_domain_proc_entry_t *sal_ptclid;
  303. static acpi_rsdp_t *acpi_systab;
  304. static acpi_rsdt_t *acpi_rsdt;
  305. static acpi_sapic_t *acpi_sapic;
  306. static acpi_entry_lsapic_t *acpi_lsapic;
  307. static struct ia64_sal_systab *sal_systab;
  308. static efi_memory_desc_t *efi_memmap, *md;
  309. static unsigned long *pal_desc, *sal_desc;
  310. static struct ia64_sal_desc_entry_point *sal_ed;
  311. static struct ia64_boot_param *bp;
  312. static struct ia64_sal_desc_ap_wakeup *sal_apwake;
  313. static unsigned char checksum = 0;
  314. static char *cp, *cmd_line, *vendor;
  315. static int mdsize, domain, last_domain ;
  316. static int cnode, nasid, cpu, num_memmd, cpus_found;
  318. /*
  319.  * Pass the parameter base address to the build_efi_xxx routines.
  320.  */
  321. build_init(8LL*GB*base_nasid);
  323. num_nodes = GetNumNodes();
  324. num_cpus = GetNumCpus();
  327. memset(fw_mem, 0, sizeof(fw_mem));
  329. pal_desc = (unsigned long *) &pal_emulator_static;
  330. sal_desc = (unsigned long *) &sal_emulator;
  331. fix_function_pointer(&pal_emulator_static);
  332. fix_function_pointer(&sal_emulator);
  334. /* Align this to 16 bytes, probably EFI does this  */
  335. mdsize = (sizeof(efi_memory_desc_t) + 15) & ~15 ;
  337. cp = fw_mem;
  338. efi_systab  = (void *) cp; cp += sizeof(*efi_systab);
  339. efi_runtime_p = efi_runtime = (void *) cp; cp += sizeof(*efi_runtime);
  340. efi_tables  = (void *) cp; cp += NUM_EFI_DESCS*sizeof(*efi_tables);
  341. sal_systab  = (void *) cp; cp += sizeof(*sal_systab);
  342. sal_ed      = (void *) cp; cp += sizeof(*sal_ed);
  343. sal_ptc     = (void *) cp; cp += sizeof(*sal_ptc);
  344. sal_apwake  = (void *) cp; cp += sizeof(*sal_apwake);
  345. acpi_systab = (void *) cp; cp += sizeof(*acpi_systab);
  346. acpi_rsdt   = (void *) cp; cp += sizeof(*acpi_rsdt);
  347. acpi_sapic  = (void *) cp; cp += sizeof(*acpi_sapic);
  348. acpi_lsapic = (void *) cp; cp += num_cpus*sizeof(*acpi_lsapic);
  349. vendor      = (char *) cp; cp += 32;
  350. efi_memmap  = (void *) cp; cp += 8*32*sizeof(*efi_memmap);
  351. sal_ptcdi   = (void *) cp; cp += CPUS_PER_FSB*(1+num_nodes)*sizeof(*sal_ptcdi);
  352. sal_ptclid  = (void *) cp; cp += ((3+num_cpus)*sizeof(*sal_ptclid)+7)/8*8;
  353. cmd_line    = (void *) cp;
  355. if (args) {
  356. if (arglen >= 1024)
  357. arglen = 1023;
  358. memcpy(cmd_line, args, arglen);
  359. } else {
  360. arglen = 0;
  361. }
  362. cmd_line[arglen] = '';
  363. #ifdef BRINGUP
  364. /* for now, just bring up bash */
  365. strcpy(cmd_line, "init=/bin/bash");
  366. #else
  367. strcpy(cmd_line, "");
  368. #endif
  370. memset(efi_systab, 0, sizeof(efi_systab));
  371. efi_systab->hdr.signature = EFI_SYSTEM_TABLE_SIGNATURE;
  372. efi_systab->hdr.revision  = EFI_SYSTEM_TABLE_REVISION;
  373. efi_systab->hdr.headersize = sizeof(efi_systab->hdr);
  374. efi_systab->fw_vendor = __fwtab_pa(base_nasid, vendor);
  375. efi_systab->fw_revision = 1;
  376. efi_systab->runtime = __fwtab_pa(base_nasid, efi_runtime);
  377. efi_systab->nr_tables = 2;
  378. efi_systab->tables = __fwtab_pa(base_nasid, efi_tables);
  379. memcpy(vendor, "Silicon-Graphics", 32);
  381. efi_runtime->hdr.signature = EFI_RUNTIME_SERVICES_SIGNATURE;
  382. efi_runtime->hdr.revision = EFI_RUNTIME_SERVICES_REVISION;
  383. efi_runtime->hdr.headersize = sizeof(efi_runtime->hdr);
  384. efi_runtime->get_time = __fwtab_pa(base_nasid, &efi_get_time);
  385. efi_runtime->set_time = __fwtab_pa(base_nasid, &efi_unimplemented);
  386. efi_runtime->get_wakeup_time = __fwtab_pa(base_nasid, &efi_unimplemented);
  387. efi_runtime->set_wakeup_time = __fwtab_pa(base_nasid, &efi_unimplemented);
  388. efi_runtime->set_virtual_address_map = __fwtab_pa(base_nasid, &efi_set_virtual_address_map);
  389. efi_runtime->get_variable = __fwtab_pa(base_nasid, &efi_unimplemented);
  390. efi_runtime->get_next_variable = __fwtab_pa(base_nasid, &efi_unimplemented);
  391. efi_runtime->set_variable = __fwtab_pa(base_nasid, &efi_unimplemented);
  392. efi_runtime->get_next_high_mono_count = __fwtab_pa(base_nasid, &efi_unimplemented);
  393. efi_runtime->reset_system = __fwtab_pa(base_nasid, &efi_reset_system);
  395. efi_tables->guid = SAL_SYSTEM_TABLE_GUID;
  396. efi_tables->table = __fwtab_pa(base_nasid, sal_systab);
  397. efi_tables++;
  398. efi_tables->guid = ACPI_TABLE_GUID;
  399. efi_tables->table = __fwtab_pa(base_nasid, acpi_systab);
  400. fix_function_pointer(&efi_unimplemented);
  401. fix_function_pointer(&efi_get_time);
  402. fix_function_pointer(&efi_success);
  403. fix_function_pointer(&efi_reset_system);
  404. fix_function_pointer(&efi_set_virtual_address_map);
  406. /* fill in the ACPI system table: */
  407. memcpy(acpi_systab->signature, "RSD PTR ", 8);
  408. acpi_systab->rsdt = (struct acpi_rsdt*)__fwtab_pa(base_nasid, acpi_rsdt);
  410. memcpy(acpi_rsdt->header.signature, "RSDT",4);
  411. acpi_rsdt->header.length = sizeof(acpi_rsdt_t);
  412. memcpy(acpi_rsdt->header.oem_id, "SGI", 3);
  413. memcpy(acpi_rsdt->header.oem_table_id, "SN1", 3);
  414. acpi_rsdt->header.oem_revision = 0x00010001;
  415. acpi_rsdt->entry_ptrs[0] = __fwtab_pa(base_nasid, acpi_sapic);
  417. memcpy(acpi_sapic->header.signature, "SPIC ", 4);
  418. acpi_sapic->header.length = sizeof(acpi_sapic_t)+num_cpus*sizeof(acpi_entry_lsapic_t);
  419. for (cnode=0; cnode<num_nodes; cnode++) {
  420. nasid = GetNasid(cnode);
  421. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  422. if (!IsCpuPresent(cnode, cpu))
  423. continue;
  424. acpi_lsapic->type = ACPI_ENTRY_LOCAL_SAPIC;
  425. acpi_lsapic->length = sizeof(acpi_entry_lsapic_t);
  426. acpi_lsapic->acpi_processor_id = cnode*4+cpu;
  427. acpi_lsapic->flags = LSAPIC_ENABLED|LSAPIC_PRESENT;
  428. acpi_lsapic->eid = cpu;
  429. acpi_lsapic->id = nasid;
  430. acpi_lsapic++;
  431. }
  432. }
  435. /* fill in the SAL system table: */
  436. memcpy(sal_systab->signature, "SST_", 4);
  437. sal_systab->size = sizeof(*sal_systab);
  438. sal_systab->sal_rev_minor = 1;
  439. sal_systab->sal_rev_major = 0;
  440. sal_systab->entry_count = 3;
  442. strcpy(sal_systab->oem_id, "SGI");
  443. strcpy(sal_systab->product_id, "SN1");
  445. /* fill in an entry point: */
  446. sal_ed->type = SAL_DESC_ENTRY_POINT;
  447. sal_ed->pal_proc = __fwtab_pa(base_nasid, pal_desc[0]);
  448. sal_ed->sal_proc = __fwtab_pa(base_nasid, sal_desc[0]);
  449. sal_ed->gp = __fwtab_pa(base_nasid, sal_desc[1]);
  451. /* kludge the PTC domain info */
  452. sal_ptc->type = SAL_DESC_PTC;
  453. sal_ptc->num_domains = 0;
  454. sal_ptc->domain_info = __fwtab_pa(base_nasid, sal_ptcdi);
  455. cpus_found = 0;
  456. last_domain = -1;
  457. sal_ptcdi--;
  458. for (cnode=0; cnode<num_nodes; cnode++) {
  459. nasid = GetNasid(cnode);
  460. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  461. if (IsCpuPresent(cnode, cpu)) {
  462. domain = cnode*CPUS_PER_NODE + cpu/CPUS_PER_FSB;
  463. if (domain != last_domain) {
  464. sal_ptc->num_domains++;
  465. sal_ptcdi++;
  466. sal_ptcdi->proc_count = 0;
  467. sal_ptcdi->proc_list = __fwtab_pa(base_nasid, sal_ptclid);
  468. last_domain = domain;
  469. }
  470. sal_ptcdi->proc_count++;
  471. sal_ptclid->id = nasid;
  472. sal_ptclid->eid = cpu;
  473. sal_ptclid++;
  474. cpus_found++;
  475. }
  476. }
  477. }
  479. if (cpus_found != num_cpus)
  480. FPROM_BUG();
  482. /* Make the AP WAKEUP entry */
  483. sal_apwake->type = SAL_DESC_AP_WAKEUP;
  484. sal_apwake->mechanism = IA64_SAL_AP_EXTERNAL_INT;
  485. sal_apwake->vector = 18;
  487. for (cp = (char *) sal_systab; cp < (char *) efi_memmap; ++cp)
  488. checksum += *cp;
  490. sal_systab->checksum = -checksum;
  492. md = &efi_memmap[0];
  493. num_memmd = build_efi_memmap((void *)md, mdsize) ;
  495. bp = id(ZERO_PAGE_ADDR + (((long)base_nasid)<<33));
  496. bp->efi_systab = __fwtab_pa(base_nasid, &fw_mem);
  497. bp->efi_memmap = __fwtab_pa(base_nasid, efi_memmap);
  498. bp->efi_memmap_size = num_memmd*mdsize;
  499. bp->efi_memdesc_size = mdsize;
  500. bp->efi_memdesc_version = 0x101;
  501. bp->command_line = __fwtab_pa(base_nasid, cmd_line);
  502. bp->console_info.num_cols = 80;
  503. bp->console_info.num_rows = 25;
  504. bp->console_info.orig_x = 0;
  505. bp->console_info.orig_y = 24;
  506. bp->num_pci_vectors = 0;
  507. bp->fpswa = 0;
  509. /*
  510.  * Now pick the BSP & store it LID value in
  511.  * a global variable. Note if BSP is greater than last cpu,
  512.  * pick the last cpu.
  513.  */
  514. for (cnode=0; cnode<num_nodes; cnode++) {
  515. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  516. if (!IsCpuPresent(cnode, cpu))
  517. continue;
  518. bsp_lid = (GetNasid(cnode)<<24) | (cpu<<16);
  519. if (bsp-- > 0)
  520. continue;
  521. return;
  522. }
  523. }
  524. }