OpenSolaris_b135/grub/grub-0.97/stage2/graphics.c
/* graphics.c - graphics mode support for GRUB */
/* Implemented as a terminal type by Jeremy Katz <katzj@redhat.com> based
* on a patch by Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
*/
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2001,2002 Red Hat, Inc.
* Portions copyright (C) 2000 Conectiva, Inc.
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifdef SUPPORT_GRAPHICS
#include <term.h>
#include <shared.h>
#include <graphics.h>
#ifdef OVERLAY_LOGO
#include <logo.xbm>
#endif /* OVERLAY_LOGO */
int saved_videomode;
unsigned char *font8x16;
int graphics_inited = 0;
#define PALETTE_REDSHIFT 16
#define PALETTE_GREENSHIFT 8
#define PALETTE_COLORMASK 63
#define PALETTE_NCOLORS 16
#define PALETTE_RED(entry) ((entry) >> PALETTE_REDSHIFT)
#define PALETTE_GREEN(entry) (((entry) >> PALETTE_GREENSHIFT) & \
PALETTE_COLORMASK)
#define PALETTE_BLUE(entry) ((entry) & PALETTE_COLORMASK)
static char splashimage[64];
static int splash_palette[PALETTE_NCOLORS];
#define HPIXELS 640
#define VPIXELS 480
#define HPIXELSPERBYTE 8
#define ROWBYTES (HPIXELS / HPIXELSPERBYTE)
#define SCREENBYTES (ROWBYTES * VPIXELS)
#define VSHADOW VSHADOW1
unsigned char VSHADOW1[SCREENBYTES];
unsigned char VSHADOW2[SCREENBYTES];
unsigned char VSHADOW4[SCREENBYTES];
unsigned char VSHADOW8[SCREENBYTES];
static unsigned char *s1 = (unsigned char*)VSHADOW1;
static unsigned char *s2 = (unsigned char*)VSHADOW2;
static unsigned char *s4 = (unsigned char*)VSHADOW4;
static unsigned char *s8 = (unsigned char*)VSHADOW8;
/* constants to define the viewable area */
const int x0 = 0;
const int x1 = ROWBYTES;
const int y0 = 0;
const int y1 = 30;
/* text buffer has to be kept around so that we can write things as we
* scroll and the like */
unsigned short text[ROWBYTES * 30];
/* why do these have to be kept here? */
int foreground = (63 << 16) | (63 << 8) | (63), background = 0, border = 0;
/* current position */
static int fontx = 0;
static int fonty = 0;
/* global state so that we don't try to recursively scroll or cursor */
static int no_scroll = 0;
/* color state */
static int graphics_standard_color = A_NORMAL;
static int graphics_normal_color = A_NORMAL;
static int graphics_highlight_color = A_REVERSE;
static int graphics_current_color = A_NORMAL;
static color_state graphics_color_state = COLOR_STATE_STANDARD;
/* graphics local functions */
static void graphics_setxy(int col, int row);
static void graphics_scroll(void);
static int read_image(char *);
#ifdef OVERLAY_LOGO
static void draw_xbmlogo(void);
#endif /* OVERLAY_LOGO */
/* FIXME: where do these really belong? */
static inline void outb(unsigned short port, unsigned char val)
{
__asm __volatile ("outb %0,%1"::"a" (val), "d" (port));
}
static void MapMask(int value) {
outb(0x3c4, 2);
outb(0x3c5, value);
}
/* bit mask register */
static void BitMask(int value) {
outb(0x3ce, 8);
outb(0x3cf, value);
}
/* Set the splash image */
void graphics_set_splash(char *splashfile) {
grub_strcpy(splashimage, splashfile);
}
/* Get the current splash image */
char *graphics_get_splash(void) {
return splashimage;
}
/* Initialize a vga16 graphics display with the palette based off of
* the image in splashimage. If the image doesn't exist, leave graphics
* mode. */
int graphics_init()
{
int image_read, index, color;
if (!graphics_inited) {
saved_videomode = set_videomode(0x12);
}
font8x16 = (unsigned char*)graphics_get_font();
image_read = read_image(splashimage);
/*
* Set VGA palette color 0 to be the system background color, 15 to be the
* system foreground color, and 17 to be the system border color.
*
* If the splashimage was read successfully, program the palette with
* its new colors; if not, set them to the background color.
*/
graphics_set_palette(0, PALETTE_RED(background), PALETTE_GREEN(background),
PALETTE_BLUE(background));
for (index = 1; index < 15; index++) {
color = (image_read ? splash_palette[index] : background);
graphics_set_palette(index, PALETTE_RED(color),
PALETTE_GREEN(color), PALETTE_BLUE(color));
}
graphics_set_palette(15, PALETTE_RED(foreground),
PALETTE_GREEN(foreground), PALETTE_BLUE(foreground));
graphics_set_palette(0x11, PALETTE_RED(border), PALETTE_GREEN(border),
PALETTE_BLUE(border));
#ifdef OVERLAY_LOGO
draw_xbmlogo();
#endif /* OVERLAY_LOGO */
graphics_inited = 1;
/* make sure that the highlight color is set correctly */
graphics_highlight_color = ((graphics_normal_color >> 4) |
((graphics_normal_color & 0xf) << 4));
return 1;
}
/* Leave graphics mode */
void graphics_end(void)
{
if (graphics_inited) {
set_videomode(saved_videomode);
graphics_inited = 0;
}
}
/* Print ch on the screen. Handle any needed scrolling or the like */
void graphics_putchar(int ch) {
ch &= 0xff;
graphics_cursor(0);
if (ch == '\n') {
if (fonty + 1 < y1)
graphics_setxy(fontx, fonty + 1);
else
graphics_scroll();
graphics_cursor(1);
return;
} else if (ch == '\r') {
graphics_setxy(x0, fonty);
graphics_cursor(1);
return;
}
graphics_cursor(0);
text[fonty * ROWBYTES + fontx] = ch;
text[fonty * ROWBYTES + fontx] &= 0x00ff;
if (graphics_current_color & 0xf0)
text[fonty * ROWBYTES + fontx] |= 0x100;
graphics_cursor(0);
if ((fontx + 1) >= x1) {
graphics_setxy(x0, fonty);
if (fonty + 1 < y1)
graphics_setxy(x0, fonty + 1);
else
graphics_scroll();
} else {
graphics_setxy(fontx + 1, fonty);
}
graphics_cursor(1);
}
/* get the current location of the cursor */
int graphics_getxy(void) {
return (fontx << 8) | fonty;
}
void graphics_gotoxy(int x, int y) {
graphics_cursor(0);
graphics_setxy(x, y);
graphics_cursor(1);
}
void graphics_cls(void) {
int i;
unsigned char *mem;
graphics_cursor(0);
graphics_gotoxy(x0, y0);
mem = (unsigned char*)VIDEOMEM;
for (i = 0; i < ROWBYTES * 30; i++)
text[i] = ' ';
graphics_cursor(1);
BitMask(0xff);
/* plane 1 */
MapMask(1);
grub_memcpy(mem, s1, SCREENBYTES);
/* plane 2 */
MapMask(2);
grub_memcpy(mem, s2, SCREENBYTES);
/* plane 3 */
MapMask(4);
grub_memcpy(mem, s4, SCREENBYTES);
/* plane 4 */
MapMask(8);
grub_memcpy(mem, s8, SCREENBYTES);
MapMask(15);
}
void graphics_setcolorstate (color_state state) {
switch (state) {
case COLOR_STATE_STANDARD:
graphics_current_color = graphics_standard_color;
break;
case COLOR_STATE_NORMAL:
graphics_current_color = graphics_normal_color;
break;
case COLOR_STATE_HIGHLIGHT:
graphics_current_color = graphics_highlight_color;
break;
default:
graphics_current_color = graphics_standard_color;
break;
}
graphics_color_state = state;
}
void graphics_setcolor (int normal_color, int highlight_color) {
graphics_normal_color = normal_color;
graphics_highlight_color = highlight_color;
graphics_setcolorstate (graphics_color_state);
}
int graphics_setcursor (int on) {
/* FIXME: we don't have a cursor in graphics */
return 1;
}
#ifdef OVERLAY_LOGO
static void draw_xbmlogo(void)
{
unsigned char mask;
unsigned xbm_index = 0, xbm_incr;
unsigned screenx, logox, logoy, fb_offset, fb_index;
/*
* Place the logo such that the right hand side will be four pixels from
* the right hand edge of the screen and the bottom will be two pixels
* from the bottom edge.
*/
fb_offset = ((VPIXELS - 1) - logo_height - 2) * ROWBYTES;
xbm_incr = (logo_width / 8) + 1;
for (logoy = 0; logoy < logo_height; logoy++) {
for (logox = 0, screenx = (HPIXELS - 1) - logo_width - 4;
logox < logo_width; logox++, screenx++) {
mask = 0x80 >> (screenx & 7);
fb_index = fb_offset + (screenx >> 3);
/*
* If a bit is clear in the bitmap, draw it onto the
* framebuffer in the default foreground color.
*/
if ((logo_bits[xbm_index + (logox >> 3)] &
(1 << (logox & 7))) == 0) {
/* system default foreground color */
s1[fb_index] |= mask;
s2[fb_index] |= mask;
s4[fb_index] |= mask;
s8[fb_index] |= mask;
}
}
xbm_index += xbm_incr;
fb_offset += ROWBYTES;
}
}
#endif /* OVERLAY_LOGO */
/*
* Read in the splashscreen image and set the palette up appropriately.
*
* Format of splashscreen is an XPM (can be gzipped) with up to 15 colors and
* is assumed to be of the proper screen dimensions.
*/
static int read_image(char *s)
{
char buf[32], pal[16];
unsigned char c, base, mask;
unsigned i, len, idx, colors, x, y, width, height;
if (!grub_open(s))
return 0;
/* read XPM header - must match memcmp string PRECISELY. */
if (!grub_read((char*)&buf, 10) || grub_memcmp(buf, "/* XPM */\n", 10)) {
errnum = ERR_NOTXPM;
grub_close();
return 0;
}
/* skip characters until we reach an initial '"' */
while (grub_read(&c, 1)) {
if (c == '"')
break;
}
/* skip whitespace */
while (grub_read(&c, 1) && (c == ' ' || c == '\t'))
;
/*
* Format here should be four integers:
*
* Width Height NumberOfColors CharactersPerPixel
*/
i = 0;
width = c - '0';
while (grub_read(&c, 1)) {
if (c >= '0' && c <= '9')
width = width * 10 + c - '0';
else
break;
}
/* skip whitespace to advance to next digit */
while (grub_read(&c, 1) && (c == ' ' || c == '\t'))
;
height = c - '0';
while (grub_read(&c, 1)) {
if (c >= '0' && c <= '9')
height = height * 10 + c - '0';
else
break;
}
/* skip whitespace to advance to next digit */
while (grub_read(&c, 1) && (c == ' ' || c == '\t')) ;
colors = c - '0';
while (grub_read(&c, 1)) {
if (c >= '0' && c <= '9')
colors = colors * 10 + c - '0';
else
break;
}
/* eat rest of line - assumes chars per pixel is one */
while (grub_read(&c, 1) && c != '"')
;
/*
* Parse the XPM palette - the format is:
*
* identifier colorspace #RRGGBB
*
* The identifier is simply a single character; the colorspace identifier
* is skipped as it's assumed to be "c" denoting RGB color.
*
* The six digits after the "#" are assumed to be a six digit RGB color
* identifier as defined in X11's rgb.txt file.
*/
for (i = 0, idx = 1; i < colors; i++) {
len = 0;
while (grub_read(&c, 1) && c != '"')
;
grub_read(&c, 1); /* char */
base = c;
grub_read(buf, 4); /* \t c # */
while (grub_read(&c, 1) && c != '"') {
if (len < sizeof(buf))
buf[len++] = c;
}
/*
* The RGB hex digits should be six characters in length.
*
* If the color field contains anything other than six
* characters, such as "None" to denote a transparent color,
* ignore it.
*/
if (len == 6) {
int r = ((hex(buf[0]) << 4) | hex(buf[1])) >> 2;
int g = ((hex(buf[2]) << 4) | hex(buf[3])) >> 2;
int b = ((hex(buf[4]) << 4) | hex(buf[5])) >> 2;
if (idx > 14) {
errnum = ERR_TOOMANYCOLORS;
grub_close();
return 0;
}
pal[idx] = base;
splash_palette[idx++] =
((r & PALETTE_COLORMASK) << PALETTE_REDSHIFT) |
((g & PALETTE_COLORMASK) << PALETTE_GREENSHIFT) |
(b & PALETTE_COLORMASK);
}
}
colors = idx - 1; /* actual number of colors used in XPM image */
x = y = len = 0;
/* clear (zero out) all four planes of the framebuffer */
for (i = 0; i < SCREENBYTES; i++)
s1[i] = s2[i] = s4[i] = s8[i] = 0;
/* parse the XPM data */
while (y < height) {
/* exit on EOF, otherwise skip characters until an initial '"' */
while (1) {
if (!grub_read(&c, 1)) {
errnum = ERR_CORRUPTXPM;
grub_close();
return 0;
}
if (c == '"')
break;
}
/* read characters until we hit an EOF or a terminating '"' */
while (grub_read(&c, 1) && c != '"') {
int pixel = 0;
/*
* Look up the specified pixel color in the palette; the
* pixel will not be drawn if its color cannot be found or
* if no colors were specified in the XPM image itself.
*/
for (i = 1; i <= colors; i++)
if (pal[i] == c) {
pixel = i;
break;
}
/*
* A bit is set in each of the "planes" of the frame buffer to
* denote a pixel drawn in each color of the palette.
*
* The planes are a binary representation of the palette, so a
* pixel in color "1" of the palette would be denoted by setting a
* bit in plane "s1"; a pixel in color "15" of the palette would
* set the same bit in each of the four planes.
*
* Pixels are represented by set bits in a byte, in the order
* left-to-right (e.g. pixel 0 is 0x80, pixel 7 is 1.)
*/
if (pixel != 0) {
mask = 0x80 >> (x & 7);
if (pixel & 1)
s1[len + (x >> 3)] |= mask;
if (pixel & 2)
s2[len + (x >> 3)] |= mask;
if (pixel & 4)
s4[len + (x >> 3)] |= mask;
if (pixel & 8)
s8[len + (x >> 3)] |= mask;
}
/*
* Increment "x"; if we hit pixel HPIXELS, wrap to the start of the
* next horizontal line if we haven't yet reached the bottom of
* the screen.
*/
if (++x >= HPIXELS) {
x = 0;
if (y++ < VPIXELS)
len += ROWBYTES;
else
break;
}
}
}
grub_close();
return 1;
}
/* Convert a character which is a hex digit to the appropriate integer */
int hex(int v)
{
if (v >= 'A' && v <= 'F')
return (v - 'A' + 10);
if (v >= 'a' && v <= 'f')
return (v - 'a' + 10);
return (v - '0');
}
/* move the graphics cursor location to col, row */
static void graphics_setxy(int col, int row) {
if (col >= x0 && col < x1) {
fontx = col;
cursorX = col << 3;
}
if (row >= y0 && row < y1) {
fonty = row;
cursorY = row << 4;
}
}
/* scroll the screen */
static void graphics_scroll() {
int i, j;
/* we don't want to scroll recursively... that would be bad */
if (no_scroll)
return;
no_scroll = 1;
/* move everything up a line */
for (j = y0 + 1; j < y1; j++) {
graphics_gotoxy(x0, j - 1);
for (i = x0; i < x1; i++) {
graphics_putchar(text[j * ROWBYTES + i]);
}
}
/* last line should be blank */
graphics_gotoxy(x0, y1 - 1);
for (i = x0; i < x1; i++)
graphics_putchar(' ');
graphics_setxy(x0, y1 - 1);
no_scroll = 0;
}
void graphics_cursor(int set) {
unsigned char *pat, *mem, *ptr, chr[16 << 2];
int i, ch, invert, offset;
if (set && no_scroll)
return;
offset = cursorY * ROWBYTES + fontx;
ch = text[fonty * ROWBYTES + fontx] & 0xff;
invert = (text[fonty * ROWBYTES + fontx] & 0xff00) != 0;
pat = font8x16 + (ch << 4);
mem = (unsigned char*)VIDEOMEM + offset;
if (!set) {
for (i = 0; i < 16; i++) {
unsigned char mask = pat[i];
if (!invert) {
chr[i ] = ((unsigned char*)VSHADOW1)[offset];
chr[16 + i] = ((unsigned char*)VSHADOW2)[offset];
chr[32 + i] = ((unsigned char*)VSHADOW4)[offset];
chr[48 + i] = ((unsigned char*)VSHADOW8)[offset];
/* FIXME: if (shade) */
if (1) {
if (ch == DISP_VERT || ch == DISP_LL ||
ch == DISP_UR || ch == DISP_LR) {
unsigned char pmask = ~(pat[i] >> 1);
chr[i ] &= pmask;
chr[16 + i] &= pmask;
chr[32 + i] &= pmask;
chr[48 + i] &= pmask;
}
if (i > 0 && ch != DISP_VERT) {
unsigned char pmask = ~(pat[i - 1] >> 1);
chr[i ] &= pmask;
chr[16 + i] &= pmask;
chr[32 + i] &= pmask;
chr[48 + i] &= pmask;
if (ch == DISP_HORIZ || ch == DISP_UR || ch == DISP_LR) {
pmask = ~pat[i - 1];
chr[i ] &= pmask;
chr[16 + i] &= pmask;
chr[32 + i] &= pmask;
chr[48 + i] &= pmask;
}
}
}
chr[i ] |= mask;
chr[16 + i] |= mask;
chr[32 + i] |= mask;
chr[48 + i] |= mask;
offset += ROWBYTES;
}
else {
chr[i ] = mask;
chr[16 + i] = mask;
chr[32 + i] = mask;
chr[48 + i] = mask;
}
}
}
else {
MapMask(15);
ptr = mem;
for (i = 0; i < 16; i++, ptr += ROWBYTES) {
cursorBuf[i] = pat[i];
*ptr = ~pat[i];
}
return;
}
offset = 0;
for (i = 1; i < 16; i <<= 1, offset += 16) {
int j;
MapMask(i);
ptr = mem;
for (j = 0; j < 16; j++, ptr += ROWBYTES)
*ptr = chr[j + offset];
}
MapMask(15);
}
#endif /* SUPPORT_GRAPHICS */