drivers/bios_emulator/atibios.c

   1 /****************************************************************************
   2 *
   3 *                    Video BOOT Graphics Card POST Module
   4 *
   5 *  ========================================================================
   6 *   Copyright (C) 2007 Freescale Semiconductor, Inc.
   7 *   Jason Jin <Jason.jin@freescale.com>
   8 *
   9 *   Copyright (C) 1991-2004 SciTech Software, Inc. All rights reserved.
  10 *
  11 *   This file may be distributed and/or modified under the terms of the
  12 *   GNU General Public License version 2.0 as published by the Free
  13 *   Software Foundation and appearing in the file LICENSE.GPL included
  14 *   in the packaging of this file.
  15 *
  16 *   Licensees holding a valid Commercial License for this product from
  17 *   SciTech Software, Inc. may use this file in accordance with the
  18 *   Commercial License Agreement provided with the Software.
  19 *
  20 *   This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING
  21 *   THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22 *   PURPOSE.
  23 *
  24 *   See http://www.scitechsoft.com/license/ for information about
  25 *   the licensing options available and how to purchase a Commercial
  26 *   License Agreement.
  27 *
  28 *   Contact license@scitechsoft.com if any conditions of this licensing
  29 *   are not clear to you, or you have questions about licensing options.
  30 *
  31 *  ========================================================================
  32 *
  33 * Language:     ANSI C
  34 * Environment:  Linux Kernel
  35 * Developer:    Kendall Bennett
  36 *
  37 * Description:  Module to implement booting PCI/AGP controllers on the
  38 *               bus. We use the x86 real mode emulator to run the BIOS on
  39 *               graphics controllers to bring the cards up.
  40 *
  41 *               Note that at present this module does *not* support
  42 *               multiple controllers.
  43 *
  44 *               The orignal name of this file is warmboot.c.
  45 *               Jason ported this file to u-boot to run the ATI video card
  46 *               BIOS in u-boot.
  47 ****************************************************************************/
  48 #include <common.h>
  49 #include <bios_emul.h>
  50 #include <errno.h>
  51 #include <malloc.h>
  52 #include <vbe.h>
  53 #include "biosemui.h"
  54
  55 /* Length of the BIOS image */
  56 #define MAX_BIOSLEN         (128 * 1024L)
  57
  58 /* Place to save PCI BAR's that we change and later restore */
  59 static u32 saveROMBaseAddress;
  60 static u32 saveBaseAddress10;
  61 static u32 saveBaseAddress14;
  62 static u32 saveBaseAddress18;
  63 static u32 saveBaseAddress20;
  64
  65 /* Addres im memory of VBE region */
  66 const int vbe_offset = 0x2000;
  67
  68 static const void *bios_ptr(const void *buf, BE_VGAInfo *vga_info,
  69                             u32 x86_dword_ptr)
  70 {
  71         u32 seg_ofs, flat;
  72
  73         seg_ofs = le32_to_cpu(x86_dword_ptr);
  74         flat = ((seg_ofs & 0xffff0000) >> 12) | (seg_ofs & 0xffff);
  75         if (flat >= 0xc0000)
  76                 return vga_info->BIOSImage + flat - 0xc0000;
  77         else
  78                 return buf + (flat - vbe_offset);
  79 }
  80
  81 static int atibios_debug_mode(BE_VGAInfo *vga_info, RMREGS *regs,
  82                               int vesa_mode, struct vbe_mode_info *mode_info)
  83 {
  84         void *buffer = (void *)(M.mem_base + vbe_offset);
  85         u16 buffer_seg = (((unsigned long)vbe_offset) >> 4) & 0xff00;
  86         u16 buffer_adr = ((unsigned long)vbe_offset) & 0xffff;
  87         struct vesa_mode_info *vm;
  88         struct vbe_info *info;
  89         const u16 *modes_bios, *ptr;
  90         u16 *modes;
  91         int size;
  92
  93         debug("VBE: Getting information\n");
  94         regs->e.eax = VESA_GET_INFO;
  95         regs->e.esi = buffer_seg;
  96         regs->e.edi = buffer_adr;
  97         info = buffer;
  98         memset(info, '\0', sizeof(*info));
  99         strcpy(info->signature, "VBE2");
 100         BE_int86(0x10, regs, regs);
 101         if (regs->e.eax != 0x4f) {
 102                 debug("VESA_GET_INFO: error %x\n", regs->e.eax);
 103                 return -ENOSYS;
 104         }
 105         debug("version %x\n", le16_to_cpu(info->version));
 106         debug("oem '%s'\n", (char *)bios_ptr(buffer, vga_info,
 107                                              info->oem_string_ptr));
 108         debug("vendor '%s'\n", (char *)bios_ptr(buffer, vga_info,
 109                                                 info->vendor_name_ptr));
 110         debug("product '%s'\n", (char *)bios_ptr(buffer, vga_info,
 111                                                  info->product_name_ptr));
 112         debug("rev '%s'\n", (char *)bios_ptr(buffer, vga_info,
 113                                              info->product_rev_ptr));
 114         modes_bios = bios_ptr(buffer, vga_info, info->modes_ptr);
 115         debug("Modes: ");
 116         for (ptr = modes_bios; *ptr != 0xffff; ptr++)
 117                 debug("%x ", le16_to_cpu(*ptr));
 118         debug("\nmemory %dMB\n", le16_to_cpu(info->total_memory) >> 4);
 119         size = (ptr - modes_bios) * sizeof(u16) + 2;
 120         modes = malloc(size);
 121         if (!modes)
 122                 return -ENOMEM;
 123         memcpy(modes, modes_bios, size);
 124
 125         regs->e.eax = VESA_GET_CUR_MODE;
 126         BE_int86(0x10, regs, regs);
 127         if (regs->e.eax != 0x4f) {
 128                 debug("VESA_GET_CUR_MODE: error %x\n", regs->e.eax);
 129                 return -ENOSYS;
 130         }
 131         debug("Current mode %x\n", regs->e.ebx);
 132
 133         for (ptr = modes; *ptr != 0xffff; ptr++) {
 134                 int mode = le16_to_cpu(*ptr);
 135                 bool linear_ok;
 136                 int attr;
 137
 138                 break;
 139                 debug("Mode %x: ", mode);
 140                 memset(buffer, '\0', sizeof(struct vbe_mode_info));
 141                 regs->e.eax = VESA_GET_MODE_INFO;
 142                 regs->e.ebx = 0;
 143                 regs->e.ecx = mode;
 144                 regs->e.edx = 0;
 145                 regs->e.esi = buffer_seg;
 146                 regs->e.edi = buffer_adr;
 147                 BE_int86(0x10, regs, regs);
 148                 if (regs->e.eax != 0x4f) {
 149                         debug("VESA_GET_MODE_INFO: error %x\n", regs->e.eax);
 150                         continue;
 151                 }
 152                 memcpy(mode_info->mode_info_block, buffer,
 153                        sizeof(struct vesa_mode_info));
 154                 mode_info->valid = true;
 155                 vm = &mode_info->vesa;
 156                 attr = le16_to_cpu(vm->mode_attributes);
 157                 linear_ok = attr & 0x80;
 158                 debug("res %d x %d, %d bpp, mm %d, (Linear %s, attr %02x)\n",
 159                       le16_to_cpu(vm->x_resolution),
 160                       le16_to_cpu(vm->y_resolution),
 161                       vm->bits_per_pixel, vm->memory_model,
 162                       linear_ok ? "OK" : "not available",
 163                       attr);
 164                 debug("\tRGB pos=%d,%d,%d, size=%d,%d,%d\n",
 165                       vm->red_mask_pos, vm->green_mask_pos, vm->blue_mask_pos,
 166                       vm->red_mask_size, vm->green_mask_size,
 167                       vm->blue_mask_size);
 168         }
 169
 170         return 0;
 171 }
 172
 173 static int atibios_set_vesa_mode(RMREGS *regs, int vesa_mode,
 174                                  struct vbe_mode_info *mode_info)
 175 {
 176         void *buffer = (void *)(M.mem_base + vbe_offset);
 177         u16 buffer_seg = (((unsigned long)vbe_offset) >> 4) & 0xff00;
 178         u16 buffer_adr = ((unsigned long)vbe_offset) & 0xffff;
 179         struct vesa_mode_info *vm;
 180
 181         debug("VBE: Setting VESA mode %#04x\n", vesa_mode);
 182         regs->e.eax = VESA_SET_MODE;
 183         regs->e.ebx = vesa_mode;
 184         /* request linear framebuffer mode and don't clear display */
 185         regs->e.ebx |= (1 << 14) | (1 << 15);
 186         BE_int86(0x10, regs, regs);
 187         if (regs->e.eax != 0x4f) {
 188                 debug("VESA_SET_MODE: error %x\n", regs->e.eax);
 189                 return -ENOSYS;
 190         }
 191
 192         memset(buffer, '\0', sizeof(struct vbe_mode_info));
 193         debug("VBE: Geting info for VESA mode %#04x\n", vesa_mode);
 194         regs->e.eax = VESA_GET_MODE_INFO;
 195         regs->e.ecx = vesa_mode;
 196         regs->e.esi = buffer_seg;
 197         regs->e.edi = buffer_adr;
 198         BE_int86(0x10, regs, regs);
 199         if (regs->e.eax != 0x4f) {
 200                 debug("VESA_GET_MODE_INFO: error %x\n", regs->e.eax);
 201                 return -ENOSYS;
 202         }
 203
 204         memcpy(mode_info->mode_info_block, buffer,
 205                 sizeof(struct vesa_mode_info));
 206         mode_info->valid = true;
 207         mode_info->video_mode = vesa_mode;
 208         vm = &mode_info->vesa;
 209         vm->x_resolution = le16_to_cpu(vm->x_resolution);
 210         vm->y_resolution = le16_to_cpu(vm->y_resolution);
 211         vm->bytes_per_scanline = le16_to_cpu(vm->bytes_per_scanline);
 212         vm->phys_base_ptr = le32_to_cpu(vm->phys_base_ptr);
 213         vm->mode_attributes = le16_to_cpu(vm->mode_attributes);
 214         debug("VBE: Init complete\n");
 215
 216         return 0;
 217 }
 218
 219 /****************************************************************************
 220 PARAMETERS:
 221 pcidev  - PCI device info for the video card on the bus to boot
 222 vga_info - BIOS emulator VGA info structure
 223
 224 REMARKS:
 225 This function executes the BIOS POST code on the controller. We assume that
 226 at this stage the controller has its I/O and memory space enabled and
 227 that all other controllers are in a disabled state.
 228 ****************************************************************************/
 229 #ifdef CONFIG_DM_PCI
 230 static void PCI_doBIOSPOST(struct udevice *pcidev, BE_VGAInfo *vga_info,
 231                            int vesa_mode, struct vbe_mode_info *mode_info)
 232 #else
 233 static void PCI_doBIOSPOST(pci_dev_t pcidev, BE_VGAInfo *vga_info,
 234                            int vesa_mode, struct vbe_mode_info *mode_info)
 235 #endif
 236 {
 237         RMREGS regs;
 238         RMSREGS sregs;
 239 #ifdef CONFIG_DM_PCI
 240         pci_dev_t bdf;
 241 #endif
 242
 243         /* Determine the value to store in AX for BIOS POST. Per the PCI specs,
 244          AH must contain the bus and AL must contain the devfn, encoded as
 245          (dev << 3) | fn
 246          */
 247         memset(&regs, 0, sizeof(regs));
 248         memset(&sregs, 0, sizeof(sregs));
 249 #ifdef CONFIG_DM_PCI
 250         bdf = dm_pci_get_bdf(pcidev);
 251         regs.x.ax = (int)PCI_BUS(bdf) << 8 |
 252                         (int)PCI_DEV(bdf) << 3 | (int)PCI_FUNC(bdf);
 253 #else
 254         regs.x.ax = ((int)PCI_BUS(pcidev) << 8) |
 255             ((int)PCI_DEV(pcidev) << 3) | (int)PCI_FUNC(pcidev);
 256 #endif
 257         /*Setup the X86 emulator for the VGA BIOS*/
 258         BE_setVGA(vga_info);
 259
 260         /*Execute the BIOS POST code*/
 261         BE_callRealMode(0xC000, 0x0003, &regs, &sregs);
 262
 263         /*Cleanup and exit*/
 264         BE_getVGA(vga_info);
 265
 266         /* Useful for debugging */
 267         if (0)
 268                 atibios_debug_mode(vga_info, &regs, vesa_mode, mode_info);
 269         if (vesa_mode != -1)
 270                 atibios_set_vesa_mode(&regs, vesa_mode, mode_info);
 271 }
 272
 273 /****************************************************************************
 274 PARAMETERS:
 275 pcidev  - PCI device info for the video card on the bus
 276 bar     - Place to return the base address register offset to use
 277
 278 RETURNS:
 279 The address to use to map the secondary BIOS (AGP devices)
 280
 281 REMARKS:
 282 Searches all the PCI base address registers for the device looking for a
 283 memory mapping that is large enough to hold our ROM BIOS. We usually end up
 284 finding the framebuffer mapping (usually BAR 0x10), and we use this mapping
 285 to map the BIOS for the device into. We use a mapping that is already
 286 assigned to the device to ensure the memory range will be passed through
 287 by any PCI->PCI or AGP->PCI bridge that may be present.
 288
 289 NOTE: Usually this function is only used for AGP devices, but it may be
 290       used for PCI devices that have already been POST'ed and the BIOS
 291       ROM base address has been zero'ed out.
 292
 293 NOTE: This function leaves the original memory aperture disabled by leaving
 294       it programmed to all 1's. It must be restored to the correct value
 295       later.
 296 ****************************************************************************/
 297 #ifdef CONFIG_DM_PCI
 298 static u32 PCI_findBIOSAddr(struct udevice *pcidev, int *bar)
 299 #else
 300 static u32 PCI_findBIOSAddr(pci_dev_t pcidev, int *bar)
 301 #endif
 302 {
 303         u32 base, size;
 304
 305         for (*bar = 0x10; *bar <= 0x14; (*bar) += 4) {
 306 #ifdef CONFIG_DM_PCI
 307                 dm_pci_read_config32(pcidev, *bar, &base);
 308 #else
 309                 pci_read_config_dword(pcidev, *bar, &base);
 310 #endif
 311                 if (!(base & 0x1)) {
 312 #ifdef CONFIG_DM_PCI
 313                         dm_pci_write_config32(pcidev, *bar, 0xFFFFFFFF);
 314                         dm_pci_read_config32(pcidev, *bar, &size);
 315 #else
 316                         pci_write_config_dword(pcidev, *bar, 0xFFFFFFFF);
 317                         pci_read_config_dword(pcidev, *bar, &size);
 318 #endif
 319                         size = ~(size & ~0xFF) + 1;
 320                         if (size >= MAX_BIOSLEN)
 321                                 return base & ~0xFF;
 322                 }
 323         }
 324         return 0;
 325 }
 326
 327 /****************************************************************************
 328 REMARKS:
 329 Some non-x86 Linux kernels map PCI relocateable I/O to values that
 330 are above 64K, which will not work with the BIOS image that requires
 331 the offset for the I/O ports to be a maximum of 16-bits. Ideally
 332 someone should fix the kernel to map the I/O ports for VGA compatible
 333 devices to a different location (or just all I/O ports since it is
 334 unlikely you can have enough devices in the machine to use up all
 335 64K of the I/O space - a total of more than 256 cards would be
 336 necessary).
 337
 338 Anyway to fix this we change all I/O mapped base registers and
 339 chop off the top bits.
 340 ****************************************************************************/
 341 #ifdef CONFIG_DM_PCI
 342 static void PCI_fixupIObase(struct udevice *pcidev, int reg, u32 *base)
 343 #else
 344 static void PCI_fixupIObase(pci_dev_t pcidev, int reg, u32 * base)
 345 #endif
 346 {
 347         if ((*base & 0x1) && (*base > 0xFFFE)) {
 348                 *base &= 0xFFFF;
 349 #ifdef CONFIG_DM_PCI
 350                 dm_pci_write_config32(pcidev, reg, *base);
 351 #else
 352                 pci_write_config_dword(pcidev, reg, *base);
 353 #endif
 354
 355         }
 356 }
 357
 358 /****************************************************************************
 359 PARAMETERS:
 360 pcidev  - PCI device info for the video card on the bus
 361
 362 RETURNS:
 363 Pointers to the mapped BIOS image
 364
 365 REMARKS:
 366 Maps a pointer to the BIOS image on the graphics card on the PCI bus.
 367 ****************************************************************************/
 368 #ifdef CONFIG_DM_PCI
 369 void *PCI_mapBIOSImage(struct udevice *pcidev)
 370 #else
 371 void *PCI_mapBIOSImage(pci_dev_t pcidev)
 372 #endif
 373 {
 374         u32 BIOSImageBus;
 375         int BIOSImageBAR;
 376         u8 *BIOSImage;
 377
 378         /*Save PCI BAR registers that might get changed*/
 379 #ifdef CONFIG_DM_PCI
 380         dm_pci_read_config32(pcidev, PCI_ROM_ADDRESS, &saveROMBaseAddress);
 381         dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_0, &saveBaseAddress10);
 382         dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_1, &saveBaseAddress14);
 383         dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_2, &saveBaseAddress18);
 384         dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_4, &saveBaseAddress20);
 385 #else
 386         pci_read_config_dword(pcidev, PCI_ROM_ADDRESS, &saveROMBaseAddress);
 387         pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_0, &saveBaseAddress10);
 388         pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_1, &saveBaseAddress14);
 389         pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_2, &saveBaseAddress18);
 390         pci_read_config_dword(pcidev, PCI_BASE_ADDRESS_4, &saveBaseAddress20);
 391 #endif
 392
 393         /*Fix up I/O base registers to less than 64K */
 394         if(saveBaseAddress14 != 0)
 395                 PCI_fixupIObase(pcidev, PCI_BASE_ADDRESS_1, &saveBaseAddress14);
 396         else
 397                 PCI_fixupIObase(pcidev, PCI_BASE_ADDRESS_4, &saveBaseAddress20);
 398
 399         /* Some cards have problems that stop us from being able to read the
 400          BIOS image from the ROM BAR. To fix this we have to do some chipset
 401          specific programming for different cards to solve this problem.
 402         */
 403
 404         BIOSImageBus = PCI_findBIOSAddr(pcidev, &BIOSImageBAR);
 405         if (BIOSImageBus == 0) {
 406                 printf("Find bios addr error\n");
 407                 return NULL;
 408         }
 409
 410 #ifdef CONFIG_DM_PCI
 411         BIOSImage = dm_pci_bus_to_virt(pcidev, BIOSImageBus,
 412                                        PCI_REGION_MEM, 0, MAP_NOCACHE);
 413
 414         /*Change the PCI BAR registers to map it onto the bus.*/
 415         dm_pci_write_config32(pcidev, BIOSImageBAR, 0);
 416         dm_pci_write_config32(pcidev, PCI_ROM_ADDRESS, BIOSImageBus | 0x1);
 417 #else
 418         BIOSImage = pci_bus_to_virt(pcidev, BIOSImageBus,
 419                                     PCI_REGION_MEM, 0, MAP_NOCACHE);
 420
 421         /*Change the PCI BAR registers to map it onto the bus.*/
 422         pci_write_config_dword(pcidev, BIOSImageBAR, 0);
 423         pci_write_config_dword(pcidev, PCI_ROM_ADDRESS, BIOSImageBus | 0x1);
 424 #endif
 425         udelay(1);
 426
 427         /*Check that the BIOS image is valid. If not fail, or return the
 428          compiled in BIOS image if that option was enabled
 429          */
 430         if (BIOSImage[0] != 0x55 || BIOSImage[1] != 0xAA || BIOSImage[2] == 0) {
 431                 return NULL;
 432         }
 433
 434         return BIOSImage;
 435 }
 436
 437 /****************************************************************************
 438 PARAMETERS:
 439 pcidev  - PCI device info for the video card on the bus
 440
 441 REMARKS:
 442 Unmaps the BIOS image for the device and restores framebuffer mappings
 443 ****************************************************************************/
 444 #ifdef CONFIG_DM_PCI
 445 void PCI_unmapBIOSImage(struct udevice *pcidev, void *BIOSImage)
 446 {
 447         dm_pci_write_config32(pcidev, PCI_ROM_ADDRESS, saveROMBaseAddress);
 448         dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_0, saveBaseAddress10);
 449         dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_1, saveBaseAddress14);
 450         dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_2, saveBaseAddress18);
 451         dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_4, saveBaseAddress20);
 452 }
 453 #else
 454 void PCI_unmapBIOSImage(pci_dev_t pcidev, void *BIOSImage)
 455 {
 456         pci_write_config_dword(pcidev, PCI_ROM_ADDRESS, saveROMBaseAddress);
 457         pci_write_config_dword(pcidev, PCI_BASE_ADDRESS_0, saveBaseAddress10);
 458         pci_write_config_dword(pcidev, PCI_BASE_ADDRESS_1, saveBaseAddress14);
 459         pci_write_config_dword(pcidev, PCI_BASE_ADDRESS_2, saveBaseAddress18);
 460         pci_write_config_dword(pcidev, PCI_BASE_ADDRESS_4, saveBaseAddress20);
 461 }
 462 #endif
 463
 464 /****************************************************************************
 465 PARAMETERS:
 466 pcidev  - PCI device info for the video card on the bus to boot
 467 VGAInfo - BIOS emulator VGA info structure
 468
 469 RETURNS:
 470 true if successfully initialised, false if not.
 471
 472 REMARKS:
 473 Loads and POST's the display controllers BIOS, directly from the BIOS
 474 image we can extract over the PCI bus.
 475 ****************************************************************************/
 476 #ifdef CONFIG_DM_PCI
 477 static int PCI_postController(struct udevice *pcidev, uchar *bios_rom,
 478                               int bios_len, BE_VGAInfo *vga_info,
 479                               int vesa_mode, struct vbe_mode_info *mode_info)
 480 #else
 481 static int PCI_postController(pci_dev_t pcidev, uchar *bios_rom, int bios_len,
 482                               BE_VGAInfo *vga_info, int vesa_mode,
 483                               struct vbe_mode_info *mode_info)
 484 #endif
 485 {
 486         u32 bios_image_len;
 487         uchar *mapped_bios;
 488         uchar *copy_of_bios;
 489 #ifdef CONFIG_DM_PCI
 490         pci_dev_t bdf;
 491 #endif
 492
 493         if (bios_rom) {
 494                 copy_of_bios = bios_rom;
 495                 bios_image_len = bios_len;
 496         } else {
 497                 /*
 498                  * Allocate memory to store copy of BIOS from display
 499                  * controller
 500                  */
 501                 mapped_bios = PCI_mapBIOSImage(pcidev);
 502                 if (mapped_bios == NULL) {
 503                         printf("videoboot: Video ROM failed to map!\n");
 504                         return false;
 505                 }
 506
 507                 bios_image_len = mapped_bios[2] * 512;
 508
 509                 copy_of_bios = malloc(bios_image_len);
 510                 if (copy_of_bios == NULL) {
 511                         printf("videoboot: Out of memory!\n");
 512                         return false;
 513                 }
 514                 memcpy(copy_of_bios, mapped_bios, bios_image_len);
 515                 PCI_unmapBIOSImage(pcidev, mapped_bios);
 516         }
 517
 518         /*Save information in vga_info structure*/
 519 #ifdef CONFIG_DM_PCI
 520         bdf = dm_pci_get_bdf(pcidev);
 521         vga_info->function = PCI_FUNC(bdf);
 522         vga_info->device = PCI_DEV(bdf);
 523         vga_info->bus = PCI_BUS(bdf);
 524 #else
 525         vga_info->function = PCI_FUNC(pcidev);
 526         vga_info->device = PCI_DEV(pcidev);
 527         vga_info->bus = PCI_BUS(pcidev);
 528 #endif
 529         vga_info->pcidev = pcidev;
 530         vga_info->BIOSImage = copy_of_bios;
 531         vga_info->BIOSImageLen = bios_image_len;
 532
 533         /*Now execute the BIOS POST for the device*/
 534         if (copy_of_bios[0] != 0x55 || copy_of_bios[1] != 0xAA) {
 535                 printf("videoboot: Video ROM image is invalid!\n");
 536                 return false;
 537         }
 538
 539         PCI_doBIOSPOST(pcidev, vga_info, vesa_mode, mode_info);
 540
 541         /*Reset the size of the BIOS image to the final size*/
 542         vga_info->BIOSImageLen = copy_of_bios[2] * 512;
 543         return true;
 544 }
 545
 546 #ifdef CONFIG_DM_PCI
 547 int biosemu_setup(struct udevice *pcidev, BE_VGAInfo **vga_infop)
 548 #else
 549 int biosemu_setup(pci_dev_t pcidev, BE_VGAInfo **vga_infop)
 550 #endif
 551 {
 552         BE_VGAInfo *VGAInfo;
 553 #ifdef CONFIG_DM_PCI
 554         pci_dev_t bdf = dm_pci_get_bdf(pcidev);
 555
 556         printf("videoboot: Booting PCI video card bus %d, function %d, device %d\n",
 557                PCI_BUS(bdf), PCI_FUNC(bdf), PCI_DEV(bdf));
 558 #else
 559         printf("videoboot: Booting PCI video card bus %d, function %d, device %d\n",
 560                PCI_BUS(pcidev), PCI_FUNC(pcidev), PCI_DEV(pcidev));
 561 #endif
 562         /*Initialise the x86 BIOS emulator*/
 563         if ((VGAInfo = malloc(sizeof(*VGAInfo))) == NULL) {
 564                 printf("videoboot: Out of memory!\n");
 565                 return -ENOMEM;
 566         }
 567         memset(VGAInfo, 0, sizeof(*VGAInfo));
 568         BE_init(0, 65536, VGAInfo, 0);
 569         *vga_infop = VGAInfo;
 570
 571         return 0;
 572 }
 573
 574 void biosemu_set_interrupt_handler(int intnum, int (*int_func)(void))
 575 {
 576         X86EMU_setupIntrFunc(intnum, (X86EMU_intrFuncs)int_func);
 577 }
 578
 579 #ifdef CONFIG_DM_PCI
 580 int biosemu_run(struct udevice *pcidev, uchar *bios_rom, int bios_len,
 581                 BE_VGAInfo *vga_info, int clean_up, int vesa_mode,
 582                 struct vbe_mode_info *mode_info)
 583 #else
 584 int biosemu_run(pci_dev_t pcidev, uchar *bios_rom, int bios_len,
 585                 BE_VGAInfo *vga_info, int clean_up, int vesa_mode,
 586                 struct vbe_mode_info *mode_info)
 587 #endif
 588 {
 589         /*Post all the display controller BIOS'es*/
 590         if (!PCI_postController(pcidev, bios_rom, bios_len, vga_info,
 591                                 vesa_mode, mode_info))
 592                 return -EINVAL;
 593
 594         /*
 595          * Cleanup and exit the emulator if requested. If the BIOS emulator
 596          * is needed after booting the card, we will not call BE_exit and
 597          * leave it enabled for further use (ie: VESA driver etc).
 598         */
 599         if (clean_up) {
 600                 BE_exit();
 601                 if (vga_info->BIOSImage &&
 602                     (ulong)(vga_info->BIOSImage) != 0xc0000)
 603                         free(vga_info->BIOSImage);
 604                 free(vga_info);
 605                 vga_info = NULL;
 606         }
 607
 608         return 0;
 609 }
 610
 611 /****************************************************************************
 612 PARAMETERS:
 613 pcidev      - PCI device info for the video card on the bus to boot
 614 pVGAInfo    - Place to return VGA info structure is requested
 615 cleanUp     - true to clean up on exit, false to leave emulator active
 616
 617 REMARKS:
 618 Boots the PCI/AGP video card on the bus using the Video ROM BIOS image
 619 and the X86 BIOS emulator module.
 620 ****************************************************************************/
 621 #ifdef CONFIG_DM_PCI
 622 int BootVideoCardBIOS(struct udevice *pcidev, BE_VGAInfo **pVGAInfo,
 623                       int clean_up)
 624 #else
 625 int BootVideoCardBIOS(pci_dev_t pcidev, BE_VGAInfo **pVGAInfo, int clean_up)
 626 #endif
 627 {
 628         BE_VGAInfo *VGAInfo;
 629         int ret;
 630
 631         ret = biosemu_setup(pcidev, &VGAInfo);
 632         if (ret)
 633                 return false;
 634         ret = biosemu_run(pcidev, NULL, 0, VGAInfo, clean_up, -1, NULL);
 635         if (ret)
 636                 return false;
 637
 638         /* Return VGA info pointer if the caller requested it*/
 639         if (pVGAInfo)
 640                 *pVGAInfo = VGAInfo;
 641
 642         return true;
 643 }