vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

MErge mainline into intwrap

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2010-08-25 23:39:42 +02:00
commit afba9f98ec
719 changed files with 55744 additions and 25714 deletions
Download patch file Download diff file Expand all files Collapse all files

253
grub-core/video/bitmap.c Normal file
View file

@ -0,0 +1,253 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2006,2007 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/video.h>
#include <grub/bitmap.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/misc.h>
/* List of bitmap readers registered to system. */
static grub_video_bitmap_reader_t bitmap_readers_list;
/* Register bitmap reader. */
void
grub_video_bitmap_reader_register (grub_video_bitmap_reader_t reader)
{
reader->next = bitmap_readers_list;
bitmap_readers_list = reader;
}
/* Unregister bitmap reader. */
void
grub_video_bitmap_reader_unregister (grub_video_bitmap_reader_t reader)
{
grub_video_bitmap_reader_t *p, q;
for (p = &bitmap_readers_list, q = *p; q; p = &(q->next), q = q->next)
if (q == reader)
{
*p = q->next;
break;
}
}
/* Creates new bitmap, saves created bitmap on success to *bitmap. */
grub_err_t
grub_video_bitmap_create (struct grub_video_bitmap **bitmap,
unsigned int width, unsigned int height,
enum grub_video_blit_format blit_format)
{
struct grub_video_mode_info *mode_info;
unsigned int size;
if (!bitmap)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
*bitmap = 0;
if (width == 0 || height == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
*bitmap = (struct grub_video_bitmap *)grub_malloc (sizeof (struct grub_video_bitmap));
if (! *bitmap)
return grub_errno;
mode_info = &((*bitmap)->mode_info);
/* Populate mode_info. */
mode_info->width = width;
mode_info->height = height;
mode_info->blit_format = blit_format;
switch (blit_format)
{
case GRUB_VIDEO_BLIT_FORMAT_RGBA_8888:
mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_RGB
| GRUB_VIDEO_MODE_TYPE_ALPHA;
mode_info->bpp = 32;
mode_info->bytes_per_pixel = 4;
mode_info->number_of_colors = 256;
mode_info->red_mask_size = 8;
mode_info->red_field_pos = 0;
mode_info->green_mask_size = 8;
mode_info->green_field_pos = 8;
mode_info->blue_mask_size = 8;
mode_info->blue_field_pos = 16;
mode_info->reserved_mask_size = 8;
mode_info->reserved_field_pos = 24;
break;
case GRUB_VIDEO_BLIT_FORMAT_RGB_888:
mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
mode_info->bpp = 24;
mode_info->bytes_per_pixel = 3;
mode_info->number_of_colors = 256;
mode_info->red_mask_size = 8;
mode_info->red_field_pos = 0;
mode_info->green_mask_size = 8;
mode_info->green_field_pos = 8;
mode_info->blue_mask_size = 8;
mode_info->blue_field_pos = 16;
mode_info->reserved_mask_size = 0;
mode_info->reserved_field_pos = 0;
break;
case GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR:
mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
mode_info->bpp = 8;
mode_info->bytes_per_pixel = 1;
mode_info->number_of_colors = 256;
mode_info->red_mask_size = 0;
mode_info->red_field_pos = 0;
mode_info->green_mask_size = 0;
mode_info->green_field_pos = 0;
mode_info->blue_mask_size = 0;
mode_info->blue_field_pos = 0;
mode_info->reserved_mask_size = 0;
mode_info->reserved_field_pos = 0;
break;
default:
grub_free (*bitmap);
*bitmap = 0;
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"unsupported bitmap format");
}
mode_info->pitch = width * mode_info->bytes_per_pixel;
/* Calculate size needed for the data. */
size = (width * mode_info->bytes_per_pixel) * height;
(*bitmap)->data = grub_zalloc (size);
if (! (*bitmap)->data)
{
grub_free (*bitmap);
*bitmap = 0;
return grub_errno;
}
return GRUB_ERR_NONE;
}
/* Frees all resources allocated by bitmap. */
grub_err_t
grub_video_bitmap_destroy (struct grub_video_bitmap *bitmap)
{
if (! bitmap)
return GRUB_ERR_NONE;
grub_free (bitmap->data);
grub_free (bitmap);
return GRUB_ERR_NONE;
}
/* Match extension to filename. */
static int
match_extension (const char *filename, const char *ext)
{
int pos;
int ext_len;
pos = grub_strlen (filename);
ext_len = grub_strlen (ext);
if (! pos || ! ext_len || ext_len > pos)
return 0;
pos -= ext_len;
return grub_strcmp (filename + pos, ext) == 0;
}
/* Loads bitmap using registered bitmap readers. */
grub_err_t
grub_video_bitmap_load (struct grub_video_bitmap **bitmap,
const char *filename)
{
grub_video_bitmap_reader_t reader = bitmap_readers_list;
if (!bitmap)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
*bitmap = 0;
while (reader)
{
if (match_extension (filename, reader->extension))
return reader->reader (bitmap, filename);
reader = reader->next;
}
return grub_error(GRUB_ERR_BAD_FILE_TYPE, "unsupported bitmap format");
}
/* Return bitmap width. */
unsigned int
grub_video_bitmap_get_width (struct grub_video_bitmap *bitmap)
{
if (!bitmap)
return 0;
return bitmap->mode_info.width;
}
/* Return bitmap height. */
unsigned int
grub_video_bitmap_get_height (struct grub_video_bitmap *bitmap)
{
if (!bitmap)
return 0;
return bitmap->mode_info.height;
}
/* Return mode info for bitmap. */
void grub_video_bitmap_get_mode_info (struct grub_video_bitmap *bitmap,
struct grub_video_mode_info *mode_info)
{
if (!bitmap)
return;
*mode_info = bitmap->mode_info;
}
/* Return pointer to bitmap's raw data. */
void *grub_video_bitmap_get_data (struct grub_video_bitmap *bitmap)
{
if (!bitmap)
return 0;
return bitmap->data;
}
/* Initialize bitmap module. */
GRUB_MOD_INIT(bitmap)
{
}
/* Finalize bitmap module. */
GRUB_MOD_FINI(bitmap)
{
}

308
grub-core/video/bitmap_scale.c Normal file
View file

@ -0,0 +1,308 @@
/* bitmap_scale.c - Bitmap scaling. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/video.h>
#include <grub/bitmap.h>
#include <grub/bitmap_scale.h>
#include <grub/types.h>
/* Prototypes for module-local functions. */
static grub_err_t scale_nn (struct grub_video_bitmap *dst,
struct grub_video_bitmap *src);
static grub_err_t scale_bilinear (struct grub_video_bitmap *dst,
struct grub_video_bitmap *src);
/* This function creates a new scaled version of the bitmap SRC. The new
bitmap has dimensions DST_WIDTH by DST_HEIGHT. The scaling algorithm
is given by SCALE_METHOD. If an error is encountered, the return code is
not equal to GRUB_ERR_NONE, and the bitmap DST is either not created, or
it is destroyed before this function returns.
Supports only direct color modes which have components separated
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
But because of this simplifying assumption, the implementation is
greatly simplified. */
grub_err_t
grub_video_bitmap_create_scaled (struct grub_video_bitmap **dst,
int dst_width, int dst_height,
struct grub_video_bitmap *src,
enum grub_video_bitmap_scale_method
scale_method)
{
*dst = 0;
/* Verify the simplifying assumptions. */
if (src == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"null src bitmap in grub_video_bitmap_create_scaled");
if (src->mode_info.red_field_pos % 8 != 0
|| src->mode_info.green_field_pos % 8 != 0
|| src->mode_info.blue_field_pos % 8 != 0
|| src->mode_info.reserved_field_pos % 8 != 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"src format not supported for scale");
if (src->mode_info.width == 0 || src->mode_info.height == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"source bitmap has a zero dimension");
if (dst_width <= 0 || dst_height <= 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"requested to scale to a size w/ a zero dimension");
if (src->mode_info.bytes_per_pixel * 8 != src->mode_info.bpp)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"bitmap to scale has inconsistent Bpp and bpp");
/* Create the new bitmap. */
grub_err_t ret;
ret = grub_video_bitmap_create (dst, dst_width, dst_height,
src->mode_info.blit_format);
if (ret != GRUB_ERR_NONE)
return ret; /* Error. */
switch (scale_method)
{
case GRUB_VIDEO_BITMAP_SCALE_METHOD_FASTEST:
case GRUB_VIDEO_BITMAP_SCALE_METHOD_NEAREST:
ret = scale_nn (*dst, src);
break;
case GRUB_VIDEO_BITMAP_SCALE_METHOD_BEST:
case GRUB_VIDEO_BITMAP_SCALE_METHOD_BILINEAR:
ret = scale_bilinear (*dst, src);
break;
default:
ret = grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid scale_method value");
break;
}
if (ret == GRUB_ERR_NONE)
{
/* Success: *dst is now a pointer to the scaled bitmap. */
return GRUB_ERR_NONE;
}
else
{
/* Destroy the bitmap and return the error code. */
grub_video_bitmap_destroy (*dst);
*dst = 0;
return ret;
}
}
/* Nearest neighbor bitmap scaling algorithm.
Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the
dimensions of DST. This function uses the nearest neighbor algorithm to
interpolate the pixels.
Supports only direct color modes which have components separated
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
But because of this simplifying assumption, the implementation is
greatly simplified. */
static grub_err_t
scale_nn (struct grub_video_bitmap *dst, struct grub_video_bitmap *src)
{
/* Verify the simplifying assumptions. */
if (dst == 0 || src == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "null bitmap in scale_nn");
if (dst->mode_info.red_field_pos % 8 != 0
|| dst->mode_info.green_field_pos % 8 != 0
|| dst->mode_info.blue_field_pos % 8 != 0
|| dst->mode_info.reserved_field_pos % 8 != 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst format not supported");
if (src->mode_info.red_field_pos % 8 != 0
|| src->mode_info.green_field_pos % 8 != 0
|| src->mode_info.blue_field_pos % 8 != 0
|| src->mode_info.reserved_field_pos % 8 != 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "src format not supported");
if (dst->mode_info.red_field_pos != src->mode_info.red_field_pos
|| dst->mode_info.red_mask_size != src->mode_info.red_mask_size
|| dst->mode_info.green_field_pos != src->mode_info.green_field_pos
|| dst->mode_info.green_mask_size != src->mode_info.green_mask_size
|| dst->mode_info.blue_field_pos != src->mode_info.blue_field_pos
|| dst->mode_info.blue_mask_size != src->mode_info.blue_mask_size
|| dst->mode_info.reserved_field_pos !=
src->mode_info.reserved_field_pos
|| dst->mode_info.reserved_mask_size !=
src->mode_info.reserved_mask_size)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
if (dst->mode_info.bytes_per_pixel != src->mode_info.bytes_per_pixel)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
if (dst->mode_info.width == 0 || dst->mode_info.height == 0
|| src->mode_info.width == 0 || src->mode_info.height == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "bitmap has a zero dimension");
grub_uint8_t *ddata = dst->data;
grub_uint8_t *sdata = src->data;
int dw = dst->mode_info.width;
int dh = dst->mode_info.height;
int sw = src->mode_info.width;
int sh = src->mode_info.height;
int dstride = dst->mode_info.pitch;
int sstride = src->mode_info.pitch;
/* bytes_per_pixel is the same for both src and dst. */
int bytes_per_pixel = dst->mode_info.bytes_per_pixel;
int dy;
for (dy = 0; dy < dh; dy++)
{
int dx;
for (dx = 0; dx < dw; dx++)
{
grub_uint8_t *dptr;
grub_uint8_t *sptr;
int sx;
int sy;
int comp;
/* Compute the source coordinate that the destination coordinate
maps to. Note: sx/sw = dx/dw => sx = sw*dx/dw. */
sx = sw * dx / dw;
sy = sh * dy / dh;
/* Get the address of the pixels in src and dst. */
dptr = ddata + dy * dstride + dx * bytes_per_pixel;
sptr = sdata + sy * sstride + sx * bytes_per_pixel;
/* Copy the pixel color value. */
for (comp = 0; comp < bytes_per_pixel; comp++)
dptr[comp] = sptr[comp];
}
}
return GRUB_ERR_NONE;
}
/* Bilinear interpolation image scaling algorithm.
Copy the bitmap SRC to the bitmap DST, scaling the bitmap to fit the
dimensions of DST. This function uses the bilinear interpolation algorithm
to interpolate the pixels.
Supports only direct color modes which have components separated
into bytes (e.g., RGBA 8:8:8:8 or BGR 8:8:8 true color).
But because of this simplifying assumption, the implementation is
greatly simplified. */
static grub_err_t
scale_bilinear (struct grub_video_bitmap *dst, struct grub_video_bitmap *src)
{
/* Verify the simplifying assumptions. */
if (dst == 0 || src == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "null bitmap in scale func");
if (dst->mode_info.red_field_pos % 8 != 0
|| dst->mode_info.green_field_pos % 8 != 0
|| dst->mode_info.blue_field_pos % 8 != 0
|| dst->mode_info.reserved_field_pos % 8 != 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst format not supported");
if (src->mode_info.red_field_pos % 8 != 0
|| src->mode_info.green_field_pos % 8 != 0
|| src->mode_info.blue_field_pos % 8 != 0
|| src->mode_info.reserved_field_pos % 8 != 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "src format not supported");
if (dst->mode_info.red_field_pos != src->mode_info.red_field_pos
|| dst->mode_info.red_mask_size != src->mode_info.red_mask_size
|| dst->mode_info.green_field_pos != src->mode_info.green_field_pos
|| dst->mode_info.green_mask_size != src->mode_info.green_mask_size
|| dst->mode_info.blue_field_pos != src->mode_info.blue_field_pos
|| dst->mode_info.blue_mask_size != src->mode_info.blue_mask_size
|| dst->mode_info.reserved_field_pos !=
src->mode_info.reserved_field_pos
|| dst->mode_info.reserved_mask_size !=
src->mode_info.reserved_mask_size)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
if (dst->mode_info.bytes_per_pixel != src->mode_info.bytes_per_pixel)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "dst and src not compatible");
if (dst->mode_info.width == 0 || dst->mode_info.height == 0
|| src->mode_info.width == 0 || src->mode_info.height == 0)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "bitmap has a zero dimension");
grub_uint8_t *ddata = dst->data;
grub_uint8_t *sdata = src->data;
int dw = dst->mode_info.width;
int dh = dst->mode_info.height;
int sw = src->mode_info.width;
int sh = src->mode_info.height;
int dstride = dst->mode_info.pitch;
int sstride = src->mode_info.pitch;
/* bytes_per_pixel is the same for both src and dst. */
int bytes_per_pixel = dst->mode_info.bytes_per_pixel;
int dy;
for (dy = 0; dy < dh; dy++)
{
int dx;
for (dx = 0; dx < dw; dx++)
{
grub_uint8_t *dptr;
grub_uint8_t *sptr;
int sx;
int sy;
int comp;
/* Compute the source coordinate that the destination coordinate
maps to. Note: sx/sw = dx/dw => sx = sw*dx/dw. */
sx = sw * dx / dw;
sy = sh * dy / dh;
/* Get the address of the pixels in src and dst. */
dptr = ddata + dy * dstride + dx * bytes_per_pixel;
sptr = sdata + sy * sstride + sx * bytes_per_pixel;
/* If we have enough space to do so, use bilinear interpolation.
Otherwise, fall back to nearest neighbor for this pixel. */
if (sx < sw - 1 && sy < sh - 1)
{
/* Do bilinear interpolation. */
/* Fixed-point .8 numbers representing the fraction of the
distance in the x (u) and y (v) direction within the
box of 4 pixels in the source. */
int u = (256 * sw * dx / dw) - (sx * 256);
int v = (256 * sh * dy / dh) - (sy * 256);
for (comp = 0; comp < bytes_per_pixel; comp++)
{
/* Get the component's values for the
four source corner pixels. */
grub_uint8_t f00 = sptr[comp];
grub_uint8_t f10 = sptr[comp + bytes_per_pixel];
grub_uint8_t f01 = sptr[comp + sstride];
grub_uint8_t f11 = sptr[comp + sstride + bytes_per_pixel];
/* Do linear interpolations along the top and bottom
rows of the box. */
grub_uint8_t f0y = (256 - v) * f00 / 256 + v * f01 / 256;
grub_uint8_t f1y = (256 - v) * f10 / 256 + v * f11 / 256;
/* Interpolate vertically. */
grub_uint8_t fxy = (256 - u) * f0y / 256 + u * f1y / 256;
dptr[comp] = fxy;
}
}
else
{
/* Fall back to nearest neighbor interpolation. */
/* Copy the pixel color value. */
for (comp = 0; comp < bytes_per_pixel; comp++)
dptr[comp] = sptr[comp];
}
}
}
return GRUB_ERR_NONE;
}

423
grub-core/video/bochs.c Normal file
View file

