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 }