WebSVN – HelenOS – Diff – /tags/0.4.1/kernel/genarch/src/fb/fb.c


/*
 * Copyright (c) 2008 Martin Decky
 * Copyright (c) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup genarch
 * @{
 */
/** @file
 */
 
#include <genarch/fb/font-8x16.h>
#include <genarch/fb/logo-196x66.h>
#include <genarch/fb/visuals.h>
#include <genarch/fb/fb.h>
#include <console/chardev.h>
#include <console/console.h>
#include <sysinfo/sysinfo.h>
#include <mm/slab.h>
#include <align.h>
#include <panic.h>
#include <memstr.h>
#include <config.h>
#include <bitops.h>
#include <print.h>
#include <string.h>
#include <ddi/ddi.h>
#include <arch/types.h>
#include <byteorder.h>
 
SPINLOCK_INITIALIZE(fb_lock);
 
static uint8_t *fb_addr;
static uint16_t *backbuf;
static uint8_t *glyphs;
static uint8_t *bgscan;
 
static unsigned int xres;
static unsigned int yres;
 
static unsigned int ylogo;
static unsigned int ytrim;
static unsigned int rowtrim;
 
static unsigned int scanline;
static unsigned int glyphscanline;
 
static unsigned int pixelbytes;
static unsigned int glyphbytes;
static unsigned int bgscanbytes;
 
static unsigned int cols;
static unsigned int rows;
static unsigned int position = 0;
 
#define BG_COLOR     0x000080
#define FG_COLOR     0xffff00
#define INV_COLOR    0xaaaaaa
 
#define RED(x, bits)         (((x) >> (8 + 8 + 8 - (bits))) & ((1 << (bits)) - 1))
#define GREEN(x, bits)       (((x) >> (8 + 8 - (bits))) & ((1 << (bits)) - 1))
#define BLUE(x, bits)        (((x) >> (8 - (bits))) & ((1 << (bits)) - 1))
 
#define COL2X(col)           ((col) * FONT_WIDTH)
#define ROW2Y(row)           ((row) * FONT_SCANLINES)
 
#define X2COL(x)             ((x) / FONT_WIDTH)
#define Y2ROW(y)             ((y) / FONT_SCANLINES)
 
#define FB_POS(x, y)         ((y) * scanline + (x) * pixelbytes)
#define BB_POS(col, row)     ((row) * cols + (col))
#define GLYPH_POS(glyph, y)  ((glyph) * glyphbytes + (y) * glyphscanline)
 
 
static void (*rgb_conv)(void *, uint32_t);
 
/*
 * RGB conversion functions.
 *
 * These functions write an RGB value to some memory in some predefined format.
 * The naming convention corresponds to the format created by these functions.
 * The functions use the so called network order (i.e. big endian) with respect
 * to their names.
 */
 
