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 } 371