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 <malloc.h>
49 #include <common.h>
50 
51 #if defined(CONFIG_BIOSEMU)
52 
53 #include "biosemui.h"
54 
55 BE_sysEnv _BE_env = {{0}};
56 static X86EMU_memFuncs _BE_mem __attribute__((section(".got2"))) = {
57 	BE_rdb,
58 	BE_rdw,
59 	BE_rdl,
60 	BE_wrb,
61 	BE_wrw,
62 	BE_wrl,
63 	};
64 
65 static X86EMU_pioFuncs _BE_pio __attribute__((section(".got2"))) = {
66 	BE_inb,
67 	BE_inw,
68 	BE_inl,
69 	BE_outb,
70 	BE_outw,
71 	BE_outl,
72 	};
73 
74 #define OFF(addr)	(u16)(((addr) >> 0) & 0xffff)
75 #define SEG(addr)	(u16)(((addr) >> 4) & 0xf000)
76 
77 /****************************************************************************
78 PARAMETERS:
79 debugFlags  - Flags to enable debugging options (debug builds only)
80 memSize	    - Amount of memory to allocate for real mode machine
81 info	    - Pointer to default VGA device information
82 
83 REMARKS:
84 This functions initialises the BElib, and uses the passed in
85 BIOS image as the BIOS that is used and emulated at 0xC0000.
86 ****************************************************************************/
87 int X86API BE_init(u32 debugFlags, int memSize, BE_VGAInfo * info, int shared)
88 {
89 #if !defined(__DRIVER__)  && !defined(__KERNEL__)
90 
91 	PM_init();
92 #endif
93 	memset(&M, 0, sizeof(M));
94 	if (memSize < 20480){
95 		printf("Emulator requires at least 20Kb of memory!\n");
96 		return 0;
97 	}
98 
99 	M.mem_base = malloc(memSize);
100 
101 	if (M.mem_base == NULL){
102 		printf("Biosemu:Out of memory!");
103 		return 0;
104 	}
105 	M.mem_size = memSize;
106 
107 	_BE_env.emulateVGA = 0;
108 	_BE_env.busmem_base = (unsigned long)malloc(128 * 1024);
109 	if ((void *)_BE_env.busmem_base == NULL){
110 		printf("Biosemu:Out of memory!");
111 		return 0;
112 	}
113 	M.x86.debug = debugFlags;
114 	_BE_bios_init((u32*)info->LowMem);
115 	X86EMU_setupMemFuncs(&_BE_mem);
116 	X86EMU_setupPioFuncs(&_BE_pio);
117 	BE_setVGA(info);
118 	return 1;
119 }
120 
121 /****************************************************************************
122 PARAMETERS:
123 info	    - Pointer to VGA device information to make current
124 
125 REMARKS:
126 This function sets the VGA BIOS functions in the emulator to point to the
127 specific VGA BIOS in use. This includes swapping the BIOS interrupt
128 vectors, BIOS image and BIOS data area to the new BIOS. This allows the
129 real mode BIOS to be swapped without resetting the entire emulator.
130 ****************************************************************************/
131 void X86API BE_setVGA(BE_VGAInfo * info)
132 {
133 
134 #ifdef __KERNEL__
135 	_BE_env.vgaInfo.function = info->function;
136 	_BE_env.vgaInfo.device = info->device;
137 	_BE_env.vgaInfo.bus = info->bus;
138 	_BE_env.vgaInfo.pcidev = info->pcidev;
139 #else
140 	_BE_env.vgaInfo.pciInfo = info->pciInfo;
141 #endif
142 	_BE_env.vgaInfo.BIOSImage = info->BIOSImage;
143 	if (info->BIOSImage) {
144 		_BE_env.biosmem_base = (ulong) info->BIOSImage;
145 		_BE_env.biosmem_limit = 0xC0000 + info->BIOSImageLen - 1;
146 	} else {
147 		_BE_env.biosmem_base = _BE_env.busmem_base + 0x20000;
148 		_BE_env.biosmem_limit = 0xC7FFF;
149 	}
150 	if (*((u32 *) info->LowMem) == 0)
151 		_BE_bios_init((u32 *) info->LowMem);
152 	memcpy((u8 *) M.mem_base, info->LowMem, sizeof(info->LowMem));
153 }
154 
155 /****************************************************************************
156 PARAMETERS:
157 info	    - Pointer to VGA device information to retrieve current
158 
159 REMARKS:
160 This function returns the VGA BIOS functions currently active in the
161 emulator, so they can be restored at a later date.
162 ****************************************************************************/
163 void X86API BE_getVGA(BE_VGAInfo * info)
164 {
165 #ifdef __KERNEL__
166 	info->function = _BE_env.vgaInfo.function;
167 	info->device = _BE_env.vgaInfo.device;
168 	info->bus = _BE_env.vgaInfo.bus;
169 	info->pcidev = _BE_env.vgaInfo.pcidev;
170 #else
171 	info->pciInfo = _BE_env.vgaInfo.pciInfo;
172 #endif
173 	info->BIOSImage = _BE_env.vgaInfo.BIOSImage;
174 	memcpy(info->LowMem, (u8 *) M.mem_base, sizeof(info->LowMem));
175 }
176 
177 /****************************************************************************
178 PARAMETERS:
179 r_seg	- Segment for pointer to convert
180 r_off	- Offset for pointer to convert
181 
182 REMARKS:
183 This function maps a real mode pointer in the emulator memory to a protected
184 mode pointer that can be used to directly access the memory.
185 
186 NOTE:	The memory is *always* in little endian format, son on non-x86
187 	systems you will need to do endian translations to access this
188 	memory.
189 ****************************************************************************/
190 void *X86API BE_mapRealPointer(uint r_seg, uint r_off)
191 {
192 	u32 addr = ((u32) r_seg << 4) + r_off;
193 
194 	if (addr >= 0xC0000 && addr <= _BE_env.biosmem_limit) {
195 		return (void *)(_BE_env.biosmem_base + addr - 0xC0000);
196 	} else if (addr >= 0xA0000 && addr <= 0xFFFFF) {
197 		return (void *)(_BE_env.busmem_base + addr - 0xA0000);
198 	}
199 	return (void *)(M.mem_base + addr);
200 }
201 
202 /****************************************************************************
203 PARAMETERS:
204 len	- Return the length of the VESA buffer
205 rseg	- Place to store VESA buffer segment
206 roff	- Place to store VESA buffer offset
207 
208 REMARKS:
209 This function returns the address of the VESA transfer buffer in real
210 _BE_piomode emulator memory. The VESA transfer buffer is always 1024 bytes long,
211 and located at 15Kb into the start of the real mode memory (16Kb is where
212 we put the real mode code we execute for issuing interrupts).
213 
214 NOTE:	The memory is *always* in little endian format, son on non-x86
215 	systems you will need to do endian translations to access this
216 	memory.
217 ****************************************************************************/
218 void *X86API BE_getVESABuf(uint * len, uint * rseg, uint * roff)
219 {
220 	*len = 1024;
221 	*rseg = SEG(0x03C00);
222 	*roff = OFF(0x03C00);
223 	return (void *)(M.mem_base + ((u32) * rseg << 4) + *roff);
224 }
225 
226 /****************************************************************************
227 REMARKS:
228 Cleans up and exits the emulator.
229 ****************************************************************************/
230 void X86API BE_exit(void)
231 {
232 	free(M.mem_base);
233 	free((void *)_BE_env.busmem_base);
234 }
235 
236 /****************************************************************************
237 PARAMETERS:
238 seg	- Segment of code to call
239 off	- Offset of code to call
240 regs	- Real mode registers to load
241 sregs	- Real mode segment registers to load
242 
243 REMARKS:
244 This functions calls a real mode far function at the specified address,
245 and loads all the x86 registers from the passed in registers structure.
246 On exit the registers returned from the call are returned in the same
247 structures.
248 ****************************************************************************/
249 void X86API BE_callRealMode(uint seg, uint off, RMREGS * regs, RMSREGS * sregs)
250 {
251 	M.x86.R_EAX = regs->e.eax;
252 	M.x86.R_EBX = regs->e.ebx;
253 	M.x86.R_ECX = regs->e.ecx;
254 	M.x86.R_EDX = regs->e.edx;
255 	M.x86.R_ESI = regs->e.esi;
256 	M.x86.R_EDI = regs->e.edi;
257 	M.x86.R_DS = sregs->ds;
258 	M.x86.R_ES = sregs->es;
259 	M.x86.R_FS = sregs->fs;
260 	M.x86.R_GS = sregs->gs;
261 
262 	((u8 *) M.mem_base)[0x4000] = 0x9A;
263 	((u8 *) M.mem_base)[0x4001] = (u8) off;
264 	((u8 *) M.mem_base)[0x4002] = (u8) (off >> 8);
265 	((u8 *) M.mem_base)[0x4003] = (u8) seg;
266 	((u8 *) M.mem_base)[0x4004] = (u8) (seg >> 8);
267 	((u8 *) M.mem_base)[0x4005] = 0xF1;	/* Illegal op-code */
268 	M.x86.R_CS = SEG(0x04000);
269 	M.x86.R_IP = OFF(0x04000);
270 
271 	M.x86.R_SS = SEG(M.mem_size - 2);
272 	M.x86.R_SP = OFF(M.mem_size - 2) + 2;
273 
274 	X86EMU_exec();
275 
276 	regs->e.cflag = M.x86.R_EFLG & F_CF;
277 	regs->e.eax = M.x86.R_EAX;
278 	regs->e.ebx = M.x86.R_EBX;
279 	regs->e.ecx = M.x86.R_ECX;
280 	regs->e.edx = M.x86.R_EDX;
281 	regs->e.esi = M.x86.R_ESI;
282 	regs->e.edi = M.x86.R_EDI;
283 	sregs->ds = M.x86.R_DS;
284 	sregs->es = M.x86.R_ES;
285 	sregs->fs = M.x86.R_FS;
286 	sregs->gs = M.x86.R_GS;
287 }
288 
289 /****************************************************************************
290 PARAMETERS:
291 intno	- Interrupt number to execute
292 in	- Real mode registers to load
293 out	- Place to store resulting real mode registers
294 
295 REMARKS:
296 This functions calls a real mode interrupt function at the specified address,
297 and loads all the x86 registers from the passed in registers structure.
298 On exit the registers returned from the call are returned in out stucture.
299 ****************************************************************************/
300 int X86API BE_int86(int intno, RMREGS * in, RMREGS * out)
301 {
302 	M.x86.R_EAX = in->e.eax;
303 	M.x86.R_EBX = in->e.ebx;
304 	M.x86.R_ECX = in->e.ecx;
305 	M.x86.R_EDX = in->e.edx;
306 	M.x86.R_ESI = in->e.esi;
307 	M.x86.R_EDI = in->e.edi;
308 	((u8 *) M.mem_base)[0x4000] = 0xCD;
309 	((u8 *) M.mem_base)[0x4001] = (u8) intno;
310 	((u8 *) M.mem_base)[0x4002] = 0xF1;
311 	M.x86.R_CS = SEG(0x04000);
312 	M.x86.R_IP = OFF(0x04000);
313 
314 	M.x86.R_SS = SEG(M.mem_size - 1);
315 	M.x86.R_SP = OFF(M.mem_size - 1) - 1;
316 
317 	X86EMU_exec();
318 	out->e.cflag = M.x86.R_EFLG & F_CF;
319 	out->e.eax = M.x86.R_EAX;
320 	out->e.ebx = M.x86.R_EBX;
321 	out->e.ecx = M.x86.R_ECX;
322 	out->e.edx = M.x86.R_EDX;
323 	out->e.esi = M.x86.R_ESI;
324 	out->e.edi = M.x86.R_EDI;
325 	return out->x.ax;
326 }
327 
328 /****************************************************************************
329 PARAMETERS:
330 intno	- Interrupt number to execute
331 in	- Real mode registers to load
332 out	- Place to store resulting real mode registers
333 sregs	- Real mode segment registers to load
334 
335 REMARKS:
336 This functions calls a real mode interrupt function at the specified address,
337 and loads all the x86 registers from the passed in registers structure.
338 On exit the registers returned from the call are returned in out stucture.
339 ****************************************************************************/
340 int X86API BE_int86x(int intno, RMREGS * in, RMREGS * out, RMSREGS * sregs)
341 {
342 	M.x86.R_EAX = in->e.eax;
343 	M.x86.R_EBX = in->e.ebx;
344 	M.x86.R_ECX = in->e.ecx;
345 	M.x86.R_EDX = in->e.edx;
346 	M.x86.R_ESI = in->e.esi;
347 	M.x86.R_EDI = in->e.edi;
348 	M.x86.R_DS = sregs->ds;
349 	M.x86.R_ES = sregs->es;
350 	M.x86.R_FS = sregs->fs;
351 	M.x86.R_GS = sregs->gs;
352 	((u8 *) M.mem_base)[0x4000] = 0xCD;
353 	((u8 *) M.mem_base)[0x4001] = (u8) intno;
354 	((u8 *) M.mem_base)[0x4002] = 0xF1;
355 	M.x86.R_CS = SEG(0x04000);
356 	M.x86.R_IP = OFF(0x04000);
357 
358 	M.x86.R_SS = SEG(M.mem_size - 1);
359 	M.x86.R_SP = OFF(M.mem_size - 1) - 1;
360 
361 	X86EMU_exec();
362 	out->e.cflag = M.x86.R_EFLG & F_CF;
363 	out->e.eax = M.x86.R_EAX;
364 	out->e.ebx = M.x86.R_EBX;
365 	out->e.ecx = M.x86.R_ECX;
366 	out->e.edx = M.x86.R_EDX;
367 	out->e.esi = M.x86.R_ESI;
368 	out->e.edi = M.x86.R_EDI;
369 	sregs->ds = M.x86.R_DS;
370 	sregs->es = M.x86.R_ES;
371 	sregs->fs = M.x86.R_FS;
372 	sregs->gs = M.x86.R_GS;
373 	return out->x.ax;
374 }
375 #endif
376