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