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