4 * Copyright (C) 1998-2001 Hewlett-Packard Co
5 * David Mosberger-Tang <davidm@hpl.hp.com>
9 # include <linux/pci.h>
12 #include <linux/efi.h>
16 #include <asm/setup.h>
20 #define MB (1024*1024UL)
22 #define SIMPLE_MEMMAP 1
25 # define NUM_MEM_DESCS 4
27 # define NUM_MEM_DESCS 16
30 static char fw_mem
[( sizeof(struct ia64_boot_param
)
31 + sizeof(efi_system_table_t
)
32 + sizeof(efi_runtime_services_t
)
33 + 1*sizeof(efi_config_table_t
)
34 + sizeof(struct ia64_sal_systab
)
35 + sizeof(struct ia64_sal_desc_entry_point
)
36 + NUM_MEM_DESCS
*(sizeof(efi_memory_desc_t
))
37 + 1024)] __attribute__ ((aligned (8)));
39 #define SECS_PER_HOUR (60 * 60)
40 #define SECS_PER_DAY (SECS_PER_HOUR * 24)
42 /* Compute the `struct tm' representation of *T,
43 offset OFFSET seconds east of UTC,
44 and store year, yday, mon, mday, wday, hour, min, sec into *TP.
45 Return nonzero if successful. */
47 offtime (unsigned long t
, efi_time_t
*tp
)
49 const unsigned short int __mon_yday
[2][13] =
52 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
54 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
56 long int days
, rem
, y
;
57 const unsigned short int *ip
;
59 days
= t
/ SECS_PER_DAY
;
60 rem
= t
% SECS_PER_DAY
;
65 while (rem
>= SECS_PER_DAY
) {
69 tp
->hour
= rem
/ SECS_PER_HOUR
;
71 tp
->minute
= rem
/ 60;
72 tp
->second
= rem
% 60;
73 /* January 1, 1970 was a Thursday. */
76 # define DIV(a, b) ((a) / (b) - ((a) % (b) < 0))
77 # define LEAPS_THRU_END_OF(y) (DIV (y, 4) - DIV (y, 100) + DIV (y, 400))
78 # define __isleap(year) \
79 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
81 while (days
< 0 || days
>= (__isleap (y
) ? 366 : 365)) {
82 /* Guess a corrected year, assuming 365 days per year. */
83 long int yg
= y
+ days
/ 365 - (days
% 365 < 0);
85 /* Adjust DAYS and Y to match the guessed year. */
86 days
-= ((yg
- y
) * 365 + LEAPS_THRU_END_OF (yg
- 1)
87 - LEAPS_THRU_END_OF (y
- 1));
91 ip
= __mon_yday
[__isleap(y
)];
92 for (y
= 11; days
< (long int) ip
[y
]; --y
)
100 extern void pal_emulator_static (void);
102 /* Macro to emulate SAL call using legacy IN and OUT calls to CF8, CFC etc.. */
104 #define BUILD_CMD(addr) ((0x80000000 | (addr)) & ~3)
106 #define REG_OFFSET(addr) (0x00000000000000FF & (addr))
107 #define DEVICE_FUNCTION(addr) (0x000000000000FF00 & (addr))
108 #define BUS_NUMBER(addr) (0x0000000000FF0000 & (addr))
111 fw_efi_get_time (efi_time_t
*tm
, efi_time_cap_t
*tc
)
113 #if defined(CONFIG_IA64_HP_SIM) || defined(CONFIG_IA64_GENERIC)
115 int tv_sec
; /* must be 32bits to work */
119 ssc((unsigned long) &tv32bits
, 0, 0, 0, SSC_GET_TOD
);
121 memset(tm
, 0, sizeof(*tm
));
122 offtime(tv32bits
.tv_sec
, tm
);
125 memset(tc
, 0, sizeof(*tc
));
127 # error Not implemented yet...
133 efi_reset_system (int reset_type
, efi_status_t status
, unsigned long data_size
, efi_char16_t
*data
)
135 #if defined(CONFIG_IA64_HP_SIM) || defined(CONFIG_IA64_GENERIC)
136 ssc(status
, 0, 0, 0, SSC_EXIT
);
138 # error Not implemented yet...
143 efi_unimplemented (void)
145 return EFI_UNSUPPORTED
;
148 static struct sal_ret_values
149 sal_emulator (long index
, unsigned long in1
, unsigned long in2
,
150 unsigned long in3
, unsigned long in4
, unsigned long in5
,
151 unsigned long in6
, unsigned long in7
)
159 * Don't do a "switch" here since that gives us code that
160 * isn't self-relocatable.
163 if (index
== SAL_FREQ_BASE
) {
164 if (in1
== SAL_FREQ_BASE_PLATFORM
)
166 else if (in1
== SAL_FREQ_BASE_INTERVAL_TIMER
) {
168 * Is this supposed to be the cr.itc frequency
169 * or something platform specific? The SAL
170 * doc ain't exactly clear on this...
173 } else if (in1
== SAL_FREQ_BASE_REALTIME_CLOCK
)
177 } else if (index
== SAL_SET_VECTORS
) {
179 } else if (index
== SAL_GET_STATE_INFO
) {
181 } else if (index
== SAL_GET_STATE_INFO_SIZE
) {
183 } else if (index
== SAL_CLEAR_STATE_INFO
) {
185 } else if (index
== SAL_MC_RENDEZ
) {
187 } else if (index
== SAL_MC_SET_PARAMS
) {
189 } else if (index
== SAL_CACHE_FLUSH
) {
191 } else if (index
== SAL_CACHE_INIT
) {
194 } else if (index
== SAL_PCI_CONFIG_READ
) {
196 * in1 contains the PCI configuration address and in2
197 * the size of the read. The value that is read is
198 * returned via the general register r9.
200 outl(BUILD_CMD(in1
), 0xCF8);
201 if (in2
== 1) /* Reading byte */
202 r9
= inb(0xCFC + ((REG_OFFSET(in1
) & 3)));
203 else if (in2
== 2) /* Reading word */
204 r9
= inw(0xCFC + ((REG_OFFSET(in1
) & 2)));
205 else /* Reading dword */
207 status
= PCIBIOS_SUCCESSFUL
;
208 } else if (index
== SAL_PCI_CONFIG_WRITE
) {
210 * in1 contains the PCI configuration address, in2 the
211 * size of the write, and in3 the actual value to be
214 outl(BUILD_CMD(in1
), 0xCF8);
215 if (in2
== 1) /* Writing byte */
216 outb(in3
, 0xCFC + ((REG_OFFSET(in1
) & 3)));
217 else if (in2
== 2) /* Writing word */
218 outw(in3
, 0xCFC + ((REG_OFFSET(in1
) & 2)));
219 else /* Writing dword */
221 status
= PCIBIOS_SUCCESSFUL
;
222 #endif /* CONFIG_PCI */
223 } else if (index
== SAL_UPDATE_PAL
) {
228 return ((struct sal_ret_values
) {status
, r9
, r10
, r11
});
231 struct ia64_boot_param
*
232 sys_fw_init (const char *args
, int arglen
)
234 efi_system_table_t
*efi_systab
;
235 efi_runtime_services_t
*efi_runtime
;
236 efi_config_table_t
*efi_tables
;
237 struct ia64_sal_systab
*sal_systab
;
238 efi_memory_desc_t
*efi_memmap
, *md
;
239 unsigned long *pal_desc
, *sal_desc
;
240 struct ia64_sal_desc_entry_point
*sal_ed
;
241 struct ia64_boot_param
*bp
;
242 unsigned char checksum
= 0;
245 # define MAKE_MD(typ, attr, start, end) \
247 md = efi_memmap + i++; \
250 md->phys_addr = start; \
252 md->num_pages = (end - start) >> 12; \
253 md->attribute = attr; \
256 memset(fw_mem
, 0, sizeof(fw_mem
));
258 pal_desc
= (unsigned long *) &pal_emulator_static
;
259 sal_desc
= (unsigned long *) &sal_emulator
;
262 efi_systab
= (void *) cp
; cp
+= sizeof(*efi_systab
);
263 efi_runtime
= (void *) cp
; cp
+= sizeof(*efi_runtime
);
264 efi_tables
= (void *) cp
; cp
+= sizeof(*efi_tables
);
265 sal_systab
= (void *) cp
; cp
+= sizeof(*sal_systab
);
266 sal_ed
= (void *) cp
; cp
+= sizeof(*sal_ed
);
267 efi_memmap
= (void *) cp
; cp
+= NUM_MEM_DESCS
*sizeof(*efi_memmap
);
268 bp
= (void *) cp
; cp
+= sizeof(*bp
);
269 cmd_line
= (void *) cp
;
274 memcpy(cmd_line
, args
, arglen
);
278 cmd_line
[arglen
] = '\0';
280 memset(efi_systab
, 0, sizeof(*efi_systab
));
281 efi_systab
->hdr
.signature
= EFI_SYSTEM_TABLE_SIGNATURE
;
282 efi_systab
->hdr
.revision
= ((1 << 16) | 00);
283 efi_systab
->hdr
.headersize
= sizeof(efi_systab
->hdr
);
284 efi_systab
->fw_vendor
= __pa("H\0e\0w\0l\0e\0t\0t\0-\0P\0a\0c\0k\0a\0r\0d\0\0");
285 efi_systab
->fw_revision
= 1;
286 efi_systab
->runtime
= (void *) __pa(efi_runtime
);
287 efi_systab
->nr_tables
= 1;
288 efi_systab
->tables
= __pa(efi_tables
);
290 efi_runtime
->hdr
.signature
= EFI_RUNTIME_SERVICES_SIGNATURE
;
291 efi_runtime
->hdr
.revision
= EFI_RUNTIME_SERVICES_REVISION
;
292 efi_runtime
->hdr
.headersize
= sizeof(efi_runtime
->hdr
);
293 efi_runtime
->get_time
= (void *)__pa(&fw_efi_get_time
);
294 efi_runtime
->set_time
= (void *)__pa(&efi_unimplemented
);
295 efi_runtime
->get_wakeup_time
= (void *)__pa(&efi_unimplemented
);
296 efi_runtime
->set_wakeup_time
= (void *)__pa(&efi_unimplemented
);
297 efi_runtime
->set_virtual_address_map
= (void *)__pa(&efi_unimplemented
);
298 efi_runtime
->get_variable
= (void *)__pa(&efi_unimplemented
);
299 efi_runtime
->get_next_variable
= (void *)__pa(&efi_unimplemented
);
300 efi_runtime
->set_variable
= (void *)__pa(&efi_unimplemented
);
301 efi_runtime
->get_next_high_mono_count
= (void *)__pa(&efi_unimplemented
);
302 efi_runtime
->reset_system
= (void *)__pa(&efi_reset_system
);
304 efi_tables
->guid
= SAL_SYSTEM_TABLE_GUID
;
305 efi_tables
->table
= __pa(sal_systab
);
307 /* fill in the SAL system table: */
308 memcpy(sal_systab
->signature
, "SST_", 4);
309 sal_systab
->size
= sizeof(*sal_systab
);
310 sal_systab
->sal_rev_minor
= 1;
311 sal_systab
->sal_rev_major
= 0;
312 sal_systab
->entry_count
= 1;
314 #ifdef CONFIG_IA64_GENERIC
315 strcpy(sal_systab
->oem_id
, "Generic");
316 strcpy(sal_systab
->product_id
, "IA-64 system");
319 #ifdef CONFIG_IA64_HP_SIM
320 strcpy(sal_systab
->oem_id
, "Hewlett-Packard");
321 strcpy(sal_systab
->product_id
, "HP-simulator");
324 /* fill in an entry point: */
325 sal_ed
->type
= SAL_DESC_ENTRY_POINT
;
326 sal_ed
->pal_proc
= __pa(pal_desc
[0]);
327 sal_ed
->sal_proc
= __pa(sal_desc
[0]);
328 sal_ed
->gp
= __pa(sal_desc
[1]);
330 for (cp
= (char *) sal_systab
; cp
< (char *) efi_memmap
; ++cp
)
333 sal_systab
->checksum
= -checksum
;
336 /* simulate free memory at physical address zero */
337 MAKE_MD(EFI_BOOT_SERVICES_DATA
, EFI_MEMORY_WB
, 0*MB
, 1*MB
);
338 MAKE_MD(EFI_PAL_CODE
, EFI_MEMORY_WB
, 1*MB
, 2*MB
);
339 MAKE_MD(EFI_CONVENTIONAL_MEMORY
, EFI_MEMORY_WB
, 2*MB
, 130*MB
);
340 MAKE_MD(EFI_CONVENTIONAL_MEMORY
, EFI_MEMORY_WB
, 4096*MB
, 4128*MB
);
342 MAKE_MD( 4, 0x9, 0x0000000000000000, 0x0000000000001000);
343 MAKE_MD( 7, 0x9, 0x0000000000001000, 0x000000000008a000);
344 MAKE_MD( 4, 0x9, 0x000000000008a000, 0x00000000000a0000);
345 MAKE_MD( 5, 0x8000000000000009, 0x00000000000c0000, 0x0000000000100000);
346 MAKE_MD( 7, 0x9, 0x0000000000100000, 0x0000000004400000);
347 MAKE_MD( 2, 0x9, 0x0000000004400000, 0x0000000004be5000);
348 MAKE_MD( 7, 0x9, 0x0000000004be5000, 0x000000007f77e000);
349 MAKE_MD( 6, 0x8000000000000009, 0x000000007f77e000, 0x000000007fb94000);
350 MAKE_MD( 6, 0x8000000000000009, 0x000000007fb94000, 0x000000007fb95000);
351 MAKE_MD( 6, 0x8000000000000009, 0x000000007fb95000, 0x000000007fc00000);
352 MAKE_MD(13, 0x8000000000000009, 0x000000007fc00000, 0x000000007fc3a000);
353 MAKE_MD( 7, 0x9, 0x000000007fc3a000, 0x000000007fea0000);
354 MAKE_MD( 5, 0x8000000000000009, 0x000000007fea0000, 0x000000007fea8000);
355 MAKE_MD( 7, 0x9, 0x000000007fea8000, 0x000000007feab000);
356 MAKE_MD( 5, 0x8000000000000009, 0x000000007feab000, 0x000000007ffff000);
357 MAKE_MD( 7, 0x9, 0x00000000ff400000, 0x0000000104000000);
360 bp
->efi_systab
= __pa(&fw_mem
);
361 bp
->efi_memmap
= __pa(efi_memmap
);
362 bp
->efi_memmap_size
= NUM_MEM_DESCS
*sizeof(efi_memory_desc_t
);
363 bp
->efi_memdesc_size
= sizeof(efi_memory_desc_t
);
364 bp
->efi_memdesc_version
= 1;
365 bp
->command_line
= __pa(cmd_line
);
366 bp
->console_info
.num_cols
= 80;
367 bp
->console_info
.num_rows
= 25;
368 bp
->console_info
.orig_x
= 0;
369 bp
->console_info
.orig_y
= 24;