1 /****************************************************************************
3 * Video BOOT Graphics Card POST Module
5 * ========================================================================
6 * Copyright (C) 2007 Freescale Semiconductor, Inc.
7 * Jason Jin <Jason.jin@freescale.com>
9 * Copyright (C) 1991-2004 SciTech Software, Inc. All rights reserved.
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.
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.
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
24 * See http://www.scitechsoft.com/license/ for information about
25 * the licensing options available and how to purchase a Commercial
28 * Contact license@scitechsoft.com if any conditions of this licensing
29 * are not clear to you, or you have questions about licensing options.
31 * ========================================================================
34 * Environment: Linux Kernel
35 * Developer: Kendall Bennett
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.
41 * Note that at present this module does *not* support
42 * multiple controllers.
44 * The orignal name of this file is warmboot.c.
45 * Jason ported this file to u-boot to run the ATI video card
47 ****************************************************************************/
50 #include <bios_emul.h>
55 #include <linux/delay.h>
58 /* Length of the BIOS image */
59 #define MAX_BIOSLEN (128 * 1024L)
61 /* Place to save PCI BAR's that we change and later restore */
62 static u32 saveROMBaseAddress;
63 static u32 saveBaseAddress10;
64 static u32 saveBaseAddress14;
65 static u32 saveBaseAddress18;
66 static u32 saveBaseAddress20;
68 /* Addres im memory of VBE region */
69 const int vbe_offset = 0x2000;
71 #ifdef CONFIG_FRAMEBUFFER_SET_VESA_MODE
72 static const void *bios_ptr(const void *buf, BE_VGAInfo *vga_info,
77 seg_ofs = le32_to_cpu(x86_dword_ptr);
78 flat = ((seg_ofs & 0xffff0000) >> 12) | (seg_ofs & 0xffff);
80 return vga_info->BIOSImage + flat - 0xc0000;
82 return buf + (flat - vbe_offset);
85 static int atibios_debug_mode(BE_VGAInfo *vga_info, RMREGS *regs,
86 int vesa_mode, struct vbe_mode_info *mode_info)
88 void *buffer = (void *)(M.mem_base + vbe_offset);
89 u16 buffer_seg = (((unsigned long)vbe_offset) >> 4) & 0xff00;
90 u16 buffer_adr = ((unsigned long)vbe_offset) & 0xffff;
91 struct vesa_mode_info *vm;
92 struct vbe_info *info;
93 const u16 *modes_bios, *ptr;
97 debug("VBE: Getting information\n");
98 regs->e.eax = VESA_GET_INFO;
99 regs->e.esi = buffer_seg;
100 regs->e.edi = buffer_adr;
102 memset(info, '\0', sizeof(*info));
103 strcpy(info->signature, "VBE2");
104 BE_int86(0x10, regs, regs);
105 if (regs->e.eax != 0x4f) {
106 debug("VESA_GET_INFO: error %x\n", regs->e.eax);
109 debug("version %x\n", le16_to_cpu(info->version));
110 debug("oem '%s'\n", (char *)bios_ptr(buffer, vga_info,
111 info->oem_string_ptr));
112 debug("vendor '%s'\n", (char *)bios_ptr(buffer, vga_info,
113 info->vendor_name_ptr));
114 debug("product '%s'\n", (char *)bios_ptr(buffer, vga_info,
115 info->product_name_ptr));
116 debug("rev '%s'\n", (char *)bios_ptr(buffer, vga_info,
117 info->product_rev_ptr));
118 modes_bios = bios_ptr(buffer, vga_info, info->modes_ptr);
120 for (ptr = modes_bios; *ptr != 0xffff; ptr++)
121 debug("%x ", le16_to_cpu(*ptr));
122 debug("\nmemory %dMB\n", le16_to_cpu(info->total_memory) >> 4);
123 size = (ptr - modes_bios) * sizeof(u16) + 2;
124 modes = malloc(size);
127 memcpy(modes, modes_bios, size);
129 regs->e.eax = VESA_GET_CUR_MODE;
130 BE_int86(0x10, regs, regs);
131 if (regs->e.eax != 0x4f) {
132 debug("VESA_GET_CUR_MODE: error %x\n", regs->e.eax);
135 debug("Current mode %x\n", regs->e.ebx);
137 for (ptr = modes; *ptr != 0xffff; ptr++) {
138 int mode = le16_to_cpu(*ptr);
142 debug("Mode %x: ", mode);
143 memset(buffer, '\0', sizeof(struct vbe_mode_info));
144 regs->e.eax = VESA_GET_MODE_INFO;
148 regs->e.esi = buffer_seg;
149 regs->e.edi = buffer_adr;
150 BE_int86(0x10, regs, regs);
151 if (regs->e.eax != 0x4f) {
152 debug("VESA_GET_MODE_INFO: error %x\n", regs->e.eax);
155 memcpy(mode_info->mode_info_block, buffer,
156 sizeof(struct vesa_mode_info));
157 mode_info->valid = true;
158 vm = &mode_info->vesa;
159 attr = le16_to_cpu(vm->mode_attributes);
160 linear_ok = attr & 0x80;
161 debug("res %d x %d, %d bpp, mm %d, (Linear %s, attr %02x)\n",
162 le16_to_cpu(vm->x_resolution),
163 le16_to_cpu(vm->y_resolution),
164 vm->bits_per_pixel, vm->memory_model,
165 linear_ok ? "OK" : "not available",
167 debug("\tRGB pos=%d,%d,%d, size=%d,%d,%d\n",
168 vm->red_mask_pos, vm->green_mask_pos, vm->blue_mask_pos,
169 vm->red_mask_size, vm->green_mask_size,
176 static int atibios_set_vesa_mode(RMREGS *regs, int vesa_mode,
177 struct vbe_mode_info *mode_info)
179 void *buffer = (void *)(M.mem_base + vbe_offset);
180 u16 buffer_seg = (((unsigned long)vbe_offset) >> 4) & 0xff00;
181 u16 buffer_adr = ((unsigned long)vbe_offset) & 0xffff;
182 struct vesa_mode_info *vm;
184 debug("VBE: Setting VESA mode %#04x\n", vesa_mode);
185 regs->e.eax = VESA_SET_MODE;
186 regs->e.ebx = vesa_mode;
187 /* request linear framebuffer mode and don't clear display */
188 regs->e.ebx |= (1 << 14) | (1 << 15);
189 BE_int86(0x10, regs, regs);
190 if (regs->e.eax != 0x4f) {
191 debug("VESA_SET_MODE: error %x\n", regs->e.eax);
195 memset(buffer, '\0', sizeof(struct vbe_mode_info));
196 debug("VBE: Geting info for VESA mode %#04x\n", vesa_mode);
197 regs->e.eax = VESA_GET_MODE_INFO;
198 regs->e.ecx = vesa_mode;
199 regs->e.esi = buffer_seg;
200 regs->e.edi = buffer_adr;
201 BE_int86(0x10, regs, regs);
202 if (regs->e.eax != 0x4f) {
203 debug("VESA_GET_MODE_INFO: error %x\n", regs->e.eax);
207 memcpy(mode_info->mode_info_block, buffer,
208 sizeof(struct vesa_mode_info));
209 mode_info->valid = true;
210 mode_info->video_mode = vesa_mode;
211 vm = &mode_info->vesa;
212 vm->x_resolution = le16_to_cpu(vm->x_resolution);
213 vm->y_resolution = le16_to_cpu(vm->y_resolution);
214 vm->bytes_per_scanline = le16_to_cpu(vm->bytes_per_scanline);
215 vm->phys_base_ptr = le32_to_cpu(vm->phys_base_ptr);
216 vm->mode_attributes = le16_to_cpu(vm->mode_attributes);
217 debug("VBE: Init complete\n");
221 #endif /* CONFIG_FRAMEBUFFER_SET_VESA_MODE */
223 /****************************************************************************
225 pcidev - PCI device info for the video card on the bus to boot
226 vga_info - BIOS emulator VGA info structure
229 This function executes the BIOS POST code on the controller. We assume that
230 at this stage the controller has its I/O and memory space enabled and
231 that all other controllers are in a disabled state.
232 ****************************************************************************/
233 static void PCI_doBIOSPOST(struct udevice *pcidev, BE_VGAInfo *vga_info,
234 int vesa_mode, struct vbe_mode_info *mode_info)
240 /* Determine the value to store in AX for BIOS POST. Per the PCI specs,
241 AH must contain the bus and AL must contain the devfn, encoded as
244 memset(®s, 0, sizeof(regs));
245 memset(&sregs, 0, sizeof(sregs));
246 bdf = dm_pci_get_bdf(pcidev);
247 regs.x.ax = (int)PCI_BUS(bdf) << 8 |
248 (int)PCI_DEV(bdf) << 3 | (int)PCI_FUNC(bdf);
249 /*Setup the X86 emulator for the VGA BIOS*/
252 /*Execute the BIOS POST code*/
253 BE_callRealMode(0xC000, 0x0003, ®s, &sregs);
258 #ifdef CONFIG_FRAMEBUFFER_SET_VESA_MODE
259 /* Useful for debugging */
261 atibios_debug_mode(vga_info, ®s, vesa_mode, mode_info);
263 atibios_set_vesa_mode(®s, vesa_mode, mode_info);
267 /****************************************************************************
269 pcidev - PCI device info for the video card on the bus
270 bar - Place to return the base address register offset to use
273 The address to use to map the secondary BIOS (AGP devices)
276 Searches all the PCI base address registers for the device looking for a
277 memory mapping that is large enough to hold our ROM BIOS. We usually end up
278 finding the framebuffer mapping (usually BAR 0x10), and we use this mapping
279 to map the BIOS for the device into. We use a mapping that is already
280 assigned to the device to ensure the memory range will be passed through
281 by any PCI->PCI or AGP->PCI bridge that may be present.
283 NOTE: Usually this function is only used for AGP devices, but it may be
284 used for PCI devices that have already been POST'ed and the BIOS
285 ROM base address has been zero'ed out.
287 NOTE: This function leaves the original memory aperture disabled by leaving
288 it programmed to all 1's. It must be restored to the correct value
290 ****************************************************************************/
291 static u32 PCI_findBIOSAddr(struct udevice *pcidev, int *bar)
295 for (*bar = 0x10; *bar <= 0x14; (*bar) += 4) {
296 dm_pci_read_config32(pcidev, *bar, &base);
298 dm_pci_write_config32(pcidev, *bar, 0xFFFFFFFF);
299 dm_pci_read_config32(pcidev, *bar, &size);
300 size = ~(size & ~0xFF) + 1;
301 if (size >= MAX_BIOSLEN)
308 /****************************************************************************
310 Some non-x86 Linux kernels map PCI relocateable I/O to values that
311 are above 64K, which will not work with the BIOS image that requires
312 the offset for the I/O ports to be a maximum of 16-bits. Ideally
313 someone should fix the kernel to map the I/O ports for VGA compatible
314 devices to a different location (or just all I/O ports since it is
315 unlikely you can have enough devices in the machine to use up all
316 64K of the I/O space - a total of more than 256 cards would be
319 Anyway to fix this we change all I/O mapped base registers and
320 chop off the top bits.
321 ****************************************************************************/
322 static void PCI_fixupIObase(struct udevice *pcidev, int reg, u32 *base)
324 if ((*base & 0x1) && (*base > 0xFFFE)) {
326 dm_pci_write_config32(pcidev, reg, *base);
331 /****************************************************************************
333 pcidev - PCI device info for the video card on the bus
336 Pointers to the mapped BIOS image
339 Maps a pointer to the BIOS image on the graphics card on the PCI bus.
340 ****************************************************************************/
341 void *PCI_mapBIOSImage(struct udevice *pcidev)
347 /*Save PCI BAR registers that might get changed*/
348 dm_pci_read_config32(pcidev, PCI_ROM_ADDRESS, &saveROMBaseAddress);
349 dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_0, &saveBaseAddress10);
350 dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_1, &saveBaseAddress14);
351 dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_2, &saveBaseAddress18);
352 dm_pci_read_config32(pcidev, PCI_BASE_ADDRESS_4, &saveBaseAddress20);
354 /*Fix up I/O base registers to less than 64K */
355 if(saveBaseAddress14 != 0)
356 PCI_fixupIObase(pcidev, PCI_BASE_ADDRESS_1, &saveBaseAddress14);
358 PCI_fixupIObase(pcidev, PCI_BASE_ADDRESS_4, &saveBaseAddress20);
360 /* Some cards have problems that stop us from being able to read the
361 BIOS image from the ROM BAR. To fix this we have to do some chipset
362 specific programming for different cards to solve this problem.
365 BIOSImageBus = PCI_findBIOSAddr(pcidev, &BIOSImageBAR);
366 if (BIOSImageBus == 0) {
367 printf("Find bios addr error\n");
371 BIOSImage = dm_pci_bus_to_virt(pcidev, BIOSImageBus, 0, PCI_REGION_TYPE,
372 PCI_REGION_MEM, MAP_NOCACHE);
374 /*Change the PCI BAR registers to map it onto the bus.*/
375 dm_pci_write_config32(pcidev, BIOSImageBAR, 0);
376 dm_pci_write_config32(pcidev, PCI_ROM_ADDRESS, BIOSImageBus | 0x1);
379 /*Check that the BIOS image is valid. If not fail, or return the
380 compiled in BIOS image if that option was enabled
382 if (BIOSImage[0] != 0x55 || BIOSImage[1] != 0xAA || BIOSImage[2] == 0) {
389 /****************************************************************************
391 pcidev - PCI device info for the video card on the bus
394 Unmaps the BIOS image for the device and restores framebuffer mappings
395 ****************************************************************************/
396 void PCI_unmapBIOSImage(struct udevice *pcidev, void *BIOSImage)
398 dm_pci_write_config32(pcidev, PCI_ROM_ADDRESS, saveROMBaseAddress);
399 dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_0, saveBaseAddress10);
400 dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_1, saveBaseAddress14);
401 dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_2, saveBaseAddress18);
402 dm_pci_write_config32(pcidev, PCI_BASE_ADDRESS_4, saveBaseAddress20);
405 /****************************************************************************
407 pcidev - PCI device info for the video card on the bus to boot
408 VGAInfo - BIOS emulator VGA info structure
411 true if successfully initialised, false if not.
414 Loads and POST's the display controllers BIOS, directly from the BIOS
415 image we can extract over the PCI bus.
416 ****************************************************************************/
417 static int PCI_postController(struct udevice *pcidev, uchar *bios_rom,
418 int bios_len, BE_VGAInfo *vga_info,
419 int vesa_mode, struct vbe_mode_info *mode_info)
427 copy_of_bios = bios_rom;
428 bios_image_len = bios_len;
431 * Allocate memory to store copy of BIOS from display
434 mapped_bios = PCI_mapBIOSImage(pcidev);
435 if (mapped_bios == NULL) {
436 printf("videoboot: Video ROM failed to map!\n");
440 bios_image_len = mapped_bios[2] * 512;
442 copy_of_bios = malloc(bios_image_len);
443 if (copy_of_bios == NULL) {
444 printf("videoboot: Out of memory!\n");
447 memcpy(copy_of_bios, mapped_bios, bios_image_len);
448 PCI_unmapBIOSImage(pcidev, mapped_bios);
451 /*Save information in vga_info structure*/
452 bdf = dm_pci_get_bdf(pcidev);
453 vga_info->function = PCI_FUNC(bdf);
454 vga_info->device = PCI_DEV(bdf);
455 vga_info->bus = PCI_BUS(bdf);
456 vga_info->pcidev = pcidev;
457 vga_info->BIOSImage = copy_of_bios;
458 vga_info->BIOSImageLen = bios_image_len;
460 /*Now execute the BIOS POST for the device*/
461 if (copy_of_bios[0] != 0x55 || copy_of_bios[1] != 0xAA) {
462 printf("videoboot: Video ROM image is invalid!\n");
466 PCI_doBIOSPOST(pcidev, vga_info, vesa_mode, mode_info);
468 /*Reset the size of the BIOS image to the final size*/
469 vga_info->BIOSImageLen = copy_of_bios[2] * 512;
473 int biosemu_setup(struct udevice *pcidev, BE_VGAInfo **vga_infop)
476 pci_dev_t bdf = dm_pci_get_bdf(pcidev);
478 printf("videoboot: Booting PCI video card bus %d, function %d, device %d\n",
479 PCI_BUS(bdf), PCI_FUNC(bdf), PCI_DEV(bdf));
480 /*Initialise the x86 BIOS emulator*/
481 if ((VGAInfo = malloc(sizeof(*VGAInfo))) == NULL) {
482 printf("videoboot: Out of memory!\n");
485 memset(VGAInfo, 0, sizeof(*VGAInfo));
486 BE_init(0, 65536, VGAInfo, 0);
487 *vga_infop = VGAInfo;
492 void biosemu_set_interrupt_handler(int intnum, int (*int_func)(void))
494 X86EMU_setupIntrFunc(intnum, (X86EMU_intrFuncs)int_func);
497 int biosemu_run(struct udevice *pcidev, uchar *bios_rom, int bios_len,
498 BE_VGAInfo *vga_info, int clean_up, int vesa_mode,
499 struct vbe_mode_info *mode_info)
501 /*Post all the display controller BIOS'es*/
502 if (!PCI_postController(pcidev, bios_rom, bios_len, vga_info,
503 vesa_mode, mode_info))
507 * Cleanup and exit the emulator if requested. If the BIOS emulator
508 * is needed after booting the card, we will not call BE_exit and
509 * leave it enabled for further use (ie: VESA driver etc).
513 if (vga_info->BIOSImage &&
514 (ulong)(vga_info->BIOSImage) != 0xc0000)
515 free(vga_info->BIOSImage);
522 /****************************************************************************
524 pcidev - PCI device info for the video card on the bus to boot
525 pVGAInfo - Place to return VGA info structure is requested
526 cleanUp - true to clean up on exit, false to leave emulator active
529 Boots the PCI/AGP video card on the bus using the Video ROM BIOS image
530 and the X86 BIOS emulator module.
531 ****************************************************************************/
532 int BootVideoCardBIOS(struct udevice *pcidev, BE_VGAInfo **pVGAInfo,
538 ret = biosemu_setup(pcidev, &VGAInfo);
541 ret = biosemu_run(pcidev, NULL, 0, VGAInfo, clean_up, -1, NULL);
545 /* Return VGA info pointer if the caller requested it*/