311 lines
11 KiB
C
311 lines
11 KiB
C
/* ----------------------------------------------------------------------- *
|
|
*
|
|
* Copyright 1999-2012 H. Peter Anvin - All Rights Reserved
|
|
* Chandramouli Narayanan - extended for EFI support
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom
|
|
* the Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall
|
|
* be included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
#include <inttypes.h>
|
|
#include <com32.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/fpu.h>
|
|
#include <syslinux/video.h>
|
|
#include <dprintf.h>
|
|
#include "efi.h"
|
|
/* We use cp865_8x16.psf as the standard font for EFI implementation
|
|
* the header file below contains raw data parsed from cp865_8x16.psf
|
|
*/
|
|
#include "cp865_8x16.h"
|
|
#include "sys/vesa/vesa.h"
|
|
#include "sys/vesa/video.h"
|
|
#include "sys/vesa/fill.h"
|
|
#include "sys/vesa/debug.h"
|
|
|
|
/* EFI GOP support
|
|
* Note GOP support uses the VESA info structure as much as possible and
|
|
* extends it as needed for EFI support. Not all of the vesa info structure
|
|
* is populated. Care must be taken in the routines that rely the vesa
|
|
* informataion structure
|
|
*/
|
|
static void find_pixmask_bits(uint32_t mask, uint8_t *first_bit, uint8_t *len) {
|
|
uint8_t bit_pos = 0, bit_len = 0;
|
|
|
|
*first_bit = 0;
|
|
*len = 0;
|
|
if (mask == 0)
|
|
return;
|
|
while (!(mask & 0x1)) {
|
|
mask = mask >> 1;
|
|
bit_pos++;
|
|
}
|
|
while (mask & 0x1) {
|
|
mask = mask >> 1;
|
|
bit_len++;
|
|
}
|
|
*first_bit = bit_pos;
|
|
*len = bit_len;
|
|
}
|
|
|
|
unsigned long lfb_size;
|
|
uint16_t lfb_line_size;
|
|
uint8_t lfb_rsize;
|
|
uint8_t lfb_gsize;
|
|
uint8_t lfb_bsize;
|
|
uint8_t lfb_resv_size;
|
|
|
|
static int efi_vesacon_set_mode(struct vesa_info *vesa_info, int *x, int *y,
|
|
enum vesa_pixel_format *bestpxf)
|
|
{
|
|
EFI_GUID GraphicsOutputProtocolGuid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
|
|
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput = NULL;
|
|
EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *gop_mode;
|
|
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *mode_info;
|
|
EFI_STATUS st;
|
|
UINT32 mode_num = 0, bestmode;
|
|
BOOLEAN mode_match = FALSE;
|
|
UINTN sz_info;
|
|
struct vesa_info *vi;
|
|
struct vesa_mode_info *mi;
|
|
int err = 0;
|
|
|
|
//debug("Hello, World!\r\n");
|
|
/* At this point, we assume that gnu-efi library is initialized */
|
|
st = LibLocateProtocol(&GraphicsOutputProtocolGuid, (VOID **) &GraphicsOutput);
|
|
if (EFI_ERROR(st)) {
|
|
debug("LiblocateProtocol for GOP failed %d\n", st);
|
|
return 1; /* function call failed */
|
|
}
|
|
|
|
/* We use the VESA info structure to store relevant GOP info as much as possible */
|
|
gop_mode = GraphicsOutput->Mode;
|
|
|
|
mode_info = gop_mode->Info;
|
|
dprintf("mode %d version %d pixlfmt %d hres=%d vres=%d\n", mode_num,
|
|
mode_info->Version, mode_info->PixelFormat,
|
|
mode_info->HorizontalResolution, mode_info->VerticalResolution);
|
|
|
|
/* simply pick the best mode that suits the caller's resolution */
|
|
for (mode_num = 0; mode_num < gop_mode->MaxMode; mode_num++) {
|
|
st = uefi_call_wrapper(GraphicsOutput->QueryMode, 4, GraphicsOutput, mode_num, &sz_info, &mode_info);
|
|
debug("mode_num = %d query_status %d\n", mode_num, st);
|
|
if (st == EFI_SUCCESS && sz_info >= sizeof(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)) {
|
|
|
|
/* For now, simply pick the best mode that suits caller's resolution (x,y)
|
|
* FIXME: Consider any additional criteria for matching mode
|
|
*/
|
|
mode_match = ((uint32_t)*x == mode_info->HorizontalResolution && (uint32_t)*y == mode_info->VerticalResolution);
|
|
debug("mode %d hres=%d vres=%d\n", mode_num, mode_info->HorizontalResolution, mode_info->VerticalResolution);
|
|
if (mode_match) {
|
|
bestmode = mode_num;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mode_match) {
|
|
/* Instead of bailing out, set the mode to the system default.
|
|
* Some systems do not have support for 640x480 for instance
|
|
* This code deals with such cases.
|
|
*/
|
|
mode_info = gop_mode->Info;
|
|
*x = mode_info->HorizontalResolution;
|
|
*y = mode_info->VerticalResolution;
|
|
bestmode = gop_mode->Mode;
|
|
debug("No matching mode, setting to available default mode %d (x=%d, y=%d)\n", bestmode, *x, *y);
|
|
}
|
|
|
|
/* Allocate space in the bounce buffer for these structures */
|
|
vi = malloc(sizeof(*vi));
|
|
if (!vi) {
|
|
err = 10; /* Out of memory */
|
|
goto exit;
|
|
}
|
|
/* Note that the generic info is untouched as we don't find any relevance to EFI */
|
|
mi = &vi->mi;
|
|
/* Set up mode-specific information */
|
|
mi->h_res = *x;
|
|
mi->v_res = *y;
|
|
mi->lfb_ptr = (uint8_t *)(VOID *)(UINTN)gop_mode->FrameBufferBase;
|
|
lfb_size = gop_mode->FrameBufferSize;
|
|
|
|
/* FIXME:
|
|
* The code below treats bpp == lfb_depth ; verify
|
|
*/
|
|
|
|
switch (mode_info->PixelFormat) {
|
|
case PixelRedGreenBlueReserved8BitPerColor:
|
|
dprintf("RGB8bit ");
|
|
mi->mode_attr = 0x0080; /* supports physical frame buffer */
|
|
mi->bpp = sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * 8;
|
|
mi->rpos = 0;
|
|
mi->gpos = 8;
|
|
mi->bpos = 16;
|
|
mi->resv_pos = 24;
|
|
lfb_resv_size = 8;
|
|
mi->logical_scan = lfb_line_size = (mode_info->PixelsPerScanLine * mi->bpp) / 8;
|
|
*bestpxf = PXF_BGRA32;
|
|
dprintf("bpp %d pixperScanLine %d logical_scan %d bytesperPix %d\n", mi->bpp, mode_info->PixelsPerScanLine,
|
|
mi->logical_scan, (mi->bpp + 7)>>3);
|
|
break;
|
|
case PixelBlueGreenRedReserved8BitPerColor:
|
|
dprintf("BGR8bit ");
|
|
mi->mode_attr = 0x0080; /* supports physical frame buffer */
|
|
mi->bpp = sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * 8;
|
|
mi->bpos = 0;
|
|
mi->gpos = 8;
|
|
mi->rpos = 16;
|
|
mi->resv_pos = 24;
|
|
lfb_resv_size = 8;
|
|
mi->logical_scan = lfb_line_size = (mode_info->PixelsPerScanLine * mi->bpp) / 8;
|
|
*bestpxf = PXF_BGRA32;
|
|
dprintf("bpp %d pixperScanLine %d logical_scan %d bytesperPix %d\n", mi->bpp, mode_info->PixelsPerScanLine,
|
|
mi->logical_scan, (mi->bpp + 7)>>3);
|
|
break;
|
|
case PixelBitMask:
|
|
mi->mode_attr = 0x0080; /* supports physical frame buffer */
|
|
dprintf("RedMask 0x%x GrnMask 0x%x BluMask 0x%x RsvMask 0x%x\n",
|
|
mode_info->PixelInformation.RedMask,
|
|
mode_info->PixelInformation.GreenMask,
|
|
mode_info->PixelInformation.BlueMask,
|
|
mode_info->PixelInformation.ReservedMask);
|
|
find_pixmask_bits(mode_info->PixelInformation.RedMask,
|
|
&mi->rpos, &lfb_rsize);
|
|
find_pixmask_bits(mode_info->PixelInformation.GreenMask,
|
|
&mi->gpos, &lfb_gsize);
|
|
find_pixmask_bits(mode_info->PixelInformation.BlueMask,
|
|
&mi->bpos, &lfb_bsize);
|
|
find_pixmask_bits(mode_info->PixelInformation.ReservedMask,
|
|
&mi->resv_pos, &lfb_resv_size);
|
|
mi->bpp = lfb_rsize + lfb_gsize +
|
|
lfb_bsize + lfb_resv_size;
|
|
mi->logical_scan = lfb_line_size = (mode_info->PixelsPerScanLine * mi->bpp) / 8;
|
|
dprintf("RPos %d Rsize %d GPos %d Gsize %d\n", mi->rpos, lfb_rsize, mi->gpos, lfb_gsize);
|
|
dprintf("BPos %d Bsize %d RsvP %d RsvSz %d\n", mi->bpos, lfb_bsize, mi->resv_pos, lfb_resv_size);
|
|
dprintf("bpp %d logical_scan %d bytesperPix %d\n", mi->bpp, mi->logical_scan, (mi->bpp + 7)>>3);
|
|
switch (mi->bpp) {
|
|
case 32:
|
|
*bestpxf = PXF_BGRA32;
|
|
break;
|
|
case 24:
|
|
*bestpxf = PXF_BGR24;
|
|
break;
|
|
case 16:
|
|
*bestpxf = PXF_LE_RGB16_565;
|
|
break;
|
|
default:
|
|
dprintf("Unable to handle bits per pixel %d, bailing out\n", mi->bpp);
|
|
err = 4;
|
|
goto exit;
|
|
}
|
|
break;
|
|
case PixelBltOnly:
|
|
/* FIXME: unsupported */
|
|
mi->mode_attr = 0x0000; /* no support for physical frame buffer */
|
|
err = 4; /* no mode found */
|
|
goto exit;
|
|
break;
|
|
default:
|
|
/* should not get here, but let's error out */
|
|
err = 4; /* no mode found */
|
|
goto exit;
|
|
break;
|
|
}
|
|
|
|
memcpy(&vesa_info->mi, mi, sizeof *mi);
|
|
|
|
/* Now set video mode */
|
|
st = uefi_call_wrapper(GraphicsOutput->SetMode, 2, GraphicsOutput, bestmode);
|
|
if (EFI_ERROR(st)) {
|
|
err = 9; /* Failed to set mode */
|
|
dprintf("Failed to set mode %d\n", bestmode);
|
|
goto exit;
|
|
}
|
|
|
|
/* TODO: Follow the code usage of vesacon_background & vesacon_shadowfb */
|
|
/*
|
|
__vesacon_background = calloc(mi->h_res*mi->v_res, 4);
|
|
__vesacon_shadowfb = calloc(mi->h_res*mi->v_res, 4);
|
|
*/
|
|
/* FIXME: the allocation takes the possible padding into account
|
|
* whereas BIOS code simply allocates hres * vres bytes.
|
|
* Which is correct?
|
|
*/
|
|
/*
|
|
* For performance reasons, or due to hardware restrictions, scan lines
|
|
* may be padded to an amount of memory alignment. These padding pixel elements
|
|
* are outside the area covered by HorizontalResolution and are not visible.
|
|
* For direct frame buffer access, this number is used as a span between starts
|
|
* of pixel lines in video memory. Based on the size of an individual pixel element
|
|
* and PixelsPerScanline, the offset in video memory from pixel element (x, y)
|
|
* to pixel element (x, y+1) has to be calculated as
|
|
* "sizeof( PixelElement ) * PixelsPerScanLine", and not
|
|
* "sizeof( PixelElement ) * HorizontalResolution", though in many cases
|
|
* those values can coincide.
|
|
*/
|
|
|
|
exit:
|
|
if (vi)
|
|
free(vi);
|
|
|
|
return err;
|
|
}
|
|
|
|
static void efi_vesacon_screencpy(size_t dst, const uint32_t *s,
|
|
size_t bytes, struct win_info *wi)
|
|
{
|
|
size_t win_off;
|
|
char *win_base = wi->win_base;
|
|
|
|
/* For EFI, we simply take the offset from the framebuffer and write to it
|
|
* FIXME: any gotchas?
|
|
*/
|
|
win_off = dst;
|
|
memcpy(win_base + win_off, s, bytes);
|
|
}
|
|
|
|
static int efi_vesacon_font_query(uint8_t **font)
|
|
{
|
|
/* set up font info
|
|
* For now, font info is stored as raw data and used
|
|
* as such. Altenatively, the font data stored in a file
|
|
* could be read and parsed. (note: for this, EFI
|
|
* file support should be exposed via firmware structure)
|
|
*/
|
|
*font = (uint8_t *)cp865_8x16_font_data;
|
|
return cp865_8x16_font_height;
|
|
}
|
|
|
|
__export int __vesacon_i915resolution(int x, int y)
|
|
{
|
|
/* We don't support this function */
|
|
return 1;
|
|
}
|
|
|
|
struct vesa_ops efi_vesa_ops = {
|
|
.set_mode = efi_vesacon_set_mode,
|
|
.screencpy = efi_vesacon_screencpy,
|
|
.font_query = efi_vesacon_font_query,
|
|
};
|