@ -0,0 +1,423 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009,2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <grub/pci.h>
#include <grub/vga.h>
static struct
{
struct grub_video_mode_info mode_info;
grub_uint8_t *ptr;
int mapped;
grub_uint32_t base;
grub_pci_device_t dev;
} framebuffer;
#define BOCHS_APERTURE_SIZE 0x800000
#define BOCHS_MAX_WIDTH 1600
#define BOCHS_MAX_HEIGHT 1200
#define BOCHS_WIDTH_ALIGN 8
enum
{
BOCHS_VBE_INDEX = 0x1ce,
BOCHS_VBE_DATA = 0x1cf,
};
enum
{
BOCHS_VBE_WIDTH = 1,
BOCHS_VBE_HEIGHT = 2,
BOCHS_VBE_BPP = 3,
BOCHS_VBE_ENABLE = 4,
BOCHS_VBE_Y_OFFSET = 9,
BOCHS_VBE_MAX
};
static void
vbe_write (grub_uint16_t val, grub_uint16_t addr)
{
grub_outw (addr, BOCHS_VBE_INDEX);
grub_outw (val, BOCHS_VBE_DATA);
}
static grub_uint16_t
vbe_read (grub_uint16_t addr)
{
grub_outw (addr, BOCHS_VBE_INDEX);
return grub_inw (BOCHS_VBE_DATA);
}
struct saved_state
{
grub_uint8_t cr[256];
grub_uint8_t gr[256];
grub_uint8_t sr[256];
grub_uint8_t r[256];
grub_uint8_t g[256];
grub_uint8_t b[256];
grub_uint8_t vbe[BOCHS_VBE_MAX];
int vbe_enable;
/* We need to preserve VGA font and VGA text. */
grub_uint8_t vram[32 * 4 * 256];
};
static struct saved_state initial_state;
static int state_saved = 0;
static void
save_state (struct saved_state *st)
{
unsigned i;
for (i = 0; i < ARRAY_SIZE (st->cr); i++)
st->cr[i] = grub_vga_cr_read (i);
for (i = 0; i < ARRAY_SIZE (st->gr); i++)
st->gr[i] = grub_vga_gr_read (i);
for (i = 0; i < ARRAY_SIZE (st->sr); i++)
st->sr[i] = grub_vga_sr_read (i);
for (i = 0; i < 256; i++)
grub_vga_palette_read (i, st->r + i, st->g + i, st->b + i);
st->vbe_enable = vbe_read (BOCHS_VBE_ENABLE) & 1;
if (st->vbe_enable)
for (i = 0; i < ARRAY_SIZE (st->vbe); i++)
st->vbe[i] = vbe_read (i);
grub_vga_sr_write (GRUB_VGA_SR_MEMORY_MODE_CHAIN4, GRUB_VGA_SR_MEMORY_MODE);
grub_memcpy (st->vram, framebuffer.ptr, sizeof (st->vram));
grub_vga_sr_write (st->sr[GRUB_VGA_SR_MEMORY_MODE], GRUB_VGA_SR_MEMORY_MODE);
}
static void
restore_state (struct saved_state *st)
{
unsigned i;
if (st->vbe_enable)
for (i = 0; i < ARRAY_SIZE (st->vbe); i++)
vbe_write (st->vbe[i], i);
else
vbe_write (0, BOCHS_VBE_ENABLE);
grub_vga_cr_write (0, 0x11);
for (i = 0; i < ARRAY_SIZE (st->cr); i++)
grub_vga_cr_write (st->cr[i], i);
for (i = 0; i < ARRAY_SIZE (st->sr); i++)
grub_vga_sr_write (st->sr[i], i);
for (i = 0; i < ARRAY_SIZE (st->gr); i++)
grub_vga_gr_write (st->gr[i], i);
for (i = 0; i < 256; i++)
grub_vga_palette_write (i, st->r[i], st->g[i], st->b[i]);
grub_vga_sr_write (GRUB_VGA_SR_MEMORY_MODE_CHAIN4, GRUB_VGA_SR_MEMORY_MODE);
grub_memcpy (framebuffer.ptr, st->vram, sizeof (st->vram));
grub_vga_sr_write (st->sr[GRUB_VGA_SR_MEMORY_MODE], GRUB_VGA_SR_MEMORY_MODE);
}
static grub_err_t
grub_video_bochs_video_init (void)
{
/* Reset frame buffer. */
grub_memset (&framebuffer, 0, sizeof(framebuffer));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_bochs_video_fini (void)
{
if (framebuffer.mapped)
grub_pci_device_unmap_range (framebuffer.dev, framebuffer.ptr,
BOCHS_APERTURE_SIZE);
if (state_saved)
{
restore_state (&initial_state);
state_saved = 0;
}
return grub_video_fb_fini ();
}
static grub_err_t
doublebuf_pageflipping_set_page (int page)
{
int start = framebuffer.mode_info.height * page;
vbe_write (start, BOCHS_VBE_Y_OFFSET);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_bochs_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data)
{
if (framebuffer.mode_info.mode_type == GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)
{
unsigned i;
if (start >= 0x100)
return GRUB_ERR_NONE;
if (start + count >= 0x100)
count = 0x100 - start;
for (i = 0; i < count; i++)
grub_vga_palette_write (start + i, palette_data[i].r, palette_data[i].g,
palette_data[i].b);
}
/* Then set color to emulated palette. */
return grub_video_fb_set_palette (start, count, palette_data);
}
static grub_err_t
grub_video_bochs_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask)
{
int depth;
grub_err_t err;
int found = 0;
int pitch, bytes_per_pixel;
grub_size_t page_size; /* The size of a page in bytes. */
auto int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid __attribute__ ((unused)));
int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid)
{
grub_pci_address_t addr;
grub_uint32_t class;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
class = grub_pci_read (addr);
if (((class >> 16) & 0xffff) != 0x0300 || pciid != 0x11111234)
return 0;
found = 1;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
framebuffer.base = grub_pci_read (addr) & GRUB_PCI_ADDR_MEM_MASK;
framebuffer.dev = dev;
return 1;
}
/* Decode depth from mode_type. If it is zero, then autodetect. */
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
if (width == 0 || height == 0)
{
width = 800;
height = 600;
}
if (width > BOCHS_MAX_WIDTH)
return grub_error (GRUB_ERR_IO, "width must be at most",
BOCHS_MAX_WIDTH);
if (height > BOCHS_MAX_HEIGHT)
return grub_error (GRUB_ERR_IO, "height must be at most",
BOCHS_MAX_HEIGHT);
if (width & (BOCHS_WIDTH_ALIGN - 1))
return grub_error (GRUB_ERR_IO, "width must be a multiple of %d",
BOCHS_WIDTH_ALIGN);
if (depth == 0
&& !grub_video_check_mode_flag (mode_type, mode_mask,
GRUB_VIDEO_MODE_TYPE_INDEX_COLOR, 0))
depth = 24;
if (depth == 0)
depth = 8;
if (depth != 32 && depth != 24 && depth != 16 && depth != 15 && depth != 8
&& depth != 4)
return grub_error (GRUB_ERR_IO, "only 32, 24, 16, 15 and 8-bpp are"
" supported by bochs video");
if (depth == 4)
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "4-bpp isn't cupported");
bytes_per_pixel = (depth + 7) / 8;
if (depth == 4)
pitch = width / 2;
else
pitch = width * bytes_per_pixel;
page_size = pitch * height;
if (page_size > BOCHS_APERTURE_SIZE)
return grub_error (GRUB_ERR_IO, "Not enough video memory for this mode");
grub_pci_iterate (find_card);
if (!found)
return grub_error (GRUB_ERR_IO, "Couldn't find graphics card");
if (found && framebuffer.base == 0)
{
/* FIXME: change framebuffer base */
return grub_error (GRUB_ERR_IO, "PCI BAR not set");
}
/* We can safely discard volatile attribute. */
framebuffer.ptr = (void *) grub_pci_device_map_range (framebuffer.dev,
framebuffer.base,
BOCHS_APERTURE_SIZE);
framebuffer.mapped = 1;
if (!state_saved)
{
save_state (&initial_state);
state_saved = 1;
}
{
vbe_write (0, BOCHS_VBE_ENABLE);
vbe_write (width, BOCHS_VBE_WIDTH);
vbe_write (height, BOCHS_VBE_HEIGHT);
vbe_write (depth, BOCHS_VBE_BPP);
vbe_write (1, BOCHS_VBE_ENABLE);
doublebuf_pageflipping_set_page (0);
}
/* Fill mode info details. */
framebuffer.mode_info.width = width;
framebuffer.mode_info.height = height;
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
framebuffer.mode_info.bpp = depth;
framebuffer.mode_info.bytes_per_pixel = bytes_per_pixel;
framebuffer.mode_info.pitch = pitch;
framebuffer.mode_info.number_of_colors = 256;
framebuffer.mode_info.reserved_mask_size = 0;
framebuffer.mode_info.reserved_field_pos = 0;
switch (depth)
{
case 4:
case 8:
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
break;
case 16:
framebuffer.mode_info.red_mask_size = 5;
framebuffer.mode_info.red_field_pos = 11;
framebuffer.mode_info.green_mask_size = 6;
framebuffer.mode_info.green_field_pos = 5;
framebuffer.mode_info.blue_mask_size = 5;
framebuffer.mode_info.blue_field_pos = 0;
break;
case 15:
framebuffer.mode_info.red_mask_size = 5;
framebuffer.mode_info.red_field_pos = 10;
framebuffer.mode_info.green_mask_size = 5;
framebuffer.mode_info.green_field_pos = 5;
framebuffer.mode_info.blue_mask_size = 5;
framebuffer.mode_info.blue_field_pos = 0;
break;
case 32:
framebuffer.mode_info.reserved_mask_size = 8;
framebuffer.mode_info.reserved_field_pos = 24;
case 24:
framebuffer.mode_info.red_mask_size = 8;
framebuffer.mode_info.red_field_pos = 16;
framebuffer.mode_info.green_mask_size = 8;
framebuffer.mode_info.green_field_pos = 8;
framebuffer.mode_info.blue_mask_size = 8;
framebuffer.mode_info.blue_field_pos = 0;
break;
}
framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
if (BOCHS_APERTURE_SIZE >= 2 * page_size)
err = grub_video_fb_setup (mode_type, mode_mask,
&framebuffer.mode_info,
framebuffer.ptr,
doublebuf_pageflipping_set_page,
framebuffer.ptr + page_size);
else
err = grub_video_fb_setup (mode_type, mode_mask,
&framebuffer.mode_info,
framebuffer.ptr, 0, 0);
/* Copy default palette to initialize emulated palette. */
err = grub_video_bochs_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
return err;
}
static struct grub_video_adapter grub_video_bochs_adapter =
{
.name = "Bochs PCI Video Driver",
.id = GRUB_VIDEO_DRIVER_BOCHS,
.prio = GRUB_VIDEO_ADAPTER_PRIO_NATIVE,
.init = grub_video_bochs_video_init,
.fini = grub_video_bochs_video_fini,
.setup = grub_video_bochs_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_fb_get_info_and_fini,
.set_palette = grub_video_bochs_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_fb_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_fb_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(video_bochs)
{
grub_video_register (&grub_video_bochs_adapter);
}
GRUB_MOD_FINI(video_bochs)
{
grub_video_unregister (&grub_video_bochs_adapter);
}

503
grub-core/video/cirrus.c Normal file
View file

@ -0,0 +1,503 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009,2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <grub/pci.h>
#include <grub/vga.h>
static struct
{
struct grub_video_mode_info mode_info;
grub_size_t page_size; /* The size of a page in bytes. */
grub_uint8_t *ptr;
int mapped;
grub_uint32_t base;
grub_pci_device_t dev;
} framebuffer;
#define CIRRUS_APERTURE_SIZE 0x1000000
#define CIRRUS_MAX_WIDTH 0x800
#define CIRRUS_MAX_HEIGHT 0x800
#define CIRRUS_MAX_PITCH (0x1ff * GRUB_VGA_CR_PITCH_DIVISOR)
enum
{
CIRRUS_CR_EXTENDED_DISPLAY = 0x1b,
CIRRUS_CR_EXTENDED_OVERLAY = 0x1d,
CIRRUS_CR_MAX
};
#define CIRRUS_CR_EXTENDED_DISPLAY_PITCH_MASK 0x10
#define CIRRUS_CR_EXTENDED_DISPLAY_PITCH_SHIFT 4
#define CIRRUS_CR_EXTENDED_DISPLAY_START_MASK1 0x1
#define CIRRUS_CR_EXTENDED_DISPLAY_START_SHIFT1 16
#define CIRRUS_CR_EXTENDED_DISPLAY_START_MASK2 0xc
#define CIRRUS_CR_EXTENDED_DISPLAY_START_SHIFT2 15
#define CIRRUS_CR_EXTENDED_OVERLAY_DISPLAY_START_MASK 0x80
#define CIRRUS_CR_EXTENDED_OVERLAY_DISPLAY_START_SHIFT 12
enum
{
CIRRUS_SR_EXTENDED_MODE = 7,
CIRRUS_SR_MAX
};
#define CIRRUS_SR_EXTENDED_MODE_LFB_ENABLE 0xf0
#define CIRRUS_SR_EXTENDED_MODE_ENABLE_EXT 0x01
#define CIRRUS_SR_EXTENDED_MODE_8BPP 0x00
#define CIRRUS_SR_EXTENDED_MODE_16BPP 0x06
#define CIRRUS_SR_EXTENDED_MODE_24BPP 0x04
#define CIRRUS_SR_EXTENDED_MODE_32BPP 0x08
#define CIRRUS_HIDDEN_DAC_ENABLE_EXT 0x80
#define CIRRUS_HIDDEN_DAC_ENABLE_ALL 0x40
#define CIRRUS_HIDDEN_DAC_8BPP 0
#define CIRRUS_HIDDEN_DAC_15BPP (CIRRUS_HIDDEN_DAC_ENABLE_EXT \
| CIRRUS_HIDDEN_DAC_ENABLE_ALL | 0)
#define CIRRUS_HIDDEN_DAC_16BPP (CIRRUS_HIDDEN_DAC_ENABLE_EXT \
| CIRRUS_HIDDEN_DAC_ENABLE_ALL | 1)
#define CIRRUS_HIDDEN_DAC_888COLOR (CIRRUS_HIDDEN_DAC_ENABLE_EXT \
| CIRRUS_HIDDEN_DAC_ENABLE_ALL | 5)
static void
write_hidden_dac (grub_uint8_t data)
{
grub_inb (GRUB_VGA_IO_PALLETTE_WRITE_INDEX);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
grub_outb (data, GRUB_VGA_IO_PIXEL_MASK);
}
static grub_uint8_t
read_hidden_dac (void)
{
grub_inb (GRUB_VGA_IO_PALLETTE_WRITE_INDEX);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
grub_inb (GRUB_VGA_IO_PIXEL_MASK);
return grub_inb (GRUB_VGA_IO_PIXEL_MASK);
}
struct saved_state
{
grub_uint8_t cr[CIRRUS_CR_MAX];
grub_uint8_t gr[GRUB_VGA_GR_MAX];
grub_uint8_t sr[CIRRUS_SR_MAX];
grub_uint8_t hidden_dac;
/* We need to preserve VGA font and VGA text. */
grub_uint8_t vram[32 * 4 * 256];
grub_uint8_t r[256];
grub_uint8_t g[256];
grub_uint8_t b[256];
};
static struct saved_state initial_state;
static int state_saved = 0;
static void
save_state (struct saved_state *st)
{
unsigned i;
for (i = 0; i < ARRAY_SIZE (st->cr); i++)
st->cr[i] = grub_vga_cr_read (i);
for (i = 0; i < ARRAY_SIZE (st->sr); i++)
st->sr[i] = grub_vga_sr_read (i);
for (i = 0; i < ARRAY_SIZE (st->gr); i++)
st->gr[i] = grub_vga_gr_read (i);
for (i = 0; i < 256; i++)
grub_vga_palette_read (i, st->r + i, st->g + i, st->b + i);
st->hidden_dac = read_hidden_dac ();
grub_vga_sr_write (GRUB_VGA_SR_MEMORY_MODE_CHAIN4, GRUB_VGA_SR_MEMORY_MODE);
grub_memcpy (st->vram, framebuffer.ptr, sizeof (st->vram));
}
static void
restore_state (struct saved_state *st)
{
unsigned i;
grub_vga_sr_write (GRUB_VGA_SR_MEMORY_MODE_CHAIN4, GRUB_VGA_SR_MEMORY_MODE);
grub_memcpy (framebuffer.ptr, st->vram, sizeof (st->vram));
for (i = 0; i < ARRAY_SIZE (st->cr); i++)
grub_vga_cr_write (st->cr[i], i);
for (i = 0; i < ARRAY_SIZE (st->sr); i++)
grub_vga_sr_write (st->sr[i], i);
for (i = 0; i < ARRAY_SIZE (st->gr); i++)
grub_vga_gr_write (st->gr[i], i);
for (i = 0; i < 256; i++)
grub_vga_palette_write (i, st->r[i], st->g[i], st->b[i]);
write_hidden_dac (st->hidden_dac);
}
static grub_err_t
grub_video_cirrus_video_init (void)
{
/* Reset frame buffer. */
grub_memset (&framebuffer, 0, sizeof(framebuffer));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_cirrus_video_fini (void)
{
if (framebuffer.mapped)
grub_pci_device_unmap_range (framebuffer.dev, framebuffer.ptr,
CIRRUS_APERTURE_SIZE);
if (state_saved)
{
restore_state (&initial_state);
state_saved = 0;
}
return grub_video_fb_fini ();
}
static grub_err_t
doublebuf_pageflipping_set_page (int page)
{
int start = framebuffer.page_size * page / 4;
grub_uint8_t cr_ext, cr_overlay;
grub_vga_cr_write (start & 0xff, GRUB_VGA_CR_START_ADDR_LOW_REGISTER);
grub_vga_cr_write ((start & 0xff00) >> 8,
GRUB_VGA_CR_START_ADDR_HIGH_REGISTER);
cr_ext = grub_vga_cr_read (CIRRUS_CR_EXTENDED_DISPLAY);
cr_ext &= ~(CIRRUS_CR_EXTENDED_DISPLAY_START_MASK1
| CIRRUS_CR_EXTENDED_DISPLAY_START_MASK2);
cr_ext |= ((start >> CIRRUS_CR_EXTENDED_DISPLAY_START_SHIFT1)
& CIRRUS_CR_EXTENDED_DISPLAY_START_MASK1);
cr_ext |= ((start >> CIRRUS_CR_EXTENDED_DISPLAY_START_SHIFT2)
& CIRRUS_CR_EXTENDED_DISPLAY_START_MASK2);
grub_vga_cr_write (cr_ext, CIRRUS_CR_EXTENDED_DISPLAY);
cr_overlay = grub_vga_cr_read (CIRRUS_CR_EXTENDED_OVERLAY);
cr_overlay &= ~(CIRRUS_CR_EXTENDED_OVERLAY_DISPLAY_START_MASK);
cr_overlay |= ((start >> CIRRUS_CR_EXTENDED_OVERLAY_DISPLAY_START_SHIFT)
& CIRRUS_CR_EXTENDED_OVERLAY_DISPLAY_START_MASK);
grub_vga_cr_write (cr_overlay, CIRRUS_CR_EXTENDED_OVERLAY);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_cirrus_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data)
{
if (framebuffer.mode_info.mode_type == GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)
{
unsigned i;
if (start >= 0x100)
return GRUB_ERR_NONE;
if (start + count >= 0x100)
count = 0x100 - start;
for (i = 0; i < count; i++)
grub_vga_palette_write (start + i, palette_data[i].r, palette_data[i].g,
palette_data[i].b);
}
/* Then set color to emulated palette. */
return grub_video_fb_set_palette (start, count, palette_data);
}
static grub_err_t
grub_video_cirrus_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask)
{
int depth;
grub_err_t err;
int found = 0;
int pitch, bytes_per_pixel;
auto int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid __attribute__ ((unused)));
int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid)
{
grub_pci_address_t addr;
grub_uint32_t class;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
class = grub_pci_read (addr);
if (((class >> 16) & 0xffff) != 0x0300 || pciid != 0x00b81013)
return 0;
found = 1;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
framebuffer.base = grub_pci_read (addr) & GRUB_PCI_ADDR_MEM_MASK;
framebuffer.dev = dev;
return 1;
}
/* Decode depth from mode_type. If it is zero, then autodetect. */
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
if (width == 0 || height == 0)
{
width = 800;
height = 600;
}
if (width & (GRUB_VGA_CR_WIDTH_DIVISOR - 1))
return grub_error (GRUB_ERR_IO,
"screen width must be a multiple of %d",
GRUB_VGA_CR_WIDTH_DIVISOR);
if (width > CIRRUS_MAX_WIDTH)
return grub_error (GRUB_ERR_IO,
"screen width must be at most %d", CIRRUS_MAX_WIDTH);
if (height > CIRRUS_MAX_HEIGHT)
return grub_error (GRUB_ERR_IO,
"screen height must be at most %d", CIRRUS_MAX_HEIGHT);
if (depth == 0
&& !grub_video_check_mode_flag (mode_type, mode_mask,
GRUB_VIDEO_MODE_TYPE_INDEX_COLOR, 0))
depth = 24;
if (depth == 0)
depth = 8;
if (depth != 32 && depth != 24 && depth != 16 && depth != 15 && depth != 8)
return grub_error (GRUB_ERR_IO, "only 32, 24, 16, 15 and 8-bit bpp are"
" supported by cirrus video");
bytes_per_pixel = (depth + 7) / 8;
pitch = width * bytes_per_pixel;
if (pitch > CIRRUS_MAX_PITCH)
return grub_error (GRUB_ERR_IO,
"screen width must be at most %d at bitdepth %d",
CIRRUS_MAX_PITCH / bytes_per_pixel, depth);
framebuffer.page_size = pitch * height;
if (framebuffer.page_size > CIRRUS_APERTURE_SIZE)
return grub_error (GRUB_ERR_IO, "Not enough video memory for this mode");
grub_pci_iterate (find_card);
if (!found)
return grub_error (GRUB_ERR_IO, "Couldn't find graphics card");
if (found && framebuffer.base == 0)
{
/* FIXME: change framebuffer base */
return grub_error (GRUB_ERR_IO, "PCI BAR not set");
}
/* We can safely discard volatile attribute. */
framebuffer.ptr = (void *) grub_pci_device_map_range (framebuffer.dev,
framebuffer.base,
CIRRUS_APERTURE_SIZE);
framebuffer.mapped = 1;
if (!state_saved)
{
save_state (&initial_state);
state_saved = 1;
}
{
struct grub_video_hw_config config = {
.pitch = pitch / GRUB_VGA_CR_PITCH_DIVISOR,
.line_compare = 0x3ff,
.vdisplay_end = height - 1,
.horizontal_end = width / GRUB_VGA_CR_WIDTH_DIVISOR
};
grub_uint8_t sr_ext = 0, hidden_dac = 0;
grub_vga_set_geometry (&config, grub_vga_cr_write);
grub_vga_gr_write (GRUB_VGA_GR_MODE_256_COLOR | GRUB_VGA_GR_MODE_READ_MODE1,
GRUB_VGA_GR_MODE);
grub_vga_gr_write (GRUB_VGA_GR_GR6_GRAPHICS_MODE, GRUB_VGA_GR_GR6);
grub_vga_sr_write (GRUB_VGA_SR_MEMORY_MODE_NORMAL, GRUB_VGA_SR_MEMORY_MODE);
grub_vga_cr_write ((config.pitch >> CIRRUS_CR_EXTENDED_DISPLAY_PITCH_SHIFT)
& CIRRUS_CR_EXTENDED_DISPLAY_PITCH_MASK,
CIRRUS_CR_EXTENDED_DISPLAY);
grub_vga_cr_write (GRUB_VGA_CR_MODE_TIMING_ENABLE
| GRUB_VGA_CR_MODE_BYTE_MODE
| GRUB_VGA_CR_MODE_NO_HERCULES | GRUB_VGA_CR_MODE_NO_CGA,
GRUB_VGA_CR_MODE);
doublebuf_pageflipping_set_page (0);
sr_ext = CIRRUS_SR_EXTENDED_MODE_LFB_ENABLE
| CIRRUS_SR_EXTENDED_MODE_ENABLE_EXT;
switch (depth)
{
/* FIXME: support 8-bit grayscale and 8-bit RGB. */
case 32:
hidden_dac = CIRRUS_HIDDEN_DAC_888COLOR;
sr_ext |= CIRRUS_SR_EXTENDED_MODE_32BPP;
break;
case 24:
hidden_dac = CIRRUS_HIDDEN_DAC_888COLOR;
sr_ext |= CIRRUS_SR_EXTENDED_MODE_24BPP;
break;
case 16:
hidden_dac = CIRRUS_HIDDEN_DAC_16BPP;
sr_ext |= CIRRUS_SR_EXTENDED_MODE_16BPP;
break;
case 15:
hidden_dac = CIRRUS_HIDDEN_DAC_15BPP;
sr_ext |= CIRRUS_SR_EXTENDED_MODE_16BPP;
break;
case 8:
hidden_dac = CIRRUS_HIDDEN_DAC_8BPP;
sr_ext |= CIRRUS_SR_EXTENDED_MODE_8BPP;
break;
}
grub_vga_sr_write (sr_ext, CIRRUS_SR_EXTENDED_MODE);
write_hidden_dac (hidden_dac);
}
/* Fill mode info details. */
framebuffer.mode_info.width = width;
framebuffer.mode_info.height = height;
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
framebuffer.mode_info.bpp = depth;
framebuffer.mode_info.bytes_per_pixel = bytes_per_pixel;
framebuffer.mode_info.pitch = pitch;
framebuffer.mode_info.number_of_colors = 256;
framebuffer.mode_info.reserved_mask_size = 0;
framebuffer.mode_info.reserved_field_pos = 0;
switch (depth)
{
case 8:
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
break;
case 16:
framebuffer.mode_info.red_mask_size = 5;
framebuffer.mode_info.red_field_pos = 11;
framebuffer.mode_info.green_mask_size = 6;
framebuffer.mode_info.green_field_pos = 5;
framebuffer.mode_info.blue_mask_size = 5;
framebuffer.mode_info.blue_field_pos = 0;
break;
case 15:
framebuffer.mode_info.red_mask_size = 5;
framebuffer.mode_info.red_field_pos = 10;
framebuffer.mode_info.green_mask_size = 5;
framebuffer.mode_info.green_field_pos = 5;
framebuffer.mode_info.blue_mask_size = 5;
framebuffer.mode_info.blue_field_pos = 0;
break;
case 32:
framebuffer.mode_info.reserved_mask_size = 8;
framebuffer.mode_info.reserved_field_pos = 24;
case 24:
framebuffer.mode_info.red_mask_size = 8;
framebuffer.mode_info.red_field_pos = 16;
framebuffer.mode_info.green_mask_size = 8;
framebuffer.mode_info.green_field_pos = 8;
framebuffer.mode_info.blue_mask_size = 8;
framebuffer.mode_info.blue_field_pos = 0;
break;
}
framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
if (CIRRUS_APERTURE_SIZE >= 2 * framebuffer.page_size)
err = grub_video_fb_setup (mode_type, mode_mask,
&framebuffer.mode_info,
framebuffer.ptr,
doublebuf_pageflipping_set_page,
framebuffer.ptr + framebuffer.page_size);
else
err = grub_video_fb_setup (mode_type, mode_mask,
&framebuffer.mode_info,
framebuffer.ptr, 0, 0);
/* Copy default palette to initialize emulated palette. */
err = grub_video_cirrus_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
return err;
}
static struct grub_video_adapter grub_video_cirrus_adapter =
{
.name = "Cirrus CLGD 5446 PCI Video Driver",
.id = GRUB_VIDEO_DRIVER_CIRRUS,
.prio = GRUB_VIDEO_ADAPTER_PRIO_NATIVE,
.init = grub_video_cirrus_video_init,
.fini = grub_video_cirrus_video_fini,
.setup = grub_video_cirrus_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_fb_get_info_and_fini,
.set_palette = grub_video_cirrus_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_fb_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_fb_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(video_cirrus)
{
grub_video_register (&grub_video_cirrus_adapter);
}
GRUB_MOD_FINI(video_cirrus)
{
grub_video_unregister (&grub_video_cirrus_adapter);
}

401
grub-core/video/efi_gop.c Normal file
View file

@ -0,0 +1,401 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <grub/efi/api.h>
#include <grub/efi/efi.h>
#include <grub/efi/graphics_output.h>
static grub_efi_guid_t graphics_output_guid = GRUB_EFI_GOP_GUID;
static struct grub_efi_gop *gop;
static unsigned old_mode;
static int restore_needed;
static struct
{
struct grub_video_mode_info mode_info;
struct grub_video_render_target *render_target;
grub_uint8_t *ptr;
} framebuffer;
static int
check_protocol (void)
{
gop = grub_efi_locate_protocol (&graphics_output_guid, 0);
if (gop)
return 1;
return 0;
}
static grub_err_t
grub_video_gop_init (void)
{
grub_memset (&framebuffer, 0, sizeof(framebuffer));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_gop_fini (void)
{
if (restore_needed)
{
efi_call_2 (gop->set_mode, gop, old_mode);
restore_needed = 0;
}
return grub_video_fb_fini ();
}
static int
grub_video_gop_get_bpp (struct grub_efi_gop_mode_info *in)
{
grub_uint32_t total_mask;
int i;
switch (in->pixel_format)
{
case GRUB_EFI_GOT_BGRA8:
case GRUB_EFI_GOT_RGBA8:
return 32;
case GRUB_EFI_GOT_BITMASK:
/* Check overlaps. */
if ((in->pixel_bitmask.r & in->pixel_bitmask.g)
|| (in->pixel_bitmask.r & in->pixel_bitmask.b)
|| (in->pixel_bitmask.g & in->pixel_bitmask.b)
|| (in->pixel_bitmask.r & in->pixel_bitmask.a)
|| (in->pixel_bitmask.g & in->pixel_bitmask.a)
|| (in->pixel_bitmask.b & in->pixel_bitmask.a))
return 0;
total_mask = in->pixel_bitmask.r | in->pixel_bitmask.g
| in->pixel_bitmask.b | in->pixel_bitmask.a;
for (i = 31; i >= 0; i--)
if (total_mask & (1 << i))
return i + 1;
/* Fall through. */
default:
return 0;
}
}
static void
grub_video_gop_get_bitmask (grub_uint32_t mask, unsigned int *mask_size,
unsigned int *field_pos)
{
int i;
int last_p;
for (i = 31; i >= 0; i--)
if (mask & (1 << i))
break;
if (i == -1)
{
*mask_size = *field_pos = 0;
return;
}
last_p = i;
for (; i >= 0; i--)
if (!(mask & (1 << i)))
break;
*field_pos = i + 1;
*mask_size = last_p - *field_pos + 1;
}
static grub_err_t
grub_video_gop_fill_mode_info (struct grub_efi_gop_mode_info *in,
struct grub_video_mode_info *out)
{
out->number_of_colors = 256;
out->width = in->width;
out->height = in->height;
out->mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
out->bpp = grub_video_gop_get_bpp (in);
out->bytes_per_pixel = out->bpp >> 3;
if (!out->bpp)
return grub_error (GRUB_ERR_IO, "unsupported video mode");
out->pitch = in->pixels_per_scanline * out->bytes_per_pixel;
switch (in->pixel_format)
{
case GRUB_EFI_GOT_RGBA8:
out->red_mask_size = 8;
out->red_field_pos = 0;
out->green_mask_size = 8;
out->green_field_pos = 8;
out->blue_mask_size = 8;
out->blue_field_pos = 16;
out->reserved_mask_size = 8;
out->reserved_field_pos = 24;
break;
case GRUB_EFI_GOT_BGRA8:
out->red_mask_size = 8;
out->red_field_pos = 16;
out->green_mask_size = 8;
out->green_field_pos = 8;
out->blue_mask_size = 8;
out->blue_field_pos = 0;
out->reserved_mask_size = 8;
out->reserved_field_pos = 24;
break;
case GRUB_EFI_GOT_BITMASK:
grub_video_gop_get_bitmask (in->pixel_bitmask.r, &out->red_mask_size,
&out->red_field_pos);
grub_video_gop_get_bitmask (in->pixel_bitmask.g, &out->green_mask_size,
&out->green_field_pos);
grub_video_gop_get_bitmask (in->pixel_bitmask.b, &out->blue_mask_size,
&out->blue_field_pos);
grub_video_gop_get_bitmask (in->pixel_bitmask.a, &out->reserved_mask_size,
&out->reserved_field_pos);
break;
default:
return grub_error (GRUB_ERR_IO, "unsupported video mode");
}
out->blit_format = grub_video_get_blit_format (out);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_gop_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask __attribute__ ((unused)))
{
unsigned int depth;
struct grub_efi_gop_mode_info *info = NULL;
unsigned best_mode = 0;
grub_err_t err;
unsigned bpp;
int found = 0;
unsigned long long best_volume = 0;
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
/* Keep current mode if possible. */
if (gop->mode->info)
{
bpp = grub_video_gop_get_bpp (gop->mode->info);
if (bpp && ((width == gop->mode->info->width
&& height == gop->mode->info->height)
|| (width == 0 && height == 0))
&& (depth == bpp || depth == 0))
{
grub_dprintf ("video", "GOP: keeping mode %d\n", gop->mode->mode);
best_mode = gop->mode->mode;
found = 1;
}
}
if (!found)
{
unsigned mode;
grub_dprintf ("video", "GOP: %d modes detected\n", gop->mode->max_mode);
for (mode = 0; mode < gop->mode->max_mode; mode++)
{
grub_efi_uintn_t size;
grub_efi_status_t status;
status = efi_call_4 (gop->query_mode, gop, mode, &size, &info);
if (status)
{
info = 0;
break;
}
grub_dprintf ("video", "GOP: mode %d: %dx%d\n", mode, info->width,
info->height);
bpp = grub_video_gop_get_bpp (info);
if (!bpp)
{
grub_dprintf ("video", "GOP: mode %d: incompatible pixel mode\n",
mode);
continue;
}
grub_dprintf ("video", "GOP: mode %d: depth %d\n", mode, bpp);
if (!(((info->width == width && info->height == height)
|| (width == 0 && height == 0))
&& (bpp == depth || depth == 0)))
{
grub_dprintf ("video", "GOP: mode %d: rejected\n", mode);
continue;
}
if (best_volume < ((unsigned long long) info->width)
* ((unsigned long long) info->height)
* ((unsigned long long) bpp))
{
best_volume = ((unsigned long long) info->width)
* ((unsigned long long) info->height)
* ((unsigned long long) bpp);
best_mode = mode;
}
found = 1;
}
}
if (!found)
{
grub_dprintf ("video", "GOP: no mode found\n");
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
}
if (best_mode != gop->mode->mode)
{
if (!restore_needed)
{
old_mode = gop->mode->mode;
restore_needed = 1;
}
efi_call_2 (gop->set_mode, gop, best_mode);
}
info = gop->mode->info;
err = grub_video_gop_fill_mode_info (info, &framebuffer.mode_info);
if (err)
{
grub_dprintf ("video", "GOP: couldn't fill mode info\n");
return err;
}
framebuffer.ptr = (void *) (grub_addr_t) gop->mode->fb_base;
grub_dprintf ("video", "GOP: initialising FB @ %p %dx%dx%d\n",
framebuffer.ptr, framebuffer.mode_info.width,
framebuffer.mode_info.height, framebuffer.mode_info.bpp);
err = grub_video_fb_create_render_target_from_pointer
(&framebuffer.render_target, &framebuffer.mode_info, framebuffer.ptr);
if (err)
{
grub_dprintf ("video", "GOP: Couldn't create FB target\n");
return err;
}
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
if (err)
{
grub_dprintf ("video", "GOP: Couldn't set FB target\n");
return err;
}
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
if (err)
grub_dprintf ("video", "GOP: Couldn't set palette\n");
else
grub_dprintf ("video", "GOP: Success\n");
return err;
}
static grub_err_t
grub_video_gop_swap_buffers (void)
{
/* TODO: Implement buffer swapping. */
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_gop_set_active_render_target (struct grub_video_render_target *target)
{
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
target = framebuffer.render_target;
return grub_video_fb_set_active_render_target (target);
}
static grub_err_t
grub_video_gop_get_info_and_fini (struct grub_video_mode_info *mode_info,
void **framebuf)
{
grub_memcpy (mode_info, &(framebuffer.mode_info), sizeof (*mode_info));
*framebuf = (char *) framebuffer.ptr;
grub_video_fb_fini ();
return GRUB_ERR_NONE;
}
static struct grub_video_adapter grub_video_gop_adapter =
{
.name = "EFI GOP driver",
.id = GRUB_VIDEO_DRIVER_EFI_GOP,
.prio = GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE,
.init = grub_video_gop_init,
.fini = grub_video_gop_fini,
.setup = grub_video_gop_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_gop_get_info_and_fini,
.set_palette = grub_video_fb_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_gop_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_gop_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(efi_gop)
{
if (check_protocol ())
grub_video_register (&grub_video_gop_adapter);
}
GRUB_MOD_FINI(efi_gop)
{
if (restore_needed)
{
efi_call_2 (gop->set_mode, gop, old_mode);
restore_needed = 0;
}
if (gop)
grub_video_unregister (&grub_video_gop_adapter);
}

341
grub-core/video/efi_uga.c Normal file
View file

@ -0,0 +1,341 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <grub/efi/api.h>
#include <grub/efi/efi.h>
#include <grub/efi/uga_draw.h>
#include <grub/pci.h>
static grub_efi_guid_t uga_draw_guid = GRUB_EFI_UGA_DRAW_GUID;
static struct grub_efi_uga_draw_protocol *uga;
static grub_uint32_t uga_fb;
static grub_uint32_t uga_pitch;
static struct
{
struct grub_video_mode_info mode_info;
struct grub_video_render_target *render_target;
grub_uint8_t *ptr;
} framebuffer;
#define RGB_MASK 0xffffff
#define RGB_MAGIC 0x121314
#define LINE_MIN 800
#define LINE_MAX 4096
#define FBTEST_STEP (0x10000 >> 2)
#define FBTEST_COUNT 8
static int
find_line_len (grub_uint32_t *fb_base, grub_uint32_t *line_len)
{
grub_uint32_t *base = (grub_uint32_t *) (grub_target_addr_t) *fb_base;
int i;
for (i = 0; i < FBTEST_COUNT; i++, base += FBTEST_STEP)
{
if ((*base & RGB_MASK) == RGB_MAGIC)
{
int j;
for (j = LINE_MIN; j <= LINE_MAX; j++)
{
if ((base[j] & RGB_MASK) == RGB_MAGIC)
{
*fb_base = (grub_uint32_t) (grub_target_addr_t) base;
*line_len = j << 2;
return 1;
}
}
break;
}
}
return 0;
}
static int
find_framebuf (grub_uint32_t *fb_base, grub_uint32_t *line_len)
{
int found = 0;
auto int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev,
grub_pci_id_t pciid);
int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev,
grub_pci_id_t pciid)
{
grub_pci_address_t addr;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
if (grub_pci_read (addr) >> 24 == 0x3)
{
int i;
grub_dprintf ("fb", "Display controller: %d:%d.%d\nDevice id: %x\n",
grub_pci_get_bus (dev), grub_pci_get_device (dev),
grub_pci_get_function (dev), pciid);
addr += 8;
for (i = 0; i < 6; i++, addr += 4)
{
grub_uint32_t old_bar1, old_bar2, type;
grub_uint64_t base64;
old_bar1 = grub_pci_read (addr);
if ((! old_bar1) || (old_bar1 & GRUB_PCI_ADDR_SPACE_IO))
continue;
type = old_bar1 & GRUB_PCI_ADDR_MEM_TYPE_MASK;
if (type == GRUB_PCI_ADDR_MEM_TYPE_64)
{
if (i == 5)
break;
old_bar2 = grub_pci_read (addr + 4);
}
else
old_bar2 = 0;
base64 = old_bar2;
base64 <<= 32;
base64 |= (old_bar1 & GRUB_PCI_ADDR_MEM_MASK);
grub_dprintf ("fb", "%s(%d): 0x%llx\n",
((old_bar1 & GRUB_PCI_ADDR_MEM_PREFETCH) ?
"VMEM" : "MMIO"), i,
(unsigned long long) base64);
if ((old_bar1 & GRUB_PCI_ADDR_MEM_PREFETCH) && (! found))
{
*fb_base = base64;
if (find_line_len (fb_base, line_len))
found++;
}
if (type == GRUB_PCI_ADDR_MEM_TYPE_64)
{
i++;
addr += 4;
}
}
}
return found;
}
grub_pci_iterate (find_card);
return found;
}
static int
check_protocol (void)
{
grub_efi_uga_draw_protocol_t *c;
c = grub_efi_locate_protocol (&uga_draw_guid, 0);
if (c)
{
grub_uint32_t width, height, depth, rate, pixel;
int ret;
if (efi_call_5 (c->get_mode, c, &width, &height, &depth, &rate))
return 0;
grub_efi_set_text_mode (0);
pixel = RGB_MAGIC;
efi_call_10 (c->blt, c, (struct grub_efi_uga_pixel *) &pixel,
GRUB_EFI_UGA_VIDEO_FILL, 0, 0, 0, 0, 1, height, 0);
ret = find_framebuf (&uga_fb, &uga_pitch);
grub_efi_set_text_mode (1);
if (ret)
{
uga = c;
return 1;
}
}
return 0;
}
static grub_err_t
grub_video_uga_init (void)
{
grub_memset (&framebuffer, 0, sizeof(framebuffer));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_uga_fini (void)
{
return grub_video_fb_fini ();
}
static grub_err_t
grub_video_uga_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask __attribute__ ((unused)))
{
unsigned int depth;
int found = 0;
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
{
grub_uint32_t w;
grub_uint32_t h;
grub_uint32_t d;
grub_uint32_t r;
if ((! efi_call_5 (uga->get_mode, uga, &w, &h, &d, &r)) &&
((! width) || (width == w)) &&
((! height) || (height == h)) &&
((! depth) || (depth == d)))
{
framebuffer.mode_info.width = w;
framebuffer.mode_info.height = h;
framebuffer.mode_info.pitch = uga_pitch;
framebuffer.ptr = (grub_uint8_t *) (grub_target_addr_t) uga_fb;
found = 1;
}
}
if (found)
{
grub_err_t err;
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
framebuffer.mode_info.bpp = 32;
framebuffer.mode_info.bytes_per_pixel = 4;
framebuffer.mode_info.number_of_colors = 256; /* TODO: fix me. */
framebuffer.mode_info.red_mask_size = 8;
framebuffer.mode_info.red_field_pos = 16;
framebuffer.mode_info.green_mask_size = 8;
framebuffer.mode_info.green_field_pos = 8;
framebuffer.mode_info.blue_mask_size = 8;
framebuffer.mode_info.blue_field_pos = 0;
framebuffer.mode_info.reserved_mask_size = 8;
framebuffer.mode_info.reserved_field_pos = 24;
framebuffer.mode_info.blit_format =
grub_video_get_blit_format (&framebuffer.mode_info);
err = grub_video_fb_create_render_target_from_pointer
(&framebuffer.render_target,
&framebuffer.mode_info,
framebuffer.ptr);
if (err)
return err;
err = grub_video_fb_set_active_render_target
(framebuffer.render_target);
if (err)
return err;
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
return err;
}
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
}
static grub_err_t
grub_video_uga_swap_buffers (void)
{
/* TODO: Implement buffer swapping. */
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_uga_set_active_render_target (struct grub_video_render_target *target)
{
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
target = framebuffer.render_target;
return grub_video_fb_set_active_render_target (target);
}
static grub_err_t
grub_video_uga_get_info_and_fini (struct grub_video_mode_info *mode_info,
void **framebuf)
{
grub_memcpy (mode_info, &(framebuffer.mode_info), sizeof (*mode_info));
*framebuf = (char *) framebuffer.ptr;
grub_video_fb_fini ();
return GRUB_ERR_NONE;
}
static struct grub_video_adapter grub_video_uga_adapter =
{
.name = "EFI UGA driver",
.id = GRUB_VIDEO_DRIVER_EFI_UGA,
.prio = GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE_DIRTY,
.init = grub_video_uga_init,
.fini = grub_video_uga_fini,
.setup = grub_video_uga_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_uga_get_info_and_fini,
.set_palette = grub_video_fb_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_uga_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_uga_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
};
GRUB_MOD_INIT(efi_uga)
{
if (check_protocol ())
grub_video_register (&grub_video_uga_adapter);
}
GRUB_MOD_FINI(efi_uga)
{
if (uga)
grub_video_unregister (&grub_video_uga_adapter);
}

240
grub-core/video/emu/sdl.c Normal file
View file

@ -0,0 +1,240 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <SDL/SDL.h>
static SDL_Surface *window = 0;
static struct grub_video_render_target *sdl_render_target;
static struct grub_video_mode_info mode_info;
static grub_err_t
grub_video_sdl_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data);
static grub_err_t
grub_video_sdl_init (void)
{
window = 0;
if (SDL_Init (SDL_INIT_VIDEO) < 0)
return grub_error (GRUB_ERR_BAD_DEVICE, "Couldn't init SDL: %s",
SDL_GetError ());
grub_memset (&mode_info, 0, sizeof (mode_info));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_sdl_fini (void)
{
SDL_Quit ();
window = 0;
grub_memset (&mode_info, 0, sizeof (mode_info));
return grub_video_fb_fini ();
}
static inline unsigned int
get_mask_size (grub_uint32_t mask)
{
unsigned i;
for (i = 0; mask > 1U << i; i++);
return i;
}
static grub_err_t
grub_video_sdl_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask)
{
int depth;
int flags = 0;
grub_err_t err;
/* Decode depth from mode_type. If it is zero, then autodetect. */
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
if (depth == 0)
depth = 32;
if (width == 0 && height == 0)
{
width = 800;
height = 600;
}
if ((mode_type & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED)
|| !(mode_mask & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED))
flags |= SDL_DOUBLEBUF;
window = SDL_SetVideoMode (width, height, depth, flags | SDL_HWSURFACE);
if (! window)
window = SDL_SetVideoMode (width, height, depth, flags | SDL_SWSURFACE);
if (! window)
return grub_error (GRUB_ERR_BAD_DEVICE, "Couldn't open window: %s",
SDL_GetError ());
grub_memset (&sdl_render_target, 0, sizeof (sdl_render_target));
mode_info.width = window->w;
mode_info.height = window->h;
mode_info.mode_type = 0;
if (window->flags & SDL_DOUBLEBUF)
mode_info.mode_type
|= GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED;
if (window->format->palette)
mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
else
mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_RGB;
mode_info.bpp = window->format->BitsPerPixel;
mode_info.bytes_per_pixel = window->format->BytesPerPixel;
mode_info.pitch = window->pitch;
/* In index color mode, number of colors. In RGB mode this is 256. */
if (window->format->palette)
mode_info.number_of_colors
= 1 << window->format->BitsPerPixel;
else
mode_info.number_of_colors = 256;
if (! window->format->palette)
{
mode_info.red_mask_size
= get_mask_size (window->format->Rmask >> window->format->Rshift);
mode_info.red_field_pos = window->format->Rshift;
mode_info.green_mask_size
= get_mask_size (window->format->Gmask >> window->format->Gshift);
mode_info.green_field_pos = window->format->Gshift;
mode_info.blue_mask_size
= get_mask_size (window->format->Bmask >> window->format->Bshift);
mode_info.blue_field_pos = window->format->Bshift;
mode_info.reserved_mask_size
= get_mask_size (window->format->Amask >> window->format->Ashift);
mode_info.reserved_field_pos = window->format->Ashift;
mode_info.blit_format
= grub_video_get_blit_format (&mode_info);
}
err = grub_video_fb_create_render_target_from_pointer (&sdl_render_target,
&mode_info,
window->pixels);
if (err)
return err;
/* Copy default palette to initialize emulated palette. */
grub_video_sdl_set_palette (0, (sizeof (grub_video_fbstd_colors)
/ sizeof (grub_video_fbstd_colors[0])),
grub_video_fbstd_colors);
/* Reset render target to SDL one. */
return grub_video_fb_set_active_render_target (sdl_render_target);
}
static grub_err_t
grub_video_sdl_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data)
{
unsigned i;
if (window->format->palette)
{
SDL_Color *tmp = grub_malloc (count * sizeof (tmp[0]));
for (i = 0; i < count; i++)
{
tmp[i].r = palette_data[i].r;
tmp[i].g = palette_data[i].g;
tmp[i].b = palette_data[i].b;
tmp[i].unused = palette_data[i].a;
}
SDL_SetColors (window, tmp, start, count);
grub_free (tmp);
}
return grub_video_fb_set_palette (start, count, palette_data);
}
static grub_err_t
grub_video_sdl_swap_buffers (void)
{
if (SDL_Flip (window) < 0)
return grub_error (GRUB_ERR_BAD_DEVICE, "couldn't swap buffers: %s",
SDL_GetError ());
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_sdl_set_active_render_target (struct grub_video_render_target *target)
{
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
return grub_video_fb_set_active_render_target (sdl_render_target);
return grub_video_fb_set_active_render_target (target);
}
static struct grub_video_adapter grub_video_sdl_adapter =
{
.name = "SDL Video Driver",
.id = GRUB_VIDEO_DRIVER_SDL,
.prio = GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE,
.init = grub_video_sdl_init,
.fini = grub_video_sdl_fini,
.setup = grub_video_sdl_setup,
.get_info = grub_video_fb_get_info,
.set_palette = grub_video_sdl_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_sdl_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_sdl_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(sdl)
{
grub_video_register (&grub_video_sdl_adapter);
}
GRUB_MOD_FINI(sdl)
{
grub_video_unregister (&grub_video_sdl_adapter);
}

1420
grub-core/video/fb/fbblit.c Normal file
View file

File diff suppressed because it is too large Load diff

177
grub-core/video/fb/fbfill.c Normal file
View file

@ -0,0 +1,177 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2006,2007,2008 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
/* SPECIAL NOTES!
Please note following when reading the code below:
- In this driver we assume that every memory can be accessed by same memory
bus. If there are different address spaces do not use this code as a base
code for other archs.
- Every function in this code assumes that bounds checking has been done in
previous phase and they are opted out in here. */
#include <grub/video_fb.h>
#include <grub/fbfill.h>
#include <grub/fbutil.h>
#include <grub/types.h>
#include <grub/video.h>
/* Generic filler that works for every supported mode. */
void
grub_video_fbfill (struct grub_video_fbblit_info *dst,
grub_video_color_t color, int x, int y,
int width, int height)
{
int i;
int j;
for (j = 0; j < height; j++)
for (i = 0; i < width; i++)
set_pixel (dst, x + i, y + j, color);
}
/* Optimized filler for direct color 32 bit modes. It is assumed that color
is already mapped to destination format. */
void
grub_video_fbfill_direct32 (struct grub_video_fbblit_info *dst,
grub_video_color_t color, int x, int y,
int width, int height)
{
int i;
int j;
grub_uint32_t *dstptr;
grub_size_t rowskip;
/* Calculate the number of bytes to advance from the end of one line
to the beginning of the next line. */
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
/* Get the start address. */
dstptr = (grub_uint32_t *) grub_video_fb_get_video_ptr (dst, x, y);
for (j = 0; j < height; j++)
{
for (i = 0; i < width; i++)
*dstptr++ = color;
/* Advance the dest pointer to the right location on the next line. */
dstptr = (grub_uint32_t *) (((char *) dstptr) + rowskip);
}
}
/* Optimized filler for direct color 24 bit modes. It is assumed that color
is already mapped to destination format. */
void
grub_video_fbfill_direct24 (struct grub_video_fbblit_info *dst,
grub_video_color_t color, int x, int y,
int width, int height)
{
int i;
int j;
grub_size_t rowskip;
grub_uint8_t *dstptr;
grub_uint8_t fill0 = (grub_uint8_t)((color >> 0) & 0xFF);
grub_uint8_t fill1 = (grub_uint8_t)((color >> 8) & 0xFF);
grub_uint8_t fill2 = (grub_uint8_t)((color >> 16) & 0xFF);
/* Calculate the number of bytes to advance from the end of one line
to the beginning of the next line. */
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
/* Get the start address. */
dstptr = (grub_uint8_t *) grub_video_fb_get_video_ptr (dst, x, y);
for (j = 0; j < height; j++)
{
for (i = 0; i < width; i++)
{
*dstptr++ = fill0;
*dstptr++ = fill1;
*dstptr++ = fill2;
}
/* Advance the dest pointer to the right location on the next line. */
dstptr += rowskip;
}
}
/* Optimized filler for direct color 16 bit modes. It is assumed that color
is already mapped to destination format. */
void
grub_video_fbfill_direct16 (struct grub_video_fbblit_info *dst,
grub_video_color_t color, int x, int y,
int width, int height)
{
int i;
int j;
grub_size_t rowskip;
grub_uint8_t *dstptr;
grub_uint8_t fill0 = (grub_uint8_t)((color >> 0) & 0xFF);
grub_uint8_t fill1 = (grub_uint8_t)((color >> 8) & 0xFF);
/* Calculate the number of bytes to advance from the end of one line
to the beginning of the next line. */
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
/* Get the start address. */
dstptr = (grub_uint8_t *) grub_video_fb_get_video_ptr (dst, x, y);
for (j = 0; j < height; j++)
{
for (i = 0; i < width; i++)
{
*dstptr++ = fill0;
*dstptr++ = fill1;
}
/* Advance the dest pointer to the right location on the next line. */
dstptr += rowskip;
}
}
/* Optimized filler for index color. It is assumed that color
is already mapped to destination format. */
void
grub_video_fbfill_direct8 (struct grub_video_fbblit_info *dst,
grub_video_color_t color, int x, int y,
int width, int height)
{
int i;
int j;
grub_size_t rowskip;
grub_uint8_t *dstptr;
grub_uint8_t fill = (grub_uint8_t)color & 0xFF;
/* Calculate the number of bytes to advance from the end of one line
to the beginning of the next line. */
rowskip = dst->mode_info->pitch - dst->mode_info->bytes_per_pixel * width;
/* Get the start address. */
dstptr = (grub_uint8_t *) grub_video_fb_get_video_ptr (dst, x, y);
for (j = 0; j < height; j++)
{
for (i = 0; i < width; i++)
*dstptr++ = fill;
/* Advance the dest pointer to the right location on the next line. */
dstptr += rowskip;
}
}

178
grub-core/video/fb/fbutil.c Normal file
View file

@ -0,0 +1,178 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2006,2007,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
/* SPECIAL NOTES!
Please note following when reading the code below:
- In this driver we assume that every memory can be accessed by same memory
bus. If there are different address spaces do not use this code as a base
code for other archs.
- Every function in this code assumes that bounds checking has been done in
previous phase and they are opted out in here. */
#include <grub/fbutil.h>
#include <grub/types.h>
#include <grub/video.h>
grub_uint8_t *
grub_video_fb_get_video_ptr (struct grub_video_fbblit_info *source,
unsigned int x, unsigned int y)
{
grub_uint8_t *ptr = 0;
switch (source->mode_info->bpp)
{
case 32:
ptr = source->data + y * source->mode_info->pitch + x * 4;
break;
case 24:
ptr = source->data + y * source->mode_info->pitch + x * 3;
break;
case 16:
case 15:
ptr = source->data + y * source->mode_info->pitch + x * 2;
break;
case 8:
ptr = source->data + y * source->mode_info->pitch + x;
break;
case 1:
/* For 1-bit bitmaps, addressing needs to be done at the bit level
and it doesn't make sense, in general, to ask for a pointer
to a particular pixel's data. */
break;
}
return ptr;
}
grub_video_color_t
get_pixel (struct grub_video_fbblit_info *source,
unsigned int x, unsigned int y)
{
grub_video_color_t color = 0;
switch (source->mode_info->bpp)
{
case 32:
color = *(grub_uint32_t *)grub_video_fb_get_video_ptr (source, x, y);
break;
case 24:
{
grub_uint8_t *ptr;
ptr = grub_video_fb_get_video_ptr (source, x, y);
color = ptr[0] | (ptr[1] << 8) | (ptr[2] << 16);
}
break;
case 16:
case 15:
color = *(grub_uint16_t *)grub_video_fb_get_video_ptr (source, x, y);
break;
case 8:
color = *(grub_uint8_t *)grub_video_fb_get_video_ptr (source, x, y);
break;
case 1:
if (source->mode_info->blit_format == GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED)
{
int bit_index = y * source->mode_info->width + x;
grub_uint8_t *ptr = source->data + bit_index / 8;
int bit_pos = 7 - bit_index % 8;
color = (*ptr >> bit_pos) & 0x01;
}
break;
default:
break;
}
return color;
}
void
set_pixel (struct grub_video_fbblit_info *source,
unsigned int x, unsigned int y, grub_video_color_t color)
{
switch (source->mode_info->bpp)
{
case 32:
{
grub_uint32_t *ptr;
ptr = (grub_uint32_t *)grub_video_fb_get_video_ptr (source, x, y);
*ptr = color;
}
break;
case 24:
{
grub_uint8_t *ptr;
grub_uint8_t *colorptr = (grub_uint8_t *)&color;
ptr = grub_video_fb_get_video_ptr (source, x, y);
ptr[0] = colorptr[0];
ptr[1] = colorptr[1];
ptr[2] = colorptr[2];
}
break;
case 16:
case 15:
{
grub_uint16_t *ptr;
ptr = (grub_uint16_t *)grub_video_fb_get_video_ptr (source, x, y);
*ptr = (grub_uint16_t) (color & 0xFFFF);
}
break;
case 8:
{
grub_uint8_t *ptr;
ptr = (grub_uint8_t *)grub_video_fb_get_video_ptr (source, x, y);
*ptr = (grub_uint8_t) (color & 0xFF);
}
break;
case 1:
if (source->mode_info->blit_format == GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED)
{
int bit_index = y * source->mode_info->width + x;
grub_uint8_t *ptr = source->data + bit_index / 8;
int bit_pos = 7 - bit_index % 8;
*ptr = (*ptr & ~(1 << bit_pos)) | ((color & 0x01) << bit_pos);
}
break;
default:
break;
}
}

1513
grub-core/video/fb/video_fb.c Normal file
View file

File diff suppressed because it is too large Load diff

808
grub-core/video/i386/pc/vbe.c Normal file
View file

@ -0,0 +1,808 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/machine/memory.h>
#include <grub/machine/vga.h>
#include <grub/machine/vbe.h>
#include <grub/video_fb.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/machine/int.h>
static int vbe_detected = -1;
static struct grub_vbe_info_block controller_info;
static struct grub_vbe_mode_info_block active_vbe_mode_info;
/* Track last mode to support cards which fail on get_mode. */
static grub_uint32_t last_set_mode = 3;
static struct
{
struct grub_video_mode_info mode_info;
unsigned int bytes_per_scan_line;
unsigned int bytes_per_pixel;
grub_uint32_t active_vbe_mode;
grub_uint8_t *ptr;
int index_color_mode;
} framebuffer;
static grub_uint32_t initial_vbe_mode;
static grub_uint16_t *vbe_mode_list;
static void *
real2pm (grub_vbe_farptr_t ptr)
{
return (void *) ((((unsigned long) ptr & 0xFFFF0000) >> 12UL)
+ ((unsigned long) ptr & 0x0000FFFF));
}
/* Call VESA BIOS 0x4f09 to set palette data, return status. */
static grub_vbe_status_t
grub_vbe_bios_set_palette_data (grub_uint32_t color_count,
grub_uint32_t start_index,
struct grub_vbe_palette_data *palette_data)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f09;
regs.ebx = 0;
regs.ecx = color_count;
regs.edx = start_index;
regs.es = (((grub_addr_t) palette_data) & 0xffff0000) >> 4;
regs.edi = ((grub_addr_t) palette_data) & 0xffff;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f00 to get VBE Controller Information, return status. */
grub_vbe_status_t
grub_vbe_bios_get_controller_info (struct grub_vbe_info_block *ci)
{
struct grub_bios_int_registers regs;
/* Store *controller_info to %es:%di. */
regs.es = (((grub_addr_t) ci) & 0xffff0000) >> 4;
regs.edi = ((grub_addr_t) ci) & 0xffff;
regs.eax = 0x4f00;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f01 to get VBE Mode Information, return status. */
grub_vbe_status_t
grub_vbe_bios_get_mode_info (grub_uint32_t mode,
struct grub_vbe_mode_info_block *mode_info)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f01;
regs.ecx = mode;
/* Store *mode_info to %es:%di. */
regs.es = ((grub_addr_t) mode_info & 0xffff0000) >> 4;
regs.edi = (grub_addr_t) mode_info & 0x0000ffff;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f02 to set video mode, return status. */
static grub_vbe_status_t
grub_vbe_bios_set_mode (grub_uint32_t mode,
struct grub_vbe_crtc_info_block *crtc_info)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f02;
regs.ebx = mode;
/* Store *crtc_info to %es:%di. */
regs.es = (((grub_addr_t) crtc_info) & 0xffff0000) >> 4;
regs.edi = ((grub_addr_t) crtc_info) & 0xffff;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f03 to return current VBE Mode, return status. */
grub_vbe_status_t
grub_vbe_bios_get_mode (grub_uint32_t *mode)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f03;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
*mode = regs.ebx & 0xffff;
return regs.eax & 0xffff;
}
grub_vbe_status_t
grub_vbe_bios_getset_dac_palette_width (int set, int *dac_mask_size)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f08;
regs.ebx = (*dac_mask_size & 0xff) >> 8;
regs.ebx = set ? 1 : 0;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
*dac_mask_size = (regs.ebx >> 8) & 0xff;
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f05 to set memory window, return status. */
grub_vbe_status_t
grub_vbe_bios_set_memory_window (grub_uint32_t window,
grub_uint32_t position)
{
struct grub_bios_int_registers regs;
/* BL = window, BH = 0, Set memory window. */
regs.ebx = window & 0x00ff;
regs.edx = position;
regs.eax = 0x4f05;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f05 to return memory window, return status. */
grub_vbe_status_t
grub_vbe_bios_get_memory_window (grub_uint32_t window,
grub_uint32_t *position)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f05;
/* BH = 1, Get memory window. BL = window. */
regs.ebx = (window & 0x00ff) | 0x100;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
*position = regs.edx & 0xffff;
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f06 to set scanline length (in bytes), return status. */
grub_vbe_status_t
grub_vbe_bios_set_scanline_length (grub_uint32_t length)
{
struct grub_bios_int_registers regs;
regs.ecx = length;
regs.eax = 0x4f06;
/* BL = 2, Set Scan Line in Bytes. */
regs.ebx = 0x0002;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f06 to return scanline length (in bytes), return status. */
grub_vbe_status_t
grub_vbe_bios_get_scanline_length (grub_uint32_t *length)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f06;
regs.ebx = 0x0001;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
/* BL = 1, Get Scan Line Length (in bytes). */
grub_bios_interrupt (0x10, &regs);
*length = regs.ebx & 0xffff;
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f07 to set display start, return status. */
static grub_vbe_status_t
grub_vbe_bios_set_display_start (grub_uint32_t x, grub_uint32_t y)
{
struct grub_bios_int_registers regs;
/* Store x in %ecx. */
regs.ecx = x;
regs.edx = y;
regs.eax = 0x4f07;
/* BL = 80h, Set Display Start during Vertical Retrace. */
regs.ebx = 0x0080;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return regs.eax & 0xffff;
}
/* Call VESA BIOS 0x4f07 to get display start, return status. */
grub_vbe_status_t
grub_vbe_bios_get_display_start (grub_uint32_t *x,
grub_uint32_t *y)
{
struct grub_bios_int_registers regs;
regs.eax = 0x4f07;
/* BL = 1, Get Display Start. */
regs.ebx = 0x0001;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
*x = regs.ecx & 0xffff;
*y = regs.edx & 0xffff;
return regs.eax & 0xffff;
}
grub_err_t
grub_vbe_probe (struct grub_vbe_info_block *info_block)
{
struct grub_vbe_info_block *vbe_ib;
grub_vbe_status_t status;
/* Clear caller's controller info block. */
if (info_block)
grub_memset (info_block, 0, sizeof (*info_block));
/* Do not probe more than one time, if not necessary. */
if (vbe_detected == -1 || info_block)
{
/* Clear old copy of controller info block. */
grub_memset (&controller_info, 0, sizeof (controller_info));
/* Mark VESA BIOS extension as undetected. */
vbe_detected = 0;
/* Use low memory scratch area as temporary storage
for VESA BIOS call. */
vbe_ib = (struct grub_vbe_info_block *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
/* Prepare info block. */
grub_memset (vbe_ib, 0, sizeof (*vbe_ib));
vbe_ib->signature[0] = 'V';
vbe_ib->signature[1] = 'B';
vbe_ib->signature[2] = 'E';
vbe_ib->signature[3] = '2';
/* Try to get controller info block. */
status = grub_vbe_bios_get_controller_info (vbe_ib);
if (status == GRUB_VBE_STATUS_OK)
{
/* Copy it for later usage. */
grub_memcpy (&controller_info, vbe_ib, sizeof (controller_info));
/* Mark VESA BIOS extension as detected. */
vbe_detected = 1;
}
}
if (! vbe_detected)
return grub_error (GRUB_ERR_BAD_DEVICE, "VESA BIOS Extension not found");
/* Make copy of controller info block to caller. */
if (info_block)
grub_memcpy (info_block, &controller_info, sizeof (*info_block));
return GRUB_ERR_NONE;
}
grub_err_t
grub_vbe_set_video_mode (grub_uint32_t vbe_mode,
struct grub_vbe_mode_info_block *vbe_mode_info)
{
grub_vbe_status_t status;
grub_uint32_t old_vbe_mode;
struct grub_vbe_mode_info_block new_vbe_mode_info;
grub_err_t err;
/* Make sure that VBE is supported. */
grub_vbe_probe (0);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
/* Try to get mode info. */
grub_vbe_get_video_mode_info (vbe_mode, &new_vbe_mode_info);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
/* For all VESA BIOS modes, force linear frame buffer. */
if (vbe_mode >= 0x100)
{
/* We only want linear frame buffer modes. */
vbe_mode |= 1 << 14;
/* Determine frame buffer pixel format. */
switch (new_vbe_mode_info.memory_model)
{
case GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL:
framebuffer.index_color_mode = 1;
break;
case GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR:
framebuffer.index_color_mode = 0;
break;
default:
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
"unsupported pixel format 0x%x",
new_vbe_mode_info.memory_model);
}
}
/* Get current mode. */
grub_vbe_get_video_mode (&old_vbe_mode);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
/* Try to set video mode. */
status = grub_vbe_bios_set_mode (vbe_mode, 0);
if (status != GRUB_VBE_STATUS_OK)
return grub_error (GRUB_ERR_BAD_DEVICE, "cannot set VBE mode %x", vbe_mode);
last_set_mode = vbe_mode;
/* Save information for later usage. */
framebuffer.active_vbe_mode = vbe_mode;
grub_memcpy (&active_vbe_mode_info, &new_vbe_mode_info, sizeof (active_vbe_mode_info));
if (vbe_mode < 0x100)
{
/* If this is not a VESA mode, guess address. */
framebuffer.ptr = (grub_uint8_t *) GRUB_MEMORY_MACHINE_VGA_ADDR;
framebuffer.index_color_mode = 1;
}
else
{
framebuffer.ptr = (grub_uint8_t *) new_vbe_mode_info.phys_base_addr;
if (controller_info.version >= 0x300)
framebuffer.bytes_per_scan_line = new_vbe_mode_info.lin_bytes_per_scan_line;
else
framebuffer.bytes_per_scan_line = new_vbe_mode_info.bytes_per_scan_line;
}
/* Check whether mode is text mode or graphics mode. */
if (new_vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_TEXT)
{
/* Text mode. */
/* No special action needed for text mode as it is not supported for
graphical support. */
}
else
{
/* Graphics mode. */
/* Calculate bytes_per_pixel value. */
switch(new_vbe_mode_info.bits_per_pixel)
{
case 32: framebuffer.bytes_per_pixel = 4; break;
case 24: framebuffer.bytes_per_pixel = 3; break;
case 16: framebuffer.bytes_per_pixel = 2; break;
case 15: framebuffer.bytes_per_pixel = 2; break;
case 8: framebuffer.bytes_per_pixel = 1; break;
default:
grub_vbe_bios_set_mode (old_vbe_mode, 0);
last_set_mode = old_vbe_mode;
return grub_error (GRUB_ERR_BAD_DEVICE,
"cannot set VBE mode %x",
vbe_mode);
break;
}
/* If video mode is in indexed color, setup default VGA palette. */
if (framebuffer.index_color_mode)
{
struct grub_vbe_palette_data *palette
= (struct grub_vbe_palette_data *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
unsigned i;
/* Make sure that the BIOS can reach the palette. */
for (i = 0; i < GRUB_VIDEO_FBSTD_NUMCOLORS; i++)
{
palette[i].red = grub_video_fbstd_colors[i].r;
palette[i].green = grub_video_fbstd_colors[i].g;
palette[i].blue = grub_video_fbstd_colors[i].b;
palette[i].alignment = 0;
}
status = grub_vbe_bios_set_palette_data (GRUB_VIDEO_FBSTD_NUMCOLORS,
0, palette);
/* Just ignore the status. */
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
if (err)
return err;
}
}
/* Copy mode info for caller. */
if (vbe_mode_info)
grub_memcpy (vbe_mode_info, &new_vbe_mode_info, sizeof (*vbe_mode_info));
return GRUB_ERR_NONE;
}
grub_err_t
grub_vbe_get_video_mode (grub_uint32_t *mode)
{
grub_vbe_status_t status;
/* Make sure that VBE is supported. */
grub_vbe_probe (0);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
/* Try to query current mode from VESA BIOS. */
status = grub_vbe_bios_get_mode (mode);
/* XXX: ATI cards don't support get_mode. */
if (status != GRUB_VBE_STATUS_OK)
*mode = last_set_mode;
return GRUB_ERR_NONE;
}
grub_err_t
grub_vbe_get_video_mode_info (grub_uint32_t mode,
struct grub_vbe_mode_info_block *mode_info)
{
struct grub_vbe_mode_info_block *mi_tmp
= (struct grub_vbe_mode_info_block *) GRUB_MEMORY_MACHINE_SCRATCH_ADDR;
grub_vbe_status_t status;
/* Make sure that VBE is supported. */
grub_vbe_probe (0);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
/* If mode is not VESA mode, skip mode info query. */
if (mode >= 0x100)
{
/* Try to get mode info from VESA BIOS. */
status = grub_vbe_bios_get_mode_info (mode, mi_tmp);
if (status != GRUB_VBE_STATUS_OK)
return grub_error (GRUB_ERR_BAD_DEVICE,
"cannot get information on the mode %x", mode);
/* Make copy of mode info block. */
grub_memcpy (mode_info, mi_tmp, sizeof (*mode_info));
}
else
/* Just clear mode info block if it isn't a VESA mode. */
grub_memset (mode_info, 0, sizeof (*mode_info));
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_vbe_init (void)
{
grub_uint16_t *rm_vbe_mode_list;
grub_uint16_t *p;
grub_size_t vbe_mode_list_size;
struct grub_vbe_info_block info_block;
/* Check if there is adapter present.
Firmware note: There has been a report that some cards store video mode
list in temporary memory. So we must first use vbe probe to get
refreshed information to receive valid pointers and data, and then
copy this information to somewhere safe. */
grub_vbe_probe (&info_block);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
/* Copy modelist to local memory. */
p = rm_vbe_mode_list = real2pm (info_block.video_mode_ptr);
while(*p++ != 0xFFFF)
;
vbe_mode_list_size = (grub_addr_t) p - (grub_addr_t) rm_vbe_mode_list;
vbe_mode_list = grub_malloc (vbe_mode_list_size);
if (! vbe_mode_list)
return grub_errno;
grub_memcpy (vbe_mode_list, rm_vbe_mode_list, vbe_mode_list_size);
/* Adapter could be found, figure out initial video mode. */
grub_vbe_get_video_mode (&initial_vbe_mode);
if (grub_errno != GRUB_ERR_NONE)
{
/* Free allocated resources. */
grub_free (vbe_mode_list);
vbe_mode_list = NULL;
return grub_errno;
}
/* Reset frame buffer. */
grub_memset (&framebuffer, 0, sizeof(framebuffer));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_vbe_fini (void)
{
grub_vbe_status_t status;
grub_err_t err;
/* Restore old video mode. */
status = grub_vbe_bios_set_mode (initial_vbe_mode, 0);
if (status != GRUB_VBE_STATUS_OK)
/* TODO: Decide, is this something we want to do. */
return grub_errno;
last_set_mode = initial_vbe_mode;
/* TODO: Free any resources allocated by driver. */
grub_free (vbe_mode_list);
vbe_mode_list = NULL;
err = grub_video_fb_fini ();
return err;
}
/*
Set framebuffer render target page and display the proper page, based on
`doublebuf_state.render_page' and `doublebuf_state.displayed_page',
respectively.
*/
static grub_err_t
doublebuf_pageflipping_set_page (int page)
{
/* Tell the video adapter to display the new front page. */
int display_start_line
= framebuffer.mode_info.height * page;
grub_vbe_status_t vbe_err =
grub_vbe_bios_set_display_start (0, display_start_line);
if (vbe_err != GRUB_VBE_STATUS_OK)
return grub_error (GRUB_ERR_IO, "couldn't commit pageflip");
return 0;
}
static grub_err_t
grub_video_vbe_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask)
{
grub_uint16_t *p;
struct grub_vbe_mode_info_block vbe_mode_info;
struct grub_vbe_mode_info_block best_vbe_mode_info;
grub_uint32_t best_vbe_mode = 0;
int depth;
/* Decode depth from mode_type. If it is zero, then autodetect. */
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
/* Walk thru mode list and try to find matching mode. */
for (p = vbe_mode_list; *p != 0xFFFF; p++)
{
grub_uint32_t vbe_mode = *p;
grub_vbe_get_video_mode_info (vbe_mode, &vbe_mode_info);
if (grub_errno != GRUB_ERR_NONE)
{
/* Could not retrieve mode info, retreat. */
grub_errno = GRUB_ERR_NONE;
break;
}
if ((vbe_mode_info.mode_attributes & 0x001) == 0)
/* If not available, skip it. */
continue;
if ((vbe_mode_info.mode_attributes & 0x008) == 0)
/* Monochrome is unusable. */
continue;
if ((vbe_mode_info.mode_attributes & 0x080) == 0)
/* We support only linear frame buffer modes. */
continue;
if ((vbe_mode_info.mode_attributes & 0x010) == 0)
/* We allow only graphical modes. */
continue;
if ((vbe_mode_info.memory_model != GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL)
&& (vbe_mode_info.memory_model != GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR))
/* Not compatible memory model. */
continue;
if (((vbe_mode_info.x_resolution != width)
|| (vbe_mode_info.y_resolution != height)) && width != 0 && height != 0)
/* Non matching resolution. */
continue;
/* Check if user requested RGB or index color mode. */
if ((mode_mask & GRUB_VIDEO_MODE_TYPE_COLOR_MASK) != 0)
{
unsigned my_mode_type = 0;
if (vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL)
my_mode_type |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
if (vbe_mode_info.memory_model == GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR)
my_mode_type |= GRUB_VIDEO_MODE_TYPE_RGB;
if ((my_mode_type & mode_mask
& (GRUB_VIDEO_MODE_TYPE_RGB | GRUB_VIDEO_MODE_TYPE_INDEX_COLOR))
!= (mode_type & mode_mask
& (GRUB_VIDEO_MODE_TYPE_RGB
| GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)))
continue;
}
/* If there is a request for specific depth, ignore others. */
if ((depth != 0) && (vbe_mode_info.bits_per_pixel != depth))
continue;
/* Select mode with most of "volume" (size of framebuffer in bits). */
if (best_vbe_mode != 0)
if ((grub_uint64_t) vbe_mode_info.bits_per_pixel
* vbe_mode_info.x_resolution * vbe_mode_info.y_resolution
< (grub_uint64_t) best_vbe_mode_info.bits_per_pixel
* best_vbe_mode_info.x_resolution * best_vbe_mode_info.y_resolution)
continue;
/* Save so far best mode information for later use. */
best_vbe_mode = vbe_mode;
grub_memcpy (&best_vbe_mode_info, &vbe_mode_info, sizeof (vbe_mode_info));
}
/* Try to initialize best mode found. */
if (best_vbe_mode != 0)
{
grub_err_t err;
/* If this fails, then we have mode selection heuristics problem,
or adapter failure. */
/* grub_vbe_set_video_mode already sets active_vbe_mode_info. */
grub_vbe_set_video_mode (best_vbe_mode, NULL);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
/* Fill mode info details. */
framebuffer.mode_info.width = active_vbe_mode_info.x_resolution;
framebuffer.mode_info.height = active_vbe_mode_info.y_resolution;
if (framebuffer.index_color_mode)
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
else
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
framebuffer.mode_info.bpp = active_vbe_mode_info.bits_per_pixel;
framebuffer.mode_info.bytes_per_pixel = framebuffer.bytes_per_pixel;
framebuffer.mode_info.pitch = framebuffer.bytes_per_scan_line;
framebuffer.mode_info.number_of_colors = 256; /* TODO: fix me. */
framebuffer.mode_info.red_mask_size = active_vbe_mode_info.red_mask_size;
framebuffer.mode_info.red_field_pos = active_vbe_mode_info.red_field_position;
framebuffer.mode_info.green_mask_size = active_vbe_mode_info.green_mask_size;
framebuffer.mode_info.green_field_pos = active_vbe_mode_info.green_field_position;
framebuffer.mode_info.blue_mask_size = active_vbe_mode_info.blue_mask_size;
framebuffer.mode_info.blue_field_pos = active_vbe_mode_info.blue_field_position;
framebuffer.mode_info.reserved_mask_size = active_vbe_mode_info.rsvd_mask_size;
framebuffer.mode_info.reserved_field_pos = active_vbe_mode_info.rsvd_field_position;
framebuffer.mode_info.blit_format = grub_video_get_blit_format (&framebuffer.mode_info);
{
/* Get video RAM size in bytes. */
grub_size_t vram_size = controller_info.total_memory << 16;
grub_size_t page_size; /* The size of a page in bytes. */
page_size = framebuffer.mode_info.pitch * framebuffer.mode_info.height;
if (vram_size >= 2 * page_size)
err = grub_video_fb_setup (mode_type, mode_mask,
&framebuffer.mode_info,
framebuffer.ptr,
doublebuf_pageflipping_set_page,
framebuffer.ptr + page_size);
else
err = grub_video_fb_setup (mode_type, mode_mask,
&framebuffer.mode_info,
framebuffer.ptr, 0, 0);
}
/* Copy default palette to initialize emulated palette. */
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
return err;
}
/* Couldn't found matching mode. */
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
}
static grub_err_t
grub_video_vbe_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data)
{
if (framebuffer.index_color_mode)
{
/* TODO: Implement setting indexed color mode palette to hardware. */
//status = grub_vbe_bios_set_palette_data (sizeof (vga_colors)
// / sizeof (struct grub_vbe_palette_data),
// 0,
// palette);
}
/* Then set color to emulated palette. */
return grub_video_fb_set_palette (start, count, palette_data);
}
static grub_err_t
grub_video_vbe_get_info_and_fini (struct grub_video_mode_info *mode_info,
void **framebuf)
{
grub_free (vbe_mode_list);
vbe_mode_list = NULL;
return grub_video_fb_get_info_and_fini (mode_info, framebuf);
}
static struct grub_video_adapter grub_video_vbe_adapter =
{
.name = "VESA BIOS Extension Video Driver",
.id = GRUB_VIDEO_DRIVER_VBE,
.prio = GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE,
.init = grub_video_vbe_init,
.fini = grub_video_vbe_fini,
.setup = grub_video_vbe_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_vbe_get_info_and_fini,
.set_palette = grub_video_vbe_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_fb_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_fb_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(video_i386_pc_vbe)
{
grub_video_register (&grub_video_vbe_adapter);
}
GRUB_MOD_FINI(video_i386_pc_vbe)
{
grub_video_unregister (&grub_video_vbe_adapter);
}

387
grub-core/video/i386/pc/vga.c Normal file
View file

@ -0,0 +1,387 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2000,2001,2002,2003,2004,2005,2007,2008,2009,2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/machine/vga.h>
#include <grub/machine/int.h>
#include <grub/machine/console.h>
#include <grub/cpu/io.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/vga.h>
#define VGA_WIDTH 640
#define VGA_HEIGHT 350
#define VGA_MEM ((grub_uint8_t *) GRUB_MEMORY_MACHINE_VGA_ADDR)
#define PAGE_OFFSET(x) ((x) * (VGA_WIDTH * VGA_HEIGHT / 8))
static unsigned char text_mode;
static unsigned char saved_map_mask;
static struct
{
struct grub_video_mode_info mode_info;
struct grub_video_render_target *render_target;
grub_uint8_t *temporary_buffer;
int front_page;
int back_page;
} framebuffer;
static unsigned char
grub_vga_set_mode (unsigned char mode)
{
struct grub_bios_int_registers regs;
unsigned char ret;
/* get current mode */
regs.eax = 0x0f00;
regs.ebx = 0;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
ret = regs.eax & 0xff;
regs.eax = mode;
regs.flags = GRUB_CPU_INT_FLAGS_DEFAULT;
grub_bios_interrupt (0x10, &regs);
return ret;
}
static inline void
wait_vretrace (void)
{
/* Wait until there is a vertical retrace. */
while (! (grub_inb (GRUB_VGA_IO_INPUT_STATUS1_REGISTER)
& GRUB_VGA_IO_INPUT_STATUS1_VERTR_BIT));
}
/* Get Map Mask Register. */
static unsigned char
get_map_mask (void)
{
return grub_vga_sr_read (GRUB_VGA_SR_MAP_MASK_REGISTER);
}
/* Set Map Mask Register. */
static void
set_map_mask (unsigned char mask)
{
grub_vga_sr_write (mask, GRUB_VGA_SR_MAP_MASK_REGISTER);
}
#if 0
/* Set Read Map Register. */
static void
set_read_map (unsigned char map)
{
grub_vga_gr_write (map, GRUB_VGA_GR_READ_MAP_REGISTER);
}
#endif
/* Set start address. */
static void
set_start_address (unsigned int start)
{
grub_vga_cr_write (start & 0xFF, GRUB_VGA_CR_START_ADDR_LOW_REGISTER);
grub_vga_cr_write (start >> 8, GRUB_VGA_CR_START_ADDR_HIGH_REGISTER);
}
static int setup = 0;
static int is_target = 0;
static grub_err_t
grub_video_vga_init (void)
{
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_vga_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask)
{
grub_err_t err;
if ((width && width != VGA_WIDTH) || (height && height != VGA_HEIGHT))
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no matching mode found");
framebuffer.temporary_buffer = grub_malloc (VGA_HEIGHT * VGA_WIDTH);
framebuffer.front_page = 0;
framebuffer.back_page = 0;
if (!framebuffer.temporary_buffer)
return grub_errno;
saved_map_mask = get_map_mask ();
text_mode = grub_vga_set_mode (0x10);
setup = 1;
set_map_mask (0x0f);
set_start_address (PAGE_OFFSET (framebuffer.front_page));
framebuffer.mode_info.width = VGA_WIDTH;
framebuffer.mode_info.height = VGA_HEIGHT;
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
if (grub_video_check_mode_flag (mode_type, mode_mask,
GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED, 1))
{
framebuffer.back_page = 1;
framebuffer.mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED;
}
framebuffer.mode_info.bpp = 8;
framebuffer.mode_info.bytes_per_pixel = 1;
framebuffer.mode_info.pitch = VGA_WIDTH;
framebuffer.mode_info.number_of_colors = 16;
framebuffer.mode_info.red_mask_size = 0;
framebuffer.mode_info.red_field_pos = 0;
framebuffer.mode_info.green_mask_size = 0;
framebuffer.mode_info.green_field_pos = 0;
framebuffer.mode_info.blue_mask_size = 0;
framebuffer.mode_info.blue_field_pos = 0;
framebuffer.mode_info.reserved_mask_size = 0;
framebuffer.mode_info.reserved_field_pos = 0;
framebuffer.mode_info.blit_format
= grub_video_get_blit_format (&framebuffer.mode_info);
err = grub_video_fb_create_render_target_from_pointer (&framebuffer.render_target,
&framebuffer.mode_info,
framebuffer.temporary_buffer);
if (err)
{
grub_dprintf ("video", "Couldn't create FB target\n");
return err;
}
is_target = 1;
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
if (err)
return err;
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_vga_fini (void)
{
if (setup)
{
set_map_mask (saved_map_mask);
grub_vga_set_mode (text_mode);
}
setup = 0;
grub_free (framebuffer.temporary_buffer);
framebuffer.temporary_buffer = 0;
return GRUB_ERR_NONE;
}
static inline void
update_target (void)
{
int plane;
if (!is_target)
return;
for (plane = 0x01; plane <= 0x08; plane <<= 1)
{
grub_uint8_t *ptr;
volatile grub_uint8_t *ptr2;
unsigned cbyte = 0;
int shift = 7;
set_map_mask (plane);
for (ptr = framebuffer.temporary_buffer,
ptr2 = VGA_MEM + PAGE_OFFSET (framebuffer.back_page);
ptr < framebuffer.temporary_buffer + VGA_WIDTH * VGA_HEIGHT; ptr++)
{
cbyte |= (!!(plane & *ptr)) << shift;
shift--;
if (shift == -1)
{
*ptr2++ = cbyte;
shift = 7;
cbyte = 0;
}
}
}
}
static grub_err_t
grub_video_vga_blit_bitmap (struct grub_video_bitmap *bitmap,
enum grub_video_blit_operators oper, int x, int y,
int offset_x, int offset_y,
unsigned int width, unsigned int height)
{
grub_err_t ret;
ret = grub_video_fb_blit_bitmap (bitmap, oper, x, y, offset_x, offset_y,
width, height);
update_target ();
return ret;
}
static grub_err_t
grub_video_vga_blit_render_target (struct grub_video_fbrender_target *source,
enum grub_video_blit_operators oper,
int x, int y, int offset_x, int offset_y,
unsigned int width, unsigned int height)
{
grub_err_t ret;
ret = grub_video_fb_blit_render_target (source, oper, x, y,
offset_x, offset_y, width, height);
update_target ();
return ret;
}
static grub_err_t
grub_video_vga_set_active_render_target (struct grub_video_render_target *target)
{
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
{
is_target = 1;
target = framebuffer.render_target;
}
else
is_target = 0;
return grub_video_fb_set_active_render_target (target);
}
static grub_err_t
grub_video_vga_get_active_render_target (struct grub_video_render_target **target)
{
grub_err_t err;
err = grub_video_fb_get_active_render_target (target);
if (err)
return err;
if (*target == framebuffer.render_target)
*target = GRUB_VIDEO_RENDER_TARGET_DISPLAY;
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_vga_swap_buffers (void)
{
if (!(framebuffer.mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED))
return GRUB_ERR_NONE;
/* Activate the other page. */
framebuffer.front_page = !framebuffer.front_page;
framebuffer.back_page = !framebuffer.back_page;
wait_vretrace ();
set_start_address (PAGE_OFFSET (framebuffer.front_page));
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_vga_set_palette (unsigned int start __attribute__ ((unused)),
unsigned int count __attribute__ ((unused)),
struct grub_video_palette_data *palette_data __attribute__ ((unused)))
{
return grub_error (GRUB_ERR_IO, "can't change palette");
}
static grub_err_t
grub_video_vga_get_info_and_fini (struct grub_video_mode_info *mode_info,
void **framebuf)
{
set_map_mask (0xf);
grub_memcpy (mode_info, &(framebuffer.mode_info), sizeof (*mode_info));
mode_info->bpp = 1;
mode_info->bytes_per_pixel = 0;
mode_info->pitch = VGA_WIDTH / 8;
mode_info->number_of_colors = 1;
mode_info->bg_red = 0;
mode_info->bg_green = 0;
mode_info->bg_blue = 0;
mode_info->bg_alpha = 255;
mode_info->fg_red = 255;
mode_info->fg_green = 255;
mode_info->fg_blue = 255;
mode_info->fg_alpha = 255;
*framebuf = VGA_MEM + PAGE_OFFSET (framebuffer.front_page);
grub_video_fb_fini ();
grub_free (framebuffer.temporary_buffer);
framebuffer.temporary_buffer = 0;
setup = 0;
return GRUB_ERR_NONE;
}
static struct grub_video_adapter grub_video_vga_adapter =
{
.name = "VGA Video Driver",
.id = GRUB_VIDEO_DRIVER_VGA,
.prio = GRUB_VIDEO_ADAPTER_PRIO_FALLBACK,
.init = grub_video_vga_init,
.fini = grub_video_vga_fini,
.setup = grub_video_vga_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_vga_get_info_and_fini,
.set_palette = grub_video_vga_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_vga_blit_bitmap,
.blit_render_target = grub_video_vga_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_vga_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_vga_set_active_render_target,
.get_active_render_target = grub_video_vga_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(vga)
{
grub_video_register (&grub_video_vga_adapter);
}
GRUB_MOD_FINI(vga)
{
grub_video_unregister (&grub_video_vga_adapter);
}

302
grub-core/video/ieee1275.c Normal file
View file

@ -0,0 +1,302 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <grub/ieee1275/ieee1275.h>
/* Only 8-bit indexed color is supported for now. */
static unsigned old_width, old_height;
static int restore_needed;
static char *display;
static struct
{
struct grub_video_mode_info mode_info;
struct grub_video_render_target *render_target;
grub_uint8_t *ptr;
} framebuffer;
static grub_err_t
grub_video_ieee1275_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data);
static void
set_video_mode (unsigned width __attribute__ ((unused)),
unsigned height __attribute__ ((unused)))
{
/* TODO */
}
static void
find_display (void)
{
auto int hook (struct grub_ieee1275_devalias *alias);
int hook (struct grub_ieee1275_devalias *alias)
{
if (grub_strcmp (alias->type, "display") == 0)
{
grub_dprintf ("video", "Found display %s\n", alias->path);
display = grub_strdup (alias->path);
return 1;
}
return 0;
}
grub_ieee1275_devices_iterate (hook);
}
static grub_err_t
grub_video_ieee1275_init (void)
{
grub_memset (&framebuffer, 0, sizeof(framebuffer));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_ieee1275_fini (void)
{
if (restore_needed)
{
set_video_mode (old_width, old_height);
restore_needed = 0;
}
return grub_video_fb_fini ();
}
static grub_err_t
grub_video_ieee1275_fill_mode_info (grub_ieee1275_phandle_t dev,
struct grub_video_mode_info *out)
{
grub_uint32_t tmp;
grub_memset (out, 0, sizeof (*out));
if (grub_ieee1275_get_integer_property (dev, "width", &tmp,
sizeof (tmp), 0))
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display width.");
out->width = tmp;
if (grub_ieee1275_get_integer_property (dev, "height", &tmp,
sizeof (tmp), 0))
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display height.");
out->height = tmp;
if (grub_ieee1275_get_integer_property (dev, "linebytes", &tmp,
sizeof (tmp), 0))
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display pitch.");
out->pitch = tmp;
out->mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
out->bpp = 8;
out->bytes_per_pixel = 1;
out->number_of_colors = 256;
out->blit_format = grub_video_get_blit_format (out);
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_ieee1275_setup (unsigned int width, unsigned int height,
unsigned int mode_type __attribute__ ((unused)),
unsigned int mode_mask __attribute__ ((unused)))
{
grub_uint32_t current_width, current_height, address;
grub_err_t err;
grub_ieee1275_phandle_t dev;
if (!display)
return grub_error (GRUB_ERR_IO, "Couldn't find display device.");
if (grub_ieee1275_finddevice (display, &dev))
return grub_error (GRUB_ERR_IO, "Couldn't open display device.");
if (grub_ieee1275_get_integer_property (dev, "width", &current_width,
sizeof (current_width), 0))
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display width.");
if (grub_ieee1275_get_integer_property (dev, "height", &current_height,
sizeof (current_width), 0))
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display height.");
if ((width == current_width && height == current_height)
|| (width == 0 && height == 0))
{
grub_dprintf ("video", "IEEE1275: keeping current mode %dx%d\n",
current_width, current_height);
}
else
{
grub_dprintf ("video", "IEEE1275: Setting mode %dx%d\n", width, height);
/* TODO. */
return grub_error (GRUB_ERR_IO, "can't set mode %dx%d", width, height);
}
err = grub_video_ieee1275_fill_mode_info (dev, &framebuffer.mode_info);
if (err)
{
grub_dprintf ("video", "IEEE1275: couldn't fill mode info\n");
return err;
}
if (grub_ieee1275_get_integer_property (dev, "address", (void *) &address,
sizeof (address), 0))
return grub_error (GRUB_ERR_IO, "Couldn't retrieve display address.");
/* For some reason sparc64 uses 32-bit pointer too. */
framebuffer.ptr = (void *) (grub_addr_t) address;
grub_video_ieee1275_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
grub_dprintf ("video", "IEEE1275: initialising FB @ %p %dx%dx%d\n",
framebuffer.ptr, framebuffer.mode_info.width,
framebuffer.mode_info.height, framebuffer.mode_info.bpp);
err = grub_video_fb_create_render_target_from_pointer
(&framebuffer.render_target, &framebuffer.mode_info, framebuffer.ptr);
if (err)
{
grub_dprintf ("video", "IEEE1275: Couldn't create FB target\n");
return err;
}
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
if (err)
{
grub_dprintf ("video", "IEEE1275: Couldn't set FB target\n");
return err;
}
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
if (err)
grub_dprintf ("video", "IEEE1275: Couldn't set palette\n");
else
grub_dprintf ("video", "IEEE1275: Success\n");
return err;
}
static grub_err_t
grub_video_ieee1275_swap_buffers (void)
{
/* TODO: Implement buffer swapping. */
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_ieee1275_set_active_render_target (struct grub_video_render_target *target)
{
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
target = framebuffer.render_target;
return grub_video_fb_set_active_render_target (target);
}
static grub_err_t
grub_video_ieee1275_get_info_and_fini (struct grub_video_mode_info *mode_info,
void **framebuf)
{
grub_memcpy (mode_info, &(framebuffer.mode_info), sizeof (*mode_info));
*framebuf = (char *) framebuffer.ptr;
grub_video_fb_fini ();
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_ieee1275_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data)
{
grub_err_t err;
struct grub_video_palette_data fb_palette_data[256];
err = grub_video_fb_set_palette (start, count, palette_data);
if (err)
return err;
grub_video_fb_get_palette (0, 256, fb_palette_data);
/* TODO. */
return GRUB_ERR_NONE;
}
static struct grub_video_adapter grub_video_ieee1275_adapter =
{
.name = "IEEE1275 video driver",
.prio = GRUB_VIDEO_ADAPTER_PRIO_FIRMWARE,
.init = grub_video_ieee1275_init,
.fini = grub_video_ieee1275_fini,
.setup = grub_video_ieee1275_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_ieee1275_get_info_and_fini,
.set_palette = grub_video_ieee1275_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_ieee1275_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_ieee1275_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(ieee1275_fb)
{
find_display ();
if (display)
grub_video_register (&grub_video_ieee1275_adapter);
}
GRUB_MOD_FINI(ieee1275_fb)
{
if (restore_needed)
{
set_video_mode (old_width, old_height);
restore_needed = 0;
}
if (display)
grub_video_unregister (&grub_video_ieee1275_adapter);
grub_free (display);
}

762
grub-core/video/readers/jpeg.c Normal file
View file

@ -0,0 +1,762 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/bitmap.h>
#include <grub/types.h>
#include <grub/normal.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/bufio.h>
/* Uncomment following define to enable JPEG debug. */
//#define JPEG_DEBUG
#define JPEG_ESC_CHAR 0xFF
#define JPEG_SAMPLING_1x1 0x11
#define JPEG_MARKER_SOI 0xd8
#define JPEG_MARKER_EOI 0xd9
#define JPEG_MARKER_DHT 0xc4
#define JPEG_MARKER_DQT 0xdb
#define JPEG_MARKER_SOF0 0xc0
#define JPEG_MARKER_SOS 0xda
#define SHIFT_BITS 8
#define CONST(x) ((int) ((x) * (1L << SHIFT_BITS) + 0.5))
#define JPEG_UNIT_SIZE 8
static const grub_uint8_t jpeg_zigzag_order[64] = {
0, 1, 8, 16, 9, 2, 3, 10,
17, 24, 32, 25, 18, 11, 4, 5,
12, 19, 26, 33, 40, 48, 41, 34,
27, 20, 13, 6, 7, 14, 21, 28,
35, 42, 49, 56, 57, 50, 43, 36,
29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46,
53, 60, 61, 54, 47, 55, 62, 63
};
#ifdef JPEG_DEBUG
static grub_command_t cmd;
#endif
typedef int jpeg_data_unit_t[64];
struct grub_jpeg_data
{
grub_file_t file;
struct grub_video_bitmap **bitmap;
int image_width;
int image_height;
grub_uint8_t *huff_value[4];
int huff_offset[4][16];
int huff_maxval[4][16];
grub_uint8_t quan_table[2][64];
int comp_index[3][3];
jpeg_data_unit_t ydu[4];
jpeg_data_unit_t crdu;
jpeg_data_unit_t cbdu;
int vs, hs;
int dc_value[3];
int bit_mask, bit_save;
};
static grub_uint8_t
grub_jpeg_get_byte (struct grub_jpeg_data *data)
{
grub_uint8_t r;
r = 0;
grub_file_read (data->file, &r, 1);
return r;
}
static grub_uint16_t
grub_jpeg_get_word (struct grub_jpeg_data *data)
{
grub_uint16_t r;
r = 0;
grub_file_read (data->file, &r, sizeof (grub_uint16_t));
return grub_be_to_cpu16 (r);
}
static int
grub_jpeg_get_bit (struct grub_jpeg_data *data)
{
int ret;
if (data->bit_mask == 0)
{
data->bit_save = grub_jpeg_get_byte (data);
if (data->bit_save == JPEG_ESC_CHAR)
{
if (grub_jpeg_get_byte (data) != 0)
{
grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: invalid 0xFF in data stream");
return 0;
}
}
data->bit_mask = 0x80;
}
ret = ((data->bit_save & data->bit_mask) != 0);
data->bit_mask >>= 1;
return ret;
}
static int
grub_jpeg_get_number (struct grub_jpeg_data *data, int num)
{
int value, i, msb;
if (num == 0)
return 0;
msb = value = grub_jpeg_get_bit (data);
for (i = 1; i < num; i++)
value = (value << 1) + (grub_jpeg_get_bit (data) != 0);
if (!msb)
value += 1 - (1 << num);
return value;
}
static int
grub_jpeg_get_huff_code (struct grub_jpeg_data *data, int id)
{
int code;
unsigned i;
code = 0;
for (i = 0; i < ARRAY_SIZE (data->huff_maxval[id]); i++)
{
code <<= 1;
if (grub_jpeg_get_bit (data))
code++;
if (code < data->huff_maxval[id][i])
return data->huff_value[id][code + data->huff_offset[id][i]];
}
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: huffman decode fails");
return 0;
}
static grub_err_t
grub_jpeg_decode_huff_table (struct grub_jpeg_data *data)
{
int id, ac, n, base, ofs;
grub_uint32_t next_marker;
grub_uint8_t count[16];
unsigned i;
next_marker = data->file->offset;
next_marker += grub_jpeg_get_word (data);
while (data->file->offset + sizeof (count) + 1 <= next_marker)
{
id = grub_jpeg_get_byte (data);
ac = (id >> 4) & 1;
id &= 0xF;
if (id > 1)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: too many huffman tables");
if (grub_file_read (data->file, &count, sizeof (count)) !=
sizeof (count))
return grub_errno;
n = 0;
for (i = 0; i < ARRAY_SIZE (count); i++)
n += count[i];
id += ac * 2;
data->huff_value[id] = grub_malloc (n);
if (grub_errno)
return grub_errno;
if (grub_file_read (data->file, data->huff_value[id], n) != n)
return grub_errno;
base = 0;
ofs = 0;
for (i = 0; i < ARRAY_SIZE (count); i++)
{
base += count[i];
ofs += count[i];
data->huff_maxval[id][i] = base;
data->huff_offset[id][i] = ofs - base;
base <<= 1;
}
}
if (data->file->offset != next_marker)
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in huffman table");
return grub_errno;
}
static grub_err_t
grub_jpeg_decode_quan_table (struct grub_jpeg_data *data)
{
int id;
grub_uint32_t next_marker;
next_marker = data->file->offset;
next_marker += grub_jpeg_get_word (data);
while (data->file->offset + sizeof (data->quan_table[id]) + 1
<= next_marker)
{
id = grub_jpeg_get_byte (data);
if (id >= 0x10) /* Upper 4-bit is precision. */
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: only 8-bit precision is supported");
if (id > 1)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: too many quantization tables");
if (grub_file_read (data->file, &data->quan_table[id],
sizeof (data->quan_table[id]))
!= sizeof (data->quan_table[id]))
return grub_errno;
}
if (data->file->offset != next_marker)
grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: extra byte in quantization table");
return grub_errno;
}
static grub_err_t
grub_jpeg_decode_sof (struct grub_jpeg_data *data)
{
int i, cc;
grub_uint32_t next_marker;
next_marker = data->file->offset;
next_marker += grub_jpeg_get_word (data);
if (grub_jpeg_get_byte (data) != 8)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: only 8-bit precision is supported");
data->image_height = grub_jpeg_get_word (data);
data->image_width = grub_jpeg_get_word (data);
if ((!data->image_height) || (!data->image_width))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid image size");
cc = grub_jpeg_get_byte (data);
if (cc != 3)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: component count must be 3");
for (i = 0; i < cc; i++)
{
int id, ss;
id = grub_jpeg_get_byte (data) - 1;
if ((id < 0) || (id >= 3))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
ss = grub_jpeg_get_byte (data); /* Sampling factor. */
if (!id)
{
data->vs = ss & 0xF; /* Vertical sampling. */
data->hs = ss >> 4; /* Horizontal sampling. */
if ((data->vs > 2) || (data->hs > 2))
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: sampling method not supported");
}
else if (ss != JPEG_SAMPLING_1x1)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: sampling method not supported");
data->comp_index[id][0] = grub_jpeg_get_byte (data);
}
if (data->file->offset != next_marker)
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sof");
return grub_errno;
}
static void
grub_jpeg_idct_transform (jpeg_data_unit_t du)
{
int *pd;
int i;
int t0, t1, t2, t3, t4, t5, t6, t7;
int v0, v1, v2, v3, v4;
pd = du;
for (i = 0; i < JPEG_UNIT_SIZE; i++, pd++)
{
if ((pd[JPEG_UNIT_SIZE * 1] | pd[JPEG_UNIT_SIZE * 2] |
pd[JPEG_UNIT_SIZE * 3] | pd[JPEG_UNIT_SIZE * 4] |
pd[JPEG_UNIT_SIZE * 5] | pd[JPEG_UNIT_SIZE * 6] |
pd[JPEG_UNIT_SIZE * 7]) == 0)
{
pd[JPEG_UNIT_SIZE * 0] <<= SHIFT_BITS;
pd[JPEG_UNIT_SIZE * 1] = pd[JPEG_UNIT_SIZE * 2]
= pd[JPEG_UNIT_SIZE * 3] = pd[JPEG_UNIT_SIZE * 4]
= pd[JPEG_UNIT_SIZE * 5] = pd[JPEG_UNIT_SIZE * 6]
= pd[JPEG_UNIT_SIZE * 7] = pd[JPEG_UNIT_SIZE * 0];
continue;
}
t0 = pd[JPEG_UNIT_SIZE * 0];
t1 = pd[JPEG_UNIT_SIZE * 2];
t2 = pd[JPEG_UNIT_SIZE * 4];
t3 = pd[JPEG_UNIT_SIZE * 6];
v4 = (t1 + t3) * CONST (0.541196100);
v0 = ((t0 + t2) << SHIFT_BITS);
v1 = ((t0 - t2) << SHIFT_BITS);
v2 = v4 - t3 * CONST (1.847759065);
v3 = v4 + t1 * CONST (0.765366865);
t0 = v0 + v3;
t3 = v0 - v3;
t1 = v1 + v2;
t2 = v1 - v2;
t4 = pd[JPEG_UNIT_SIZE * 7];
t5 = pd[JPEG_UNIT_SIZE * 5];
t6 = pd[JPEG_UNIT_SIZE * 3];
t7 = pd[JPEG_UNIT_SIZE * 1];
v0 = t4 + t7;
v1 = t5 + t6;
v2 = t4 + t6;
v3 = t5 + t7;
v4 = (v2 + v3) * CONST (1.175875602);
v0 *= CONST (0.899976223);
v1 *= CONST (2.562915447);
v2 = v2 * CONST (1.961570560) - v4;
v3 = v3 * CONST (0.390180644) - v4;
t4 = t4 * CONST (0.298631336) - v0 - v2;
t5 = t5 * CONST (2.053119869) - v1 - v3;
t6 = t6 * CONST (3.072711026) - v1 - v2;
t7 = t7 * CONST (1.501321110) - v0 - v3;
pd[JPEG_UNIT_SIZE * 0] = t0 + t7;
pd[JPEG_UNIT_SIZE * 7] = t0 - t7;
pd[JPEG_UNIT_SIZE * 1] = t1 + t6;
pd[JPEG_UNIT_SIZE * 6] = t1 - t6;
pd[JPEG_UNIT_SIZE * 2] = t2 + t5;
pd[JPEG_UNIT_SIZE * 5] = t2 - t5;
pd[JPEG_UNIT_SIZE * 3] = t3 + t4;
pd[JPEG_UNIT_SIZE * 4] = t3 - t4;
}
pd = du;
for (i = 0; i < JPEG_UNIT_SIZE; i++, pd += JPEG_UNIT_SIZE)
{
if ((pd[1] | pd[2] | pd[3] | pd[4] | pd[5] | pd[6] | pd[7]) == 0)
{
pd[0] >>= (SHIFT_BITS + 3);
pd[1] = pd[2] = pd[3] = pd[4] = pd[5] = pd[6] = pd[7] = pd[0];
continue;
}
v4 = (pd[2] + pd[6]) * CONST (0.541196100);
v0 = (pd[0] + pd[4]) << SHIFT_BITS;
v1 = (pd[0] - pd[4]) << SHIFT_BITS;
v2 = v4 - pd[6] * CONST (1.847759065);
v3 = v4 + pd[2] * CONST (0.765366865);
t0 = v0 + v3;
t3 = v0 - v3;
t1 = v1 + v2;
t2 = v1 - v2;
t4 = pd[7];
t5 = pd[5];
t6 = pd[3];
t7 = pd[1];
v0 = t4 + t7;
v1 = t5 + t6;
v2 = t4 + t6;
v3 = t5 + t7;
v4 = (v2 + v3) * CONST (1.175875602);
v0 *= CONST (0.899976223);
v1 *= CONST (2.562915447);
v2 = v2 * CONST (1.961570560) - v4;
v3 = v3 * CONST (0.390180644) - v4;
t4 = t4 * CONST (0.298631336) - v0 - v2;
t5 = t5 * CONST (2.053119869) - v1 - v3;
t6 = t6 * CONST (3.072711026) - v1 - v2;
t7 = t7 * CONST (1.501321110) - v0 - v3;
pd[0] = (t0 + t7) >> (SHIFT_BITS * 2 + 3);
pd[7] = (t0 - t7) >> (SHIFT_BITS * 2 + 3);
pd[1] = (t1 + t6) >> (SHIFT_BITS * 2 + 3);
pd[6] = (t1 - t6) >> (SHIFT_BITS * 2 + 3);
pd[2] = (t2 + t5) >> (SHIFT_BITS * 2 + 3);
pd[5] = (t2 - t5) >> (SHIFT_BITS * 2 + 3);
pd[3] = (t3 + t4) >> (SHIFT_BITS * 2 + 3);
pd[4] = (t3 - t4) >> (SHIFT_BITS * 2 + 3);
}
for (i = 0; i < JPEG_UNIT_SIZE * JPEG_UNIT_SIZE; i++)
{
du[i] += 128;
if (du[i] < 0)
du[i] = 0;
if (du[i] > 255)
du[i] = 255;
}
}
static void
grub_jpeg_decode_du (struct grub_jpeg_data *data, int id, jpeg_data_unit_t du)
{
int h1, h2, qt;
unsigned pos;
grub_memset (du, 0, sizeof (jpeg_data_unit_t));
qt = data->comp_index[id][0];
h1 = data->comp_index[id][1];
h2 = data->comp_index[id][2];
data->dc_value[id] +=
grub_jpeg_get_number (data, grub_jpeg_get_huff_code (data, h1));
du[0] = data->dc_value[id] * (int) data->quan_table[qt][0];
pos = 1;
while (pos < ARRAY_SIZE (data->quan_table[qt]))
{
int num, val;
num = grub_jpeg_get_huff_code (data, h2);
if (!num)
break;
val = grub_jpeg_get_number (data, num & 0xF);
num >>= 4;
pos += num;
du[jpeg_zigzag_order[pos]] = val * (int) data->quan_table[qt][pos];
pos++;
}
grub_jpeg_idct_transform (du);
}
static void
grub_jpeg_ycrcb_to_rgb (int yy, int cr, int cb, grub_uint8_t * rgb)
{
int dd;
cr -= 128;
cb -= 128;
/* Red */
dd = yy + ((cr * CONST (1.402)) >> SHIFT_BITS);
if (dd < 0)
dd = 0;
if (dd > 255)
dd = 255;
*(rgb++) = dd;
/* Green */
dd = yy - ((cb * CONST (0.34414) + cr * CONST (0.71414)) >> SHIFT_BITS);
if (dd < 0)
dd = 0;
if (dd > 255)
dd = 255;
*(rgb++) = dd;
/* Blue */
dd = yy + ((cb * CONST (1.772)) >> SHIFT_BITS);
if (dd < 0)
dd = 0;
if (dd > 255)
dd = 255;
*(rgb++) = dd;
}
static grub_err_t
grub_jpeg_decode_sos (struct grub_jpeg_data *data)
{
int i, cc, r1, c1, nr1, nc1, vb, hb;
grub_uint8_t *ptr1;
grub_uint32_t data_offset;
data_offset = data->file->offset;
data_offset += grub_jpeg_get_word (data);
cc = grub_jpeg_get_byte (data);
if (cc != 3)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"jpeg: component count must be 3");
for (i = 0; i < cc; i++)
{
int id, ht;
id = grub_jpeg_get_byte (data) - 1;
if ((id < 0) || (id >= 3))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid index");
ht = grub_jpeg_get_byte (data);
data->comp_index[id][1] = (ht >> 4);
data->comp_index[id][2] = (ht & 0xF) + 2;
}
grub_jpeg_get_byte (data); /* Skip 3 unused bytes. */
grub_jpeg_get_word (data);
if (data->file->offset != data_offset)
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: extra byte in sos");
if (grub_video_bitmap_create (data->bitmap, data->image_width,
data->image_height,
GRUB_VIDEO_BLIT_FORMAT_RGB_888))
return grub_errno;
data->bit_mask = 0x0;
vb = data->vs * 8;
hb = data->hs * 8;
nr1 = (data->image_height + vb - 1) / vb;
nc1 = (data->image_width + hb - 1) / hb;
ptr1 = (*data->bitmap)->data;
for (r1 = 0; r1 < nr1;
r1++, ptr1 += (vb * data->image_width - hb * nc1) * 3)
for (c1 = 0; c1 < nc1; c1++, ptr1 += hb * 3)
{
int r2, c2, nr2, nc2;
grub_uint8_t *ptr2;
for (r2 = 0; r2 < data->vs; r2++)
for (c2 = 0; c2 < data->hs; c2++)
grub_jpeg_decode_du (data, 0, data->ydu[r2 * 2 + c2]);
grub_jpeg_decode_du (data, 1, data->cbdu);
grub_jpeg_decode_du (data, 2, data->crdu);
if (grub_errno)
return grub_errno;
nr2 = (r1 == nr1 - 1) ? (data->image_height - r1 * vb) : vb;
nc2 = (c1 == nc1 - 1) ? (data->image_width - c1 * hb) : hb;
ptr2 = ptr1;
for (r2 = 0; r2 < nr2; r2++, ptr2 += (data->image_width - nc2) * 3)
for (c2 = 0; c2 < nc2; c2++, ptr2 += 3)
{
int i0, yy, cr, cb;
i0 = (r2 / data->vs) * 8 + (c2 / data->hs);
cr = data->crdu[i0];
cb = data->cbdu[i0];
yy =
data->ydu[(r2 / 8) * 2 + (c2 / 8)][(r2 % 8) * 8 + (c2 % 8)];
grub_jpeg_ycrcb_to_rgb (yy, cr, cb, ptr2);
}
}
return grub_errno;
}
static grub_uint8_t
grub_jpeg_get_marker (struct grub_jpeg_data *data)
{
grub_uint8_t r;
r = grub_jpeg_get_byte (data);
if (r != JPEG_ESC_CHAR)
{
grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid maker");
return 0;
}
return grub_jpeg_get_byte (data);
}
static grub_err_t
grub_jpeg_decode_jpeg (struct grub_jpeg_data *data)
{
if (grub_jpeg_get_marker (data) != JPEG_MARKER_SOI) /* Start Of Image. */
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "jpeg: invalid jpeg file");
while (grub_errno == 0)
{
grub_uint8_t marker;
marker = grub_jpeg_get_marker (data);
if (grub_errno)
break;
#ifdef JPEG_DEBUG
grub_printf ("jpeg marker: %x\n", marker);
#endif
switch (marker)
{
case JPEG_MARKER_DHT: /* Define Huffman Table. */
grub_jpeg_decode_huff_table (data);
break;
case JPEG_MARKER_DQT: /* Define Quantization Table. */
grub_jpeg_decode_quan_table (data);
break;
case JPEG_MARKER_SOF0: /* Start Of Frame 0. */
grub_jpeg_decode_sof (data);
break;
case JPEG_MARKER_SOS: /* Start Of Scan. */
grub_jpeg_decode_sos (data);
break;
case JPEG_MARKER_EOI: /* End Of Image. */
return grub_errno;
default: /* Skip unrecognized marker. */
{
grub_uint16_t sz;
sz = grub_jpeg_get_word (data);
if (grub_errno)
return (grub_errno);
grub_file_seek (data->file, data->file->offset + sz - 2);
}
}
}
return grub_errno;
}
static grub_err_t
grub_video_reader_jpeg (struct grub_video_bitmap **bitmap,
const char *filename)
{
grub_file_t file;
struct grub_jpeg_data *data;
file = grub_buffile_open (filename, 0);
if (!file)
return grub_errno;
data = grub_zalloc (sizeof (*data));
if (data != NULL)
{
int i;
data->file = file;
data->bitmap = bitmap;
grub_jpeg_decode_jpeg (data);
for (i = 0; i < 4; i++)
if (data->huff_value[i])
grub_free (data->huff_value[i]);
grub_free (data);
}
if (grub_errno != GRUB_ERR_NONE)
{
grub_video_bitmap_destroy (*bitmap);
*bitmap = 0;
}
grub_file_close (file);
return grub_errno;
}
#if defined(JPEG_DEBUG)
static grub_err_t
grub_cmd_jpegtest (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
struct grub_video_bitmap *bitmap = 0;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
grub_video_reader_jpeg (&bitmap, args[0]);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
grub_video_bitmap_destroy (bitmap);
return GRUB_ERR_NONE;
}
#endif
static struct grub_video_bitmap_reader jpg_reader = {
.extension = ".jpg",
.reader = grub_video_reader_jpeg,
.next = 0
};
static struct grub_video_bitmap_reader jpeg_reader = {
.extension = ".jpeg",
.reader = grub_video_reader_jpeg,
.next = 0
};
GRUB_MOD_INIT (jpeg)
{
grub_video_bitmap_reader_register (&jpg_reader);
grub_video_bitmap_reader_register (&jpeg_reader);
#if defined(JPEG_DEBUG)
cmd = grub_register_command ("jpegtest", grub_cmd_jpegtest,
"FILE", "Tests loading of JPEG bitmap.");
#endif
}
GRUB_MOD_FINI (jpeg)
{
#if defined(JPEG_DEBUG)
grub_unregister_command (cmd);
#endif
grub_video_bitmap_reader_unregister (&jpeg_reader);
grub_video_bitmap_reader_unregister (&jpg_reader);
}

913
grub-core/video/readers/png.c Normal file
View file

@ -0,0 +1,913 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/bitmap.h>
#include <grub/types.h>
#include <grub/normal.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/bufio.h>
/* Uncomment following define to enable PNG debug. */
//#define PNG_DEBUG
#define PNG_COLOR_MASK_PALETTE 1
#define PNG_COLOR_MASK_COLOR 2
#define PNG_COLOR_MASK_ALPHA 4
#define PNG_COLOR_TYPE_GRAY 0
#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
#define PNG_COLOR_TYPE_RGBA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
#define PNG_COLOR_TYPE_GRAYA (PNG_COLOR_MASK_ALPHA)
#define PNG_COMPRESSION_BASE 0
#define PNG_INTERLACE_NONE 0
#define PNG_INTERLACE_ADAM7 1
#define PNG_FILTER_TYPE_BASE 0
#define PNG_FILTER_VALUE_NONE 0
#define PNG_FILTER_VALUE_SUB 1
#define PNG_FILTER_VALUE_UP 2
#define PNG_FILTER_VALUE_AVG 3
#define PNG_FILTER_VALUE_PAETH 4
#define PNG_FILTER_VALUE_LAST 5
#define PNG_CHUNK_IHDR 0x49484452
#define PNG_CHUNK_IDAT 0x49444154
#define PNG_CHUNK_IEND 0x49454e44
#define Z_DEFLATED 8
#define Z_FLAG_DICT 32
#define INFLATE_STORED 0
#define INFLATE_FIXED 1
#define INFLATE_DYNAMIC 2
#define WSIZE 0x8000
#define DEFLATE_HCLEN_BASE 4
#define DEFLATE_HCLEN_MAX 19
#define DEFLATE_HLIT_BASE 257
#define DEFLATE_HLIT_MAX 288
#define DEFLATE_HDIST_BASE 1
#define DEFLATE_HDIST_MAX 30
#define DEFLATE_HUFF_LEN 16
#ifdef PNG_DEBUG
static grub_command_t cmd;
#endif
struct huff_table
{
int *values, *maxval, *offset;
int num_values, max_length;
};
struct grub_png_data
{
grub_file_t file;
struct grub_video_bitmap **bitmap;
int bit_count, bit_save;
grub_uint32_t next_offset;
int image_width, image_height, bpp, is_16bit, raw_bytes;
grub_uint8_t *image_data;
int inside_idat, idat_remain;
int code_values[DEFLATE_HLIT_MAX];
int code_maxval[DEFLATE_HUFF_LEN];
int code_offset[DEFLATE_HUFF_LEN];
int dist_values[DEFLATE_HDIST_MAX];
int dist_maxval[DEFLATE_HUFF_LEN];
int dist_offset[DEFLATE_HUFF_LEN];
struct huff_table code_table;
struct huff_table dist_table;
grub_uint8_t slide[WSIZE];
int wp;
grub_uint8_t *cur_rgb;
int cur_column, cur_filter, first_line;
};
static grub_uint32_t
grub_png_get_dword (struct grub_png_data *data)
{
grub_uint32_t r;
r = 0;
grub_file_read (data->file, &r, sizeof (grub_uint32_t));
return grub_be_to_cpu32 (r);
}
static grub_uint8_t
grub_png_get_byte (struct grub_png_data *data)
{
grub_uint8_t r;
if ((data->inside_idat) && (data->idat_remain == 0))
{
grub_uint32_t len, type;
do
{
/* Skip crc checksum. */
grub_png_get_dword (data);
if (data->file->offset != data->next_offset)
{
grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: chunk size error");
return 0;
}
len = grub_png_get_dword (data);
type = grub_png_get_dword (data);
if (type != PNG_CHUNK_IDAT)
{
grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: unexpected end of data");
return 0;
}
data->next_offset = data->file->offset + len + 4;
}
while (len == 0);
data->idat_remain = len;
}
r = 0;
grub_file_read (data->file, &r, 1);
if (data->inside_idat)
data->idat_remain--;
return r;
}
static int
grub_png_get_bits (struct grub_png_data *data, int num)
{
int code, shift;
if (data->bit_count == 0)
{
data->bit_save = grub_png_get_byte (data);
data->bit_count = 8;
}
code = 0;
shift = 0;
while (grub_errno == 0)
{
int n;
n = data->bit_count;
if (n > num)
n = num;
code += (int) (data->bit_save & ((1 << n) - 1)) << shift;
num -= n;
if (!num)
{
data->bit_count -= n;
data->bit_save >>= n;
break;
}
shift += n;
data->bit_save = grub_png_get_byte (data);
data->bit_count = 8;
}
return code;
}
static grub_err_t
grub_png_decode_image_header (struct grub_png_data *data)
{
int color_type;
int color_bits;
data->image_width = grub_png_get_dword (data);
data->image_height = grub_png_get_dword (data);
if ((!data->image_height) || (!data->image_width))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid image size");
color_bits = grub_png_get_byte (data);
if ((color_bits != 8) && (color_bits != 16))
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: bit depth must be 8 or 16");
data->is_16bit = (color_bits == 16);
color_type = grub_png_get_byte (data);
if (color_type == PNG_COLOR_TYPE_RGB)
{
if (grub_video_bitmap_create (data->bitmap, data->image_width,
data->image_height,
GRUB_VIDEO_BLIT_FORMAT_RGB_888))
return grub_errno;
data->bpp = 3;
}
else if (color_type == PNG_COLOR_TYPE_RGBA)
{
if (grub_video_bitmap_create (data->bitmap, data->image_width,
data->image_height,
GRUB_VIDEO_BLIT_FORMAT_RGBA_8888))
return grub_errno;
data->bpp = 4;
}
else
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: color type not supported");
if (data->is_16bit)
{
data->bpp <<= 1;
data->image_data = grub_malloc (data->image_height *
data->image_width * data->bpp);
if (grub_errno)
return grub_errno;
data->cur_rgb = data->image_data;
}
else
{
data->image_data = 0;
data->cur_rgb = (*data->bitmap)->data;
}
data->raw_bytes = data->image_height * (data->image_width + 1) * data->bpp;
data->cur_column = 0;
data->first_line = 1;
if (grub_png_get_byte (data) != PNG_COMPRESSION_BASE)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: compression method not supported");
if (grub_png_get_byte (data) != PNG_FILTER_TYPE_BASE)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: filter method not supported");
if (grub_png_get_byte (data) != PNG_INTERLACE_NONE)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: interlace method not supported");
/* Skip crc checksum. */
grub_png_get_dword (data);
return grub_errno;
}
/* Order of the bit length code lengths. */
static const grub_uint8_t bitorder[] = {
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
};
/* Copy lengths for literal codes 257..285. */
static const int cplens[] = {
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
};
/* Extra bits for literal codes 257..285. */
static const grub_uint8_t cplext[] = {
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
}; /* 99==invalid */
/* Copy offsets for distance codes 0..29. */
static const int cpdist[] = {
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
8193, 12289, 16385, 24577
};
/* Extra bits for distance codes. */
static const grub_uint8_t cpdext[] = {
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
12, 12, 13, 13
};
static void
grub_png_init_huff_table (struct huff_table *ht, int cur_maxlen,
int *cur_values, int *cur_maxval, int *cur_offset)
{
ht->values = cur_values;
ht->maxval = cur_maxval;
ht->offset = cur_offset;
ht->num_values = 0;
ht->max_length = cur_maxlen;
grub_memset (cur_maxval, 0, sizeof (int) * cur_maxlen);
}
static void
grub_png_insert_huff_item (struct huff_table *ht, int code, int len)
{
int i, n;
if (len == 0)
return;
if (len > ht->max_length)
{
grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid code length");
return;
}
n = 0;
for (i = len; i < ht->max_length; i++)
n += ht->maxval[i];
for (i = 0; i < n; i++)
ht->values[ht->num_values - i] = ht->values[ht->num_values - i - 1];
ht->values[ht->num_values - n] = code;
ht->num_values++;
ht->maxval[len - 1]++;
}
static void
grub_png_build_huff_table (struct huff_table *ht)
{
int base, ofs, i;
base = 0;
ofs = 0;
for (i = 0; i < ht->max_length; i++)
{
base += ht->maxval[i];
ofs += ht->maxval[i];
ht->maxval[i] = base;
ht->offset[i] = ofs - base;
base <<= 1;
}
}
static int
grub_png_get_huff_code (struct grub_png_data *data, struct huff_table *ht)
{
int code, i;
code = 0;
for (i = 0; i < ht->max_length; i++)
{
code = (code << 1) + grub_png_get_bits (data, 1);
if (code < ht->maxval[i])
return ht->values[code + ht->offset[i]];
}
return 0;
}
static grub_err_t
grub_png_init_fixed_block (struct grub_png_data *data)
{
int i;
grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
data->code_values, data->code_maxval,
data->code_offset);
for (i = 0; i < 144; i++)
grub_png_insert_huff_item (&data->code_table, i, 8);
for (; i < 256; i++)
grub_png_insert_huff_item (&data->code_table, i, 9);
for (; i < 280; i++)
grub_png_insert_huff_item (&data->code_table, i, 7);
for (; i < DEFLATE_HLIT_MAX; i++)
grub_png_insert_huff_item (&data->code_table, i, 8);
grub_png_build_huff_table (&data->code_table);
grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
data->dist_values, data->dist_maxval,
data->dist_offset);
for (i = 0; i < DEFLATE_HDIST_MAX; i++)
grub_png_insert_huff_item (&data->dist_table, i, 5);
grub_png_build_huff_table (&data->dist_table);
return grub_errno;
}
static grub_err_t
grub_png_init_dynamic_block (struct grub_png_data *data)
{
int nl, nd, nb, i, prev;
struct huff_table cl;
int cl_values[sizeof (bitorder)];
int cl_maxval[8];
int cl_offset[8];
grub_uint8_t lens[DEFLATE_HCLEN_MAX];
nl = DEFLATE_HLIT_BASE + grub_png_get_bits (data, 5);
nd = DEFLATE_HDIST_BASE + grub_png_get_bits (data, 5);
nb = DEFLATE_HCLEN_BASE + grub_png_get_bits (data, 4);
if ((nl > DEFLATE_HLIT_MAX) || (nd > DEFLATE_HDIST_MAX) ||
(nb > DEFLATE_HCLEN_MAX))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: too much data");
grub_png_init_huff_table (&cl, 8, cl_values, cl_maxval, cl_offset);
for (i = 0; i < nb; i++)
lens[bitorder[i]] = grub_png_get_bits (data, 3);
for (; i < DEFLATE_HCLEN_MAX; i++)
lens[bitorder[i]] = 0;
for (i = 0; i < DEFLATE_HCLEN_MAX; i++)
grub_png_insert_huff_item (&cl, i, lens[i]);
grub_png_build_huff_table (&cl);
grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
data->code_values, data->code_maxval,
data->code_offset);
grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
data->dist_values, data->dist_maxval,
data->dist_offset);
prev = 0;
for (i = 0; i < nl + nd; i++)
{
int n, code;
struct huff_table *ht;
if (grub_errno)
return grub_errno;
if (i < nl)
{
ht = &data->code_table;
code = i;
}
else
{
ht = &data->dist_table;
code = i - nl;
}
n = grub_png_get_huff_code (data, &cl);
if (n < 16)
{
grub_png_insert_huff_item (ht, code, n);
prev = n;
}
else if (n == 16)
{
int c;
c = 3 + grub_png_get_bits (data, 2);
while (c > 0)
{
grub_png_insert_huff_item (ht, code++, prev);
i++;
c--;
}
i--;
}
else if (n == 17)
i += 3 + grub_png_get_bits (data, 3) - 1;
else
i += 11 + grub_png_get_bits (data, 7) - 1;
}
grub_png_build_huff_table (&data->code_table);
grub_png_build_huff_table (&data->dist_table);
return grub_errno;
}
static grub_err_t
grub_png_output_byte (struct grub_png_data *data, grub_uint8_t n)
{
int row_bytes;
if (--data->raw_bytes < 0)
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "image size overflown");
if (data->cur_column == 0)
{
if (n >= PNG_FILTER_VALUE_LAST)
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid filter value");
data->cur_filter = n;
}
else
*(data->cur_rgb++) = n;
data->cur_column++;
row_bytes = data->image_width * data->bpp;
if (data->cur_column == row_bytes + 1)
{
grub_uint8_t *blank_line = NULL;
grub_uint8_t *cur = data->cur_rgb - row_bytes;
grub_uint8_t *left = cur;
grub_uint8_t *up;
if (data->first_line)
{
blank_line = grub_zalloc (row_bytes);
if (blank_line == NULL)
return grub_errno;
up = blank_line;
}
else
up = cur - row_bytes;
switch (data->cur_filter)
{
case PNG_FILTER_VALUE_SUB:
{
int i;
cur += data->bpp;
for (i = data->bpp; i < row_bytes; i++, cur++, left++)
*cur += *left;
break;
}
case PNG_FILTER_VALUE_UP:
{
int i;
for (i = 0; i < row_bytes; i++, cur++, up++)
*cur += *up;
break;
}
case PNG_FILTER_VALUE_AVG:
{
int i;
for (i = 0; i < data->bpp; i++, cur++, up++)
*cur += *up >> 1;
for (; i < row_bytes; i++, cur++, up++, left++)
*cur += ((int) *up + (int) *left) >> 1;
break;
}
case PNG_FILTER_VALUE_PAETH:
{
int i;
grub_uint8_t *upper_left = up;
for (i = 0; i < data->bpp; i++, cur++, up++)
*cur += *up;
for (; i < row_bytes; i++, cur++, up++, left++, upper_left++)
{
int a, b, c, pa, pb, pc;
a = *left;
b = *up;
c = *upper_left;
pa = b - c;
pb = a - c;
pc = pa + pb;
if (pa < 0)
pa = -pa;
if (pb < 0)
pb = -pb;
if (pc < 0)
pc = -pc;
*cur += ((pa <= pb) && (pa <= pc)) ? a : (pb <= pc) ? b : c;
}
}
}
if (blank_line)
grub_free (blank_line);
data->cur_column = 0;
data->first_line = 0;
}
return grub_errno;
}
static grub_err_t
grub_png_read_dynamic_block (struct grub_png_data *data)
{
while (grub_errno == 0)
{
int n;
n = grub_png_get_huff_code (data, &data->code_table);
if (n < 256)
{
data->slide[data->wp] = n;
grub_png_output_byte (data, n);
data->wp++;
if (data->wp >= WSIZE)
data->wp = 0;
}
else if (n == 256)
break;
else
{
int len, dist, pos;
n -= 257;
len = cplens[n];
if (cplext[n])
len += grub_png_get_bits (data, cplext[n]);
n = grub_png_get_huff_code (data, &data->dist_table);
dist = cpdist[n];
if (cpdext[n])
dist += grub_png_get_bits (data, cpdext[n]);
pos = data->wp - dist;
if (pos < 0)
pos += WSIZE;
while (len > 0)
{
data->slide[data->wp] = data->slide[pos];
grub_png_output_byte (data, data->slide[data->wp]);
data->wp++;
if (data->wp >= WSIZE)
data->wp = 0;
pos++;
if (pos >= WSIZE)
pos = 0;
len--;
}
}
}
return grub_errno;
}
static grub_err_t
grub_png_decode_image_data (struct grub_png_data *data)
{
grub_uint8_t cmf, flg;
int final;
cmf = grub_png_get_byte (data);
flg = grub_png_get_byte (data);
if ((cmf & 0xF) != Z_DEFLATED)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: only support deflate compression method");
if (flg & Z_FLAG_DICT)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: dictionary not supported");
do
{
int block_type;
final = grub_png_get_bits (data, 1);
block_type = grub_png_get_bits (data, 2);
switch (block_type)
{
case INFLATE_STORED:
{
grub_uint16_t i, len;
data->bit_count = 0;
len = grub_png_get_byte (data);
len += ((grub_uint16_t) grub_png_get_byte (data)) << 8;
/* Skip NLEN field. */
grub_png_get_byte (data);
grub_png_get_byte (data);
for (i = 0; i < len; i++)
grub_png_output_byte (data, grub_png_get_byte (data));
break;
}
case INFLATE_FIXED:
grub_png_init_fixed_block (data);
grub_png_read_dynamic_block (data);
break;
case INFLATE_DYNAMIC:
grub_png_init_dynamic_block (data);
grub_png_read_dynamic_block (data);
break;
default:
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: unknown block type");
}
}
while ((!final) && (grub_errno == 0));
/* Skip adler checksum. */
grub_png_get_dword (data);
/* Skip crc checksum. */
grub_png_get_dword (data);
return grub_errno;
}
static const grub_uint8_t png_magic[8] =
{ 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0x0a };
static void
grub_png_convert_image (struct grub_png_data *data)
{
int i;
grub_uint8_t *d1, *d2;
d1 = (*data->bitmap)->data;
d2 = data->image_data + 1;
/* Only copy the upper 8 bit. */
for (i = 0; i < (data->image_width * data->image_height * data->bpp >> 1);
i++, d1++, d2+=2)
*d1 = *d2;
}
static grub_err_t
grub_png_decode_png (struct grub_png_data *data)
{
grub_uint8_t magic[8];
if (grub_file_read (data->file, &magic[0], 8) != 8)
return grub_errno;
if (grub_memcmp (magic, png_magic, sizeof (png_magic)))
return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: not a png file");
while (1)
{
grub_uint32_t len, type;
len = grub_png_get_dword (data);
type = grub_png_get_dword (data);
data->next_offset = data->file->offset + len + 4;
switch (type)
{
case PNG_CHUNK_IHDR:
grub_png_decode_image_header (data);
break;
case PNG_CHUNK_IDAT:
data->inside_idat = 1;
data->idat_remain = len;
data->bit_count = 0;
grub_png_decode_image_data (data);
data->inside_idat = 0;
break;
case PNG_CHUNK_IEND:
if (data->is_16bit)
grub_png_convert_image (data);
return grub_errno;
default:
grub_file_seek (data->file, data->file->offset + len + 4);
}
if (grub_errno)
break;
if (data->file->offset != data->next_offset)
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"png: chunk size error");
}
return grub_errno;
}
static grub_err_t
grub_video_reader_png (struct grub_video_bitmap **bitmap,
const char *filename)
{
grub_file_t file;
struct grub_png_data *data;
file = grub_buffile_open (filename, 0);
if (!file)
return grub_errno;
data = grub_zalloc (sizeof (*data));
if (data != NULL)
{
data->file = file;
data->bitmap = bitmap;
grub_png_decode_png (data);
grub_free (data->image_data);
grub_free (data);
}
if (grub_errno != GRUB_ERR_NONE)
{
grub_video_bitmap_destroy (*bitmap);
*bitmap = 0;
}
grub_file_close (file);
return grub_errno;
}
#if defined(PNG_DEBUG)
static grub_err_t
grub_cmd_pngtest (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
struct grub_video_bitmap *bitmap = 0;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
grub_video_reader_png (&bitmap, args[0]);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
grub_video_bitmap_destroy (bitmap);
return GRUB_ERR_NONE;
}
#endif
static struct grub_video_bitmap_reader png_reader = {
.extension = ".png",
.reader = grub_video_reader_png,
.next = 0
};
GRUB_MOD_INIT (png)
{
grub_video_bitmap_reader_register (&png_reader);
#if defined(PNG_DEBUG)
cmd = grub_register_command ("pngtest", grub_cmd_pngtest,
"FILE",
"Tests loading of PNG bitmap.");
#endif
}
GRUB_MOD_FINI (png)
{
#if defined(PNG_DEBUG)
grub_unregister_command (cmd);
#endif
grub_video_bitmap_reader_unregister (&png_reader);
}

495
grub-core/video/readers/tga.c Normal file
View file

@ -0,0 +1,495 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2006,2007 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/bitmap.h>
#include <grub/types.h>
#include <grub/normal.h>
#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/misc.h>
#include <grub/bufio.h>
/* Uncomment following define to enable TGA debug. */
//#define TGA_DEBUG
#if defined(TGA_DEBUG)
#define dump_int_field(x) grub_printf( #x " = %d (0x%04x)\n", x, x);
static grub_command_t cmd;
#endif
enum
{
GRUB_TGA_IMAGE_TYPE_NONE = 0,
GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_INDEXCOLOR = 1,
GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR = 2,
GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_BLACK_AND_WHITE = 3,
GRUB_TGA_IMAGE_TYPE_RLE_INDEXCOLOR = 9,
GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR = 10,
GRUB_TGA_IMAGE_TYPE_RLE_BLACK_AND_WHITE = 11,
};
enum
{
GRUB_TGA_COLOR_MAP_TYPE_NONE = 0,
GRUB_TGA_COLOR_MAP_TYPE_INCLUDED = 1
};
enum
{
GRUB_TGA_IMAGE_ORIGIN_RIGHT = 0x10,
GRUB_TGA_IMAGE_ORIGIN_TOP = 0x20
};
struct grub_tga_header
{
grub_uint8_t id_length;
grub_uint8_t color_map_type;
grub_uint8_t image_type;
/* Color Map Specification. */
grub_uint16_t color_map_first_index;
grub_uint16_t color_map_length;
grub_uint8_t color_map_bpp;
/* Image Specification. */
grub_uint16_t image_x_origin;
grub_uint16_t image_y_origin;
grub_uint16_t image_width;
grub_uint16_t image_height;
grub_uint8_t image_bpp;
grub_uint8_t image_descriptor;
} __attribute__ ((packed));
static grub_err_t
tga_load_truecolor_rle_R8G8B8 (struct grub_video_bitmap *bitmap,
struct grub_tga_header *header,
grub_file_t file)
{
unsigned int x;
unsigned int y;
grub_uint8_t type;
grub_uint8_t *ptr;
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
grub_uint8_t bytes_per_pixel;
bytes_per_pixel = header->image_bpp / 8;
for (y = 0; y < header->image_height; y++)
{
ptr = bitmap->data;
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
ptr += y * bitmap->mode_info.pitch;
else
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
for (x = 0; x < header->image_width;)
{
if (grub_file_read (file, &type, sizeof (type)) != sizeof(type))
return grub_errno;
if (type & 0x80)
{
/* RLE-encoded packet. */
type &= 0x7f;
type++;
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
!= bytes_per_pixel)
return grub_errno;
while (type)
{
if (x < header->image_width)
{
ptr[0] = tmp[2];
ptr[1] = tmp[1];
ptr[2] = tmp[0];
ptr += 3;
}
type--;
x++;
}
}
else
{
/* RAW-encoded packet. */
type++;
while (type)
{
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
!= bytes_per_pixel)
return grub_errno;
if (x < header->image_width)
{
ptr[0] = tmp[2];
ptr[1] = tmp[1];
ptr[2] = tmp[0];
ptr += 3;
}
type--;
x++;
}
}
}
}
return GRUB_ERR_NONE;
}
static grub_err_t
tga_load_truecolor_rle_R8G8B8A8 (struct grub_video_bitmap *bitmap,
struct grub_tga_header *header,
grub_file_t file)
{
unsigned int x;
unsigned int y;
grub_uint8_t type;
grub_uint8_t *ptr;
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
grub_uint8_t bytes_per_pixel;
bytes_per_pixel = header->image_bpp / 8;
for (y = 0; y < header->image_height; y++)
{
ptr = bitmap->data;
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
ptr += y * bitmap->mode_info.pitch;
else
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
for (x = 0; x < header->image_width;)
{
if (grub_file_read (file, &type, sizeof (type)) != sizeof(type))
return grub_errno;
if (type & 0x80)
{
/* RLE-encoded packet. */
type &= 0x7f;
type++;
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
!= bytes_per_pixel)
return grub_errno;
while (type)
{
if (x < header->image_width)
{
ptr[0] = tmp[2];
ptr[1] = tmp[1];
ptr[2] = tmp[0];
ptr[3] = tmp[3];
ptr += 4;
}
type--;
x++;
}
}
else
{
/* RAW-encoded packet. */
type++;
while (type)
{
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
!= bytes_per_pixel)
return grub_errno;
if (x < header->image_width)
{
ptr[0] = tmp[2];
ptr[1] = tmp[1];
ptr[2] = tmp[0];
ptr[3] = tmp[3];
ptr += 4;
}
type--;
x++;
}
}
}
}
return GRUB_ERR_NONE;
}
static grub_err_t
tga_load_truecolor_R8G8B8 (struct grub_video_bitmap *bitmap,
struct grub_tga_header *header,
grub_file_t file)
{
unsigned int x;
unsigned int y;
grub_uint8_t *ptr;
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
grub_uint8_t bytes_per_pixel;
bytes_per_pixel = header->image_bpp / 8;
for (y = 0; y < header->image_height; y++)
{
ptr = bitmap->data;
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
ptr += y * bitmap->mode_info.pitch;
else
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
for (x = 0; x < header->image_width; x++)
{
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
!= bytes_per_pixel)
return grub_errno;
ptr[0] = tmp[2];
ptr[1] = tmp[1];
ptr[2] = tmp[0];
ptr += 3;
}
}
return GRUB_ERR_NONE;
}
static grub_err_t
tga_load_truecolor_R8G8B8A8 (struct grub_video_bitmap *bitmap,
struct grub_tga_header *header,
grub_file_t file)
{
unsigned int x;
unsigned int y;
grub_uint8_t *ptr;
grub_uint8_t tmp[4]; /* Size should be max_bpp / 8. */
grub_uint8_t bytes_per_pixel;
bytes_per_pixel = header->image_bpp / 8;
for (y = 0; y < header->image_height; y++)
{
ptr = bitmap->data;
if ((header->image_descriptor & GRUB_TGA_IMAGE_ORIGIN_TOP) != 0)
ptr += y * bitmap->mode_info.pitch;
else
ptr += (header->image_height - 1 - y) * bitmap->mode_info.pitch;
for (x = 0; x < header->image_width; x++)
{
if (grub_file_read (file, &tmp[0], bytes_per_pixel)
!= bytes_per_pixel)
return grub_errno;
ptr[0] = tmp[2];
ptr[1] = tmp[1];
ptr[2] = tmp[0];
ptr[3] = tmp[3];
ptr += 4;
}
}
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_reader_tga (struct grub_video_bitmap **bitmap,
const char *filename)
{
grub_file_t file;
grub_ssize_t pos;
struct grub_tga_header header;
int has_alpha;
file = grub_buffile_open (filename, 0);
if (! file)
return grub_errno;
/* TGA Specification states that we SHOULD start by reading
ID from end of file, but we really don't care about that as we are
not going to support developer area & extensions at this point. */
/* Read TGA header from beginning of file. */
if (grub_file_read (file, &header, sizeof (header))
!= sizeof (header))
{
grub_file_close (file);
return grub_errno;
}
/* Skip ID field. */
pos = grub_file_tell (file);
pos += header.id_length;
grub_file_seek (file, pos);
if (grub_errno != GRUB_ERR_NONE)
{
grub_file_close (file);
return grub_errno;
}
#if defined(TGA_DEBUG)
grub_printf("tga: header\n");
dump_int_field(header.id_length);
dump_int_field(header.color_map_type);
dump_int_field(header.image_type);
dump_int_field(header.color_map_first_index);
dump_int_field(header.color_map_length);
dump_int_field(header.color_map_bpp);
dump_int_field(header.image_x_origin);
dump_int_field(header.image_y_origin);
dump_int_field(header.image_width);
dump_int_field(header.image_height);
dump_int_field(header.image_bpp);
dump_int_field(header.image_descriptor);
#endif
/* Check that bitmap encoding is supported. */
switch (header.image_type)
{
case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
break;
default:
grub_file_close (file);
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"unsupported bitmap format (unknown encoding)");
}
/* Check that bitmap depth is supported. */
switch (header.image_bpp)
{
case 24:
has_alpha = 0;
break;
case 32:
has_alpha = 1;
break;
default:
grub_file_close (file);
return grub_error (GRUB_ERR_BAD_FILE_TYPE,
"unsupported bitmap format (bpp=%d)",
header.image_bpp);
}
/* Allocate bitmap. If there is alpha information store it too. */
if (has_alpha)
{
grub_video_bitmap_create (bitmap, header.image_width,
header.image_height,
GRUB_VIDEO_BLIT_FORMAT_RGBA_8888);
if (grub_errno != GRUB_ERR_NONE)
{
grub_file_close (file);
return grub_errno;
}
/* Load bitmap data. */
switch (header.image_type)
{
case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
tga_load_truecolor_R8G8B8A8 (*bitmap, &header, file);
break;
case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
tga_load_truecolor_rle_R8G8B8A8 (*bitmap, &header, file);
break;
}
}
else
{
grub_video_bitmap_create (bitmap, header.image_width,
header.image_height,
GRUB_VIDEO_BLIT_FORMAT_RGB_888);
if (grub_errno != GRUB_ERR_NONE)
{
grub_file_close (file);
return grub_errno;
}
/* Load bitmap data. */
switch (header.image_type)
{
case GRUB_TGA_IMAGE_TYPE_UNCOMPRESSED_TRUECOLOR:
tga_load_truecolor_R8G8B8 (*bitmap, &header, file);
break;
case GRUB_TGA_IMAGE_TYPE_RLE_TRUECOLOR:
tga_load_truecolor_rle_R8G8B8 (*bitmap, &header, file);
break;
}
}
/* If there was a loading problem, destroy bitmap. */
if (grub_errno != GRUB_ERR_NONE)
{
grub_video_bitmap_destroy (*bitmap);
*bitmap = 0;
}
grub_file_close (file);
return grub_errno;
}
#if defined(TGA_DEBUG)
static grub_err_t
grub_cmd_tgatest (grub_command_t cmd __attribute__ ((unused)),
int argc, char **args)
{
struct grub_video_bitmap *bitmap = 0;
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
grub_video_reader_tga (&bitmap, args[0]);
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
grub_video_bitmap_destroy (bitmap);
return GRUB_ERR_NONE;
}
#endif
static struct grub_video_bitmap_reader tga_reader = {
.extension = ".tga",
.reader = grub_video_reader_tga,
.next = 0
};
GRUB_MOD_INIT(tga)
{
grub_video_bitmap_reader_register (&tga_reader);
#if defined(TGA_DEBUG)
cmd = grub_register_command ("tgatest", grub_cmd_tgatest,
"FILE", "Tests loading of TGA bitmap.");
#endif
}
GRUB_MOD_FINI(tga)
{
#if defined(TGA_DEBUG)
grub_unregister_command (cmd);
#endif
grub_video_bitmap_reader_unregister (&tga_reader);
}

787
grub-core/video/sm712.c Normal file
View file

@ -0,0 +1,787 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2005,2006,2007,2008,2009,2010 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#define grub_video_render_target grub_video_fbrender_target
#include <grub/err.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/video.h>
#include <grub/video_fb.h>
#include <grub/pci.h>
#include <grub/vga.h>
#include "sm712_init.c"
#define GRUB_SM712_TOTAL_MEMORY_SPACE 0x700400
#define GRUB_SM712_REG_BASE 0x700000
#define GRUB_SM712_PCIID 0x0712126f
enum
{
GRUB_SM712_SR_TV_CONTROL = 0x65,
GRUB_SM712_SR_RAM_LUT = 0x66,
GRUB_SM712_SR_CLOCK_CONTROL1 = 0x68,
GRUB_SM712_SR_CLOCK_CONTROL2 = 0x69,
GRUB_SM712_SR_VCLK_NUM = 0x6c,
GRUB_SM712_SR_VCLK_DENOM = 0x6d,
GRUB_SM712_SR_VCLK2_NUM = 0x6e,
GRUB_SM712_SR_VCLK2_DENOM = 0x6f,
GRUB_SM712_SR_POPUP_ICON_LOW = 0x80,
GRUB_SM712_SR_POPUP_ICON_HIGH = 0x81,
GRUB_SM712_SR_POPUP_ICON_CTRL = 0x82,
GRUB_SM712_SR_POPUP_ICON_COLOR1 = 0x84,
GRUB_SM712_SR_POPUP_ICON_COLOR2 = 0x85,
GRUB_SM712_SR_POPUP_ICON_COLOR3 = 0x86,
GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_X_LOW = 0x88,
GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_X_HIGH = 0x89,
GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_Y_LOW = 0x8a,
GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_Y_HIGH = 0x8b,
GRUB_SM712_SR_HW_CURSOR_FG_COLOR = 0x8c,
GRUB_SM712_SR_HW_CURSOR_BG_COLOR = 0x8d,
GRUB_SM712_SR_POPUP_ICON_X_LOW = 0x90,
GRUB_SM712_SR_POPUP_ICON_X_HIGH = 0x91,
GRUB_SM712_SR_POPUP_ICON_Y_LOW = 0x92,
GRUB_SM712_SR_POPUP_ICON_Y_HIGH = 0x93,
GRUB_SM712_SR_PANEL_HW_VIDEO_CONTROL = 0xa0,
GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_LOW = 0xa1,
GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_HIGH = 0xa2,
GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_MASK_LOW = 0xa3,
GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_MASK_HIGH = 0xa4,
GRUB_SM712_SR_PANEL_HW_VIDEO_RED_CONSTANT = 0xa5,
GRUB_SM712_SR_PANEL_HW_VIDEO_GREEN_CONSTANT = 0xa6,
GRUB_SM712_SR_PANEL_HW_VIDEO_BLUE_CONSTANT = 0xa7,
GRUB_SM712_SR_PANEL_HW_VIDEO_TOP_BOUNDARY = 0xa8,
GRUB_SM712_SR_PANEL_HW_VIDEO_LEFT_BOUNDARY = 0xa9,
GRUB_SM712_SR_PANEL_HW_VIDEO_BOTTOM_BOUNDARY = 0xaa,
GRUB_SM712_SR_PANEL_HW_VIDEO_RIGHT_BOUNDARY = 0xab,
GRUB_SM712_SR_PANEL_HW_VIDEO_TOP_LEFT_OVERFLOW_BOUNDARY = 0xac,
GRUB_SM712_SR_PANEL_HW_VIDEO_BOTTOM_RIGHT_OVERFLOW_BOUNDARY = 0xad,
GRUB_SM712_SR_PANEL_HW_VIDEO_VERTICAL_STRETCH_FACTOR = 0xae,
GRUB_SM712_SR_PANEL_HW_VIDEO_HORIZONTAL_STRETCH_FACTOR = 0xaf,
};
enum
{
GRUB_SM712_SR_TV_CRT_SRAM = 0x00,
GRUB_SM712_SR_TV_LCD_SRAM = 0x08
};
enum
{
GRUB_SM712_SR_TV_ALT_CLOCK = 0x00,
GRUB_SM712_SR_TV_FREE_RUN_CLOCK = 0x04
};
enum
{
GRUB_SM712_SR_TV_CLOCK_CKIN_NTSC = 0x00,
GRUB_SM712_SR_TV_CLOCK_REFCLK_PAL = 0x04
};
enum
{
GRUB_SM712_SR_TV_HSYNC = 0x00,
GRUB_SM712_SR_TV_COMPOSITE_HSYNC = 0x01
};
enum
{
GRUB_SM712_SR_RAM_LUT_NORMAL = 0,
GRUB_SM712_SR_RAM_LUT_LCD_RAM_OFF = 0x80,
GRUB_SM712_SR_RAM_LUT_CRT_RAM_OFF = 0x40,
GRUB_SM712_SR_RAM_LUT_LCD_RAM_NO_WRITE = 0x20,
GRUB_SM712_SR_RAM_LUT_CRT_RAM_NO_WRITE = 0x10,
GRUB_SM712_SR_RAM_LUT_CRT_8BIT = 0x08,
GRUB_SM712_SR_RAM_LUT_CRT_GAMMA = 0x04
};
enum
{
GRUB_SM712_SR_CLOCK_CONTROL1_VCLK_FROM_CCR = 0x40,
GRUB_SM712_SR_CLOCK_CONTROL1_8DOT_CLOCK = 0x10,
};
enum
{
GRUB_SM712_SR_CLOCK_CONTROL2_PROGRAM_VCLOCK = 0x03
};
#define GRUB_SM712_SR_POPUP_ICON_HIGH_MASK 0x7
#define GRUB_SM712_SR_POPUP_ICON_HIGH_HW_CURSOR_EN 0x80
enum
{
GRUB_SM712_SR_POPUP_ICON_CTRL_DISABLED = 0,
GRUB_SM712_SR_POPUP_ICON_CTRL_ZOOM_ENABLED = 0x40,
GRUB_SM712_SR_POPUP_ICON_CTRL_ENABLED = 0x80
};
#define RGB332_BLACK 0
#define RGB332_WHITE 0xff
enum
{
GRUB_SM712_CR_OVERFLOW_INTERLACE = 0x30,
GRUB_SM712_CR_INTERLACE_RETRACE = 0x31,
GRUB_SM712_CR_TV_VDISPLAY_START = 0x32,
GRUB_SM712_CR_TV_VDISPLAY_END_HIGH = 0x33,
GRUB_SM712_CR_TV_VDISPLAY_END_LOW = 0x34,
GRUB_SM712_CR_DDA_CONTROL_LOW = 0x35,
GRUB_SM712_CR_DDA_CONTROL_HIGH = 0x36,
GRUB_SM712_CR_TV_EQUALIZER = 0x38,
GRUB_SM712_CR_TV_SERRATION = 0x39,
GRUB_SM712_CR_HSYNC_CTRL = 0x3a,
GRUB_SM712_CR_DEBUG = 0x3c,
GRUB_SM712_CR_SHADOW_VGA_HTOTAL = 0x40,
GRUB_SM712_CR_SHADOW_VGA_HBLANK_START = 0x41,
GRUB_SM712_CR_SHADOW_VGA_HBLANK_END = 0x42,
GRUB_SM712_CR_SHADOW_VGA_HRETRACE_START = 0x43,
GRUB_SM712_CR_SHADOW_VGA_HRETRACE_END = 0x44,
GRUB_SM712_CR_SHADOW_VGA_VERTICAL_TOTAL = 0x45,
GRUB_SM712_CR_SHADOW_VGA_VBLANK_START = 0x46,
GRUB_SM712_CR_SHADOW_VGA_VBLANK_END = 0x47,
GRUB_SM712_CR_SHADOW_VGA_VRETRACE_START = 0x48,
GRUB_SM712_CR_SHADOW_VGA_VRETRACE_END = 0x49,
GRUB_SM712_CR_SHADOW_VGA_OVERFLOW = 0x4a,
GRUB_SM712_CR_SHADOW_VGA_CELL_HEIGHT = 0x4b,
GRUB_SM712_CR_SHADOW_VGA_HDISPLAY_END = 0x4c,
GRUB_SM712_CR_SHADOW_VGA_VDISPLAY_END = 0x4d,
GRUB_SM712_CR_DDA_LOOKUP_REG3_START = 0x90,
GRUB_SM712_CR_DDA_LOOKUP_REG2_START = 0x91,
GRUB_SM712_CR_DDA_LOOKUP_REG1_START = 0xa0,
GRUB_SM712_CR_VCENTERING_OFFSET = 0xa6,
GRUB_SM712_CR_HCENTERING_OFFSET = 0xa7,
};
#define GRUB_SM712_CR_DEBUG_NONE 0
#define SM712_DDA_REG3_COMPARE_SHIFT 2
#define SM712_DDA_REG3_COMPARE_MASK 0xfc
#define SM712_DDA_REG3_DDA_SHIFT 8
#define SM712_DDA_REG3_DDA_MASK 0x3
#define SM712_DDA_REG2_DDA_MASK 0xff
#define SM712_DDA_REG2_VCENTER_MASK 0x3f
static struct
{
grub_uint8_t compare;
grub_uint16_t dda;
grub_uint8_t vcentering;
} dda_lookups[] = {
{ 21, 469, 2},
{ 23, 477, 2},
{ 33, 535, 2},
{ 35, 682, 21},
{ 34, 675, 2},
{ 55, 683, 6},
};
static struct
{
struct grub_video_mode_info mode_info;
struct grub_video_render_target *render_target;
grub_uint8_t *ptr;
int mapped;
grub_uint32_t base;
grub_pci_device_t dev;
} framebuffer;
#ifndef TEST
static grub_err_t
grub_video_sm712_video_init (void)
{
/* Reset frame buffer. */
grub_memset (&framebuffer, 0, sizeof(framebuffer));
return grub_video_fb_init ();
}
static grub_err_t
grub_video_sm712_video_fini (void)
{
if (framebuffer.mapped)
grub_pci_device_unmap_range (framebuffer.dev, framebuffer.ptr,
GRUB_SM712_TOTAL_MEMORY_SPACE);
return grub_video_fb_fini ();
}
#endif
static inline void
grub_sm712_write_reg (grub_uint8_t val, grub_uint16_t addr)
{
#ifdef TEST
printf (" {1, 0x%x, 0x%x},\n", addr, val);
#else
*(volatile grub_uint8_t *) (framebuffer.ptr + GRUB_SM712_REG_BASE
+ addr) = val;
#endif
}
static inline grub_uint8_t
grub_sm712_read_reg (grub_uint16_t addr)
{
#ifdef TEST
printf (" {-1, 0x%x, 0x5},\n", addr);
#else
return *(volatile grub_uint8_t *) (framebuffer.ptr + GRUB_SM712_REG_BASE
+ addr);
#endif
}
static inline grub_uint8_t
grub_sm712_sr_read (grub_uint8_t addr)
{
grub_sm712_write_reg (addr, GRUB_VGA_IO_SR_INDEX);
return grub_sm712_read_reg (GRUB_VGA_IO_SR_DATA);
}
static inline void
grub_sm712_sr_write (grub_uint8_t val, grub_uint8_t addr)
{
grub_sm712_write_reg (addr, GRUB_VGA_IO_SR_INDEX);
grub_sm712_write_reg (val, GRUB_VGA_IO_SR_DATA);
}
static inline void
grub_sm712_gr_write (grub_uint8_t val, grub_uint8_t addr)
{
grub_sm712_write_reg (addr, GRUB_VGA_IO_GR_INDEX);
grub_sm712_write_reg (val, GRUB_VGA_IO_GR_DATA);
}
static inline void
grub_sm712_cr_write (grub_uint8_t val, grub_uint8_t addr)
{
grub_sm712_write_reg (addr, GRUB_VGA_IO_CR_INDEX);
grub_sm712_write_reg (val, GRUB_VGA_IO_CR_DATA);
}
static inline void
grub_sm712_write_arx (grub_uint8_t val, grub_uint8_t addr)
{
grub_sm712_read_reg (GRUB_VGA_IO_INPUT_STATUS1_REGISTER);
grub_sm712_write_reg (addr, GRUB_VGA_IO_ARX);
grub_sm712_read_reg (GRUB_VGA_IO_ARX_READ);
grub_sm712_write_reg (val, GRUB_VGA_IO_ARX);
}
static inline void
grub_sm712_cr_shadow_write (grub_uint8_t val, grub_uint8_t addr)
{
grub_uint8_t mapping[] =
{
[GRUB_VGA_CR_HTOTAL] = GRUB_SM712_CR_SHADOW_VGA_HTOTAL,
[GRUB_VGA_CR_HORIZ_END] = 0xff,
[GRUB_VGA_CR_HBLANK_START] = GRUB_SM712_CR_SHADOW_VGA_HBLANK_START,
[GRUB_VGA_CR_HBLANK_END] = GRUB_SM712_CR_SHADOW_VGA_HBLANK_END,
[GRUB_VGA_CR_HORIZ_SYNC_PULSE_START] = GRUB_SM712_CR_SHADOW_VGA_HRETRACE_START,
[GRUB_VGA_CR_HORIZ_SYNC_PULSE_END] = GRUB_SM712_CR_SHADOW_VGA_HRETRACE_END,
[GRUB_VGA_CR_VERT_TOTAL] = GRUB_SM712_CR_SHADOW_VGA_VERTICAL_TOTAL,
[GRUB_VGA_CR_OVERFLOW] = GRUB_SM712_CR_SHADOW_VGA_OVERFLOW,
[GRUB_VGA_CR_BYTE_PANNING] = 0xff,
[GRUB_VGA_CR_CELL_HEIGHT] = GRUB_SM712_CR_SHADOW_VGA_CELL_HEIGHT,
[GRUB_VGA_CR_CURSOR_START] = 0xff,
[GRUB_VGA_CR_CURSOR_END] = 0xff,
[GRUB_VGA_CR_START_ADDR_HIGH_REGISTER] = 0xff,
[GRUB_VGA_CR_START_ADDR_LOW_REGISTER] = 0xff,
[GRUB_VGA_CR_CURSOR_ADDR_HIGH] = 0xff,
[GRUB_VGA_CR_CURSOR_ADDR_LOW] = 0xff,
[GRUB_VGA_CR_VSYNC_START] = GRUB_SM712_CR_SHADOW_VGA_VRETRACE_START,
[GRUB_VGA_CR_VSYNC_END] = GRUB_SM712_CR_SHADOW_VGA_VRETRACE_END,
[GRUB_VGA_CR_VDISPLAY_END] = GRUB_SM712_CR_SHADOW_VGA_VDISPLAY_END,
[GRUB_VGA_CR_PITCH] = GRUB_SM712_CR_SHADOW_VGA_HDISPLAY_END,
[GRUB_VGA_CR_UNDERLINE_LOCATION] = 0xff,
[GRUB_VGA_CR_VERTICAL_BLANK_START] = GRUB_SM712_CR_SHADOW_VGA_VBLANK_START,
[GRUB_VGA_CR_VERTICAL_BLANK_END] = GRUB_SM712_CR_SHADOW_VGA_VBLANK_END,
[GRUB_VGA_CR_MODE] = 0xff,
[GRUB_VGA_CR_LINE_COMPARE] = 0xff
};
if (addr >= ARRAY_SIZE (mapping) || mapping[addr] == 0xff)
return;
grub_sm712_cr_write (val, mapping[addr]);
}
static inline void
grub_sm712_write_dda_lookup (int idx, grub_uint8_t compare, grub_uint16_t dda,
grub_uint8_t vcentering)
{
grub_sm712_cr_write (((compare << SM712_DDA_REG3_COMPARE_SHIFT)
& SM712_DDA_REG3_COMPARE_MASK)
| ((dda >> SM712_DDA_REG3_DDA_SHIFT)
& SM712_DDA_REG3_DDA_MASK),
GRUB_SM712_CR_DDA_LOOKUP_REG3_START + 2 * idx);
grub_sm712_cr_write (dda & SM712_DDA_REG2_DDA_MASK,
GRUB_SM712_CR_DDA_LOOKUP_REG2_START + 2 * idx);
grub_sm712_cr_write (vcentering & SM712_DDA_REG2_VCENTER_MASK,
GRUB_SM712_CR_DDA_LOOKUP_REG1_START + idx);
}
static grub_err_t
grub_video_sm712_setup (unsigned int width, unsigned int height,
unsigned int mode_type, unsigned int mode_mask __attribute__ ((unused)))
{
int depth;
grub_err_t err;
int found = 0;
unsigned i;
#ifndef TEST
auto int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid __attribute__ ((unused)));
int NESTED_FUNC_ATTR find_card (grub_pci_device_t dev, grub_pci_id_t pciid __attribute__ ((unused)))
{
grub_pci_address_t addr;
grub_uint32_t class;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
class = grub_pci_read (addr);
if (((class >> 16) & 0xffff) != GRUB_PCI_CLASS_SUBCLASS_VGA
|| pciid != GRUB_SM712_PCIID)
return 0;
found = 1;
addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
framebuffer.base = grub_pci_read (addr);
framebuffer.dev = dev;
return 1;
}
/* Decode depth from mode_type. If it is zero, then autodetect. */
depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
>> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
if ((width != 1024 && width != 0) || (height != 600 && height != 0)
|| (depth != 16 && depth != 0))
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
"Only 1024x600x16 is supported");
grub_pci_iterate (find_card);
if (!found)
return grub_error (GRUB_ERR_IO, "Couldn't find graphics card");
#endif
/* Fill mode info details. */
framebuffer.mode_info.width = 1024;
framebuffer.mode_info.height = 600;
framebuffer.mode_info.mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
framebuffer.mode_info.bpp = 16;
framebuffer.mode_info.bytes_per_pixel = 2;
framebuffer.mode_info.pitch = 1024 * 2;
framebuffer.mode_info.number_of_colors = 256;
framebuffer.mode_info.red_mask_size = 5;
framebuffer.mode_info.red_field_pos = 11;
framebuffer.mode_info.green_mask_size = 6;
framebuffer.mode_info.green_field_pos = 5;
framebuffer.mode_info.blue_mask_size = 5;
framebuffer.mode_info.blue_field_pos = 0;
framebuffer.mode_info.reserved_mask_size = 0;
framebuffer.mode_info.reserved_field_pos = 0;
#ifndef TEST
framebuffer.mode_info.blit_format
= grub_video_get_blit_format (&framebuffer.mode_info);
#endif
#ifndef TEST
if (found && framebuffer.base == 0)
{
grub_pci_address_t addr;
/* FIXME: choose address dynamically if needed. */
framebuffer.base = 0x04000000;
addr = grub_pci_make_address (framebuffer.dev, GRUB_PCI_REG_ADDRESS_REG0);
grub_pci_write (addr, framebuffer.base);
/* Set latency. */
addr = grub_pci_make_address (framebuffer.dev, GRUB_PCI_REG_CACHELINE);
grub_pci_write (addr, 0x8);
/* Enable address spaces. */
addr = grub_pci_make_address (framebuffer.dev, GRUB_PCI_REG_COMMAND);
grub_pci_write (addr, 0x7);
}
#endif
/* We can safely discard volatile attribute. */
#ifndef TEST
framebuffer.ptr
= (void *) grub_pci_device_map_range (framebuffer.dev,
framebuffer.base,
GRUB_SM712_TOTAL_MEMORY_SPACE);
#endif
framebuffer.mapped = 1;
/* Initialise SM712. */
#ifndef TEST
/* FIXME */
grub_vga_sr_write (0x11, 0x18);
#endif
#ifndef TEST
/* Prevent garbage from appearing on the screen. */
grub_memset (framebuffer.ptr, 0,
framebuffer.mode_info.height * framebuffer.mode_info.pitch);
#endif
/* FIXME */
grub_sm712_sr_write (0, 0x21);
grub_sm712_sr_write (0x7a, 0x62);
grub_sm712_sr_write (0x16, 0x6a);
grub_sm712_sr_write (0x2, 0x6b);
grub_sm712_write_reg (0, GRUB_VGA_IO_PIXEL_MASK);
grub_sm712_sr_write (GRUB_VGA_SR_RESET_ASYNC, GRUB_VGA_SR_RESET);
grub_sm712_write_reg (GRUB_VGA_IO_MISC_NEGATIVE_VERT_POLARITY
| GRUB_VGA_IO_MISC_NEGATIVE_HORIZ_POLARITY
| GRUB_VGA_IO_MISC_UPPER_64K
| GRUB_VGA_IO_MISC_EXTERNAL_CLOCK_0
| GRUB_VGA_IO_MISC_ENABLE_VRAM_ACCESS
| GRUB_VGA_IO_MISC_COLOR, GRUB_VGA_IO_MISC_WRITE);
grub_sm712_sr_write (GRUB_VGA_SR_RESET_ASYNC | GRUB_VGA_SR_RESET_SYNC,
GRUB_VGA_SR_RESET);
grub_sm712_sr_write (GRUB_VGA_SR_CLOCKING_MODE_8_DOT_CLOCK,
GRUB_VGA_SR_CLOCKING_MODE);
grub_sm712_sr_write (GRUB_VGA_ALL_PLANES, GRUB_VGA_SR_MAP_MASK_REGISTER);
grub_sm712_sr_write (0, GRUB_VGA_SR_CHAR_MAP_SELECT);
grub_sm712_sr_write (GRUB_VGA_SR_MEMORY_MODE_CHAIN4
| GRUB_VGA_SR_MEMORY_MODE_SEQUENTIAL_ADDRESSING
| GRUB_VGA_SR_MEMORY_MODE_EXTERNAL_VIDEO_MEMORY,
GRUB_VGA_SR_MEMORY_MODE);
for (i = 0; i < ARRAY_SIZE (sm712_sr_seq1); i++)
grub_sm712_sr_write (sm712_sr_seq1[i], 0x10 + i);
for (i = 0; i < ARRAY_SIZE (sm712_sr_seq2); i++)
grub_sm712_sr_write (sm712_sr_seq2[i], 0x30 + i);
/* Undocumented. */
grub_sm712_sr_write (0x1a, 0x63);
/* Undocumented. */
grub_sm712_sr_write (0x1a, 0x64);
grub_sm712_sr_write (GRUB_SM712_SR_TV_CRT_SRAM | GRUB_SM712_SR_TV_ALT_CLOCK
| GRUB_SM712_SR_TV_CLOCK_CKIN_NTSC
| GRUB_SM712_SR_TV_HSYNC,
GRUB_SM712_SR_TV_CONTROL);
grub_sm712_sr_write (GRUB_SM712_SR_RAM_LUT_NORMAL, GRUB_SM712_SR_RAM_LUT);
/* Undocumented. */
grub_sm712_sr_write (0x00, 0x67);
grub_sm712_sr_write (GRUB_SM712_SR_CLOCK_CONTROL1_VCLK_FROM_CCR
| GRUB_SM712_SR_CLOCK_CONTROL1_8DOT_CLOCK,
GRUB_SM712_SR_CLOCK_CONTROL1);
grub_sm712_sr_write (GRUB_SM712_SR_CLOCK_CONTROL2_PROGRAM_VCLOCK,
GRUB_SM712_SR_CLOCK_CONTROL2);
grub_sm712_sr_write (82, GRUB_SM712_SR_VCLK_NUM);
grub_sm712_sr_write (137, GRUB_SM712_SR_VCLK_DENOM);
grub_sm712_sr_write (9, GRUB_SM712_SR_VCLK2_NUM);
grub_sm712_sr_write (2, GRUB_SM712_SR_VCLK2_DENOM);
/* FIXME */
grub_sm712_sr_write (0x04, 0x70);
/* FIXME */
grub_sm712_sr_write (0x45, 0x71);
/* Undocumented */
grub_sm712_sr_write (0x30, 0x72);
/* Undocumented */
grub_sm712_sr_write (0x30, 0x73);
/* Undocumented */
grub_sm712_sr_write (0x40, 0x74);
/* Undocumented */
grub_sm712_sr_write (0x20, 0x75);
grub_sm712_sr_write (0xff, GRUB_SM712_SR_POPUP_ICON_LOW);
grub_sm712_sr_write (GRUB_SM712_SR_POPUP_ICON_HIGH_MASK,
GRUB_SM712_SR_POPUP_ICON_HIGH);
grub_sm712_sr_write (GRUB_SM712_SR_POPUP_ICON_CTRL_DISABLED,
GRUB_SM712_SR_POPUP_ICON_CTRL);
/* Undocumented */
grub_sm712_sr_write (0x0, 0x83);
grub_sm712_sr_write (8, GRUB_SM712_SR_POPUP_ICON_COLOR1);
grub_sm712_sr_write (0, GRUB_SM712_SR_POPUP_ICON_COLOR2);
grub_sm712_sr_write (0x42, GRUB_SM712_SR_POPUP_ICON_COLOR3);
/* Undocumented */
grub_sm712_sr_write (0x3a, 0x87);
/* Why theese coordinates? */
grub_sm712_sr_write (0x59, GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_X_LOW);
grub_sm712_sr_write (0x02, GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_X_HIGH);
grub_sm712_sr_write (0x44, GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_Y_LOW);
grub_sm712_sr_write (0x02, GRUB_SM712_SR_HW_CURSOR_UPPER_LEFT_Y_HIGH);
grub_sm712_sr_write (RGB332_BLACK, GRUB_SM712_SR_HW_CURSOR_FG_COLOR);
grub_sm712_sr_write (RGB332_WHITE, GRUB_SM712_SR_HW_CURSOR_BG_COLOR);
/* Undocumented */
grub_sm712_sr_write (0x3a, 0x8e);
grub_sm712_sr_write (0x3a, 0x8f);
grub_sm712_sr_write (0, GRUB_SM712_SR_POPUP_ICON_X_LOW);
grub_sm712_sr_write (0, GRUB_SM712_SR_POPUP_ICON_X_HIGH);
grub_sm712_sr_write (0, GRUB_SM712_SR_POPUP_ICON_Y_LOW);
grub_sm712_sr_write (0, GRUB_SM712_SR_POPUP_ICON_Y_HIGH);
grub_sm712_sr_write (0, GRUB_SM712_SR_PANEL_HW_VIDEO_CONTROL);
grub_sm712_sr_write (0x10, GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_LOW);
grub_sm712_sr_write (0x08, GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_HIGH);
grub_sm712_sr_write (0x00, GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_MASK_LOW);
grub_sm712_sr_write (0x02, GRUB_SM712_SR_PANEL_HW_VIDEO_COLOR_KEY_MASK_HIGH);
grub_sm712_sr_write (0xed, GRUB_SM712_SR_PANEL_HW_VIDEO_RED_CONSTANT);
grub_sm712_sr_write (0xed, GRUB_SM712_SR_PANEL_HW_VIDEO_GREEN_CONSTANT);
grub_sm712_sr_write (0xed, GRUB_SM712_SR_PANEL_HW_VIDEO_BLUE_CONSTANT);
grub_sm712_sr_write (0x7b, GRUB_SM712_SR_PANEL_HW_VIDEO_TOP_BOUNDARY);
grub_sm712_sr_write (0xfb, GRUB_SM712_SR_PANEL_HW_VIDEO_LEFT_BOUNDARY);
grub_sm712_sr_write (0xff, GRUB_SM712_SR_PANEL_HW_VIDEO_BOTTOM_BOUNDARY);
grub_sm712_sr_write (0xff, GRUB_SM712_SR_PANEL_HW_VIDEO_RIGHT_BOUNDARY);
/* Doesn't match documentation? */
grub_sm712_sr_write (0x97, GRUB_SM712_SR_PANEL_HW_VIDEO_TOP_LEFT_OVERFLOW_BOUNDARY);
grub_sm712_sr_write (0xef, GRUB_SM712_SR_PANEL_HW_VIDEO_BOTTOM_RIGHT_OVERFLOW_BOUNDARY);
grub_sm712_sr_write (0xbf, GRUB_SM712_SR_PANEL_HW_VIDEO_VERTICAL_STRETCH_FACTOR);
grub_sm712_sr_write (0xdf, GRUB_SM712_SR_PANEL_HW_VIDEO_HORIZONTAL_STRETCH_FACTOR);
grub_sm712_gr_write (GRUB_VGA_NO_PLANES, GRUB_VGA_GR_SET_RESET_PLANE);
grub_sm712_gr_write (GRUB_VGA_NO_PLANES, GRUB_VGA_GR_SET_RESET_PLANE_ENABLE);
grub_sm712_gr_write (GRUB_VGA_NO_PLANES, GRUB_VGA_GR_COLOR_COMPARE);
grub_sm712_gr_write (GRUB_VGA_GR_DATA_ROTATE_NOP, GRUB_VGA_GR_DATA_ROTATE);
grub_sm712_gr_write (GRUB_VGA_NO_PLANES, GRUB_VGA_GR_READ_MAP_REGISTER);
grub_sm712_gr_write (GRUB_VGA_GR_MODE_256_COLOR, GRUB_VGA_GR_MODE);
grub_sm712_gr_write (GRUB_VGA_GR_GR6_MMAP_A0
| GRUB_VGA_GR_GR6_GRAPHICS_MODE, GRUB_VGA_GR_GR6);
grub_sm712_gr_write (GRUB_VGA_ALL_PLANES, GRUB_VGA_GR_COLOR_COMPARE_DISABLE);
grub_sm712_gr_write (0xff, GRUB_VGA_GR_BITMASK);
/* Write palette mapping. */
for (i = 0; i < 16; i++)
grub_sm712_write_arx (i, i);
grub_sm712_write_arx (GRUB_VGA_ARX_MODE_ENABLE_256COLOR
| GRUB_VGA_ARX_MODE_GRAPHICS, GRUB_VGA_ARX_MODE);
grub_sm712_write_arx (0, GRUB_VGA_ARX_OVERSCAN);
grub_sm712_write_arx (GRUB_VGA_ALL_PLANES, GRUB_VGA_ARX_COLOR_PLANE_ENABLE);
grub_sm712_write_arx (0, GRUB_VGA_ARX_HORIZONTAL_PANNING);
grub_sm712_write_arx (0, GRUB_VGA_ARX_COLOR_SELECT);
/* FIXME: compute this generically. */
{
struct grub_video_hw_config config =
{
.vertical_total = 806,
.vertical_blank_start = 0x300,
.vertical_blank_end = 0,
.vertical_sync_start = 0x303,
.vertical_sync_end = 0x9,
.line_compare = 0x3ff,
.vdisplay_end = 0x300,
.pitch = 0x80,
.horizontal_total = 164,
.horizontal_end = 128,
.horizontal_blank_start = 128,
.horizontal_blank_end = 0,
.horizontal_sync_pulse_start = 133,
.horizontal_sync_pulse_end = 22
};
grub_vga_set_geometry (&config, grub_sm712_cr_write);
config.horizontal_sync_pulse_start = 134;
config.horizontal_sync_pulse_end = 21;
config.vertical_sync_start = 0x301;
config.vertical_sync_end = 0x0;
config.line_compare = 0x0ff;
config.vdisplay_end = 0x258;
config.pitch = 0x7f;
grub_vga_set_geometry (&config, grub_sm712_cr_shadow_write);
}
grub_sm712_cr_write (GRUB_VGA_CR_BYTE_PANNING_NORMAL,
GRUB_VGA_CR_BYTE_PANNING);
grub_sm712_cr_write (0, GRUB_VGA_CR_CURSOR_START);
grub_sm712_cr_write (0, GRUB_VGA_CR_CURSOR_END);
grub_sm712_cr_write (0, GRUB_VGA_CR_START_ADDR_HIGH_REGISTER);
grub_sm712_cr_write (0, GRUB_VGA_CR_START_ADDR_LOW_REGISTER);
grub_sm712_cr_write (0, GRUB_VGA_CR_CURSOR_ADDR_HIGH);
grub_sm712_cr_write (0, GRUB_VGA_CR_CURSOR_ADDR_LOW);
grub_sm712_cr_write (GRUB_VGA_CR_UNDERLINE_LOCATION_DWORD_MODE,
GRUB_VGA_CR_UNDERLINE_LOCATION);
grub_sm712_cr_write (GRUB_VGA_CR_MODE_ADDRESS_WRAP
| GRUB_VGA_CR_MODE_BYTE_MODE
| GRUB_VGA_CR_MODE_TIMING_ENABLE
| GRUB_VGA_CR_MODE_NO_CGA
| GRUB_VGA_CR_MODE_NO_HERCULES,
GRUB_VGA_CR_MODE);
grub_sm712_cr_write (0, GRUB_SM712_CR_OVERFLOW_INTERLACE);
grub_sm712_cr_write (0, GRUB_SM712_CR_INTERLACE_RETRACE);
grub_sm712_cr_write (0, GRUB_SM712_CR_TV_VDISPLAY_START);
grub_sm712_cr_write (0, GRUB_SM712_CR_TV_VDISPLAY_END_HIGH);
grub_sm712_cr_write (0, GRUB_SM712_CR_TV_VDISPLAY_END_LOW);
grub_sm712_cr_write (0x80, GRUB_SM712_CR_DDA_CONTROL_LOW);
grub_sm712_cr_write (0x02, GRUB_SM712_CR_DDA_CONTROL_HIGH);
/* Undocumented */
grub_sm712_cr_write (0x20, 0x37);
grub_sm712_cr_write (0, GRUB_SM712_CR_TV_EQUALIZER);
grub_sm712_cr_write (0, GRUB_SM712_CR_TV_SERRATION);
grub_sm712_cr_write (0, GRUB_SM712_CR_HSYNC_CTRL);
/* Undocumented */
grub_sm712_cr_write (0x40, 0x3b);
grub_sm712_cr_write (GRUB_SM712_CR_DEBUG_NONE, GRUB_SM712_CR_DEBUG);
/* Undocumented */
grub_sm712_cr_write (0xff, 0x3d);
grub_sm712_cr_write (0x46, 0x3e);
grub_sm712_cr_write (0x91, 0x3f);
for (i = 0; i < ARRAY_SIZE (dda_lookups); i++)
grub_sm712_write_dda_lookup (i, dda_lookups[i].compare, dda_lookups[i].dda,
dda_lookups[i].vcentering);
/* Undocumented */
grub_sm712_cr_write (0, 0x9c);
grub_sm712_cr_write (0, 0x9d);
grub_sm712_cr_write (0, 0x9e);
grub_sm712_cr_write (0, 0x9f);
grub_sm712_cr_write (0, GRUB_SM712_CR_VCENTERING_OFFSET);
grub_sm712_cr_write (0, GRUB_SM712_CR_HCENTERING_OFFSET);
grub_sm712_write_reg (GRUB_VGA_IO_MISC_NEGATIVE_HORIZ_POLARITY
| GRUB_VGA_IO_MISC_UPPER_64K
| GRUB_VGA_IO_MISC_28MHZ
| GRUB_VGA_IO_MISC_ENABLE_VRAM_ACCESS
| GRUB_VGA_IO_MISC_COLOR,
GRUB_VGA_IO_MISC_WRITE);
#ifndef TEST
/* Undocumented? */
*(volatile grub_uint32_t *) ((char *) framebuffer.ptr + 0x40c00c) = 0;
*(volatile grub_uint32_t *) ((char *) framebuffer.ptr + 0x40c040) = 0;
*(volatile grub_uint32_t *) ((char *) framebuffer.ptr + 0x40c000) = 0x20000;
*(volatile grub_uint32_t *) ((char *) framebuffer.ptr + 0x40c010) = 0x1020100;
#endif
(void) grub_sm712_sr_read (0x16);
#ifndef TEST
err = grub_video_fb_create_render_target_from_pointer (&framebuffer
.render_target,
&framebuffer.mode_info,
framebuffer.ptr);
if (err)
return err;
err = grub_video_fb_set_active_render_target (framebuffer.render_target);
if (err)
return err;
/* Copy default palette to initialize emulated palette. */
err = grub_video_fb_set_palette (0, GRUB_VIDEO_FBSTD_NUMCOLORS,
grub_video_fbstd_colors);
#endif
return err;
}
#ifndef TEST
static grub_err_t
grub_video_sm712_swap_buffers (void)
{
/* TODO: Implement buffer swapping. */
return GRUB_ERR_NONE;
}
static grub_err_t
grub_video_sm712_set_active_render_target (struct grub_video_render_target *target)
{
if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
target = framebuffer.render_target;
return grub_video_fb_set_active_render_target (target);
}
static grub_err_t
grub_video_sm712_get_info_and_fini (struct grub_video_mode_info *mode_info,
void **framebuf)
{
grub_memcpy (mode_info, &(framebuffer.mode_info), sizeof (*mode_info));
*framebuf = (char *) framebuffer.ptr;
grub_video_fb_fini ();
return GRUB_ERR_NONE;
}
static struct grub_video_adapter grub_video_sm712_adapter =
{
.name = "SM712 Video Driver",
.id = GRUB_VIDEO_DRIVER_SM712,
.prio = GRUB_VIDEO_ADAPTER_PRIO_NATIVE,
.init = grub_video_sm712_video_init,
.fini = grub_video_sm712_video_fini,
.setup = grub_video_sm712_setup,
.get_info = grub_video_fb_get_info,
.get_info_and_fini = grub_video_sm712_get_info_and_fini,
.set_palette = grub_video_fb_set_palette,
.get_palette = grub_video_fb_get_palette,
.set_viewport = grub_video_fb_set_viewport,
.get_viewport = grub_video_fb_get_viewport,
.map_color = grub_video_fb_map_color,
.map_rgb = grub_video_fb_map_rgb,
.map_rgba = grub_video_fb_map_rgba,
.unmap_color = grub_video_fb_unmap_color,
.fill_rect = grub_video_fb_fill_rect,
.blit_bitmap = grub_video_fb_blit_bitmap,
.blit_render_target = grub_video_fb_blit_render_target,
.scroll = grub_video_fb_scroll,
.swap_buffers = grub_video_sm712_swap_buffers,
.create_render_target = grub_video_fb_create_render_target,
.delete_render_target = grub_video_fb_delete_render_target,
.set_active_render_target = grub_video_sm712_set_active_render_target,
.get_active_render_target = grub_video_fb_get_active_render_target,
.next = 0
};
GRUB_MOD_INIT(video_sm712)
{
grub_video_register (&grub_video_sm712_adapter);
}
GRUB_MOD_FINI(video_sm712)
{
grub_video_unregister (&grub_video_sm712_adapter);
}
#else
int
main ()
{
grub_video_sm712_setup (1024, 600, 0, 0);
}
#endif

