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