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

Merge mainline into yeeloongfw

Browse source
This commit is contained in:
Vladimir 'phcoder' Serbinenko 2010-04-05 17:35:03 +02:00
commit a6132b9f3f
172 changed files with 12449 additions and 6208 deletions
Download patch file Download diff file Expand all files Collapse all files

4
video/bitmap.c
View file

@ -243,11 +243,11 @@ void *grub_video_bitmap_get_data (struct grub_video_bitmap *bitmap)
}
/* Initialize bitmap module. */
GRUB_MOD_INIT(video_bitmap)
GRUB_MOD_INIT(bitmap)
{
}
/* Finalize bitmap module. */
GRUB_MOD_FINI(video_bitmap)
GRUB_MOD_FINI(bitmap)
{
}

11
video/fb/fbblit.c
View file

@ -1170,10 +1170,15 @@ grub_video_fbblit_blend_XXXA8888_1bit (struct grub_video_fbblit_info *dst,
grub_uint8_t a;
if (*srcptr & srcmask)
color = fgcolor;
{
color = fgcolor;
a = src->mode_info->fg_alpha;
}
else
color = bgcolor;
a = (color >> 24) & 0xff;
{
color = bgcolor;
a = src->mode_info->bg_alpha;
}
if (a == 255)
*(grub_uint32_t *) dstptr = color;

300
video/ieee1275.c Normal file
View file

@ -0,0 +1,300 @@
/*
* 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",
.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);
}

4
video/readers/jpeg.c
View file

@ -729,7 +729,7 @@ static struct grub_video_bitmap_reader jpeg_reader = {
.next = 0
};
GRUB_MOD_INIT (video_reader_jpeg)
GRUB_MOD_INIT (jpeg)
{
grub_video_bitmap_reader_register (&jpg_reader);
grub_video_bitmap_reader_register (&jpeg_reader);
@ -740,7 +740,7 @@ GRUB_MOD_INIT (video_reader_jpeg)
#endif
}
GRUB_MOD_FINI (video_reader_jpeg)
GRUB_MOD_FINI (jpeg)
{
#if defined(JPEG_DEBUG)
grub_unregister_command (cmd);

4
video/readers/png.c
View file

@ -894,7 +894,7 @@ static struct grub_video_bitmap_reader png_reader = {
.next = 0
};
GRUB_MOD_INIT (video_reader_png)
GRUB_MOD_INIT (png)
{
grub_video_bitmap_reader_register (&png_reader);
#if defined(PNG_DEBUG)
@ -904,7 +904,7 @@ GRUB_MOD_INIT (video_reader_png)
#endif
}
GRUB_MOD_FINI (video_reader_png)
GRUB_MOD_FINI (png)
{
#if defined(PNG_DEBUG)
grub_unregister_command (cmd);

4
video/readers/tga.c
View file

@ -477,7 +477,7 @@ static struct grub_video_bitmap_reader tga_reader = {
.next = 0
};
GRUB_MOD_INIT(video_reader_tga)
GRUB_MOD_INIT(tga)
{
grub_video_bitmap_reader_register (&tga_reader);
#if defined(TGA_DEBUG)
@ -486,7 +486,7 @@ GRUB_MOD_INIT(video_reader_tga)
#endif
}
GRUB_MOD_FINI(video_reader_tga)
GRUB_MOD_FINI(tga)
{
#if defined(TGA_DEBUG)
grub_unregister_command (cmd);

1
video/sm712.c
View file

@ -243,6 +243,7 @@ grub_video_sm712_get_info_and_fini (struct grub_video_mode_info *mode_info,
static struct grub_video_adapter grub_video_sm712_adapter =
{
.name = "SM712 Video Driver",
.id = GRUB_VIDEO_DRIVER_SM712,
.init = grub_video_sm712_video_init,
.fini = grub_video_sm712_video_fini,

4
video/video.c
View file

@ -696,11 +696,11 @@ grub_video_set_mode (const char *modestring,
}
/* Initialize Video API module. */
GRUB_MOD_INIT(video_video)
GRUB_MOD_INIT(video)
{
}
/* Finalize Video API module. */
GRUB_MOD_FINI(video_video)
GRUB_MOD_FINI(video)
{
}