drivers/bios_emulator/bios.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 BIOS specific functions.
  38 *
  39 *               Jason ported this file to u-boot to run the ATI video card
  40 *               video BIOS.
  41 *
  42 ****************************************************************************/
  43
  44 #include <common.h>
  45 #include "biosemui.h"
  46
  47 /*----------------------------- Implementation ----------------------------*/
  48
  49 /****************************************************************************
  50 PARAMETERS:
  51 intno   - Interrupt number being serviced
  52
  53 REMARKS:
  54 Handler for undefined interrupts.
  55 ****************************************************************************/
  56 static void X86API undefined_intr(int intno)
  57 {
  58         if (BE_rdw(intno * 4 + 2) == BIOS_SEG) {
  59                 DB(printf("biosEmu: undefined interrupt %xh called!\n", intno);)
  60         } else
  61                 X86EMU_prepareForInt(intno);
  62 }
  63
  64 /****************************************************************************
  65 PARAMETERS:
  66 intno   - Interrupt number being serviced
  67
  68 REMARKS:
  69 This function handles the default system BIOS Int 10h (the default is stored
  70 in the Int 42h vector by the system BIOS at bootup). We only need to handle
  71 a small number of special functions used by the BIOS during POST time.
  72 ****************************************************************************/
  73 static void X86API int42(int intno)
  74 {
  75         if (M.x86.R_AH == 0x12 && M.x86.R_BL == 0x32) {
  76                 if (M.x86.R_AL == 0) {
  77                         /* Enable CPU accesses to video memory */
  78                         PM_outpb(0x3c2, PM_inpb(0x3cc) | (u8) 0x02);
  79                         return;
  80                 } else if (M.x86.R_AL == 1) {
  81                         /* Disable CPU accesses to video memory */
  82                         PM_outpb(0x3c2, PM_inpb(0x3cc) & (u8) ~ 0x02);
  83                         return;
  84                 }
  85 #ifdef  DEBUG
  86                 else {
  87                         printf("int42: unknown function AH=0x12, BL=0x32, AL=%#02x\n",
  88                              M.x86.R_AL);
  89                 }
  90 #endif
  91         }
  92 #ifdef  DEBUG
  93         else {
  94                 printf("int42: unknown function AH=%#02x, AL=%#02x, BL=%#02x\n",
  95                      M.x86.R_AH, M.x86.R_AL, M.x86.R_BL);
  96         }
  97 #endif
  98 }
  99
 100 /****************************************************************************
 101 PARAMETERS:
 102 intno   - Interrupt number being serviced
 103
 104 REMARKS:
 105 This function handles the default system BIOS Int 10h. If the POST code
 106 has not yet re-vectored the Int 10h BIOS interrupt vector, we handle this
 107 by simply calling the int42 interrupt handler above. Very early in the
 108 BIOS POST process, the vector gets replaced and we simply let the real
 109 mode interrupt handler process the interrupt.
 110 ****************************************************************************/
 111 static void X86API int10(int intno)
 112 {
 113         if (BE_rdw(intno * 4 + 2) == BIOS_SEG)
 114                 int42(intno);
 115         else
 116                 X86EMU_prepareForInt(intno);
 117 }
 118
 119 /* Result codes returned by the PCI BIOS */
 120
 121 #define SUCCESSFUL          0x00
 122 #define FUNC_NOT_SUPPORT    0x81
 123 #define BAD_VENDOR_ID       0x83
 124 #define DEVICE_NOT_FOUND    0x86
 125 #define BAD_REGISTER_NUMBER 0x87
 126 #define SET_FAILED          0x88
 127 #define BUFFER_TOO_SMALL    0x89
 128
 129 /****************************************************************************
 130 PARAMETERS:
 131 intno   - Interrupt number being serviced
 132
 133 REMARKS:
 134 This function handles the default Int 1Ah interrupt handler for the real
 135 mode code, which provides support for the PCI BIOS functions. Since we only
 136 want to allow the real mode BIOS code *only* see the PCI config space for
 137 its own device, we only return information for the specific PCI config
 138 space that we have passed in to the init function. This solves problems
 139 when using the BIOS to warm boot a secondary adapter when there is an
 140 identical adapter before it on the bus (some BIOS'es get confused in this
 141 case).
 142 ****************************************************************************/
 143 static void X86API int1A(int unused)
 144 {
 145         u16 pciSlot;
 146
 147 #ifdef __KERNEL__
 148         u8 interface, subclass, baseclass;
 149
 150         /* Initialise the PCI slot number */
 151         pciSlot = ((int)_BE_env.vgaInfo.bus << 8) |
 152             ((int)_BE_env.vgaInfo.device << 3) | (int)_BE_env.vgaInfo.function;
 153 #else
 154 /* Fail if no PCI device information has been registered */
 155         if (!_BE_env.vgaInfo.pciInfo)
 156                 return;
 157
 158         pciSlot = (u16) (_BE_env.vgaInfo.pciInfo->slot.i >> 8);
 159 #endif
 160         switch (M.x86.R_AX) {
 161         case 0xB101:            /* PCI bios present? */
 162                 M.x86.R_AL = 0x00;      /* no config space/special cycle generation support */
 163                 M.x86.R_EDX = 0x20494350;       /* " ICP" */
 164                 M.x86.R_BX = 0x0210;    /* Version 2.10 */
 165                 M.x86.R_CL = 0; /* Max bus number in system */
 166                 CLEAR_FLAG(F_CF);
 167                 break;
 168         case 0xB102:            /* Find PCI device */
 169                 M.x86.R_AH = DEVICE_NOT_FOUND;
 170 #ifdef __KERNEL__
 171                 if (M.x86.R_DX == _BE_env.vgaInfo.VendorID &&
 172                     M.x86.R_CX == _BE_env.vgaInfo.DeviceID && M.x86.R_SI == 0) {
 173 #else
 174                 if (M.x86.R_DX == _BE_env.vgaInfo.pciInfo->VendorID &&
 175                     M.x86.R_CX == _BE_env.vgaInfo.pciInfo->DeviceID &&
 176                     M.x86.R_SI == 0) {
 177 #endif
 178                         M.x86.R_AH = SUCCESSFUL;
 179                         M.x86.R_BX = pciSlot;
 180                 }
 181                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 182                 break;
 183         case 0xB103:            /* Find PCI class code */
 184                 M.x86.R_AH = DEVICE_NOT_FOUND;
 185 #ifdef __KERNEL__
 186                 pci_read_config_byte(_BE_env.vgaInfo.pcidev, PCI_CLASS_PROG,
 187                                      &interface);
 188                 pci_read_config_byte(_BE_env.vgaInfo.pcidev, PCI_CLASS_DEVICE,
 189                                      &subclass);
 190                 pci_read_config_byte(_BE_env.vgaInfo.pcidev,
 191                                      PCI_CLASS_DEVICE + 1, &baseclass);
 192                 if (M.x86.R_CL == interface && M.x86.R_CH == subclass
 193                     && (u8) (M.x86.R_ECX >> 16) == baseclass) {
 194 #else
 195                 if (M.x86.R_CL == _BE_env.vgaInfo.pciInfo->Interface &&
 196                     M.x86.R_CH == _BE_env.vgaInfo.pciInfo->SubClass &&
 197                     (u8) (M.x86.R_ECX >> 16) ==
 198                     _BE_env.vgaInfo.pciInfo->BaseClass) {
 199 #endif
 200                         M.x86.R_AH = SUCCESSFUL;
 201                         M.x86.R_BX = pciSlot;
 202                 }
 203                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 204                 break;
 205         case 0xB108:            /* Read configuration byte */
 206                 M.x86.R_AH = BAD_REGISTER_NUMBER;
 207                 if (M.x86.R_BX == pciSlot) {
 208                         M.x86.R_AH = SUCCESSFUL;
 209 #ifdef __KERNEL__
 210                         pci_read_config_byte(_BE_env.vgaInfo.pcidev, M.x86.R_DI,
 211                                              &M.x86.R_CL);
 212 #else
 213                         M.x86.R_CL =
 214                             (u8) PCI_accessReg(M.x86.R_DI, 0, PCI_READ_BYTE,
 215                                                _BE_env.vgaInfo.pciInfo);
 216 #endif
 217                 }
 218                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 219                 break;
 220         case 0xB109:            /* Read configuration word */
 221                 M.x86.R_AH = BAD_REGISTER_NUMBER;
 222                 if (M.x86.R_BX == pciSlot) {
 223                         M.x86.R_AH = SUCCESSFUL;
 224 #ifdef __KERNEL__
 225                         pci_read_config_word(_BE_env.vgaInfo.pcidev, M.x86.R_DI,
 226                                              &M.x86.R_CX);
 227 #else
 228                         M.x86.R_CX =
 229                             (u16) PCI_accessReg(M.x86.R_DI, 0, PCI_READ_WORD,
 230                                                 _BE_env.vgaInfo.pciInfo);
 231 #endif
 232                 }
 233                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 234                 break;
 235         case 0xB10A:            /* Read configuration dword */
 236                 M.x86.R_AH = BAD_REGISTER_NUMBER;
 237                 if (M.x86.R_BX == pciSlot) {
 238                         M.x86.R_AH = SUCCESSFUL;
 239 #ifdef __KERNEL__
 240                         pci_read_config_dword(_BE_env.vgaInfo.pcidev,
 241                                               M.x86.R_DI, &M.x86.R_ECX);
 242 #else
 243                         M.x86.R_ECX =
 244                             (u32) PCI_accessReg(M.x86.R_DI, 0, PCI_READ_DWORD,
 245                                                 _BE_env.vgaInfo.pciInfo);
 246 #endif
 247                 }
 248                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 249                 break;
 250         case 0xB10B:            /* Write configuration byte */
 251                 M.x86.R_AH = BAD_REGISTER_NUMBER;
 252                 if (M.x86.R_BX == pciSlot) {
 253                         M.x86.R_AH = SUCCESSFUL;
 254 #ifdef __KERNEL__
 255                         pci_write_config_byte(_BE_env.vgaInfo.pcidev,
 256                                               M.x86.R_DI, M.x86.R_CL);
 257 #else
 258                         PCI_accessReg(M.x86.R_DI, M.x86.R_CL, PCI_WRITE_BYTE,
 259                                       _BE_env.vgaInfo.pciInfo);
 260 #endif
 261                 }
 262                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 263                 break;
 264         case 0xB10C:            /* Write configuration word */
 265                 M.x86.R_AH = BAD_REGISTER_NUMBER;
 266                 if (M.x86.R_BX == pciSlot) {
 267                         M.x86.R_AH = SUCCESSFUL;
 268 #ifdef __KERNEL__
 269                         pci_write_config_word(_BE_env.vgaInfo.pcidev,
 270                                               M.x86.R_DI, M.x86.R_CX);
 271 #else
 272                         PCI_accessReg(M.x86.R_DI, M.x86.R_CX, PCI_WRITE_WORD,
 273                                       _BE_env.vgaInfo.pciInfo);
 274 #endif
 275                 }
 276                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 277                 break;
 278         case 0xB10D:            /* Write configuration dword */
 279                 M.x86.R_AH = BAD_REGISTER_NUMBER;
 280                 if (M.x86.R_BX == pciSlot) {
 281                         M.x86.R_AH = SUCCESSFUL;
 282 #ifdef __KERNEL__
 283                         pci_write_config_dword(_BE_env.vgaInfo.pcidev,
 284                                                M.x86.R_DI, M.x86.R_ECX);
 285 #else
 286                         PCI_accessReg(M.x86.R_DI, M.x86.R_ECX, PCI_WRITE_DWORD,
 287                                       _BE_env.vgaInfo.pciInfo);
 288 #endif
 289                 }
 290                 CONDITIONAL_SET_FLAG((M.x86.R_AH != SUCCESSFUL), F_CF);
 291                 break;
 292         default:
 293                 printf("biosEmu/bios.int1a: unknown function AX=%#04x\n",
 294                        M.x86.R_AX);
 295         }
 296 }
 297
 298 /****************************************************************************
 299 REMARKS:
 300 This function initialises the BIOS emulation functions for the specific
 301 PCI display device. We insulate the real mode BIOS from any other devices
 302 on the bus, so that it will work correctly thinking that it is the only
 303 device present on the bus (ie: avoiding any adapters present in from of
 304 the device we are trying to control).
 305 ****************************************************************************/
 306 #define BE_constLE_32(v)    ((((((v)&0xff00)>>8)|(((v)&0xff)<<8))<<16)|(((((v)&0xff000000)>>8)|(((v)&0x00ff0000)<<8))>>16))
 307
 308 void _BE_bios_init(u32 * intrTab)
 309 {
 310         int i;
 311         X86EMU_intrFuncs bios_intr_tab[256];
 312
 313         for (i = 0; i < 256; ++i) {
 314                 intrTab[i] = BE_constLE_32(BIOS_SEG << 16);
 315                 bios_intr_tab[i] = undefined_intr;
 316         }
 317         bios_intr_tab[0x10] = int10;
 318         bios_intr_tab[0x1A] = int1A;
 319         bios_intr_tab[0x42] = int42;
 320         bios_intr_tab[0x6D] = int10;
 321         X86EMU_setupIntrFuncs(bios_intr_tab);
 322 }