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 }
644