This is a BIOS emulator, porting from SciTech for u-boot, mainly for
[oweals/u-boot.git] / drivers / bios_emulator / biosemu.c
1 /****************************************************************************
2 *
3 *                        BIOS emulator and interface
4 *                      to Realmode X86 Emulator Library
5 *
6 *  Copyright (C) 2007 Freescale Semiconductor, Inc. All rights reserved.
7 *  Jason Jin <Jason.jin@freescale.com>
8 *
9 *               Copyright (C) 1996-1999 SciTech Software, Inc.
10 *
11 *  ========================================================================
12 *
13 *  Permission to use, copy, modify, distribute, and sell this software and
14 *  its documentation for any purpose is hereby granted without fee,
15 *  provided that the above copyright notice appear in all copies and that
16 *  both that copyright notice and this permission notice appear in
17 *  supporting documentation, and that the name of the authors not be used
18 *  in advertising or publicity pertaining to distribution of the software
19 *  without specific, written prior permission.  The authors makes no
20 *  representations about the suitability of this software for any purpose.
21 *  It is provided "as is" without express or implied warranty.
22 *
23 *  THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
24 *  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
25 *  EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
26 *  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
27 *  USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
28 *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
29 *  PERFORMANCE OF THIS SOFTWARE.
30 *
31 *  ========================================================================
32 *
33 * Language:     ANSI C
34 * Environment:  Any
35 * Developer:    Kendall Bennett
36 *
37 * Description:  Module implementing the system specific functions. This
38 *               module is always compiled and linked in the OS depedent
39 *               libraries, and never in a binary portable driver.
40 *
41 *               Jason ported this file to u-boot to run the ATI video card BIOS
42 *               in u-boot. Made all the video memory be emulated during the
43 *               BIOS runing process which may affect the VGA function but the
44 *               frambuffer function can work after run the BIOS.
45 *
46 ****************************************************************************/
47
48 #include "biosemui.h"
49 #include <malloc.h>
50
51 BE_sysEnv _BE_env = {{0}};
52 static X86EMU_memFuncs _BE_mem __attribute__((section(".got2"))) = {
53         BE_rdb,
54         BE_rdw,
55         BE_rdl,
56         BE_wrb,
57         BE_wrw,
58         BE_wrl,
59         };
60
61 static X86EMU_pioFuncs _BE_pio __attribute__((section(".got2"))) = {
62         BE_inb,
63         BE_inw,
64         BE_inl,
65         BE_outb,
66         BE_outw,
67         BE_outl,
68         };
69
70 #define OFF(addr)       (u16)(((addr) >> 0) & 0xffff)
71 #define SEG(addr)       (u16)(((addr) >> 4) & 0xf000)
72
73 /****************************************************************************
74 PARAMETERS:
75 debugFlags  - Flags to enable debugging options (debug builds only)
76 memSize     - Amount of memory to allocate for real mode machine
77 info        - Pointer to default VGA device information
78
79 REMARKS:
80 This functions initialises the BElib, and uses the passed in
81 BIOS image as the BIOS that is used and emulated at 0xC0000.
82 ****************************************************************************/
83 int X86API BE_init(u32 debugFlags, int memSize, BE_VGAInfo * info, int shared)
84 {
85 #if !defined(__DRIVER__)  && !defined(__KERNEL__)
86
87         PM_init();
88 #endif
89         memset(&M, 0, sizeof(M));
90         if (memSize < 20480){
91                 printf("Emulator requires at least 20Kb of memory!\n");
92                 return 0;
93         }
94
95         M.mem_base = (unsigned long)malloc(memSize);
96
97         if (M.mem_base == NULL){
98                 printf("Biosemu:Out of memory!");
99                 return 0;
100         }
101         M.mem_size = memSize;
102
103         _BE_env.emulateVGA = 0;
104         _BE_env.busmem_base = (unsigned long)malloc(128 * 1024);
105         if (_BE_env.busmem_base == NULL){
106                 printf("Biosemu:Out of memory!");
107                 return 0;
108         }
109         M.x86.debug = debugFlags;
110         _BE_bios_init((u32*)info->LowMem);
111         X86EMU_setupMemFuncs(&_BE_mem);
112         X86EMU_setupPioFuncs(&_BE_pio);
113         BE_setVGA(info);
114         return 1;
115 }
116
117 /****************************************************************************
118 PARAMETERS:
119 info        - Pointer to VGA device information to make current
120
121 REMARKS:
122 This function sets the VGA BIOS functions in the emulator to point to the
123 specific VGA BIOS in use. This includes swapping the BIOS interrupt
124 vectors, BIOS image and BIOS data area to the new BIOS. This allows the
125 real mode BIOS to be swapped without resetting the entire emulator.
126 ****************************************************************************/
127 void X86API BE_setVGA(BE_VGAInfo * info)
128 {
129
130 #ifdef __KERNEL__
131         _BE_env.vgaInfo.function = info->function;
132         _BE_env.vgaInfo.device = info->device;
133         _BE_env.vgaInfo.bus = info->bus;
134         _BE_env.vgaInfo.pcidev = info->pcidev;
135 #else
136         _BE_env.vgaInfo.pciInfo = info->pciInfo;
137 #endif
138         _BE_env.vgaInfo.BIOSImage = info->BIOSImage;
139         if (info->BIOSImage) {
140                 _BE_env.biosmem_base = (ulong) info->BIOSImage;
141                 _BE_env.biosmem_limit = 0xC0000 + info->BIOSImageLen - 1;
142         } else {
143                 _BE_env.biosmem_base = _BE_env.busmem_base + 0x20000;
144                 _BE_env.biosmem_limit = 0xC7FFF;
145         }
146         if (*((u32 *) info->LowMem) == 0)
147                 _BE_bios_init((u32 *) info->LowMem);
148         memcpy((u8 *) M.mem_base, info->LowMem, sizeof(info->LowMem));
149 }
150
151 /****************************************************************************
152 PARAMETERS:
153 info        - Pointer to VGA device information to retrieve current
154
155 REMARKS:
156 This function returns the VGA BIOS functions currently active in the
157 emulator, so they can be restored at a later date.
158 ****************************************************************************/
159 void X86API BE_getVGA(BE_VGAInfo * info)
160 {
161 #ifdef __KERNEL__
162         info->function = _BE_env.vgaInfo.function;
163         info->device = _BE_env.vgaInfo.device;
164         info->bus = _BE_env.vgaInfo.bus;
165         info->pcidev = _BE_env.vgaInfo.pcidev;
166 #else
167         info->pciInfo = _BE_env.vgaInfo.pciInfo;
168 #endif
169         info->BIOSImage = _BE_env.vgaInfo.BIOSImage;
170         memcpy(info->LowMem, (u8 *) M.mem_base, sizeof(info->LowMem));
171 }
172
173 /****************************************************************************
174 PARAMETERS:
175 r_seg   - Segment for pointer to convert
176 r_off   - Offset for pointer to convert
177
178 REMARKS:
179 This function maps a real mode pointer in the emulator memory to a protected
180 mode pointer that can be used to directly access the memory.
181
182 NOTE:   The memory is *always* in little endian format, son on non-x86
183         systems you will need to do endian translations to access this
184         memory.
185 ****************************************************************************/
186 void *X86API BE_mapRealPointer(uint r_seg, uint r_off)
187 {
188         u32 addr = ((u32) r_seg << 4) + r_off;
189
190         if (addr >= 0xC0000 && addr <= _BE_env.biosmem_limit) {
191                 return (void *)(_BE_env.biosmem_base + addr - 0xC0000);
192         } else if (addr >= 0xA0000 && addr <= 0xFFFFF) {
193                 return (void *)(_BE_env.busmem_base + addr - 0xA0000);
194         }
195         return (void *)(M.mem_base + addr);
196 }
197
198 /****************************************************************************
199 PARAMETERS:
200 len     - Return the length of the VESA buffer
201 rseg    - Place to store VESA buffer segment
202 roff    - Place to store VESA buffer offset
203
204 REMARKS:
205 This function returns the address of the VESA transfer buffer in real
206 _BE_piomode emulator memory. The VESA transfer buffer is always 1024 bytes long,
207 and located at 15Kb into the start of the real mode memory (16Kb is where
208 we put the real mode code we execute for issuing interrupts).
209
210 NOTE:   The memory is *always* in little endian format, son on non-x86
211         systems you will need to do endian translations to access this
212         memory.
213 ****************************************************************************/
214 void *X86API BE_getVESABuf(uint * len, uint * rseg, uint * roff)
215 {
216         *len = 1024;
217         *rseg = SEG(0x03C00);
218         *roff = OFF(0x03C00);
219         return (void *)(M.mem_base + ((u32) * rseg << 4) + *roff);
220 }
221
222 /****************************************************************************
223 REMARKS:
224 Cleans up and exits the emulator.
225 ****************************************************************************/
226 void X86API BE_exit(void)
227 {
228         free(M.mem_base);
229         free(_BE_env.busmem_base);
230 }
231
232 /****************************************************************************
233 PARAMETERS:
234 seg     - Segment of code to call
235 off     - Offset of code to call
236 regs    - Real mode registers to load
237 sregs   - Real mode segment registers to load
238
239 REMARKS:
240 This functions calls a real mode far function at the specified address,
241 and loads all the x86 registers from the passed in registers structure.
242 On exit the registers returned from the call are returned in the same
243 structures.
244 ****************************************************************************/
245 void X86API BE_callRealMode(uint seg, uint off, RMREGS * regs, RMSREGS * sregs)
246 {
247         M.x86.R_EAX = regs->e.eax;
248         M.x86.R_EBX = regs->e.ebx;
249         M.x86.R_ECX = regs->e.ecx;
250         M.x86.R_EDX = regs->e.edx;
251         M.x86.R_ESI = regs->e.esi;
252         M.x86.R_EDI = regs->e.edi;
253         M.x86.R_DS = sregs->ds;
254         M.x86.R_ES = sregs->es;
255         M.x86.R_FS = sregs->fs;
256         M.x86.R_GS = sregs->gs;
257
258         ((u8 *) M.mem_base)[0x4000] = 0x9A;
259         ((u8 *) M.mem_base)[0x4001] = (u8) off;
260         ((u8 *) M.mem_base)[0x4002] = (u8) (off >> 8);
261         ((u8 *) M.mem_base)[0x4003] = (u8) seg;
262         ((u8 *) M.mem_base)[0x4004] = (u8) (seg >> 8);
263         ((u8 *) M.mem_base)[0x4005] = 0xF1;     /* Illegal op-code */
264         M.x86.R_CS = SEG(0x04000);
265         M.x86.R_IP = OFF(0x04000);
266
267         M.x86.R_SS = SEG(M.mem_size - 2);
268         M.x86.R_SP = OFF(M.mem_size - 2) + 2;
269
270         X86EMU_exec();
271
272         regs->e.cflag = M.x86.R_EFLG & F_CF;
273         regs->e.eax = M.x86.R_EAX;
274         regs->e.ebx = M.x86.R_EBX;
275         regs->e.ecx = M.x86.R_ECX;
276         regs->e.edx = M.x86.R_EDX;
277         regs->e.esi = M.x86.R_ESI;
278         regs->e.edi = M.x86.R_EDI;
279         sregs->ds = M.x86.R_DS;
280         sregs->es = M.x86.R_ES;
281         sregs->fs = M.x86.R_FS;
282         sregs->gs = M.x86.R_GS;
283 }
284
285 /****************************************************************************
286 PARAMETERS:
287 intno   - Interrupt number to execute
288 in      - Real mode registers to load
289 out     - Place to store resulting real mode registers
290
291 REMARKS:
292 This functions calls a real mode interrupt function at the specified address,
293 and loads all the x86 registers from the passed in registers structure.
294 On exit the registers returned from the call are returned in out stucture.
295 ****************************************************************************/
296 int X86API BE_int86(int intno, RMREGS * in, RMREGS * out)
297 {
298         M.x86.R_EAX = in->e.eax;
299         M.x86.R_EBX = in->e.ebx;
300         M.x86.R_ECX = in->e.ecx;
301         M.x86.R_EDX = in->e.edx;
302         M.x86.R_ESI = in->e.esi;
303         M.x86.R_EDI = in->e.edi;
304         ((u8 *) M.mem_base)[0x4000] = 0xCD;
305         ((u8 *) M.mem_base)[0x4001] = (u8) intno;
306         ((u8 *) M.mem_base)[0x4002] = 0xF1;
307         M.x86.R_CS = SEG(0x04000);
308         M.x86.R_IP = OFF(0x04000);
309
310         M.x86.R_SS = SEG(M.mem_size - 1);
311         M.x86.R_SP = OFF(M.mem_size - 1) - 1;
312
313         X86EMU_exec();
314         out->e.cflag = M.x86.R_EFLG & F_CF;
315         out->e.eax = M.x86.R_EAX;
316         out->e.ebx = M.x86.R_EBX;
317         out->e.ecx = M.x86.R_ECX;
318         out->e.edx = M.x86.R_EDX;
319         out->e.esi = M.x86.R_ESI;
320         out->e.edi = M.x86.R_EDI;
321         return out->x.ax;
322 }
323
324 /****************************************************************************
325 PARAMETERS:
326 intno   - Interrupt number to execute
327 in      - Real mode registers to load
328 out     - Place to store resulting real mode registers
329 sregs   - Real mode segment registers to load
330
331 REMARKS:
332 This functions calls a real mode interrupt function at the specified address,
333 and loads all the x86 registers from the passed in registers structure.
334 On exit the registers returned from the call are returned in out stucture.
335 ****************************************************************************/
336 int X86API BE_int86x(int intno, RMREGS * in, RMREGS * out, RMSREGS * sregs)
337 {
338         M.x86.R_EAX = in->e.eax;
339         M.x86.R_EBX = in->e.ebx;
340         M.x86.R_ECX = in->e.ecx;
341         M.x86.R_EDX = in->e.edx;
342         M.x86.R_ESI = in->e.esi;
343         M.x86.R_EDI = in->e.edi;
344         M.x86.R_DS = sregs->ds;
345         M.x86.R_ES = sregs->es;
346         M.x86.R_FS = sregs->fs;
347         M.x86.R_GS = sregs->gs;
348         ((u8 *) M.mem_base)[0x4000] = 0xCD;
349         ((u8 *) M.mem_base)[0x4001] = (u8) intno;
350         ((u8 *) M.mem_base)[0x4002] = 0xF1;
351         M.x86.R_CS = SEG(0x04000);
352         M.x86.R_IP = OFF(0x04000);
353
354         M.x86.R_SS = SEG(M.mem_size - 1);
355         M.x86.R_SP = OFF(M.mem_size - 1) - 1;
356
357         X86EMU_exec();
358         out->e.cflag = M.x86.R_EFLG & F_CF;
359         out->e.eax = M.x86.R_EAX;
360         out->e.ebx = M.x86.R_EBX;
361         out->e.ecx = M.x86.R_ECX;
362         out->e.edx = M.x86.R_EDX;
363         out->e.esi = M.x86.R_ESI;
364         out->e.edi = M.x86.R_EDI;
365         sregs->ds = M.x86.R_DS;
366         sregs->es = M.x86.R_ES;
367         sregs->fs = M.x86.R_FS;
368         sregs->gs = M.x86.R_GS;
369         return out->x.ax;
370 }