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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
fw-emu.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：25k
源码类别：

Linux/Unix编程

开发平台：

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-2002 Silicon Graphics, Inc.  All rights reserved.
  9.  * 
  10.  * This program is free software; you can redistribute it and/or modify it 
  11.  * under the terms of version 2 of the GNU General Public License 
  12.  * as published by the Free Software Foundation.
  13.  * 
  14.  * This program is distributed in the hope that it would be useful, but 
  15.  * WITHOUT ANY WARRANTY; without even the implied warranty of 
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
  17.  * 
  18.  * Further, this software is distributed without any warranty that it is 
  19.  * free of the rightful claim of any third person regarding infringement 
  20.  * or the like.  Any license provided herein, whether implied or 
  21.  * otherwise, applies only to this software file.  Patent licenses, if 
  22.  * any, provided herein do not apply to combinations of this program with 
  23.  * other software, or any other product whatsoever.
  24.  * 
  25.  * You should have received a copy of the GNU General Public 
  26.  * License along with this program; if not, write the Free Software 
  27.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  28.  * 
  29.  * Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, 
  30.  * Mountain View, CA  94043, or:
  31.  * 
  32.  * http://www.sgi.com 
  33.  * 
  34.  * For further information regarding this notice, see: 
  35.  * 
  36.  * http://oss.sgi.com/projects/GenInfo/NoticeExplan
  37.  */
  38. #include <linux/config.h>
  39. #include <linux/efi.h>
  40. #include <asm/pal.h>
  41. #include <asm/sal.h>
  42. #include <asm/sn/sn_sal.h>
  43. #include <asm/processor.h>
  44. #include <asm/sn/sn_cpuid.h>
  45. #ifdef CONFIG_IA64_SGI_SN2
  46. #include <asm/sn/sn2/addrs.h>
  47. #include <asm/sn/sn2/shub_mmr.h>
  48. #endif
  49. #include <asm/acpi-ext.h>
  50. #include "fpmem.h"
  52. #define zzACPI_1_0 1 /* Include ACPI 1.0 tables */
  54. #define OEMID "SGI"
  55. #ifdef CONFIG_IA64_SGI_SN1
  56. #define PRODUCT "SN1"
  57. #define PROXIMITY_DOMAIN(nasid) (nasid)
  58. #else
  59. #define PRODUCT "SN2"
  60. #define PROXIMITY_DOMAIN(nasid) (((nasid)>>1) & 255)
  61. #endif
  63. #define MB (1024*1024UL)
  64. #define GB (MB*1024UL)
  65. #define BOOT_PARAM_ADDR 0x40000
  66. #define MAX(i,j) ((i) > (j) ? (i) : (j))
  67. #define MIN(i,j) ((i) < (j) ? (i) : (j))
  68. #define ABS(i) ((i) > 0   ? (i) : -(i))
  69. #define ALIGN8(p) (((long)(p) +7) & ~7)
  71. #define FPROM_BUG() do {while (1);} while (0)
  72. #define MAX_SN_NODES 128
  73. #define MAX_LSAPICS 512
  74. #define MAX_CPUS 512
  75. #define MAX_CPUS_NODE 4
  76. #define CPUS_PER_NODE 4
  77. #define CPUS_PER_FSB 2
  78. #define CPUS_PER_FSB_MASK (CPUS_PER_FSB-1)
  80. #ifdef ACPI_1_0
  81. #define NUM_EFI_DESCS 3
  82. #else
  83. #define NUM_EFI_DESCS 2
  84. #endif
  86. #define RSDP_CHECKSUM_LENGTH 20
  88. typedef union ia64_nasid_va {
  89.         struct {
  90. #if defined(CONFIG_IA64_SGI_SN1)
  91.                 unsigned long off   : 33;       /* intra-region offset */
  92. unsigned long nasid :  7; /* NASID */
  93. unsigned long off2  : 21; /* fill */
  94.                 unsigned long reg   :  3;       /* region number */
  95. #elif defined(CONFIG_IA64_SGI_SN2)
  96.                 unsigned long off   : 36;       /* intra-region offset */
  97. unsigned long attr  :  2;
  98. unsigned long nasid : 11; /* NASID */
  99. unsigned long off2  : 12; /* fill */
  100.                 unsigned long reg   :  3;       /* region number */
  101. #endif
  102.         } f;
  103.         unsigned long l;
  104.         void *p;
  105. } ia64_nasid_va;
  107. typedef struct {
  108. unsigned long pc;
  109. unsigned long gp;
  110. } func_ptr_t;
  111.  
  112. #define IS_VIRTUAL_MODE()   ({struct ia64_psr psr; asm("mov %0=psr" : "=r"(psr)); psr.dt;})
  113. #define ADDR_OF(p) (IS_VIRTUAL_MODE() ? ((void*)((long)(p)+PAGE_OFFSET)) : ((void*) (p)))
  115. #if defined(CONFIG_IA64_SGI_SN1)
  116. #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;})
  117. #elif defined(CONFIG_IA64_SGI_SN2)
  118. #define __fwtab_pa(n,x) ({ia64_nasid_va _v; _v.l = (long) (x); _v.f.nasid = (x) ? (n) : 0; _v.f.reg = 0; _v.f.attr = 3; _v.l;})
  119. #endif
  121. /*
  122.  * The following variables are passed thru registersfrom the configuration file and
  123.  * are set via the _start function.
  124.  */
  125. long base_nasid;
  126. long num_cpus;
  127. long bsp_entry_pc=0;
  128. long num_nodes;
  129. long app_entry_pc;
  130. int bsp_lid;
  131. func_ptr_t ap_entry;
  134. extern void pal_emulator(void);
  135. static efi_runtime_services_t    *efi_runtime_p;
  136. static char fw_mem[(  sizeof(efi_system_table_t)
  137.     + sizeof(efi_runtime_services_t)
  138.     + NUM_EFI_DESCS*sizeof(efi_config_table_t)
  139.     + sizeof(struct ia64_sal_systab)
  140.     + sizeof(struct ia64_sal_desc_entry_point)
  141.     + sizeof(struct ia64_sal_desc_ap_wakeup)
  142. #ifdef ACPI_1_0
  143.     + sizeof(acpi_rsdp_t)
  144.     + sizeof(acpi_rsdt_t)
  145.     + sizeof(acpi_sapic_t)
  146.     + MAX_LSAPICS*(sizeof(acpi_entry_lsapic_t))
  147. #endif
  148.     + sizeof(acpi20_rsdp_t)
  149.     + sizeof(acpi_xsdt_t)
  150.     + sizeof(acpi_slit_t)
  151.     +   MAX_SN_NODES*MAX_SN_NODES+8
  152.     + sizeof(acpi_madt_t)
  153.     +   16*MAX_CPUS
  154.     + (1+8*MAX_SN_NODES)*(sizeof(efi_memory_desc_t))
  155.     + sizeof(acpi_srat_t)
  156.     +   MAX_CPUS*sizeof(srat_cpu_affinity_t)
  157.     +   MAX_SN_NODES*sizeof(srat_memory_affinity_t)
  158.     + sizeof(ia64_sal_desc_ptc_t) +
  159.     + MAX_SN_NODES*sizeof(ia64_sal_ptc_domain_info_t) +
  160.     + MAX_CPUS*sizeof(ia64_sal_ptc_domain_proc_entry_t) +
  161.     + 1024)] __attribute__ ((aligned (8)));
  164. static efi_status_t
  165. efi_get_time (efi_time_t *tm, efi_time_cap_t *tc)
  166. {
  167. if (tm) {
  168. memset(tm, 0, sizeof(*tm));
  169. tm->year = 2000;
  170. tm->month = 2;
  171. tm->day = 13;
  172. tm->hour = 10;
  173. tm->minute = 11;
  174. tm->second = 12;
  175. }
  177. if (tc) {
  178. tc->resolution = 10;
  179. tc->accuracy = 12;
  180. tc->sets_to_zero = 1;
  181. }
  183. return EFI_SUCCESS;
  184. }
  186. static void
  187. efi_reset_system (int reset_type, efi_status_t status, unsigned long data_size, efi_char16_t *data)
  188. {
  189. while(1); /* Is there a pseudo-op to stop medusa */
  190. }
  192. static efi_status_t
  193. efi_success (void)
  194. {
  195. return EFI_SUCCESS;
  196. }
  198. static efi_status_t
  199. efi_unimplemented (void)
  200. {
  201. return EFI_UNSUPPORTED;
  202. }
  204. #ifdef CONFIG_IA64_SGI_SN2
  206. #undef cpu_physical_id
  207. #define cpu_physical_id(cpuid)                  ((ia64_get_lid() >> 16) & 0xffff)
  209. void
  210. fprom_send_cpei(void) {
  211.         long            *p, val;
  212.         long            physid;
  213.         long            nasid, slice;
  215.         physid = cpu_physical_id(0);
  216.         nasid = cpu_physical_id_to_nasid(physid);
  217.         slice = cpu_physical_id_to_slice(physid);
  219.         p = (long*)GLOBAL_MMR_ADDR(nasid, SH_IPI_INT);
  220.         val =   (1UL<<SH_IPI_INT_SEND_SHFT) |
  221.                 (physid<<SH_IPI_INT_PID_SHFT) |
  222.                 ((long)0<<SH_IPI_INT_TYPE_SHFT) |
  223.                 ((long)0x1e<<SH_IPI_INT_IDX_SHFT) |
  224.                 (0x000feeUL<<SH_IPI_INT_BASE_SHFT);
  225.         *p = val;
  227. }
  228. #endif
  231. static long
  232. sal_emulator (long index, unsigned long in1, unsigned long in2,
  233.       unsigned long in3, unsigned long in4, unsigned long in5,
  234.       unsigned long in6, unsigned long in7)
  235. {
  236. register long r9 asm ("r9") = 0;
  237. register long r10 asm ("r10") = 0;
  238. register long r11 asm ("r11") = 0;
  239. long status;
  241. /*
  242.  * Don't do a "switch" here since that gives us code that
  243.  * isn't self-relocatable.
  244.  */
  245. status = 0;
  246. if (index == SAL_FREQ_BASE) {
  247. switch (in1) {
  248.       case SAL_FREQ_BASE_PLATFORM:
  249. r9 = 500000000;
  250. break;
  252.       case SAL_FREQ_BASE_INTERVAL_TIMER:
  253. /*
  254.  * Is this supposed to be the cr.itc frequency
  255.  * or something platform specific?  The SAL
  256.  * doc ain't exactly clear on this...
  257.  */
  258. r9 = 700000000;
  259. break;
  261.       case SAL_FREQ_BASE_REALTIME_CLOCK:
  262. r9 = 50000000;
  263. break;
  265.       default:
  266. status = -1;
  267. break;
  268. }
  269. } else if (index == SAL_SET_VECTORS) {
  270. if (in1 == SAL_VECTOR_OS_BOOT_RENDEZ) {
  271. func_ptr_t *fp;
  272. fp = ADDR_OF(&ap_entry);
  273. fp->pc = in2;
  274. fp->gp = in3;
  275. } else if (in1 == SAL_VECTOR_OS_MCA || in1 == SAL_VECTOR_OS_INIT) {
  276. } else {
  277. status = -1;
  278. }
  279. ;
  280. } else if (index == SAL_GET_STATE_INFO) {
  281. ;
  282. } else if (index == SAL_GET_STATE_INFO_SIZE) {
  283. ;
  284. } else if (index == SAL_CLEAR_STATE_INFO) {
  285. ;
  286. } else if (index == SAL_MC_RENDEZ) {
  287. ;
  288. } else if (index == SAL_MC_SET_PARAMS) {
  289. ;
  290. } else if (index == SAL_CACHE_FLUSH) {
  291. ;
  292. } else if (index == SAL_CACHE_INIT) {
  293. ;
  294. } else if (index == SAL_UPDATE_PAL) {
  295. ;
  296. #ifdef CONFIG_IA64_SGI_SN2
  297. } else if (index == SN_SAL_LOG_CE) {
  298. #ifdef ajmtestcpei
  299. fprom_send_cpei();
  300. #else /* ajmtestcpei */
  301. ;
  302. #endif /* ajmtestcpei */
  303. #endif
  304. } else if (index == SN_SAL_PROBE) {
  305. r9 = 0UL;
  306. if (in2 == 4) {
  307. r9 = *(unsigned *)in1;
  308. if (r9 == -1) {
  309. status = 1;
  310. }
  311. } else if (in2 == 2) {
  312. r9 = *(unsigned short *)in1;
  313. if (r9 == -1) {
  314. status = 1;
  315. }
  316. } else if (in2 == 1) {
  317. r9 = *(unsigned char *)in1;
  318. if (r9 == -1) {
  319. status = 1;
  320. }
  321. } else if (in2 == 8) {
  322. r9 = *(unsigned long *)in1;
  323. if (r9 == -1) {
  324. status = 1;
  325. }
  326. } else {
  327. status = 2;
  328. }
  329. } else if (index == SN_SAL_GET_KLCONFIG_ADDR) {
  330. r9 = 0x30000;
  331. } else if (index == SN_SAL_CONSOLE_PUTC) {
  332. status = -1;
  333. } else if (index == SN_SAL_CONSOLE_GETC) {
  334. status = -1;
  335. } else if (index == SN_SAL_CONSOLE_POLL) {
  336. status = -1;
  337. } else {
  338. status = -1;
  339. }
  341. asm volatile ("" :: "r"(r9), "r"(r10), "r"(r11));
  342. return status;
  343. }
  346. /*
  347.  * This is here to work around a bug in egcs-1.1.1b that causes the
  348.  * compiler to crash (seems like a bug in the new alias analysis code.
  349.  */
  350. void *
  351. id (long addr)
  352. {
  353. return (void *) addr;
  354. }
  357. /*
  358.  * Fix the addresses in a function pointer by adding base node address
  359.  * to pc & gp.
  360.  */
  361. void
  362. fix_function_pointer(void *fp)
  363. {
  364. func_ptr_t *_fp;
  366. _fp = fp;
  367. _fp->pc = __fwtab_pa(base_nasid, _fp->pc);
  368. _fp->gp = __fwtab_pa(base_nasid, _fp->gp);
  369. }
  371. void
  372. fix_virt_function_pointer(void **fptr)
  373. {
  374.         func_ptr_t      *fp;
  375. long *p;
  377. p = (long*)fptr;
  378.         fp = *fptr;
  379.         fp->pc = fp->pc | PAGE_OFFSET;
  380.         fp->gp = fp->gp | PAGE_OFFSET;
  381. *p |= PAGE_OFFSET;
  382. }
  385. int
  386. efi_set_virtual_address_map(void)
  387. {
  388.         efi_runtime_services_t            *runtime;
  390.         runtime = efi_runtime_p;
  391.         fix_virt_function_pointer((void**)&runtime->get_time);
  392.         fix_virt_function_pointer((void**)&runtime->set_time);
  393.         fix_virt_function_pointer((void**)&runtime->get_wakeup_time);
  394.         fix_virt_function_pointer((void**)&runtime->set_wakeup_time);
  395.         fix_virt_function_pointer((void**)&runtime->set_virtual_address_map);
  396.         fix_virt_function_pointer((void**)&runtime->get_variable);
  397.         fix_virt_function_pointer((void**)&runtime->get_next_variable);
  398.         fix_virt_function_pointer((void**)&runtime->set_variable);
  399.         fix_virt_function_pointer((void**)&runtime->get_next_high_mono_count);
  400.         fix_virt_function_pointer((void**)&runtime->reset_system);
  401.         return EFI_SUCCESS;;
  402. }
  404. void
  405. acpi_table_init(acpi_desc_table_hdr_t *p, char *sig, int siglen, int revision, int oem_revision)
  406. {
  407. memcpy(p->signature, sig, siglen);
  408. memcpy(p->oem_id, OEMID, 6);
  409. memcpy(p->oem_table_id, sig, 4);
  410. memcpy(p->oem_table_id+4, PRODUCT, 4);
  411. p->revision = revision;
  412. p->oem_revision = (revision<<16) + oem_revision;
  413. p->creator_id = 1;
  414. p->creator_revision = 1;
  415. }
  417. void
  418. acpi_checksum(acpi_desc_table_hdr_t *p, int length)
  419. {
  420. u8 *cp, *cpe, checksum;
  422. p->checksum = 0;
  423. p->length = length;
  424. checksum = 0;
  425. for (cp=(u8*)p, cpe=cp+p->length; cp<cpe; cp++)
  426. checksum += *cp;
  427. p->checksum = -checksum;
  428. }
  430. void
  431. acpi_checksum_rsdp20(acpi20_rsdp_t *p, int length)
  432. {
  433. u8 *cp, *cpe, checksum;
  435. p->checksum = 0;
  436. p->length = length;
  437. checksum = 0;
  438. for (cp=(u8*)p, cpe=cp+RSDP_CHECKSUM_LENGTH; cp<cpe; cp++)
  439. checksum += *cp;
  440. p->checksum = -checksum;
  441. }
  443. int
  444. nasid_present(int nasid)
  445. {
  446. int cnode;
  447. for (cnode=0; cnode<num_nodes; cnode++)
  448. if (GetNasid(cnode) == nasid)
  449. return 1;
  450. return 0;
  451. }
  453. void
  454. sys_fw_init (const char *args, int arglen, int bsp)
  455. {
  456. /*
  457.  * Use static variables to keep from overflowing the RSE stack
  458.  */
  459. static efi_system_table_t *efi_systab;
  460. static efi_runtime_services_t *efi_runtime;
  461. static efi_config_table_t *efi_tables;
  462. static ia64_sal_desc_ptc_t *sal_ptc;
  463. static ia64_sal_ptc_domain_info_t *sal_ptcdi;
  464. static ia64_sal_ptc_domain_proc_entry_t *sal_ptclid;
  465. #ifdef ACPI_1_0
  466. static acpi_rsdp_t *acpi_rsdp;
  467. static acpi_rsdt_t *acpi_rsdt;
  468. static acpi_sapic_t *acpi_sapic;
  469. static acpi_entry_lsapic_t *acpi_lsapic;
  470. #endif
  471. static acpi20_rsdp_t *acpi20_rsdp;
  472. static acpi_xsdt_t *acpi_xsdt;
  473. static acpi_slit_t *acpi_slit;
  474. static acpi_madt_t *acpi_madt;
  475. static acpi20_entry_lsapic_t *lsapic20;
  476. static struct ia64_sal_systab *sal_systab;
  477. static acpi_srat_t *acpi_srat;
  478. static srat_cpu_affinity_t *srat_cpu_affinity;
  479. static srat_memory_affinity_t *srat_memory_affinity;
  480. static efi_memory_desc_t *efi_memmap, *md;
  481. static unsigned long *pal_desc, *sal_desc;
  482. static struct ia64_sal_desc_entry_point *sal_ed;
  483. static struct ia64_boot_param *bp;
  484. static struct ia64_sal_desc_ap_wakeup *sal_apwake;
  485. static unsigned char checksum;
  486. static char *cp, *cmd_line, *vendor;
  487. static void *ptr;
  488. static int mdsize, domain, last_domain ;
  489. static int i, j, cnode, max_nasid, nasid, cpu, num_memmd, cpus_found;
  491. /*
  492.  * Pass the parameter base address to the build_efi_xxx routines.
  493.  */
  494. #if defined(CONFIG_IA64_SGI_SN1)
  495. build_init(8LL*GB*base_nasid);
  496. #else
  497. build_init(0x3000000000UL | ((long)base_nasid<<38));
  498. #endif
  500. num_nodes = GetNumNodes();
  501. num_cpus = GetNumCpus();
  502. for (max_nasid=0, cnode=0; cnode<num_nodes; cnode++)
  503. max_nasid = MAX(max_nasid, GetNasid(cnode));
  506. memset(fw_mem, 0, sizeof(fw_mem));
  508. pal_desc = (unsigned long *) &pal_emulator;
  509. sal_desc = (unsigned long *) &sal_emulator;
  510. fix_function_pointer(&pal_emulator);
  511. fix_function_pointer(&sal_emulator);
  513. /* Align this to 16 bytes, probably EFI does this  */
  514. mdsize = (sizeof(efi_memory_desc_t) + 15) & ~15 ;
  516. cp = fw_mem;
  517. efi_systab  = (void *) cp; cp += ALIGN8(sizeof(*efi_systab));
  518. efi_runtime_p = efi_runtime = (void *) cp; cp += ALIGN8(sizeof(*efi_runtime));
  519. efi_tables  = (void *) cp; cp += ALIGN8(NUM_EFI_DESCS*sizeof(*efi_tables));
  520. sal_systab  = (void *) cp; cp += ALIGN8(sizeof(*sal_systab));
  521. sal_ed      = (void *) cp; cp += ALIGN8(sizeof(*sal_ed));
  522. sal_ptc     = (void *) cp; cp += ALIGN8(sizeof(*sal_ptc));
  523. sal_apwake  = (void *) cp; cp += ALIGN8(sizeof(*sal_apwake));
  524. acpi20_rsdp = (void *) cp; cp += ALIGN8(sizeof(*acpi20_rsdp));
  525. acpi_xsdt   = (void *) cp; cp += ALIGN8(sizeof(*acpi_xsdt) + 64); 
  526. /* save space for more OS defined table pointers. */
  528. #ifdef ACPI_1_0
  529. acpi_rsdp   = (void *) cp; cp += ALIGN8(sizeof(*acpi_rsdp));
  530. acpi_rsdt   = (void *) cp; cp += ALIGN8(sizeof(*acpi_rsdt));
  531. acpi_sapic  = (void *) cp; cp += sizeof(*acpi_sapic);
  532. acpi_lsapic = (void *) cp; cp += num_cpus*sizeof(*acpi_lsapic);
  533. #endif
  534. acpi_slit   = (void *) cp; cp += ALIGN8(sizeof(*acpi_slit) + 8 + (max_nasid+1)*(max_nasid+1));
  535. acpi_madt   = (void *) cp; cp += ALIGN8(sizeof(*acpi_madt) + 8 * num_cpus+ 8);
  536. acpi_srat   = (void *) cp; cp += ALIGN8(sizeof(acpi_srat_t));
  537. cp         += sizeof(srat_cpu_affinity_t)*num_cpus + sizeof(srat_memory_affinity_t)*num_nodes;
  538. vendor      = (char *) cp; cp += ALIGN8(40);
  539. efi_memmap  = (void *) cp; cp += ALIGN8(8*32*sizeof(*efi_memmap));
  540. sal_ptcdi   = (void *) cp; cp += ALIGN8(CPUS_PER_FSB*(1+num_nodes)*sizeof(*sal_ptcdi));
  541. sal_ptclid  = (void *) cp; cp += ALIGN8(((3+num_cpus)*sizeof(*sal_ptclid)+7)/8*8);
  542. cmd_line    = (void *) cp;
  544. if (args) {
  545. if (arglen >= 1024)
  546. arglen = 1023;
  547. memcpy(cmd_line, args, arglen);
  548. } else {
  549. arglen = 0;
  550. }
  551. cmd_line[arglen] = '';
  552. /* 
  553.  * For now, just bring up bash.
  554.  * If you want to execute all the startup scripts, delete the "init=..".
  555.  * You can also edit this line to pass other arguments to the kernel.
  556.  *    Note: disable kernel text replication.
  557.  */
  558. strcpy(cmd_line, "init=/bin/bash ktreplicate=0");
  560. memset(efi_systab, 0, sizeof(efi_systab));
  561. efi_systab->hdr.signature = EFI_SYSTEM_TABLE_SIGNATURE;
  562. efi_systab->hdr.revision  = EFI_SYSTEM_TABLE_REVISION;
  563. efi_systab->hdr.headersize = sizeof(efi_systab->hdr);
  564. efi_systab->fw_vendor = __fwtab_pa(base_nasid, vendor);
  565. efi_systab->fw_revision = 1;
  566. efi_systab->runtime = __fwtab_pa(base_nasid, efi_runtime);
  567. efi_systab->nr_tables = 2;
  568. efi_systab->tables = __fwtab_pa(base_nasid, efi_tables);
  569. memcpy(vendor, "Silicon-Graphics", 40);
  571. efi_runtime->hdr.signature = EFI_RUNTIME_SERVICES_SIGNATURE;
  572. efi_runtime->hdr.revision = EFI_RUNTIME_SERVICES_REVISION;
  573. efi_runtime->hdr.headersize = sizeof(efi_runtime->hdr);
  574. efi_runtime->get_time = __fwtab_pa(base_nasid, &efi_get_time);
  575. efi_runtime->set_time = __fwtab_pa(base_nasid, &efi_unimplemented);
  576. efi_runtime->get_wakeup_time = __fwtab_pa(base_nasid, &efi_unimplemented);
  577. efi_runtime->set_wakeup_time = __fwtab_pa(base_nasid, &efi_unimplemented);
  578. efi_runtime->set_virtual_address_map = __fwtab_pa(base_nasid, &efi_set_virtual_address_map);
  579. efi_runtime->get_variable = __fwtab_pa(base_nasid, &efi_unimplemented);
  580. efi_runtime->get_next_variable = __fwtab_pa(base_nasid, &efi_unimplemented);
  581. efi_runtime->set_variable = __fwtab_pa(base_nasid, &efi_unimplemented);
  582. efi_runtime->get_next_high_mono_count = __fwtab_pa(base_nasid, &efi_unimplemented);
  583. efi_runtime->reset_system = __fwtab_pa(base_nasid, &efi_reset_system);
  585. efi_tables->guid = SAL_SYSTEM_TABLE_GUID;
  586. efi_tables->table = __fwtab_pa(base_nasid, sal_systab);
  587. efi_tables++;
  588. #ifdef ACPI_1_0
  589. efi_tables->guid = ACPI_TABLE_GUID;
  590. efi_tables->table = __fwtab_pa(base_nasid, acpi_rsdp);
  591. efi_tables++;
  592. #endif
  593. efi_tables->guid = ACPI_20_TABLE_GUID;
  594. efi_tables->table = __fwtab_pa(base_nasid, acpi20_rsdp);
  595. efi_tables++;
  597. fix_function_pointer(&efi_unimplemented);
  598. fix_function_pointer(&efi_get_time);
  599. fix_function_pointer(&efi_success);
  600. fix_function_pointer(&efi_reset_system);
  601. fix_function_pointer(&efi_set_virtual_address_map);
  603. #ifdef ACPI_1_0
  604. /* fill in the ACPI system table - has a pointer to the ACPI table header */
  605. memcpy(acpi_rsdp->signature, "RSD PTR ", 8);
  606. acpi_rsdp->rsdt = (struct acpi_rsdt*)__fwtab_pa(base_nasid, acpi_rsdt);
  608. acpi_table_init(&acpi_rsdt->header, ACPI_RSDT_SIG, ACPI_RSDT_SIG_LEN, 1, 1);
  609. acpi_rsdt->header.length = sizeof(acpi_rsdt_t);
  610. acpi_rsdt->entry_ptrs[0] = __fwtab_pa(base_nasid, acpi_sapic);
  612. memcpy(acpi_sapic->header.signature, "SPIC ", 4);
  613. acpi_sapic->header.length = sizeof(acpi_sapic_t)+num_cpus*sizeof(acpi_entry_lsapic_t);
  615. for (cnode=0; cnode<num_nodes; cnode++) {
  616. nasid = GetNasid(cnode);
  617. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  618. if (!IsCpuPresent(cnode, cpu))
  619. continue;
  620. acpi_lsapic->type = ACPI_ENTRY_LOCAL_SAPIC;
  621. acpi_lsapic->length = sizeof(acpi_entry_lsapic_t);
  622. acpi_lsapic->acpi_processor_id = cnode*4+cpu;
  623. acpi_lsapic->flags = LSAPIC_ENABLED|LSAPIC_PRESENT;
  624. #if defined(CONFIG_IA64_SGI_SN1)
  625. acpi_lsapic->eid = cpu;
  626. acpi_lsapic->id = nasid;
  627. #else
  628. acpi_lsapic->eid = nasid&0xffff;
  629. acpi_lsapic->id = (cpu<<4) | (nasid>>16);
  630. #endif
  631. acpi_lsapic++;
  632. }
  633. }
  634. #endif
  637. /* fill in the ACPI20 system table - has a pointer to the ACPI table header */
  638. memcpy(acpi20_rsdp->signature, "RSD PTR ", 8);
  639. acpi20_rsdp->xsdt = (struct acpi_xsdt*)__fwtab_pa(base_nasid, acpi_xsdt);
  640. acpi20_rsdp->revision = 2;
  641. acpi_checksum_rsdp20(acpi20_rsdp, sizeof(acpi20_rsdp_t));
  643. /* Set up the XSDT table  - contains pointers to the other ACPI tables */
  644. acpi_table_init(&acpi_xsdt->header, ACPI_XSDT_SIG, ACPI_XSDT_SIG_LEN, 1, 1);
  645. acpi_xsdt->entry_ptrs[0] = __fwtab_pa(base_nasid, acpi_madt);
  646. acpi_xsdt->entry_ptrs[1] = __fwtab_pa(base_nasid, acpi_slit);
  647. acpi_xsdt->entry_ptrs[2] = __fwtab_pa(base_nasid, acpi_srat);
  648. acpi_checksum(&acpi_xsdt->header, sizeof(acpi_xsdt_t) + 16);
  650. /* Set up the MADT table */
  651. acpi_table_init(&acpi_madt->header, ACPI_MADT_SIG, ACPI_MADT_SIG_LEN, 1, 1);
  652. lsapic20 = (acpi20_entry_lsapic_t*) (acpi_madt + 1);
  653. for (cnode=0; cnode<num_nodes; cnode++) {
  654. nasid = GetNasid(cnode);
  655. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  656. if (!IsCpuPresent(cnode, cpu))
  657. continue;
  658. lsapic20->type = ACPI20_ENTRY_LOCAL_SAPIC;
  659. lsapic20->length = sizeof(acpi_entry_lsapic_t);
  660. lsapic20->acpi_processor_id = cnode*4+cpu;
  661. lsapic20->flags = LSAPIC_ENABLED|LSAPIC_PRESENT;
  662. #if defined(CONFIG_IA64_SGI_SN1)
  663. lsapic20->eid = cpu;
  664. lsapic20->id = nasid;
  665. #else
  666. lsapic20->eid = nasid&0xffff;
  667. lsapic20->id = (cpu<<4) | (nasid>>16);
  668. #endif
  669. lsapic20 = (acpi20_entry_lsapic_t*) ((long)lsapic20+sizeof(acpi_entry_lsapic_t));
  670. }
  671. }
  672. acpi_checksum(&acpi_madt->header, (char*)lsapic20 - (char*)acpi_madt);
  674. /* Set up the SRAT table */
  675. acpi_table_init(&acpi_srat->header, ACPI_SRAT_SIG, ACPI_SRAT_SIG_LEN, ACPI_SRAT_REVISION, 1);
  676. ptr = acpi_srat+1;
  677. for (cnode=0; cnode<num_nodes; cnode++) {
  678. nasid = GetNasid(cnode);
  679. srat_memory_affinity = ptr;
  680. ptr = srat_memory_affinity+1;
  681. srat_memory_affinity->type = SRAT_MEMORY_STRUCTURE;
  682. srat_memory_affinity->length = sizeof(srat_memory_affinity_t);
  683. srat_memory_affinity->proximity_domain = PROXIMITY_DOMAIN(nasid);
  684. srat_memory_affinity->base_addr_lo = 0;
  685. srat_memory_affinity->length_lo = 0;
  686. #if defined(CONFIG_IA64_SGI_SN1)
  687. srat_memory_affinity->base_addr_hi = nasid<<1;
  688. srat_memory_affinity->length_hi = SN1_NODE_SIZE>>32;
  689. #else
  690. srat_memory_affinity->base_addr_hi = (nasid<<6) | (3<<4);
  691. srat_memory_affinity->length_hi = SN2_NODE_SIZE>>32;
  692. #endif
  693. srat_memory_affinity->memory_type = ACPI_ADDRESS_RANGE_MEMORY;
  694. srat_memory_affinity->flags = SRAT_MEMORY_FLAGS_ENABLED;
  695. }
  697. for (cnode=0; cnode<num_nodes; cnode++) {
  698. nasid = GetNasid(cnode);
  699. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  700. if (!IsCpuPresent(cnode, cpu))
  701. continue;
  702. srat_cpu_affinity = ptr;
  703. ptr = srat_cpu_affinity + 1;
  704. srat_cpu_affinity->type = SRAT_CPU_STRUCTURE;
  705. srat_cpu_affinity->length = sizeof(srat_cpu_affinity_t);
  706. srat_cpu_affinity->proximity_domain = PROXIMITY_DOMAIN(nasid);
  707. srat_cpu_affinity->flags = SRAT_CPU_FLAGS_ENABLED;
  708. #if defined(CONFIG_IA64_SGI_SN1)
  709. srat_cpu_affinity->apic_id = nasid;
  710. srat_cpu_affinity->local_sapic_eid = cpu;
  711. #else
  712. srat_cpu_affinity->local_sapic_eid = nasid&0xffff;
  713. srat_cpu_affinity->apic_id = (cpu<<4) | (nasid>>16);
  714. #endif
  715. }
  716. }
  717. acpi_checksum(&acpi_srat->header, (char*)ptr - (char*)acpi_srat);
  720. /* Set up the SLIT table */
  721. acpi_table_init(&acpi_slit->header, ACPI_SLIT_SIG, ACPI_SLIT_SIG_LEN, ACPI_SLIT_REVISION, 1);
  722. acpi_slit->localities = PROXIMITY_DOMAIN(max_nasid)+1;
  723. cp=acpi_slit->entries;
  724. memset(cp, 255, acpi_slit->localities*acpi_slit->localities);
  726. for (i=0; i<=max_nasid; i++)
  727. for (j=0; j<=max_nasid; j++)
  728. if (nasid_present(i) && nasid_present(j))
  729. *(cp+PROXIMITY_DOMAIN(i)*acpi_slit->localities+PROXIMITY_DOMAIN(j)) = 10 + MIN(254, 5*ABS(i-j));
  731. cp = acpi_slit->entries + acpi_slit->localities*acpi_slit->localities;
  732. acpi_checksum(&acpi_slit->header, cp - (char*)acpi_slit);
  735. /* fill in the SAL system table: */
  736. memcpy(sal_systab->signature, "SST_", 4);
  737. sal_systab->size = sizeof(*sal_systab);
  738. sal_systab->sal_rev_minor = 1;
  739. sal_systab->sal_rev_major = 0;
  740. sal_systab->entry_count = 3;
  742. strcpy(sal_systab->oem_id, "SGI");
  743. strcpy(sal_systab->product_id, "SN1");
  745. /* fill in an entry point: */
  746. sal_ed->type = SAL_DESC_ENTRY_POINT;
  747. sal_ed->pal_proc = __fwtab_pa(base_nasid, pal_desc[0]);
  748. sal_ed->sal_proc = __fwtab_pa(base_nasid, sal_desc[0]);
  749. sal_ed->gp = __fwtab_pa(base_nasid, sal_desc[1]);
  751. /* kludge the PTC domain info */
  752. sal_ptc->type = SAL_DESC_PTC;
  753. sal_ptc->num_domains = 0;
  754. sal_ptc->domain_info = __fwtab_pa(base_nasid, sal_ptcdi);
  755. cpus_found = 0;
  756. last_domain = -1;
  757. sal_ptcdi--;
  758. for (cnode=0; cnode<num_nodes; cnode++) {
  759. nasid = GetNasid(cnode);
  760. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  761. if (IsCpuPresent(cnode, cpu)) {
  762. domain = cnode*CPUS_PER_NODE + cpu/CPUS_PER_FSB;
  763. if (domain != last_domain) {
  764. sal_ptc->num_domains++;
  765. sal_ptcdi++;
  766. sal_ptcdi->proc_count = 0;
  767. sal_ptcdi->proc_list = __fwtab_pa(base_nasid, sal_ptclid);
  768. last_domain = domain;
  769. }
  770. sal_ptcdi->proc_count++;
  771. sal_ptclid->id = nasid;
  772. sal_ptclid->eid = cpu;
  773. sal_ptclid++;
  774. cpus_found++;
  775. }
  776. }
  777. }
  779. if (cpus_found != num_cpus)
  780. FPROM_BUG();
  782. /* Make the AP WAKEUP entry */
  783. sal_apwake->type = SAL_DESC_AP_WAKEUP;
  784. sal_apwake->mechanism = IA64_SAL_AP_EXTERNAL_INT;
  785. sal_apwake->vector = 18;
  787. for (checksum=0, cp=(char*)sal_systab; cp < (char *)efi_memmap; ++cp)
  788. checksum += *cp;
  789. sal_systab->checksum = -checksum;
  791. /* If the checksum is correct, the kernel tries to use the
  792.  * table. We dont build enough table & the kernel aborts.
  793.  * Note that the PROM hasd thhhe same problem!!
  794.  */
  795. #ifdef DOESNT_WORK
  796. for (checksum=0, cp=(char*)acpi_rsdp, cpe=cp+RSDP_CHECKSUM_LENGTH; cp<cpe; ++cp)
  797. checksum += *cp;
  798. acpi_rsdp->checksum = -checksum;
  799. #endif
  801. md = &efi_memmap[0];
  802. num_memmd = build_efi_memmap((void *)md, mdsize) ;
  804. bp = (struct ia64_boot_param*) __fwtab_pa(base_nasid, BOOT_PARAM_ADDR);
  805. bp->efi_systab = __fwtab_pa(base_nasid, &fw_mem);
  806. bp->efi_memmap = __fwtab_pa(base_nasid, efi_memmap);
  807. bp->efi_memmap_size = num_memmd*mdsize;
  808. bp->efi_memdesc_size = mdsize;
  809. bp->efi_memdesc_version = 0x101;
  810. bp->command_line = __fwtab_pa(base_nasid, cmd_line);
  811. bp->console_info.num_cols = 80;
  812. bp->console_info.num_rows = 25;
  813. bp->console_info.orig_x = 0;
  814. bp->console_info.orig_y = 24;
  815. bp->fpswa = 0;
  817. /*
  818.  * Now pick the BSP & store it LID value in
  819.  * a global variable. Note if BSP is greater than last cpu,
  820.  * pick the last cpu.
  821.  */
  822. for (cnode=0; cnode<num_nodes; cnode++) {
  823. for(cpu=0; cpu<CPUS_PER_NODE; cpu++) {
  824. if (!IsCpuPresent(cnode, cpu))
  825. continue;
  826. #ifdef CONFIG_IA64_SGI_SN1
  827. bsp_lid = (GetNasid(cnode)<<24) | (cpu<<16);
  828. #else
  829. bsp_lid = (GetNasid(cnode)<<16) | (cpu<<28);
  830. #endif
  831. if (bsp-- > 0)
  832. continue;
  833. return;
  834. }
  835. }
  836. }