static void rgb_0888(void *dst, uint32_t rgb)
{
    *((uint32_t *) dst) = host2uint32_t_be((0 << 24) |
        (RED(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | (BLUE(rgb, 8)));
}
 
static void bgr_0888(void *dst, uint32_t rgb)
{
    *((uint32_t *) dst) = host2uint32_t_be((0 << 24) |
        (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | (RED(rgb, 8)));
}
 
static void rgb_8880(void *dst, uint32_t rgb)
{
    *((uint32_t *) dst) = host2uint32_t_be((RED(rgb, 8) << 24) |
        (GREEN(rgb, 8) << 16) | (BLUE(rgb, 8) << 8) | 0);
}
 
static void bgr_8880(void *dst, uint32_t rgb)
{
    *((uint32_t *) dst) = host2uint32_t_be((BLUE(rgb, 8) << 24) |
        (GREEN(rgb, 8) << 16) | (RED(rgb, 8) << 8) | 0);
}
 
static void rgb_888(void *dst, uint32_t rgb)
{
    ((uint8_t *) dst)[0] = RED(rgb, 8);
    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
    ((uint8_t *) dst)[2] = BLUE(rgb, 8);
}
 
static void bgr_888(void *dst, uint32_t rgb)
{
    ((uint8_t *) dst)[0] = BLUE(rgb, 8);
    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
    ((uint8_t *) dst)[2] = RED(rgb, 8);
}
 
static void rgb_555_be(void *dst, uint32_t rgb)
{
    *((uint16_t *) dst) = host2uint16_t_be(RED(rgb, 5) << 10 |
        GREEN(rgb, 5) << 5 | BLUE(rgb, 5));
}
 
static void rgb_555_le(void *dst, uint32_t rgb)
{
    *((uint16_t *) dst) = host2uint16_t_le(RED(rgb, 5) << 10 |
        GREEN(rgb, 5) << 5 | BLUE(rgb, 5));
}
 
static void rgb_565_be(void *dst, uint32_t rgb)
{
    *((uint16_t *) dst) = host2uint16_t_be(RED(rgb, 5) << 11 |
        GREEN(rgb, 6) << 5 | BLUE(rgb, 5));
}
 
static void rgb_565_le(void *dst, uint32_t rgb)
{
    *((uint16_t *) dst) = host2uint16_t_le(RED(rgb, 5) << 11 |
        GREEN(rgb, 6) << 5 | BLUE(rgb, 5));
}
 
 
/** BGR 3:2:3
 *
 * Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
 * will most likely use a color palette. The color appearance
 * will be pretty random and depend on the default installed
 * palette. This could be fixed by supporting custom palette
 * and setting it to simulate the 8-bit truecolor.
 *
 * Currently we set the palette on the ia32, amd64 and sparc64 port.
 *
 * Note that the byte is being inverted by this function. The reason is
 * that we would like to use a color palette where the white color code
 * is 0 and the black color code is 255, as some machines (Sun Blade 1500)
 * use these codes for black and white and prevent to set codes
 * 0 and 255 to other colors.
 *
 */
static void bgr_323(void *dst, uint32_t rgb)
{
    *((uint8_t *) dst)
        = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
}
 
 
/** Hide logo and refresh screen
 *
 */
static void logo_hide(bool silent)
{
    ylogo = 0;
    ytrim = yres;
    rowtrim = rows;
    if (!silent)
        fb_redraw();
}
 
 
/** Draw character at given position
 *
 */
static void glyph_draw(uint16_t glyph, unsigned int col, unsigned int row, bool silent, bool overlay)
{
    unsigned int x = COL2X(col);
    unsigned int y = ROW2Y(row);
    unsigned int yd;
   
    if (y >= ytrim)
        logo_hide(silent);
   
    if (!overlay)
        backbuf[BB_POS(col, row)] = glyph;
   
    if (!silent) {
        for (yd = 0; yd < FONT_SCANLINES; yd++)
            memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],
                &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
    }
}
 
 
/** Scroll screen down by one row
 *
 *
 */
static void screen_scroll(bool silent)
{
    if (ylogo > 0) {
        logo_hide(silent);
        return;
    }
   
    if (!silent) {
        unsigned int row;
       
        for (row = 0; row < rows; row++) {
            unsigned int y = ROW2Y(row);
            unsigned int yd;
           
            for (yd = 0; yd < FONT_SCANLINES; yd++) {
                unsigned int x;
                unsigned int col;
               
                for (col = 0, x = 0; col < cols; col++,
                    x += FONT_WIDTH) {
                    uint16_t glyph;
                   
                    if (row < rows - 1) {
                        if (backbuf[BB_POS(col, row)] ==
                            backbuf[BB_POS(col, row + 1)])
                            continue;
                       
                        glyph = backbuf[BB_POS(col, row + 1)];
                    } else
                        glyph = 0;
                   
                    memcpy(&fb_addr[FB_POS(x, y + yd)],
                        &glyphs[GLYPH_POS(glyph, yd)],
                        glyphscanline);
                }
            }
        }
    }
   
    memmove(backbuf, &backbuf[BB_POS(0, 1)], cols * (rows - 1) * sizeof(uint16_t));
    memsetw(&backbuf[BB_POS(0, rows - 1)], cols, 0);
}
 
 
static void cursor_put(bool silent)
{
    unsigned int col = position % cols;
    unsigned int row = position / cols;
   
    glyph_draw(fb_font_glyph(U_CURSOR), col, row, silent, true);
}
 
 
static void cursor_remove(bool silent)
{
    unsigned int col = position % cols;
    unsigned int row = position / cols;
   
    glyph_draw(backbuf[BB_POS(col, row)], col, row, silent, true);
}
 
 
/** Print character to screen
 *
 * Emulate basic terminal commands.
 *
 */
static void fb_putchar(outdev_t *dev, wchar_t ch, bool silent)
{
    spinlock_lock(&fb_lock);
   
    switch (ch) {
    case '\n':
        cursor_remove(silent);
        position += cols;
        position -= position % cols;
        break;
    case '\r':
        cursor_remove(silent);
        position -= position % cols;
        break;
    case '\b':
        cursor_remove(silent);
        if (position % cols)
            position--;
        break;
    case '\t':
        cursor_remove(silent);
        do {
            glyph_draw(fb_font_glyph(' '), position % cols,
                position / cols, silent, false);
            position++;
        } while ((position % 8) && (position < cols * rows));
        break;
    default:
        glyph_draw(fb_font_glyph(ch), position % cols,
            position / cols, silent, false);
        position++;
    }
   
    if (position >= cols * rows) {
        position -= cols;
        screen_scroll(silent);
    }
   
    cursor_put(silent);
   
    spinlock_unlock(&fb_lock);
}
 
static outdev_t fb_console;
static outdev_operations_t fb_ops = {
    .write = fb_putchar
};
 
 
/** Render glyphs
 *
 * Convert glyphs from device independent font
 * description to current visual representation.
 *
 */
static void glyphs_render(void)
{
    /* Prerender glyphs */
    uint16_t glyph;
   
    for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
        uint32_t fg_color;
       
        if (glyph == FONT_GLYPHS - 1)
            fg_color = INV_COLOR;
        else
            fg_color = FG_COLOR;
       
        unsigned int y;
       
        for (y = 0; y < FONT_SCANLINES; y++) {
            unsigned int x;
           
            for (x = 0; x < FONT_WIDTH; x++) {
                void *dst = &glyphs[GLYPH_POS(glyph, y) +
                    x * pixelbytes];
                uint32_t rgb = (fb_font[glyph][y] &
                    (1 << (7 - x))) ? fg_color : BG_COLOR;
                rgb_conv(dst, rgb);
            }
        }
    }
   
    /* Prerender background scanline */
    unsigned int x;
   
    for (x = 0; x < xres; x++)
        rgb_conv(&bgscan[x * pixelbytes], BG_COLOR);
}
 
 
/** Refresh the screen
 *
 */
void fb_redraw(void)
{
    if (ylogo > 0) {
        unsigned int y;
       
        for (y = 0; y < LOGO_HEIGHT; y++) {
            unsigned int x;
           
            for (x = 0; x < xres; x++)
                rgb_conv(&fb_addr[FB_POS(x, y)],
                    (x < LOGO_WIDTH) ?
                    fb_logo[y * LOGO_WIDTH + x] :
                    LOGO_COLOR);
        }
    }
   
    unsigned int row;
   
    for (row = 0; row < rowtrim; row++) {
        unsigned int y = ylogo + ROW2Y(row);
        unsigned int yd;
       
        for (yd = 0; yd < FONT_SCANLINES; yd++) {
            unsigned int x;
            unsigned int col;
           
            for (col = 0, x = 0; col < cols;
                col++, x += FONT_WIDTH) {
                uint16_t glyph = backbuf[BB_POS(col, row)];
                void *dst = &fb_addr[FB_POS(x, y + yd)];
                void *src = &glyphs[GLYPH_POS(glyph, yd)];
                memcpy(dst, src, glyphscanline);
            }
        }
    }
   
    if (COL2X(cols) < xres) {
        unsigned int y;
        unsigned int size = (xres - COL2X(cols)) * pixelbytes;
       
        for (y = ylogo; y < yres; y++)
            memcpy(&fb_addr[FB_POS(COL2X(cols), y)], bgscan, size);
    }
   
    if (ROW2Y(rowtrim) + ylogo < yres) {
        unsigned int y;
       
        for (y = ROW2Y(rowtrim) + ylogo; y < yres; y++)
            memcpy(&fb_addr[FB_POS(0, y)], bgscan, bgscanbytes);
    }
}
 
 
/** Initialize framebuffer as a output character device
 *
 * @param addr   Physical address of the framebuffer
 * @param x      Screen width in pixels
 * @param y      Screen height in pixels
 * @param scan   Bytes per one scanline
 * @param visual Color model
 *
 */
void fb_init(fb_properties_t *props)
{
    switch (props->visual) {
    case VISUAL_INDIRECT_8:
        rgb_conv = bgr_323;
        pixelbytes = 1;
        break;
    case VISUAL_RGB_5_5_5_LE:
        rgb_conv = rgb_555_le;
        pixelbytes = 2;
        break;
    case VISUAL_RGB_5_5_5_BE:
        rgb_conv = rgb_555_be;
        pixelbytes = 2;
        break;
    case VISUAL_RGB_5_6_5_LE:
        rgb_conv = rgb_565_le;
        pixelbytes = 2;
        break;
    case VISUAL_RGB_5_6_5_BE:
        rgb_conv = rgb_565_be;
        pixelbytes = 2;
        break;
    case VISUAL_RGB_8_8_8:
        rgb_conv = rgb_888;
        pixelbytes = 3;
        break;
    case VISUAL_BGR_8_8_8:
        rgb_conv = bgr_888;
        pixelbytes = 3;
        break;
    case VISUAL_RGB_8_8_8_0:
        rgb_conv = rgb_8880;
        pixelbytes = 4;
        break;
    case VISUAL_RGB_0_8_8_8:
        rgb_conv = rgb_0888;
        pixelbytes = 4;
        break;
    case VISUAL_BGR_0_8_8_8:
        rgb_conv = bgr_0888;
        pixelbytes = 4;
        break;
    case VISUAL_BGR_8_8_8_0:
        rgb_conv = bgr_8880;
        pixelbytes = 4;
        break;
    default:
        panic("Unsupported visual.");
    }
   
    xres = props->x;
    yres = props->y;
    scanline = props->scan;
   
    cols = X2COL(xres);
    rows = Y2ROW(yres);
   
    if (yres > ylogo) {
        ylogo = LOGO_HEIGHT;
        rowtrim = rows - Y2ROW(ylogo);
        if (ylogo % FONT_SCANLINES > 0)
            rowtrim--;
        ytrim = ROW2Y(rowtrim);
    } else {
        ylogo = 0;
        ytrim = yres;
        rowtrim = rows;
    }
   
    glyphscanline = FONT_WIDTH * pixelbytes;
    glyphbytes = ROW2Y(glyphscanline);
    bgscanbytes = xres * pixelbytes;
   
    size_t fbsize = scanline * yres;
    size_t bbsize = cols * rows * sizeof(uint16_t);
    size_t glyphsize = FONT_GLYPHS * glyphbytes;
   
    backbuf = (uint16_t *) malloc(bbsize, 0);
    if (!backbuf)
        panic("Unable to allocate backbuffer.");
   
    glyphs = (uint8_t *) malloc(glyphsize, 0);
    if (!glyphs)
        panic("Unable to allocate glyphs.");
   
    bgscan = malloc(bgscanbytes, 0);
    if (!bgscan)
        panic("Unable to allocate background pixel.");
   
    memsetw(backbuf, cols * rows, 0);
   
    glyphs_render();
   
    fb_addr = (uint8_t *) hw_map((uintptr_t) props->addr, fbsize);
   
    sysinfo_set_item_val("fb", NULL, true);
    sysinfo_set_item_val("fb.kind", NULL, 1);
    sysinfo_set_item_val("fb.width", NULL, xres);
    sysinfo_set_item_val("fb.height", NULL, yres);
    sysinfo_set_item_val("fb.scanline", NULL, scanline);
    sysinfo_set_item_val("fb.visual", NULL, props->visual);
    sysinfo_set_item_val("fb.address.physical", NULL, props->addr);
   
    fb_redraw();
   
    outdev_initialize("fb", &fb_console, &fb_ops);
    stdout = &fb_console;
}
 
/** @}
 */
 

Rev 4685	Rev 4687
1	/*	1	/*
2	* Copyright (c) 2008 Martin Decky	2	* Copyright (c) 2008 Martin Decky
3	* Copyright (c) 2006 Ondrej Palkovsky	3	* Copyright (c) 2006 Ondrej Palkovsky
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	/** @addtogroup genarch	30	/** @addtogroup genarch
31	* @{	31	* @{
32	*/	32	*/
33	/** @file	33	/** @file
34	*/	34	*/
35		35
36	#include <genarch/fb/font-8x16.h>	36	#include <genarch/fb/font-8x16.h>
37	#include <genarch/fb/logo-196x66.h>	37	#include <genarch/fb/logo-196x66.h>
38	#include <genarch/fb/visuals.h>	38	#include <genarch/fb/visuals.h>
39	#include <genarch/fb/fb.h>	39	#include <genarch/fb/fb.h>
40	#include <console/chardev.h>	40	#include <console/chardev.h>
41	#include <console/console.h>	41	#include <console/console.h>
42	#include <sysinfo/sysinfo.h>	42	#include <sysinfo/sysinfo.h>
43	#include <mm/slab.h>	43	#include <mm/slab.h>
44	#include <align.h>	44	#include <align.h>
45	#include <panic.h>	45	#include <panic.h>
46	#include <memstr.h>	46	#include <memstr.h>
47	#include <config.h>	47	#include <config.h>
48	#include <bitops.h>	48	#include <bitops.h>
49	#include <print.h>	49	#include <print.h>
50	#include <string.h>	50	#include <string.h>
51	#include <ddi/ddi.h>	51	#include <ddi/ddi.h>
52	#include <arch/types.h>	52	#include <arch/types.h>
53	#include <byteorder.h>	53	#include <byteorder.h>
54		54
55	SPINLOCK_INITIALIZE(fb_lock);	55	SPINLOCK_INITIALIZE(fb_lock);
56		56
57	static uint8_t *fb_addr;	57	static uint8_t *fb_addr;
58	static uint16_t *backbuf;	58	static uint16_t *backbuf;
59	static uint8_t *glyphs;	59	static uint8_t *glyphs;
60	static uint8_t *bgscan;	60	static uint8_t *bgscan;
61		61
62	static unsigned int xres;	62	static unsigned int xres;
63	static unsigned int yres;	63	static unsigned int yres;
64		64
65	static unsigned int ylogo;	65	static unsigned int ylogo;
66	static unsigned int ytrim;	66	static unsigned int ytrim;
67	static unsigned int rowtrim;	67	static unsigned int rowtrim;
68		68
69	static unsigned int scanline;	69	static unsigned int scanline;
70	static unsigned int glyphscanline;	70	static unsigned int glyphscanline;
71		71
72	static unsigned int pixelbytes;	72	static unsigned int pixelbytes;
73	static unsigned int glyphbytes;	73	static unsigned int glyphbytes;
74	static unsigned int bgscanbytes;	74	static unsigned int bgscanbytes;
75		75
76	static unsigned int cols;	76	static unsigned int cols;
77	static unsigned int rows;	77	static unsigned int rows;
78	static unsigned int position = 0;	78	static unsigned int position = 0;
79		79
80	#define BG_COLOR 0x000080	80	#define BG_COLOR 0x000080
81	#define FG_COLOR 0xffff00	81	#define FG_COLOR 0xffff00
82	#define INV_COLOR 0xaaaaaa	82	#define INV_COLOR 0xaaaaaa
83		83
84	#define RED(x, bits) (((x) >> (8 + 8 + 8 - (bits))) & ((1 << (bits)) - 1))	84	#define RED(x, bits) (((x) >> (8 + 8 + 8 - (bits))) & ((1 << (bits)) - 1))
85	#define GREEN(x, bits) (((x) >> (8 + 8 - (bits))) & ((1 << (bits)) - 1))	85	#define GREEN(x, bits) (((x) >> (8 + 8 - (bits))) & ((1 << (bits)) - 1))
86	#define BLUE(x, bits) (((x) >> (8 - (bits))) & ((1 << (bits)) - 1))	86	#define BLUE(x, bits) (((x) >> (8 - (bits))) & ((1 << (bits)) - 1))
87		87
88	#define COL2X(col) ((col) * FONT_WIDTH)	88	#define COL2X(col) ((col) * FONT_WIDTH)
89	#define ROW2Y(row) ((row) * FONT_SCANLINES)	89	#define ROW2Y(row) ((row) * FONT_SCANLINES)
90		90
91	#define X2COL(x) ((x) / FONT_WIDTH)	91	#define X2COL(x) ((x) / FONT_WIDTH)
92	#define Y2ROW(y) ((y) / FONT_SCANLINES)	92	#define Y2ROW(y) ((y) / FONT_SCANLINES)
93		93
94	#define FB_POS(x, y) ((y) * scanline + (x) * pixelbytes)	94	#define FB_POS(x, y) ((y) * scanline + (x) * pixelbytes)
95	#define BB_POS(col, row) ((row) * cols + (col))	95	#define BB_POS(col, row) ((row) * cols + (col))
96	#define GLYPH_POS(glyph, y) ((glyph) * glyphbytes + (y) * glyphscanline)	96	#define GLYPH_POS(glyph, y) ((glyph) * glyphbytes + (y) * glyphscanline)
97		97
98		98
99	static void (rgb_conv)(void , uint32_t);	99	static void (rgb_conv)(void , uint32_t);
100		100
101	/*	101	/*
102	* RGB conversion functions.	102	* RGB conversion functions.
103	*	103	*
104	* These functions write an RGB value to some memory in some predefined format.	104	* These functions write an RGB value to some memory in some predefined format.
105	* The naming convention corresponds to the format created by these functions.	105	* The naming convention corresponds to the format created by these functions.
106	* The functions use the so called network order (i.e. big endian) with respect	106	* The functions use the so called network order (i.e. big endian) with respect
107	* to their names.	107	* to their names.
108	*/	108	*/
109		109
110	static void rgb_0888(void *dst, uint32_t rgb)	110	static void rgb_0888(void *dst, uint32_t rgb)
111	{	111	{
112	((uint32_t ) dst) = host2uint32_t_be((0 << 24) \|	112	((uint32_t ) dst) = host2uint32_t_be((0 << 24) \|
113	(RED(rgb, 8) << 16) \| (GREEN(rgb, 8) << 8) \| (BLUE(rgb, 8)));	113	(RED(rgb, 8) << 16) \| (GREEN(rgb, 8) << 8) \| (BLUE(rgb, 8)));
114	}	114	}
115		115
116	static void bgr_0888(void *dst, uint32_t rgb)	116	static void bgr_0888(void *dst, uint32_t rgb)
117	{	117	{
118	((uint32_t ) dst) = host2uint32_t_be((0 << 24) \|	118	((uint32_t ) dst) = host2uint32_t_be((0 << 24) \|
119	(BLUE(rgb, 8) << 16) \| (GREEN(rgb, 8) << 8) \| (RED(rgb, 8)));	119	(BLUE(rgb, 8) << 16) \| (GREEN(rgb, 8) << 8) \| (RED(rgb, 8)));
120	}	120	}
121		121
122	static void rgb_8880(void *dst, uint32_t rgb)	122	static void rgb_8880(void *dst, uint32_t rgb)
123	{	123	{
124	((uint32_t ) dst) = host2uint32_t_be((RED(rgb, 8) << 24) \|	124	((uint32_t ) dst) = host2uint32_t_be((RED(rgb, 8) << 24) \|
125	(GREEN(rgb, 8) << 16) \| (BLUE(rgb, 8) << 8) \| 0);	125	(GREEN(rgb, 8) << 16) \| (BLUE(rgb, 8) << 8) \| 0);
126	}	126	}
127		127
128	static void bgr_8880(void *dst, uint32_t rgb)	128	static void bgr_8880(void *dst, uint32_t rgb)
129	{	129	{
130	((uint32_t ) dst) = host2uint32_t_be((BLUE(rgb, 8) << 24) \|	130	((uint32_t ) dst) = host2uint32_t_be((BLUE(rgb, 8) << 24) \|
131	(GREEN(rgb, 8) << 16) \| (RED(rgb, 8) << 8) \| 0);	131	(GREEN(rgb, 8) << 16) \| (RED(rgb, 8) << 8) \| 0);
132	}	132	}
133		133
134	static void rgb_888(void *dst, uint32_t rgb)	134	static void rgb_888(void *dst, uint32_t rgb)
135	{	135	{
136	((uint8_t *) dst)[0] = RED(rgb, 8);	136	((uint8_t *) dst)[0] = RED(rgb, 8);
137	((uint8_t *) dst)[1] = GREEN(rgb, 8);	137	((uint8_t *) dst)[1] = GREEN(rgb, 8);
138	((uint8_t *) dst)[2] = BLUE(rgb, 8);	138	((uint8_t *) dst)[2] = BLUE(rgb, 8);
139	}	139	}
140		140
141	static void bgr_888(void *dst, uint32_t rgb)	141	static void bgr_888(void *dst, uint32_t rgb)
142	{	142	{
143	((uint8_t *) dst)[0] = BLUE(rgb, 8);	143	((uint8_t *) dst)[0] = BLUE(rgb, 8);
144	((uint8_t *) dst)[1] = GREEN(rgb, 8);	144	((uint8_t *) dst)[1] = GREEN(rgb, 8);
145	((uint8_t *) dst)[2] = RED(rgb, 8);	145	((uint8_t *) dst)[2] = RED(rgb, 8);
146	}	146	}
147		147
148	static void rgb_555_be(void *dst, uint32_t rgb)	148	static void rgb_555_be(void *dst, uint32_t rgb)
149	{	149	{
150	((uint16_t ) dst) = host2uint16_t_be(RED(rgb, 5) << 10 \|	150	((uint16_t ) dst) = host2uint16_t_be(RED(rgb, 5) << 10 \|
151	GREEN(rgb, 5) << 5 \| BLUE(rgb, 5));	151	GREEN(rgb, 5) << 5 \| BLUE(rgb, 5));
152	}	152	}
153		153
154	static void rgb_555_le(void *dst, uint32_t rgb)	154	static void rgb_555_le(void *dst, uint32_t rgb)
155	{	155	{
156	((uint16_t ) dst) = host2uint16_t_le(RED(rgb, 5) << 10 \|	156	((uint16_t ) dst) = host2uint16_t_le(RED(rgb, 5) << 10 \|
157	GREEN(rgb, 5) << 5 \| BLUE(rgb, 5));	157	GREEN(rgb, 5) << 5 \| BLUE(rgb, 5));
158	}	158	}
159		159
160	static void rgb_565_be(void *dst, uint32_t rgb)	160	static void rgb_565_be(void *dst, uint32_t rgb)
161	{	161	{
162	((uint16_t ) dst) = host2uint16_t_be(RED(rgb, 5) << 11 \|	162	((uint16_t ) dst) = host2uint16_t_be(RED(rgb, 5) << 11 \|
163	GREEN(rgb, 6) << 5 \| BLUE(rgb, 5));	163	GREEN(rgb, 6) << 5 \| BLUE(rgb, 5));
164	}	164	}
165		165
166	static void rgb_565_le(void *dst, uint32_t rgb)	166	static void rgb_565_le(void *dst, uint32_t rgb)
167	{	167	{
168	((uint16_t ) dst) = host2uint16_t_le(RED(rgb, 5) << 11 \|	168	((uint16_t ) dst) = host2uint16_t_le(RED(rgb, 5) << 11 \|
169	GREEN(rgb, 6) << 5 \| BLUE(rgb, 5));	169	GREEN(rgb, 6) << 5 \| BLUE(rgb, 5));
170	}	170	}
171		171
172		172
173	/** BGR 3:2:3	173	/** BGR 3:2:3
174	*	174	*
175	* Even though we try 3:2:3 color scheme here, an 8-bit framebuffer	175	* Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
176	* will most likely use a color palette. The color appearance	176	* will most likely use a color palette. The color appearance
177	* will be pretty random and depend on the default installed	177	* will be pretty random and depend on the default installed
178	* palette. This could be fixed by supporting custom palette	178	* palette. This could be fixed by supporting custom palette
179	* and setting it to simulate the 8-bit truecolor.	179	* and setting it to simulate the 8-bit truecolor.
180	*	180	*
181	* Currently we set the palette on the ia32, amd64 and sparc64 port.	181	* Currently we set the palette on the ia32, amd64 and sparc64 port.
182	*	182	*
183	* Note that the byte is being inverted by this function. The reason is	183	* Note that the byte is being inverted by this function. The reason is
184	* that we would like to use a color palette where the white color code	184	* that we would like to use a color palette where the white color code
185	* is 0 and the black color code is 255, as some machines (Sun Blade 1500)	185	* is 0 and the black color code is 255, as some machines (Sun Blade 1500)
186	* use these codes for black and white and prevent to set codes	186	* use these codes for black and white and prevent to set codes
187	* 0 and 255 to other colors.	187	* 0 and 255 to other colors.
188	*	188	*
189	*/	189	*/
190	static void bgr_323(void *dst, uint32_t rgb)	190	static void bgr_323(void *dst, uint32_t rgb)
191	{	191	{
192	((uint8_t ) dst)	192	((uint8_t ) dst)
193	= ~((RED(rgb, 3) << 5) \| (GREEN(rgb, 2) << 3) \| BLUE(rgb, 3));	193	= ~((RED(rgb, 3) << 5) \| (GREEN(rgb, 2) << 3) \| BLUE(rgb, 3));
194	}	194	}
195		195
196		196
197	/** Hide logo and refresh screen	197	/** Hide logo and refresh screen
198	*	198	*
199	*/	199	*/
200	static void logo_hide(bool silent)	200	static void logo_hide(bool silent)
201	{	201	{
202	ylogo = 0;	202	ylogo = 0;
203	ytrim = yres;	203	ytrim = yres;
204	rowtrim = rows;	204	rowtrim = rows;
205	if (!silent)	205	if (!silent)
206	fb_redraw();	206	fb_redraw();
207	}	207	}
208		208
209		209
210	/** Draw character at given position	210	/** Draw character at given position
211	*	211	*
212	*/	212	*/
213	static void glyph_draw(uint16_t glyph, unsigned int col, unsigned int row, bool silent, bool overlay)	213	static void glyph_draw(uint16_t glyph, unsigned int col, unsigned int row, bool silent, bool overlay)
214	{	214	{
215	unsigned int x = COL2X(col);	215	unsigned int x = COL2X(col);
216	unsigned int y = ROW2Y(row);	216	unsigned int y = ROW2Y(row);
217	unsigned int yd;	217	unsigned int yd;
218		218
219	if (y >= ytrim)	219	if (y >= ytrim)
220	logo_hide(silent);	220	logo_hide(silent);
221		221
222	if (!overlay)	222	if (!overlay)
223	backbuf[BB_POS(col, row)] = glyph;	223	backbuf[BB_POS(col, row)] = glyph;
224		224
225	if (!silent) {	225	if (!silent) {
226	for (yd = 0; yd < FONT_SCANLINES; yd++)	226	for (yd = 0; yd < FONT_SCANLINES; yd++)
227	memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],	227	memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],
228	&glyphs[GLYPH_POS(glyph, yd)], glyphscanline);	228	&glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
229	}	229	}
230	}	230	}
231		231
232		232
233	/** Scroll screen down by one row	233	/** Scroll screen down by one row
234	*	234	*
235	*	235	*
236	*/	236	*/
237	static void screen_scroll(bool silent)	237	static void screen_scroll(bool silent)
238	{	238	{
239	if (ylogo > 0) {	239	if (ylogo > 0) {
240	logo_hide(silent);	240	logo_hide(silent);
241	return;	241	return;
242	}	242	}
243		243
244	if (!silent) {	244	if (!silent) {
245	unsigned int row;	245	unsigned int row;
246		246
247	for (row = 0; row < rows; row++) {	247	for (row = 0; row < rows; row++) {
248	unsigned int y = ROW2Y(row);	248	unsigned int y = ROW2Y(row);
249	unsigned int yd;	249	unsigned int yd;
250		250
251	for (yd = 0; yd < FONT_SCANLINES; yd++) {	251	for (yd = 0; yd < FONT_SCANLINES; yd++) {
252	unsigned int x;	252	unsigned int x;
253	unsigned int col;	253	unsigned int col;
254		254
255	for (col = 0, x = 0; col < cols; col++,	255	for (col = 0, x = 0; col < cols; col++,
256	x += FONT_WIDTH) {	256	x += FONT_WIDTH) {
257	uint16_t glyph;	257	uint16_t glyph;
258		258
259	if (row < rows - 1) {	259	if (row < rows - 1) {
260	if (backbuf[BB_POS(col, row)] ==	260	if (backbuf[BB_POS(col, row)] ==
261	backbuf[BB_POS(col, row + 1)])	261	backbuf[BB_POS(col, row + 1)])
262	continue;	262	continue;
263		263
264	glyph = backbuf[BB_POS(col, row + 1)];	264	glyph = backbuf[BB_POS(col, row + 1)];
265	} else	265	} else
266	glyph = 0;	266	glyph = 0;
267		267
268	memcpy(&fb_addr[FB_POS(x, y + yd)],	268	memcpy(&fb_addr[FB_POS(x, y + yd)],
269	&glyphs[GLYPH_POS(glyph, yd)],	269	&glyphs[GLYPH_POS(glyph, yd)],
270	glyphscanline);	270	glyphscanline);
271	}	271	}
272	}	272	}
273	}	273	}
274	}	274	}
275		275
276	memmove(backbuf, &backbuf[BB_POS(0, 1)], cols * (rows - 1) * sizeof(uint16_t));	276	memmove(backbuf, &backbuf[BB_POS(0, 1)], cols * (rows - 1) * sizeof(uint16_t));
277	memsetw(&backbuf[BB_POS(0, rows - 1)], cols, 0);	277	memsetw(&backbuf[BB_POS(0, rows - 1)], cols, 0);
278	}	278	}
279		279
280		280
281	static void cursor_put(bool silent)	281	static void cursor_put(bool silent)
282	{	282	{
283	unsigned int col = position % cols;	283	unsigned int col = position % cols;
284	unsigned int row = position / cols;	284	unsigned int row = position / cols;
285		285
286	glyph_draw(fb_font_glyph(U_CURSOR), col, row, silent, true);	286	glyph_draw(fb_font_glyph(U_CURSOR), col, row, silent, true);
287	}	287	}
288		288
289		289
290	static void cursor_remove(bool silent)	290	static void cursor_remove(bool silent)
291	{	291	{
292	unsigned int col = position % cols;	292	unsigned int col = position % cols;
293	unsigned int row = position / cols;	293	unsigned int row = position / cols;
294		294
295	glyph_draw(backbuf[BB_POS(col, row)], col, row, silent, true);	295	glyph_draw(backbuf[BB_POS(col, row)], col, row, silent, true);
296	}	296	}
297		297
298		298
299	/** Print character to screen	299	/** Print character to screen
300	*	300	*
301	* Emulate basic terminal commands.	301	* Emulate basic terminal commands.
302	*	302	*
303	*/	303	*/
304	static void fb_putchar(outdev_t *dev, wchar_t ch, bool silent)	304	static void fb_putchar(outdev_t *dev, wchar_t ch, bool silent)
305	{	305	{
306	spinlock_lock(&fb_lock);	306	spinlock_lock(&fb_lock);
307		307
308	switch (ch) {	308	switch (ch) {
309	case '\n':	309	case '\n':
310	cursor_remove(silent);	310	cursor_remove(silent);
311	position += cols;	311	position += cols;
312	position -= position % cols;	312	position -= position % cols;
313	break;	313	break;
314	case '\r':	314	case '\r':
315	cursor_remove(silent);	315	cursor_remove(silent);
316	position -= position % cols;	316	position -= position % cols;
317	break;	317	break;
318	case '\b':	318	case '\b':
319	cursor_remove(silent);	319	cursor_remove(silent);
320	if (position % cols)	320	if (position % cols)
321	position--;	321	position--;
322	break;	322	break;
323	case '\t':	323	case '\t':
324	cursor_remove(silent);	324	cursor_remove(silent);
325	do {	325	do {
326	glyph_draw(fb_font_glyph(' '), position % cols,	326	glyph_draw(fb_font_glyph(' '), position % cols,
327	position / cols, silent, false);	327	position / cols, silent, false);
328	position++;	328	position++;
329	} while ((position % 8) && (position < cols * rows));	329	} while ((position % 8) && (position < cols * rows));
330	break;	330	break;
331	default:	331	default:
332	glyph_draw(fb_font_glyph(ch), position % cols,	332	glyph_draw(fb_font_glyph(ch), position % cols,
333	position / cols, silent, false);	333	position / cols, silent, false);
334	position++;	334	position++;
335	}	335	}
336		336
337	if (position >= cols * rows) {	337	if (position >= cols * rows) {
338	position -= cols;	338	position -= cols;
339	screen_scroll(silent);	339	screen_scroll(silent);
340	}	340	}
341		341
342	cursor_put(silent);	342	cursor_put(silent);
343		343
344	spinlock_unlock(&fb_lock);	344	spinlock_unlock(&fb_lock);
345	}	345	}
346		346
347	static outdev_t fb_console;	347	static outdev_t fb_console;
348	static outdev_operations_t fb_ops = {	348	static outdev_operations_t fb_ops = {
349	.write = fb_putchar	349	.write = fb_putchar
350	};	350	};
351		351
352		352
353	/** Render glyphs	353	/** Render glyphs
354	*	354	*
355	* Convert glyphs from device independent font	355	* Convert glyphs from device independent font
356	* description to current visual representation.	356	* description to current visual representation.
357	*	357	*
358	*/	358	*/
359	static void glyphs_render(void)	359	static void glyphs_render(void)
360	{	360	{
361	/* Prerender glyphs */	361	/* Prerender glyphs */
362	uint16_t glyph;	362	uint16_t glyph;
363		363
364	for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {	364	for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
365	uint32_t fg_color;	365	uint32_t fg_color;
366		366
367	if (glyph == FONT_GLYPHS - 1)	367	if (glyph == FONT_GLYPHS - 1)
368	fg_color = INV_COLOR;	368	fg_color = INV_COLOR;
369	else	369	else
370	fg_color = FG_COLOR;	370	fg_color = FG_COLOR;
371		371
372	unsigned int y;	372	unsigned int y;
373		373
374	for (y = 0; y < FONT_SCANLINES; y++) {	374	for (y = 0; y < FONT_SCANLINES; y++) {
375	unsigned int x;	375	unsigned int x;
376		376
377	for (x = 0; x < FONT_WIDTH; x++) {	377	for (x = 0; x < FONT_WIDTH; x++) {
378	void *dst = &glyphs[GLYPH_POS(glyph, y) +	378	void *dst = &glyphs[GLYPH_POS(glyph, y) +
379	x * pixelbytes];	379	x * pixelbytes];
380	uint32_t rgb = (fb_font[glyph][y] &	380	uint32_t rgb = (fb_font[glyph][y] &
381	(1 << (7 - x))) ? fg_color : BG_COLOR;	381	(1 << (7 - x))) ? fg_color : BG_COLOR;
382	rgb_conv(dst, rgb);	382	rgb_conv(dst, rgb);
383	}	383	}
384	}	384	}
385	}	385	}
386		386
387	/* Prerender background scanline */	387	/* Prerender background scanline */
388	unsigned int x;	388	unsigned int x;
389		389
390	for (x = 0; x < xres; x++)	390	for (x = 0; x < xres; x++)
391	rgb_conv(&bgscan[x * pixelbytes], BG_COLOR);	391	rgb_conv(&bgscan[x * pixelbytes], BG_COLOR);
392	}	392	}
393		393
394		394
395	/** Refresh the screen	395	/** Refresh the screen
396	*	396	*
397	*/	397	*/
398	void fb_redraw(void)	398	void fb_redraw(void)
399	{	399	{
400	if (ylogo > 0) {	400	if (ylogo > 0) {
401	unsigned int y;	401	unsigned int y;
402		402
403	for (y = 0; y < LOGO_HEIGHT; y++) {	403	for (y = 0; y < LOGO_HEIGHT; y++) {
404	unsigned int x;	404	unsigned int x;
405		405
406	for (x = 0; x < xres; x++)	406	for (x = 0; x < xres; x++)
407	rgb_conv(&fb_addr[FB_POS(x, y)],	407	rgb_conv(&fb_addr[FB_POS(x, y)],
408	(x < LOGO_WIDTH) ?	408	(x < LOGO_WIDTH) ?
409	fb_logo[y * LOGO_WIDTH + x] :	409	fb_logo[y * LOGO_WIDTH + x] :
410	LOGO_COLOR);	410	LOGO_COLOR);
411	}	411	}
412	}	412	}
413		413
414	unsigned int row;	414	unsigned int row;
415		415
416	for (row = 0; row < rowtrim; row++) {	416	for (row = 0; row < rowtrim; row++) {
417	unsigned int y = ylogo + ROW2Y(row);	417	unsigned int y = ylogo + ROW2Y(row);
418	unsigned int yd;	418	unsigned int yd;
419		419
420	for (yd = 0; yd < FONT_SCANLINES; yd++) {	420	for (yd = 0; yd < FONT_SCANLINES; yd++) {
421	unsigned int x;	421	unsigned int x;
422	unsigned int col;	422	unsigned int col;
423		423
424	for (col = 0, x = 0; col < cols;	424	for (col = 0, x = 0; col < cols;
425	col++, x += FONT_WIDTH) {	425	col++, x += FONT_WIDTH) {
426	uint16_t glyph = backbuf[BB_POS(col, row)];	426	uint16_t glyph = backbuf[BB_POS(col, row)];
427	void *dst = &fb_addr[FB_POS(x, y + yd)];	427	void *dst = &fb_addr[FB_POS(x, y + yd)];
428	void *src = &glyphs[GLYPH_POS(glyph, yd)];	428	void *src = &glyphs[GLYPH_POS(glyph, yd)];
429	memcpy(dst, src, glyphscanline);	429	memcpy(dst, src, glyphscanline);
430	}	430	}
431	}	431	}
432	}	432	}
433		433
434	if (COL2X(cols) < xres) {	434	if (COL2X(cols) < xres) {
435	unsigned int y;	435	unsigned int y;
436	unsigned int size = (xres - COL2X(cols)) * pixelbytes;	436	unsigned int size = (xres - COL2X(cols)) * pixelbytes;
437		437
438	for (y = ylogo; y < yres; y++)	438	for (y = ylogo; y < yres; y++)
439	memcpy(&fb_addr[FB_POS(COL2X(cols), y)], bgscan, size);	439	memcpy(&fb_addr[FB_POS(COL2X(cols), y)], bgscan, size);
440	}	440	}
441		441
442	if (ROW2Y(rowtrim) + ylogo < yres) {	442	if (ROW2Y(rowtrim) + ylogo < yres) {
443	unsigned int y;	443	unsigned int y;
444		444
445	for (y = ROW2Y(rowtrim) + ylogo; y < yres; y++)	445	for (y = ROW2Y(rowtrim) + ylogo; y < yres; y++)
446	memcpy(&fb_addr[FB_POS(0, y)], bgscan, bgscanbytes);	446	memcpy(&fb_addr[FB_POS(0, y)], bgscan, bgscanbytes);
447	}	447	}
448	}	448	}
449		449
450		450
451	/** Initialize framebuffer as a output character device	451	/** Initialize framebuffer as a output character device
452	*	452	*
453	* @param addr Physical address of the framebuffer	453	* @param addr Physical address of the framebuffer
454	* @param x Screen width in pixels	454	* @param x Screen width in pixels
455	* @param y Screen height in pixels	455	* @param y Screen height in pixels
456	* @param scan Bytes per one scanline	456	* @param scan Bytes per one scanline
457	* @param visual Color model	457	* @param visual Color model
458	*	458	*
459	*/	459	*/
460	void fb_init(fb_properties_t *props)	460	void fb_init(fb_properties_t *props)
461	{	461	{
462	switch (props->visual) {	462	switch (props->visual) {
463	case VISUAL_INDIRECT_8:	463	case VISUAL_INDIRECT_8:
464	rgb_conv = bgr_323;	464	rgb_conv = bgr_323;
465	pixelbytes = 1;	465	pixelbytes = 1;
466	break;	466	break;
467	case VISUAL_RGB_5_5_5_LE:	467	case VISUAL_RGB_5_5_5_LE:
468	rgb_conv = rgb_555_le;	468	rgb_conv = rgb_555_le;
469	pixelbytes = 2;	469	pixelbytes = 2;
470	break;	470	break;
471	case VISUAL_RGB_5_5_5_BE:	471	case VISUAL_RGB_5_5_5_BE:
472	rgb_conv = rgb_555_be;	472	rgb_conv = rgb_555_be;
473	pixelbytes = 2;	473	pixelbytes = 2;
474	break;	474	break;
475	case VISUAL_RGB_5_6_5_LE:	475	case VISUAL_RGB_5_6_5_LE:
476	rgb_conv = rgb_565_le;	476	rgb_conv = rgb_565_le;
477	pixelbytes = 2;	477	pixelbytes = 2;
478	break;	478	break;
479	case VISUAL_RGB_5_6_5_BE:	479	case VISUAL_RGB_5_6_5_BE:
480	rgb_conv = rgb_565_be;	480	rgb_conv = rgb_565_be;
481	pixelbytes = 2;	481	pixelbytes = 2;
482	break;	482	break;
483	case VISUAL_RGB_8_8_8:	483	case VISUAL_RGB_8_8_8:
484	rgb_conv = rgb_888;	484	rgb_conv = rgb_888;
485	pixelbytes = 3;	485	pixelbytes = 3;
486	break;	486	break;
487	case VISUAL_BGR_8_8_8:	487	case VISUAL_BGR_8_8_8:
488	rgb_conv = bgr_888;	488	rgb_conv = bgr_888;
489	pixelbytes = 3;	489	pixelbytes = 3;
490	break;	490	break;
491	case VISUAL_RGB_8_8_8_0:	491	case VISUAL_RGB_8_8_8_0:
492	rgb_conv = rgb_8880;	492	rgb_conv = rgb_8880;
493	pixelbytes = 4;	493	pixelbytes = 4;
494	break;	494	break;
495	case VISUAL_RGB_0_8_8_8:	495	case VISUAL_RGB_0_8_8_8:
496	rgb_conv = rgb_0888;	496	rgb_conv = rgb_0888;
497	pixelbytes = 4;	497	pixelbytes = 4;
498	break;	498	break;
499	case VISUAL_BGR_0_8_8_8:	499	case VISUAL_BGR_0_8_8_8:
500	rgb_conv = bgr_0888;	500	rgb_conv = bgr_0888;

Subversion Repositories HelenOS

(root)/tags/0.4.1/kernel/genarch/src/fb/fb.c – Rev 4685 → 4687