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 <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 = (unsigned long)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 (_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(_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