Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2014 Google, Inc |
| 4 | * |
| 5 | * From coreboot, originally based on the Linux kernel (drivers/pci/pci.c). |
| 6 | * |
| 7 | * Modifications are: |
| 8 | * Copyright (C) 2003-2004 Linux Networx |
| 9 | * (Written by Eric Biederman <ebiederman@lnxi.com> for Linux Networx) |
| 10 | * Copyright (C) 2003-2006 Ronald G. Minnich <rminnich@gmail.com> |
| 11 | * Copyright (C) 2004-2005 Li-Ta Lo <ollie@lanl.gov> |
| 12 | * Copyright (C) 2005-2006 Tyan |
| 13 | * (Written by Yinghai Lu <yhlu@tyan.com> for Tyan) |
| 14 | * Copyright (C) 2005-2009 coresystems GmbH |
| 15 | * (Written by Stefan Reinauer <stepan@coresystems.de> for coresystems GmbH) |
| 16 | * |
| 17 | * PCI Bus Services, see include/linux/pci.h for further explanation. |
| 18 | * |
| 19 | * Copyright 1993 -- 1997 Drew Eckhardt, Frederic Potter, |
| 20 | * David Mosberger-Tang |
| 21 | * |
| 22 | * Copyright 1997 -- 1999 Martin Mares <mj@atrey.karlin.mff.cuni.cz> |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 23 | */ |
| 24 | |
| 25 | #include <common.h> |
| 26 | #include <bios_emul.h> |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 27 | #include <dm.h> |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 28 | #include <errno.h> |
Simon Glass | da25eff | 2019-12-28 10:44:56 -0700 | [diff] [blame] | 29 | #include <init.h> |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 30 | #include <malloc.h> |
| 31 | #include <pci.h> |
| 32 | #include <pci_rom.h> |
| 33 | #include <vbe.h> |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 34 | #include <video.h> |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 35 | #include <video_fb.h> |
Bin Meng | f6d504f | 2015-07-06 16:31:36 +0800 | [diff] [blame] | 36 | #include <linux/screen_info.h> |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 37 | |
Bin Meng | 62a8f7d | 2017-04-21 07:24:46 -0700 | [diff] [blame] | 38 | #ifdef CONFIG_X86 |
Simon Glass | 5c2aabf | 2019-09-25 08:56:32 -0600 | [diff] [blame] | 39 | #include <acpi_s3.h> |
Bin Meng | 62a8f7d | 2017-04-21 07:24:46 -0700 | [diff] [blame] | 40 | DECLARE_GLOBAL_DATA_PTR; |
| 41 | #endif |
| 42 | |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 43 | __weak bool board_should_run_oprom(struct udevice *dev) |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 44 | { |
Bin Meng | 62a8f7d | 2017-04-21 07:24:46 -0700 | [diff] [blame] | 45 | #if defined(CONFIG_X86) && defined(CONFIG_HAVE_ACPI_RESUME) |
| 46 | if (gd->arch.prev_sleep_state == ACPI_S3) { |
| 47 | if (IS_ENABLED(CONFIG_S3_VGA_ROM_RUN)) |
| 48 | return true; |
| 49 | else |
| 50 | return false; |
| 51 | } |
| 52 | #endif |
| 53 | |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 54 | return true; |
| 55 | } |
| 56 | |
Bin Meng | f49c485 | 2016-06-14 02:02:40 -0700 | [diff] [blame] | 57 | __weak bool board_should_load_oprom(struct udevice *dev) |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 58 | { |
Bin Meng | 0ea6bcb | 2016-06-14 02:02:39 -0700 | [diff] [blame] | 59 | return true; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | __weak uint32_t board_map_oprom_vendev(uint32_t vendev) |
| 63 | { |
| 64 | return vendev; |
| 65 | } |
| 66 | |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 67 | static int pci_rom_probe(struct udevice *dev, struct pci_rom_header **hdrp) |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 68 | { |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 69 | struct pci_child_platdata *pplat = dev_get_parent_platdata(dev); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 70 | struct pci_rom_header *rom_header; |
| 71 | struct pci_rom_data *rom_data; |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 72 | u16 rom_vendor, rom_device; |
Bin Meng | 932f80e | 2015-04-24 15:48:03 +0800 | [diff] [blame] | 73 | u32 rom_class; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 74 | u32 vendev; |
| 75 | u32 mapped_vendev; |
| 76 | u32 rom_address; |
| 77 | |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 78 | vendev = pplat->vendor << 16 | pplat->device; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 79 | mapped_vendev = board_map_oprom_vendev(vendev); |
| 80 | if (vendev != mapped_vendev) |
| 81 | debug("Device ID mapped to %#08x\n", mapped_vendev); |
| 82 | |
Bin Meng | 4de3886 | 2015-07-06 16:31:33 +0800 | [diff] [blame] | 83 | #ifdef CONFIG_VGA_BIOS_ADDR |
| 84 | rom_address = CONFIG_VGA_BIOS_ADDR; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 85 | #else |
Simon Glass | 1c1695b | 2015-01-14 21:37:04 -0700 | [diff] [blame] | 86 | |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 87 | dm_pci_read_config32(dev, PCI_ROM_ADDRESS, &rom_address); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 88 | if (rom_address == 0x00000000 || rom_address == 0xffffffff) { |
| 89 | debug("%s: rom_address=%x\n", __func__, rom_address); |
| 90 | return -ENOENT; |
| 91 | } |
| 92 | |
| 93 | /* Enable expansion ROM address decoding. */ |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 94 | dm_pci_write_config32(dev, PCI_ROM_ADDRESS, |
| 95 | rom_address | PCI_ROM_ADDRESS_ENABLE); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 96 | #endif |
| 97 | debug("Option ROM address %x\n", rom_address); |
Minghuan Lian | f40ad9f | 2015-01-22 13:21:55 +0800 | [diff] [blame] | 98 | rom_header = (struct pci_rom_header *)(unsigned long)rom_address; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 99 | |
| 100 | debug("PCI expansion ROM, signature %#04x, INIT size %#04x, data ptr %#04x\n", |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 101 | le16_to_cpu(rom_header->signature), |
| 102 | rom_header->size * 512, le16_to_cpu(rom_header->data)); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 103 | |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 104 | if (le16_to_cpu(rom_header->signature) != PCI_ROM_HDR) { |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 105 | printf("Incorrect expansion ROM header signature %04x\n", |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 106 | le16_to_cpu(rom_header->signature)); |
Bin Meng | a966473 | 2015-07-08 13:06:41 +0800 | [diff] [blame] | 107 | #ifndef CONFIG_VGA_BIOS_ADDR |
| 108 | /* Disable expansion ROM address decoding */ |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 109 | dm_pci_write_config32(dev, PCI_ROM_ADDRESS, rom_address); |
Bin Meng | a966473 | 2015-07-08 13:06:41 +0800 | [diff] [blame] | 110 | #endif |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 111 | return -EINVAL; |
| 112 | } |
| 113 | |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 114 | rom_data = (((void *)rom_header) + le16_to_cpu(rom_header->data)); |
| 115 | rom_vendor = le16_to_cpu(rom_data->vendor); |
| 116 | rom_device = le16_to_cpu(rom_data->device); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 117 | |
| 118 | debug("PCI ROM image, vendor ID %04x, device ID %04x,\n", |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 119 | rom_vendor, rom_device); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 120 | |
| 121 | /* If the device id is mapped, a mismatch is expected */ |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 122 | if ((pplat->vendor != rom_vendor || pplat->device != rom_device) && |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 123 | (vendev == mapped_vendev)) { |
| 124 | printf("ID mismatch: vendor ID %04x, device ID %04x\n", |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 125 | rom_vendor, rom_device); |
Simon Glass | 02db217 | 2014-12-29 19:32:27 -0700 | [diff] [blame] | 126 | /* Continue anyway */ |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 127 | } |
| 128 | |
Bin Meng | 932f80e | 2015-04-24 15:48:03 +0800 | [diff] [blame] | 129 | rom_class = (le16_to_cpu(rom_data->class_hi) << 8) | rom_data->class_lo; |
| 130 | debug("PCI ROM image, Class Code %06x, Code Type %02x\n", |
| 131 | rom_class, rom_data->type); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 132 | |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 133 | if (pplat->class != rom_class) { |
Bin Meng | 932f80e | 2015-04-24 15:48:03 +0800 | [diff] [blame] | 134 | debug("Class Code mismatch ROM %06x, dev %06x\n", |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 135 | rom_class, pplat->class); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 136 | } |
| 137 | *hdrp = rom_header; |
| 138 | |
| 139 | return 0; |
| 140 | } |
| 141 | |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 142 | /** |
| 143 | * pci_rom_load() - Load a ROM image and return a pointer to it |
| 144 | * |
| 145 | * @rom_header: Pointer to ROM image |
| 146 | * @ram_headerp: Returns a pointer to the image in RAM |
| 147 | * @allocedp: Returns true if @ram_headerp was allocated and needs |
| 148 | * to be freed |
| 149 | * @return 0 if OK, -ve on error. Note that @allocedp is set up regardless of |
| 150 | * the error state. Even if this function returns an error, it may have |
| 151 | * allocated memory. |
| 152 | */ |
| 153 | static int pci_rom_load(struct pci_rom_header *rom_header, |
| 154 | struct pci_rom_header **ram_headerp, bool *allocedp) |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 155 | { |
| 156 | struct pci_rom_data *rom_data; |
| 157 | unsigned int rom_size; |
| 158 | unsigned int image_size = 0; |
| 159 | void *target; |
| 160 | |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 161 | *allocedp = false; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 162 | do { |
| 163 | /* Get next image, until we see an x86 version */ |
| 164 | rom_header = (struct pci_rom_header *)((void *)rom_header + |
| 165 | image_size); |
| 166 | |
| 167 | rom_data = (struct pci_rom_data *)((void *)rom_header + |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 168 | le16_to_cpu(rom_header->data)); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 169 | |
Simon Glass | dfca446 | 2014-12-29 19:32:23 -0700 | [diff] [blame] | 170 | image_size = le16_to_cpu(rom_data->ilen) * 512; |
| 171 | } while ((rom_data->type != 0) && (rom_data->indicator == 0)); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 172 | |
| 173 | if (rom_data->type != 0) |
| 174 | return -EACCES; |
| 175 | |
| 176 | rom_size = rom_header->size * 512; |
| 177 | |
Simon Glass | 1b6b9b9 | 2014-12-29 19:32:24 -0700 | [diff] [blame] | 178 | #ifdef PCI_VGA_RAM_IMAGE_START |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 179 | target = (void *)PCI_VGA_RAM_IMAGE_START; |
Simon Glass | 1b6b9b9 | 2014-12-29 19:32:24 -0700 | [diff] [blame] | 180 | #else |
| 181 | target = (void *)malloc(rom_size); |
| 182 | if (!target) |
| 183 | return -ENOMEM; |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 184 | *allocedp = true; |
Simon Glass | 1b6b9b9 | 2014-12-29 19:32:24 -0700 | [diff] [blame] | 185 | #endif |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 186 | if (target != rom_header) { |
Simon Glass | f689808 | 2015-01-01 16:18:01 -0700 | [diff] [blame] | 187 | ulong start = get_timer(0); |
| 188 | |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 189 | debug("Copying VGA ROM Image from %p to %p, 0x%x bytes\n", |
| 190 | rom_header, target, rom_size); |
| 191 | memcpy(target, rom_header, rom_size); |
| 192 | if (memcmp(target, rom_header, rom_size)) { |
| 193 | printf("VGA ROM copy failed\n"); |
| 194 | return -EFAULT; |
| 195 | } |
Simon Glass | f689808 | 2015-01-01 16:18:01 -0700 | [diff] [blame] | 196 | debug("Copy took %lums\n", get_timer(start)); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 197 | } |
| 198 | *ram_headerp = target; |
| 199 | |
| 200 | return 0; |
| 201 | } |
| 202 | |
Bin Meng | c8990bd | 2015-08-13 00:29:16 -0700 | [diff] [blame] | 203 | struct vbe_mode_info mode_info; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 204 | |
Bin Meng | f6d504f | 2015-07-06 16:31:36 +0800 | [diff] [blame] | 205 | void setup_video(struct screen_info *screen_info) |
| 206 | { |
Bin Meng | f6d504f | 2015-07-06 16:31:36 +0800 | [diff] [blame] | 207 | struct vesa_mode_info *vesa = &mode_info.vesa; |
| 208 | |
Bin Meng | e751844 | 2015-07-30 03:49:13 -0700 | [diff] [blame] | 209 | /* Sanity test on VESA parameters */ |
| 210 | if (!vesa->x_resolution || !vesa->y_resolution) |
| 211 | return; |
| 212 | |
Bin Meng | f6d504f | 2015-07-06 16:31:36 +0800 | [diff] [blame] | 213 | screen_info->orig_video_isVGA = VIDEO_TYPE_VLFB; |
| 214 | |
| 215 | screen_info->lfb_width = vesa->x_resolution; |
| 216 | screen_info->lfb_height = vesa->y_resolution; |
| 217 | screen_info->lfb_depth = vesa->bits_per_pixel; |
| 218 | screen_info->lfb_linelength = vesa->bytes_per_scanline; |
| 219 | screen_info->lfb_base = vesa->phys_base_ptr; |
| 220 | screen_info->lfb_size = |
| 221 | ALIGN(screen_info->lfb_linelength * screen_info->lfb_height, |
| 222 | 65536); |
| 223 | screen_info->lfb_size >>= 16; |
| 224 | screen_info->red_size = vesa->red_mask_size; |
| 225 | screen_info->red_pos = vesa->red_mask_pos; |
| 226 | screen_info->green_size = vesa->green_mask_size; |
| 227 | screen_info->green_pos = vesa->green_mask_pos; |
| 228 | screen_info->blue_size = vesa->blue_mask_size; |
| 229 | screen_info->blue_pos = vesa->blue_mask_pos; |
| 230 | screen_info->rsvd_size = vesa->reserved_mask_size; |
| 231 | screen_info->rsvd_pos = vesa->reserved_mask_pos; |
Bin Meng | f6d504f | 2015-07-06 16:31:36 +0800 | [diff] [blame] | 232 | } |
| 233 | |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 234 | int dm_pci_run_vga_bios(struct udevice *dev, int (*int15_handler)(void), |
| 235 | int exec_method) |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 236 | { |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 237 | struct pci_child_platdata *pplat = dev_get_parent_platdata(dev); |
Andreas Bießmann | cb8aefa | 2016-02-16 23:29:31 +0100 | [diff] [blame] | 238 | struct pci_rom_header *rom = NULL, *ram = NULL; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 239 | int vesa_mode = -1; |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 240 | bool emulate, alloced; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 241 | int ret; |
| 242 | |
| 243 | /* Only execute VGA ROMs */ |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 244 | if (((pplat->class >> 8) ^ PCI_CLASS_DISPLAY_VGA) & 0xff00) { |
| 245 | debug("%s: Class %#x, should be %#x\n", __func__, pplat->class, |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 246 | PCI_CLASS_DISPLAY_VGA); |
| 247 | return -ENODEV; |
| 248 | } |
| 249 | |
Bin Meng | f49c485 | 2016-06-14 02:02:40 -0700 | [diff] [blame] | 250 | if (!board_should_load_oprom(dev)) |
Simon Glass | baac4eb | 2018-10-01 12:22:44 -0600 | [diff] [blame] | 251 | return log_msg_ret("Should not load OPROM", -ENXIO); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 252 | |
Simon Glass | f9d94d3 | 2015-11-29 13:17:57 -0700 | [diff] [blame] | 253 | ret = pci_rom_probe(dev, &rom); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 254 | if (ret) |
| 255 | return ret; |
| 256 | |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 257 | ret = pci_rom_load(rom, &ram, &alloced); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 258 | if (ret) |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 259 | goto err; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 260 | |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 261 | if (!board_should_run_oprom(dev)) { |
| 262 | ret = -ENXIO; |
| 263 | goto err; |
| 264 | } |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 265 | |
| 266 | #if defined(CONFIG_FRAMEBUFFER_SET_VESA_MODE) && \ |
| 267 | defined(CONFIG_FRAMEBUFFER_VESA_MODE) |
| 268 | vesa_mode = CONFIG_FRAMEBUFFER_VESA_MODE; |
| 269 | #endif |
Simon Glass | c49a8f8 | 2015-01-01 16:18:05 -0700 | [diff] [blame] | 270 | debug("Selected vesa mode %#x\n", vesa_mode); |
Simon Glass | 684818d | 2015-01-27 22:13:34 -0700 | [diff] [blame] | 271 | |
| 272 | if (exec_method & PCI_ROM_USE_NATIVE) { |
| 273 | #ifdef CONFIG_X86 |
| 274 | emulate = false; |
| 275 | #else |
| 276 | if (!(exec_method & PCI_ROM_ALLOW_FALLBACK)) { |
| 277 | printf("BIOS native execution is only available on x86\n"); |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 278 | ret = -ENOSYS; |
| 279 | goto err; |
Simon Glass | 684818d | 2015-01-27 22:13:34 -0700 | [diff] [blame] | 280 | } |
| 281 | emulate = true; |
| 282 | #endif |
| 283 | } else { |
| 284 | #ifdef CONFIG_BIOSEMU |
| 285 | emulate = true; |
| 286 | #else |
| 287 | if (!(exec_method & PCI_ROM_ALLOW_FALLBACK)) { |
| 288 | printf("BIOS emulation not available - see CONFIG_BIOSEMU\n"); |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 289 | ret = -ENOSYS; |
| 290 | goto err; |
Simon Glass | 684818d | 2015-01-27 22:13:34 -0700 | [diff] [blame] | 291 | } |
| 292 | emulate = false; |
| 293 | #endif |
| 294 | } |
| 295 | |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 296 | if (emulate) { |
| 297 | #ifdef CONFIG_BIOSEMU |
| 298 | BE_VGAInfo *info; |
| 299 | |
Simon Glass | d3e0c8f | 2016-01-17 16:11:09 -0700 | [diff] [blame] | 300 | ret = biosemu_setup(dev, &info); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 301 | if (ret) |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 302 | goto err; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 303 | biosemu_set_interrupt_handler(0x15, int15_handler); |
Simon Glass | d3e0c8f | 2016-01-17 16:11:09 -0700 | [diff] [blame] | 304 | ret = biosemu_run(dev, (uchar *)ram, 1 << 16, info, |
| 305 | true, vesa_mode, &mode_info); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 306 | if (ret) |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 307 | goto err; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 308 | #endif |
| 309 | } else { |
Simon Glass | 69c5b2d | 2019-04-25 21:59:08 -0600 | [diff] [blame] | 310 | #if defined(CONFIG_X86) && (CONFIG_IS_ENABLED(X86_32BIT_INIT) || CONFIG_TPL) |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 311 | bios_set_interrupt_handler(0x15, int15_handler); |
| 312 | |
Simon Glass | a063086 | 2015-11-29 13:17:58 -0700 | [diff] [blame] | 313 | bios_run_on_x86(dev, (unsigned long)ram, vesa_mode, |
| 314 | &mode_info); |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 315 | #endif |
| 316 | } |
Simon Glass | c49a8f8 | 2015-01-01 16:18:05 -0700 | [diff] [blame] | 317 | debug("Final vesa mode %#x\n", mode_info.video_mode); |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 318 | ret = 0; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 319 | |
Simon Glass | 7548d64 | 2016-01-15 05:23:22 -0700 | [diff] [blame] | 320 | err: |
| 321 | if (alloced) |
| 322 | free(ram); |
| 323 | return ret; |
Simon Glass | f87bbff | 2014-11-14 20:56:33 -0700 | [diff] [blame] | 324 | } |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 325 | |
| 326 | #ifdef CONFIG_DM_VIDEO |
Bin Meng | 23f5cb5 | 2016-10-09 04:14:15 -0700 | [diff] [blame] | 327 | int vbe_setup_video_priv(struct vesa_mode_info *vesa, |
| 328 | struct video_priv *uc_priv, |
| 329 | struct video_uc_platdata *plat) |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 330 | { |
| 331 | if (!vesa->x_resolution) |
Simon Glass | baac4eb | 2018-10-01 12:22:44 -0600 | [diff] [blame] | 332 | return log_msg_ret("No x resolution", -ENXIO); |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 333 | uc_priv->xsize = vesa->x_resolution; |
| 334 | uc_priv->ysize = vesa->y_resolution; |
Simon Glass | 7d18673 | 2018-11-29 15:08:52 -0700 | [diff] [blame] | 335 | uc_priv->line_length = vesa->bytes_per_scanline; |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 336 | switch (vesa->bits_per_pixel) { |
| 337 | case 32: |
| 338 | case 24: |
| 339 | uc_priv->bpix = VIDEO_BPP32; |
| 340 | break; |
| 341 | case 16: |
| 342 | uc_priv->bpix = VIDEO_BPP16; |
| 343 | break; |
| 344 | default: |
| 345 | return -EPROTONOSUPPORT; |
| 346 | } |
| 347 | plat->base = vesa->phys_base_ptr; |
| 348 | plat->size = vesa->bytes_per_scanline * vesa->y_resolution; |
| 349 | |
| 350 | return 0; |
| 351 | } |
| 352 | |
| 353 | int vbe_setup_video(struct udevice *dev, int (*int15_handler)(void)) |
| 354 | { |
| 355 | struct video_uc_platdata *plat = dev_get_uclass_platdata(dev); |
| 356 | struct video_priv *uc_priv = dev_get_uclass_priv(dev); |
| 357 | int ret; |
| 358 | |
| 359 | /* If we are running from EFI or coreboot, this can't work */ |
Bin Meng | 57b65e6 | 2016-10-09 04:14:12 -0700 | [diff] [blame] | 360 | if (!ll_boot_init()) { |
| 361 | printf("Not available (previous bootloader prevents it)\n"); |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 362 | return -EPERM; |
Bin Meng | 57b65e6 | 2016-10-09 04:14:12 -0700 | [diff] [blame] | 363 | } |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 364 | bootstage_start(BOOTSTAGE_ID_ACCUM_LCD, "vesa display"); |
| 365 | ret = dm_pci_run_vga_bios(dev, int15_handler, PCI_ROM_USE_NATIVE | |
| 366 | PCI_ROM_ALLOW_FALLBACK); |
| 367 | bootstage_accum(BOOTSTAGE_ID_ACCUM_LCD); |
| 368 | if (ret) { |
| 369 | debug("failed to run video BIOS: %d\n", ret); |
| 370 | return ret; |
| 371 | } |
| 372 | |
| 373 | ret = vbe_setup_video_priv(&mode_info.vesa, uc_priv, plat); |
| 374 | if (ret) { |
| 375 | debug("No video mode configured\n"); |
| 376 | return ret; |
| 377 | } |
| 378 | |
Bin Meng | be4551e | 2018-04-11 22:02:18 -0700 | [diff] [blame] | 379 | printf("Video: %dx%dx%d\n", uc_priv->xsize, uc_priv->ysize, |
Bin Meng | 57b65e6 | 2016-10-09 04:14:12 -0700 | [diff] [blame] | 380 | mode_info.vesa.bits_per_pixel); |
| 381 | |
Simon Glass | 4ef5d2d | 2016-10-05 20:42:17 -0600 | [diff] [blame] | 382 | return 0; |
| 383 | } |
| 384 | #endif |