1/* 2 * PAL & SAL emulation. 3 * 4 * Copyright (C) 1998-2001 Hewlett-Packard Co 5 * David Mosberger-Tang <davidm@hpl.hp.com> 6 */ 7 8#ifdef CONFIG_PCI 9# include <linux/pci.h> 10#endif 11 12#include <linux/efi.h> 13#include <asm/io.h> 14#include <asm/pal.h> 15#include <asm/sal.h> 16 17#include "ssc.h" 18 19#define MB (1024*1024UL) 20 21#define SIMPLE_MEMMAP 1 22 23#if SIMPLE_MEMMAP 24# define NUM_MEM_DESCS 4 25#else 26# define NUM_MEM_DESCS 16 27#endif 28 29static char fw_mem[( sizeof(struct ia64_boot_param) 30 + sizeof(efi_system_table_t) 31 + sizeof(efi_runtime_services_t) 32 + 1*sizeof(efi_config_table_t) 33 + sizeof(struct ia64_sal_systab) 34 + sizeof(struct ia64_sal_desc_entry_point) 35 + NUM_MEM_DESCS*(sizeof(efi_memory_desc_t)) 36 + 1024)] __attribute__ ((aligned (8))); 37 38#define SECS_PER_HOUR (60 * 60) 39#define SECS_PER_DAY (SECS_PER_HOUR * 24) 40 41/* Compute the `struct tm' representation of *T, 42 offset OFFSET seconds east of UTC, 43 and store year, yday, mon, mday, wday, hour, min, sec into *TP. 44 Return nonzero if successful. */ 45int 46offtime (unsigned long t, efi_time_t *tp) 47{ 48 const unsigned short int __mon_yday[2][13] = 49 { 50 /* Normal years. */ 51 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }, 52 /* Leap years. */ 53 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 } 54 }; 55 long int days, rem, y; 56 const unsigned short int *ip; 57 58 days = t / SECS_PER_DAY; 59 rem = t % SECS_PER_DAY; 60 while (rem < 0) { 61 rem += SECS_PER_DAY; 62 --days; 63 } 64 while (rem >= SECS_PER_DAY) { 65 rem -= SECS_PER_DAY; 66 ++days; 67 } 68 tp->hour = rem / SECS_PER_HOUR; 69 rem %= SECS_PER_HOUR; 70 tp->minute = rem / 60; 71 tp->second = rem % 60; 72 /* January 1, 1970 was a Thursday. */ 73 y = 1970; 74 75# define DIV(a, b) ((a) / (b) - ((a) % (b) < 0)) 76# define LEAPS_THRU_END_OF(y) (DIV (y, 4) - DIV (y, 100) + DIV (y, 400)) 77# define __isleap(year) \ 78 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0)) 79 80 while (days < 0 || days >= (__isleap (y) ? 366 : 365)) { 81 /* Guess a corrected year, assuming 365 days per year. */ 82 long int yg = y + days / 365 - (days % 365 < 0); 83 84 /* Adjust DAYS and Y to match the guessed year. */ 85 days -= ((yg - y) * 365 + LEAPS_THRU_END_OF (yg - 1) 86 - LEAPS_THRU_END_OF (y - 1)); 87 y = yg; 88 } 89 tp->year = y; 90 ip = __mon_yday[__isleap(y)]; 91 for (y = 11; days < (long int) ip[y]; --y) 92 continue; 93 days -= ip[y]; 94 tp->month = y + 1; 95 tp->day = days + 1; 96 return 1; 97} 98 99extern void pal_emulator_static (void); 100 101/* Macro to emulate SAL call using legacy IN and OUT calls to CF8, CFC etc.. */ 102 103#define BUILD_CMD(addr) ((0x80000000 | (addr)) & ~3) 104 105#define REG_OFFSET(addr) (0x00000000000000FF & (addr)) 106#define DEVICE_FUNCTION(addr) (0x000000000000FF00 & (addr)) 107#define BUS_NUMBER(addr) (0x0000000000FF0000 & (addr)) 108 109static efi_status_t 110fw_efi_get_time (efi_time_t *tm, efi_time_cap_t *tc) 111{ 112#if defined(CONFIG_IA64_HP_SIM) || defined(CONFIG_IA64_GENERIC) 113 struct { 114 int tv_sec; /* must be 32bits to work */ 115 int tv_usec; 116 } tv32bits; 117 118 ssc((unsigned long) &tv32bits, 0, 0, 0, SSC_GET_TOD); 119 120 memset(tm, 0, sizeof(*tm)); 121 offtime(tv32bits.tv_sec, tm); 122 123 if (tc) 124 memset(tc, 0, sizeof(*tc)); 125#else 126# error Not implemented yet... 127#endif 128 return EFI_SUCCESS; 129} 130 131static void 132efi_reset_system (int reset_type, efi_status_t status, unsigned long data_size, efi_char16_t *data) 133{ 134#if defined(CONFIG_IA64_HP_SIM) || defined(CONFIG_IA64_GENERIC) 135 ssc(status, 0, 0, 0, SSC_EXIT); 136#else 137# error Not implemented yet... 138#endif 139} 140 141static efi_status_t 142efi_unimplemented (void) 143{ 144 return EFI_UNSUPPORTED; 145} 146 147static struct sal_ret_values 148sal_emulator (long index, unsigned long in1, unsigned long in2, 149 unsigned long in3, unsigned long in4, unsigned long in5, 150 unsigned long in6, unsigned long in7) 151{ 152 long r9 = 0; 153 long r10 = 0; 154 long r11 = 0; 155 long status; 156 157 /* 158 * Don't do a "switch" here since that gives us code that 159 * isn't self-relocatable. 160 */ 161 status = 0; 162 if (index == SAL_FREQ_BASE) { 163 switch (in1) { 164 case SAL_FREQ_BASE_PLATFORM: 165 r9 = 200000000; 166 break; 167 168 case SAL_FREQ_BASE_INTERVAL_TIMER: 169 /* 170 * Is this supposed to be the cr.itc frequency 171 * or something platform specific? The SAL 172 * doc ain't exactly clear on this... 173 */ 174 r9 = 700000000; 175 break; 176 177 case SAL_FREQ_BASE_REALTIME_CLOCK: 178 r9 = 1; 179 break; 180 181 default: 182 status = -1; 183 break; 184 } 185 } else if (index == SAL_SET_VECTORS) { 186 ; 187 } else if (index == SAL_GET_STATE_INFO) { 188 ; 189 } else if (index == SAL_GET_STATE_INFO_SIZE) { 190 ; 191 } else if (index == SAL_CLEAR_STATE_INFO) { 192 ; 193 } else if (index == SAL_MC_RENDEZ) { 194 ; 195 } else if (index == SAL_MC_SET_PARAMS) { 196 ; 197 } else if (index == SAL_CACHE_FLUSH) { 198 ; 199 } else if (index == SAL_CACHE_INIT) { 200 ; 201#ifdef CONFIG_PCI 202 } else if (index == SAL_PCI_CONFIG_READ) { 203 /* 204 * in1 contains the PCI configuration address and in2 205 * the size of the read. The value that is read is 206 * returned via the general register r9. 207 */ 208 outl(BUILD_CMD(in1), 0xCF8); 209 if (in2 == 1) /* Reading byte */ 210 r9 = inb(0xCFC + ((REG_OFFSET(in1) & 3))); 211 else if (in2 == 2) /* Reading word */ 212 r9 = inw(0xCFC + ((REG_OFFSET(in1) & 2))); 213 else /* Reading dword */ 214 r9 = inl(0xCFC); 215 status = PCIBIOS_SUCCESSFUL; 216 } else if (index == SAL_PCI_CONFIG_WRITE) { 217 /* 218 * in1 contains the PCI configuration address, in2 the 219 * size of the write, and in3 the actual value to be 220 * written out. 221 */ 222 outl(BUILD_CMD(in1), 0xCF8); 223 if (in2 == 1) /* Writing byte */ 224 outb(in3, 0xCFC + ((REG_OFFSET(in1) & 3))); 225 else if (in2 == 2) /* Writing word */ 226 outw(in3, 0xCFC + ((REG_OFFSET(in1) & 2))); 227 else /* Writing dword */ 228 outl(in3, 0xCFC); 229 status = PCIBIOS_SUCCESSFUL; 230#endif /* CONFIG_PCI */ 231 } else if (index == SAL_UPDATE_PAL) { 232 ; 233 } else { 234 status = -1; 235 } 236 return ((struct sal_ret_values) {status, r9, r10, r11}); 237} 238 239struct ia64_boot_param * 240sys_fw_init (const char *args, int arglen) 241{ 242 efi_system_table_t *efi_systab; 243 efi_runtime_services_t *efi_runtime; 244 efi_config_table_t *efi_tables; 245 struct ia64_sal_systab *sal_systab; 246 efi_memory_desc_t *efi_memmap, *md; 247 unsigned long *pal_desc, *sal_desc; 248 struct ia64_sal_desc_entry_point *sal_ed; 249 struct ia64_boot_param *bp; 250 unsigned char checksum = 0; 251 char *cp, *cmd_line; 252 int i = 0; 253# define MAKE_MD(typ, attr, start, end) \ 254 do { \ 255 md = efi_memmap + i++; \ 256 md->type = typ; \ 257 md->pad = 0; \ 258 md->phys_addr = start; \ 259 md->virt_addr = 0; \ 260 md->num_pages = (end - start) >> 12; \ 261 md->attribute = attr; \ 262 } while (0) 263 264 memset(fw_mem, 0, sizeof(fw_mem)); 265 266 pal_desc = (unsigned long *) &pal_emulator_static; 267 sal_desc = (unsigned long *) &sal_emulator; 268 269 cp = fw_mem; 270 efi_systab = (void *) cp; cp += sizeof(*efi_systab); 271 efi_runtime = (void *) cp; cp += sizeof(*efi_runtime); 272 efi_tables = (void *) cp; cp += sizeof(*efi_tables); 273 sal_systab = (void *) cp; cp += sizeof(*sal_systab); 274 sal_ed = (void *) cp; cp += sizeof(*sal_ed); 275 efi_memmap = (void *) cp; cp += NUM_MEM_DESCS*sizeof(*efi_memmap); 276 bp = (void *) cp; cp += sizeof(*bp); 277 cmd_line = (void *) cp; 278 279 if (args) { 280 if (arglen >= 1024) 281 arglen = 1023; 282 memcpy(cmd_line, args, arglen); 283 } else { 284 arglen = 0; 285 } 286 cmd_line[arglen] = '\0'; 287 288 memset(efi_systab, 0, sizeof(efi_systab)); 289 efi_systab->hdr.signature = EFI_SYSTEM_TABLE_SIGNATURE; 290 efi_systab->hdr.revision = ((1 << 16) | 00); 291 efi_systab->hdr.headersize = sizeof(efi_systab->hdr); 292 efi_systab->fw_vendor = __pa("H\0e\0w\0l\0e\0t\0t\0-\0P\0a\0c\0k\0a\0r\0d\0\0"); 293 efi_systab->fw_revision = 1; 294 efi_systab->runtime = (void *) __pa(efi_runtime); 295 efi_systab->nr_tables = 1; 296 efi_systab->tables = __pa(efi_tables); 297 298 efi_runtime->hdr.signature = EFI_RUNTIME_SERVICES_SIGNATURE; 299 efi_runtime->hdr.revision = EFI_RUNTIME_SERVICES_REVISION; 300 efi_runtime->hdr.headersize = sizeof(efi_runtime->hdr); 301 efi_runtime->get_time = __pa(&fw_efi_get_time); 302 efi_runtime->set_time = __pa(&efi_unimplemented); 303 efi_runtime->get_wakeup_time = __pa(&efi_unimplemented); 304 efi_runtime->set_wakeup_time = __pa(&efi_unimplemented); 305 efi_runtime->set_virtual_address_map = __pa(&efi_unimplemented); 306 efi_runtime->get_variable = __pa(&efi_unimplemented); 307 efi_runtime->get_next_variable = __pa(&efi_unimplemented); 308 efi_runtime->set_variable = __pa(&efi_unimplemented); 309 efi_runtime->get_next_high_mono_count = __pa(&efi_unimplemented); 310 efi_runtime->reset_system = __pa(&efi_reset_system); 311 312 efi_tables->guid = SAL_SYSTEM_TABLE_GUID; 313 efi_tables->table = __pa(sal_systab); 314 315 /* fill in the SAL system table: */ 316 memcpy(sal_systab->signature, "SST_", 4); 317 sal_systab->size = sizeof(*sal_systab); 318 sal_systab->sal_rev_minor = 1; 319 sal_systab->sal_rev_major = 0; 320 sal_systab->entry_count = 1; 321 322#ifdef CONFIG_IA64_GENERIC 323 strcpy(sal_systab->oem_id, "Generic"); 324 strcpy(sal_systab->product_id, "IA-64 system"); 325#endif 326 327#ifdef CONFIG_IA64_HP_SIM 328 strcpy(sal_systab->oem_id, "Hewlett-Packard"); 329 strcpy(sal_systab->product_id, "HP-simulator"); 330#endif 331 332#ifdef CONFIG_IA64_SDV 333 strcpy(sal_systab->oem_id, "Intel"); 334 strcpy(sal_systab->product_id, "SDV"); 335#endif 336 337 /* fill in an entry point: */ 338 sal_ed->type = SAL_DESC_ENTRY_POINT; 339 sal_ed->pal_proc = __pa(pal_desc[0]); 340 sal_ed->sal_proc = __pa(sal_desc[0]); 341 sal_ed->gp = __pa(sal_desc[1]); 342 343 for (cp = (char *) sal_systab; cp < (char *) efi_memmap; ++cp) 344 checksum += *cp; 345 346 sal_systab->checksum = -checksum; 347 348#if SIMPLE_MEMMAP 349 /* simulate free memory at physical address zero */ 350 MAKE_MD(EFI_BOOT_SERVICES_DATA, EFI_MEMORY_WB, 0*MB, 1*MB); 351 MAKE_MD(EFI_PAL_CODE, EFI_MEMORY_WB, 1*MB, 2*MB); 352 MAKE_MD(EFI_CONVENTIONAL_MEMORY, EFI_MEMORY_WB, 2*MB, 130*MB); 353 MAKE_MD(EFI_CONVENTIONAL_MEMORY, EFI_MEMORY_WB, 4096*MB, 4128*MB); 354#else 355 MAKE_MD( 4, 0x9, 0x0000000000000000, 0x0000000000001000); 356 MAKE_MD( 7, 0x9, 0x0000000000001000, 0x000000000008a000); 357 MAKE_MD( 4, 0x9, 0x000000000008a000, 0x00000000000a0000); 358 MAKE_MD( 5, 0x8000000000000009, 0x00000000000c0000, 0x0000000000100000); 359 MAKE_MD( 7, 0x9, 0x0000000000100000, 0x0000000004400000); 360 MAKE_MD( 2, 0x9, 0x0000000004400000, 0x0000000004be5000); 361 MAKE_MD( 7, 0x9, 0x0000000004be5000, 0x000000007f77e000); 362 MAKE_MD( 6, 0x8000000000000009, 0x000000007f77e000, 0x000000007fb94000); 363 MAKE_MD( 6, 0x8000000000000009, 0x000000007fb94000, 0x000000007fb95000); 364 MAKE_MD( 6, 0x8000000000000009, 0x000000007fb95000, 0x000000007fc00000); 365 MAKE_MD(13, 0x8000000000000009, 0x000000007fc00000, 0x000000007fc3a000); 366 MAKE_MD( 7, 0x9, 0x000000007fc3a000, 0x000000007fea0000); 367 MAKE_MD( 5, 0x8000000000000009, 0x000000007fea0000, 0x000000007fea8000); 368 MAKE_MD( 7, 0x9, 0x000000007fea8000, 0x000000007feab000); 369 MAKE_MD( 5, 0x8000000000000009, 0x000000007feab000, 0x000000007ffff000); 370 MAKE_MD( 7, 0x9, 0x00000000ff400000, 0x0000000104000000); 371#endif 372 373 bp->efi_systab = __pa(&fw_mem); 374 bp->efi_memmap = __pa(efi_memmap); 375 bp->efi_memmap_size = NUM_MEM_DESCS*sizeof(efi_memory_desc_t); 376 bp->efi_memdesc_size = sizeof(efi_memory_desc_t); 377 bp->efi_memdesc_version = 1; 378 bp->command_line = __pa(cmd_line); 379 bp->console_info.num_cols = 80; 380 bp->console_info.num_rows = 25; 381 bp->console_info.orig_x = 0; 382 bp->console_info.orig_y = 24; 383 bp->fpswa = 0; 384 385 return bp; 386} 387