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