14
grub-core/video/sm712_init.c Normal file
View file

@ -0,0 +1,14 @@
/* Following sequence is a capture of sm712 initialisation sequence. */
static grub_uint8_t sm712_sr_seq1[] =
{ 0xc8, 0x40, 0x14, 0x60, 0x0, 0xa, 0x92, 0x0,
0x51, 0x00, 0x01, 0x00, 0x0, 0x0, 0x00, 0x0,
0xc4, 0x30, 0x02, 0x00, 0x1 };
static grub_uint8_t sm712_sr_seq2[] =
{ 0x28, 0x03, 0x24, 0x09, 0xc0, 0x3a, 0x3a, 0x3a,
0x3a, 0x3a, 0x3a, 0x3a, 0x00, 0x00, 0x03, 0xff,
0x00, 0xfc, 0x00, 0x00, 0x20, 0x18, 0x00, 0xfc,
0x20, 0x0c, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3a,
0x06, 0x68, 0xa7, 0x7f, 0x83, 0x24, 0xff, 0x03,
0x00, 0x60, 0x59, 0x3a, 0x3a, 0x00, 0x00, 0x3a,
0x01, 0x80 };

673
grub-core/video/video.c Normal file
View file

@ -0,0 +1,673 @@
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2006,2007,2008,2009 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/video.h>
#include <grub/types.h>
#include <grub/dl.h>
#include <grub/misc.h>
#include <grub/mm.h>
/* The list of video adapters registered to system. */
grub_video_adapter_t grub_video_adapter_list = NULL;
/* Active video adapter. */
static grub_video_adapter_t grub_video_adapter_active;
/* Restore back to initial mode (where applicable). */
grub_err_t
grub_video_restore (void)
{
if (grub_video_adapter_active)
{
grub_video_adapter_active->fini ();
if (grub_errno != GRUB_ERR_NONE)
return grub_errno;
grub_video_adapter_active = 0;
}
return GRUB_ERR_NONE;
}
/* Get information about active video mode. */
grub_err_t
grub_video_get_info (struct grub_video_mode_info *mode_info)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
/* If mode_info is NULL just report that video adapter is active. */
if (! mode_info)
{
grub_errno = GRUB_ERR_NONE;
return grub_errno;
}
return grub_video_adapter_active->get_info (mode_info);
}
grub_video_driver_id_t
grub_video_get_driver_id (void)
{
if (! grub_video_adapter_active)
return GRUB_VIDEO_DRIVER_NONE;
return grub_video_adapter_active->id;
}
/* Get information about active video mode. */
grub_err_t
grub_video_get_info_and_fini (struct grub_video_mode_info *mode_info,
void **framebuffer)
{
grub_err_t err;
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
err = grub_video_adapter_active->get_info_and_fini (mode_info, framebuffer);
if (err)
return err;
grub_video_adapter_active = 0;
return GRUB_ERR_NONE;
}
/* Determine optimized blitting formation for specified video mode info. */
enum grub_video_blit_format
grub_video_get_blit_format (struct grub_video_mode_info *mode_info)
{
/* Check if we have any known 32 bit modes. */
if (mode_info->bpp == 32)
{
if ((mode_info->red_mask_size == 8)
&& (mode_info->red_field_pos == 16)
&& (mode_info->green_mask_size == 8)
&& (mode_info->green_field_pos == 8)
&& (mode_info->blue_mask_size == 8)
&& (mode_info->blue_field_pos == 0))
{
return GRUB_VIDEO_BLIT_FORMAT_BGRA_8888;
}
else if ((mode_info->red_mask_size == 8)
&& (mode_info->red_field_pos == 0)
&& (mode_info->green_mask_size == 8)
&& (mode_info->green_field_pos == 8)
&& (mode_info->blue_mask_size == 8)
&& (mode_info->blue_field_pos == 16))
{
return GRUB_VIDEO_BLIT_FORMAT_RGBA_8888;
}
}
/* Check if we have any known 24 bit modes. */
else if (mode_info->bpp == 24)
{
if ((mode_info->red_mask_size == 8)
&& (mode_info->red_field_pos == 16)
&& (mode_info->green_mask_size == 8)
&& (mode_info->green_field_pos == 8)
&& (mode_info->blue_mask_size == 8)
&& (mode_info->blue_field_pos == 0))
{
return GRUB_VIDEO_BLIT_FORMAT_BGR_888;
}
else if ((mode_info->red_mask_size == 8)
&& (mode_info->red_field_pos == 0)
&& (mode_info->green_mask_size == 8)
&& (mode_info->green_field_pos == 8)
&& (mode_info->blue_mask_size == 8)
&& (mode_info->blue_field_pos == 16))
{
return GRUB_VIDEO_BLIT_FORMAT_RGB_888;
}
}
/* Check if we have any known 16 bit modes. */
else if (mode_info->bpp == 16)
{
if ((mode_info->red_mask_size == 5)
&& (mode_info->red_field_pos == 11)
&& (mode_info->green_mask_size == 6)
&& (mode_info->green_field_pos == 5)
&& (mode_info->blue_mask_size == 5)
&& (mode_info->blue_field_pos == 0))
{
return GRUB_VIDEO_BLIT_FORMAT_BGR_565;
}
else if ((mode_info->red_mask_size == 5)
&& (mode_info->red_field_pos == 0)
&& (mode_info->green_mask_size == 6)
&& (mode_info->green_field_pos == 5)
&& (mode_info->blue_mask_size == 5)
&& (mode_info->blue_field_pos == 11))
{
return GRUB_VIDEO_BLIT_FORMAT_RGB_565;
}
}
else if (mode_info->bpp == 1)
return GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED;
/* Backup route. Unknown format. */
/* If there are more than 8 bits per color, assume RGB(A) mode. */
if (mode_info->bpp > 8)
{
if (mode_info->reserved_mask_size > 0)
{
return GRUB_VIDEO_BLIT_FORMAT_RGBA;
}
else
{
return GRUB_VIDEO_BLIT_FORMAT_RGB;
}
}
/* Assume as indexcolor mode. */
return GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR;
}
/* Set new indexed color palette entries. */
grub_err_t
grub_video_set_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->set_palette (start, count, palette_data);
}
/* Get indexed color palette entries. */
grub_err_t
grub_video_get_palette (unsigned int start, unsigned int count,
struct grub_video_palette_data *palette_data)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->get_palette (start, count, palette_data);
}
/* Set viewport dimensions. */
grub_err_t
grub_video_set_viewport (unsigned int x, unsigned int y,
unsigned int width, unsigned int height)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->set_viewport (x, y, width, height);
}
/* Get viewport dimensions. */
grub_err_t
grub_video_get_viewport (unsigned int *x, unsigned int *y,
unsigned int *width, unsigned int *height)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->get_viewport (x, y, width, height);
}
/* Map color name to adapter specific color. */
grub_video_color_t
grub_video_map_color (grub_uint32_t color_name)
{
if (! grub_video_adapter_active)
return 0;
return grub_video_adapter_active->map_color (color_name);
}
/* Map RGB value to adapter specific color. */
grub_video_color_t
grub_video_map_rgb (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue)
{
if (! grub_video_adapter_active)
return 0;
return grub_video_adapter_active->map_rgb (red, green, blue);
}
/* Map RGBA value to adapter specific color. */
grub_video_color_t
grub_video_map_rgba (grub_uint8_t red, grub_uint8_t green, grub_uint8_t blue,
grub_uint8_t alpha)
{
if (! grub_video_adapter_active)
return 0;
return grub_video_adapter_active->map_rgba (red, green, blue, alpha);
}
/* Unmap video color back to RGBA components. */
grub_err_t
grub_video_unmap_color (grub_video_color_t color, grub_uint8_t *red,
grub_uint8_t *green, grub_uint8_t *blue,
grub_uint8_t *alpha)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->unmap_color (color,
red,
green,
blue,
alpha);
}
/* Fill rectangle using specified color. */
grub_err_t
grub_video_fill_rect (grub_video_color_t color, int x, int y,
unsigned int width, unsigned int height)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->fill_rect (color, x, y, width, height);
}
/* Blit bitmap to screen. */
grub_err_t
grub_video_blit_bitmap (struct grub_video_bitmap *bitmap,
enum grub_video_blit_operators oper,
int x, int y, int offset_x, int offset_y,
unsigned int width, unsigned int height)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->blit_bitmap (bitmap, oper, x, y,
offset_x, offset_y,
width, height);
}
/* Blit render target to active render target. */
grub_err_t
grub_video_blit_render_target (struct grub_video_render_target *target,
enum grub_video_blit_operators oper,
int x, int y, int offset_x, int offset_y,
unsigned int width, unsigned int height)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->blit_render_target (target, oper, x, y,
offset_x, offset_y,
width, height);
}
/* Scroll viewport and fill new areas with specified color. */
grub_err_t
grub_video_scroll (grub_video_color_t color, int dx, int dy)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->scroll (color, dx, dy);
}
/* Swap buffers (swap active render target). */
grub_err_t
grub_video_swap_buffers (void)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->swap_buffers ();
}
/* Create new render target. */
grub_err_t
grub_video_create_render_target (struct grub_video_render_target **result,
unsigned int width, unsigned int height,
unsigned int mode_type)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->create_render_target (result,
width, height,
mode_type);
}
/* Delete render target. */
grub_err_t
grub_video_delete_render_target (struct grub_video_render_target *target)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->delete_render_target (target);
}
/* Set active render target. */
grub_err_t
grub_video_set_active_render_target (struct grub_video_render_target *target)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->set_active_render_target (target);
}
/* Get active render target. */
grub_err_t
grub_video_get_active_render_target (struct grub_video_render_target **target)
{
if (! grub_video_adapter_active)
return grub_error (GRUB_ERR_BAD_DEVICE, "no video mode activated");
return grub_video_adapter_active->get_active_render_target (target);
}
/* Parse <width>x<height>[x<depth>]*/
static grub_err_t
parse_modespec (const char *current_mode, int *width, int *height, int *depth)
{
const char *value;
const char *param = current_mode;
*width = *height = *depth = -1;
if (grub_strcmp (param, "auto") == 0)
{
*width = *height = 0;
return GRUB_ERR_NONE;
}
/* Find width value. */
value = param;
param = grub_strchr(param, 'x');
if (param == NULL)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"Invalid mode: %s\n",
current_mode);
param++;
*width = grub_strtoul (value, 0, 0);
if (grub_errno != GRUB_ERR_NONE)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"Invalid mode: %s\n",
current_mode);
/* Find height value. */
value = param;
param = grub_strchr(param, 'x');
if (param == NULL)
{
*height = grub_strtoul (value, 0, 0);
if (grub_errno != GRUB_ERR_NONE)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"Invalid mode: %s\n",
current_mode);
}
else
{
/* We have optional color depth value. */
param++;
*height = grub_strtoul (value, 0, 0);
if (grub_errno != GRUB_ERR_NONE)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"Invalid mode: %s\n",
current_mode);
/* Convert color depth value. */
value = param;
*depth = grub_strtoul (value, 0, 0);
if (grub_errno != GRUB_ERR_NONE)
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"Invalid mode: %s\n",
current_mode);
}
return GRUB_ERR_NONE;
}
grub_err_t
grub_video_set_mode (const char *modestring,
unsigned int modemask,
unsigned int modevalue)
{
char *tmp;
char *next_mode;
char *current_mode;
char *modevar;
modevalue &= modemask;
/* Take copy of env.var. as we don't want to modify that. */
modevar = grub_strdup (modestring);
/* Initialize next mode. */
next_mode = modevar;
if (! modevar)
return grub_error (GRUB_ERR_OUT_OF_MEMORY,
"couldn't allocate space for local modevar copy");
if (grub_memcmp (next_mode, "keep", sizeof ("keep")) == 0
|| grub_memcmp (next_mode, "keep,", sizeof ("keep,") - 1) == 0
|| grub_memcmp (next_mode, "keep;", sizeof ("keep;") - 1) == 0)
{
int suitable = 1;
grub_err_t err;
if (grub_video_adapter_active)
{
struct grub_video_mode_info mode_info;
grub_memset (&mode_info, 0, sizeof (mode_info));
err = grub_video_get_info (&mode_info);
if (err)
{
suitable = 0;
grub_errno = GRUB_ERR_NONE;
}
if ((mode_info.mode_type & modemask) != modevalue)
suitable = 0;
}
else if (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) != 0)
&& ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) == 0))
suitable = 0;
if (suitable)
{
grub_free (modevar);
return GRUB_ERR_NONE;
}
next_mode += sizeof ("keep") - 1;
if (! *next_mode)
{
grub_free (modevar);
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"no suitable mode found");
}
/* Skip separator. */
next_mode++;
}
/* De-activate last set video adapter. */
if (grub_video_adapter_active)
{
/* Finalize adapter. */
grub_video_adapter_active->fini ();
if (grub_errno != GRUB_ERR_NONE)
grub_errno = GRUB_ERR_NONE;
/* Mark active adapter as not set. */
grub_video_adapter_active = 0;
}
/* Loop until all modes has been tested out. */
while (next_mode != NULL)
{
int width = -1;
int height = -1;
int depth = -1;
grub_err_t err;
unsigned int flags = modevalue;
unsigned int flagmask = modemask;
/* Use last next_mode as current mode. */
tmp = next_mode;
/* Save position of next mode and separate modes. */
for (; *next_mode; next_mode++)
if (*next_mode == ',' || *next_mode == ';')
break;
if (*next_mode)
{
*next_mode = 0;
next_mode++;
}
else
next_mode = 0;
/* Skip whitespace. */
while (grub_isspace (*tmp))
tmp++;
/* Initialize token holders. */
current_mode = tmp;
/* XXX: we assume that we're in pure text mode if
no video mode is initialized. Is it always true? */
if (grub_strcmp (current_mode, "text") == 0)
{
struct grub_video_mode_info mode_info;
grub_memset (&mode_info, 0, sizeof (mode_info));
if (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) == 0)
|| ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) != 0))
{
/* Valid mode found from adapter, and it has been activated.
Specify it as active adapter. */
grub_video_adapter_active = NULL;
/* Free memory. */
grub_free (modevar);
return GRUB_ERR_NONE;
}
}
err = parse_modespec (current_mode, &width, &height, &depth);
if (err)
{
/* Free memory before returning. */
grub_free (modevar);
return err;
}
/* Try out video mode. */
/* If user requested specific depth check if this depth is supported. */
if (depth != -1 && (flagmask & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
&&
(((flags & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
!= ((depth << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
& GRUB_VIDEO_MODE_TYPE_DEPTH_MASK))))
continue;
if (depth != -1)
{
flags |= (depth << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
& GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
flagmask |= GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
}
/* Try to initialize requested mode. Ignore any errors. */
grub_video_adapter_t p;
/* Loop thru all possible video adapter trying to find requested mode. */
for (p = grub_video_adapter_list; p; p = p->next)
{
struct grub_video_mode_info mode_info;
grub_memset (&mode_info, 0, sizeof (mode_info));
/* Try to initialize adapter, if it fails, skip to next adapter. */
err = p->init ();
if (err != GRUB_ERR_NONE)
{
grub_errno = GRUB_ERR_NONE;
continue;
}
/* Try to initialize video mode. */
err = p->setup (width, height, flags, flagmask);
if (err != GRUB_ERR_NONE)
{
p->fini ();
grub_errno = GRUB_ERR_NONE;
continue;
}
err = p->get_info (&mode_info);
if (err != GRUB_ERR_NONE)
{
p->fini ();
grub_errno = GRUB_ERR_NONE;
continue;
}
flags = mode_info.mode_type & ~GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
flags |= (mode_info.bpp << GRUB_VIDEO_MODE_TYPE_DEPTH_POS)
& GRUB_VIDEO_MODE_TYPE_DEPTH_MASK;
/* Check that mode is suitable for upper layer. */
if ((flags & GRUB_VIDEO_MODE_TYPE_PURE_TEXT)
? (((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modemask) != 0)
&& ((GRUB_VIDEO_MODE_TYPE_PURE_TEXT & modevalue) == 0))
: ((flags & modemask) != modevalue))
{
p->fini ();
grub_errno = GRUB_ERR_NONE;
continue;
}
/* Valid mode found from adapter, and it has been activated.
Specify it as active adapter. */
grub_video_adapter_active = p;
/* Free memory. */
grub_free (modevar);
return GRUB_ERR_NONE;
}
}
/* Free memory. */
grub_free (modevar);
return grub_error (GRUB_ERR_BAD_ARGUMENT,
"no suitable mode found");
}
/* Initialize Video API module. */
GRUB_MOD_INIT(video)
{
}
/* Finalize Video API module. */
GRUB_MOD_FINI(video)
{
}