WebSVN – HelenOS – Diff – /branches/snapshot/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>
 
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);
 
 
/** ARGB 8:8:8:8 conversion
 *
 */
static void rgb_0888(void *dst, uint32_t rgb)
{
    *((uint32_t *) dst) = rgb & 0xffffff;
}
 
 
/** ABGR 8:8:8:8 conversion
 *
 */
static void bgr_0888(void *dst, uint32_t rgb)
{
    *((uint32_t *) dst)
        = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
}
 
 
/** RGB 8:8:8 conversion
 *
 */
static void rgb_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);
}
 
 
/** BGR 8:8:8 conversion
 *
 */
static void bgr_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);
}
 
 
/** RGB 5:5:5 conversion
 *
 */
static void rgb_555(void *dst, uint32_t rgb)
{
    *((uint16_t *) dst)
        = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
}
 
 
/** RGB 5:6:5 conversion
 *
 */
static void rgb_565(void *dst, uint32_t rgb)
{
    *((uint16_t *) dst)
        = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
}
 
 
/** RGB 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 rgb_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 = rgb_323;
        pixelbytes = 1;
        break;
    case VISUAL_RGB_5_5_5:
        rgb_conv = rgb_555;
        pixelbytes = 2;
        break;
    case VISUAL_RGB_5_6_5:
        rgb_conv = rgb_565;
        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_888;
        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;
    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 4223	Rev 4605
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		53
54	SPINLOCK_INITIALIZE(fb_lock);	54	SPINLOCK_INITIALIZE(fb_lock);
55		55
56	static uint8_t *fb_addr;	56	static uint8_t *fb_addr;
57	static uint16_t *backbuf;	57	static uint16_t *backbuf;
58	static uint8_t *glyphs;	58	static uint8_t *glyphs;
59	static uint8_t *bgscan;	59	static uint8_t *bgscan;
60		60
61	static unsigned int xres;	61	static unsigned int xres;
62	static unsigned int yres;	62	static unsigned int yres;
63		63
64	static unsigned int ylogo;	64	static unsigned int ylogo;
65	static unsigned int ytrim;	65	static unsigned int ytrim;
66	static unsigned int rowtrim;	66	static unsigned int rowtrim;
67		67
68	static unsigned int scanline;	68	static unsigned int scanline;
69	static unsigned int glyphscanline;	69	static unsigned int glyphscanline;
70		70
71	static unsigned int pixelbytes;	71	static unsigned int pixelbytes;
72	static unsigned int glyphbytes;	72	static unsigned int glyphbytes;
73	static unsigned int bgscanbytes;	73	static unsigned int bgscanbytes;
74		74
75	static unsigned int cols;	75	static unsigned int cols;
76	static unsigned int rows;	76	static unsigned int rows;
77	static unsigned int position = 0;	77	static unsigned int position = 0;
78		78
79	#define BG_COLOR 0x000080	79	#define BG_COLOR 0x000080
80	#define FG_COLOR 0xffff00	80	#define FG_COLOR 0xffff00
81	#define INV_COLOR 0xaaaaaa	81	#define INV_COLOR 0xaaaaaa
82		82
83	#define RED(x, bits) ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))	83	#define RED(x, bits) ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
84	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))	84	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
85	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))	85	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))
86		86
87	#define COL2X(col) ((col) * FONT_WIDTH)	87	#define COL2X(col) ((col) * FONT_WIDTH)
88	#define ROW2Y(row) ((row) * FONT_SCANLINES)	88	#define ROW2Y(row) ((row) * FONT_SCANLINES)
89		89
90	#define X2COL(x) ((x) / FONT_WIDTH)	90	#define X2COL(x) ((x) / FONT_WIDTH)
91	#define Y2ROW(y) ((y) / FONT_SCANLINES)	91	#define Y2ROW(y) ((y) / FONT_SCANLINES)
92		92
93	#define FB_POS(x, y) ((y) * scanline + (x) * pixelbytes)	93	#define FB_POS(x, y) ((y) * scanline + (x) * pixelbytes)
94	#define BB_POS(col, row) ((row) * cols + (col))	94	#define BB_POS(col, row) ((row) * cols + (col))
95	#define GLYPH_POS(glyph, y) ((glyph) * glyphbytes + (y) * glyphscanline)	95	#define GLYPH_POS(glyph, y) ((glyph) * glyphbytes + (y) * glyphscanline)
96		96
97		97
98	static void (rgb_conv)(void , uint32_t);	98	static void (rgb_conv)(void , uint32_t);
99		99
100		100
101	/** ARGB 8:8:8:8 conversion	101	/** ARGB 8:8:8:8 conversion
102	*	102	*
103	*/	103	*/
104	static void rgb_0888(void *dst, uint32_t rgb)	104	static void rgb_0888(void *dst, uint32_t rgb)
105	{	105	{
106	((uint32_t ) dst) = rgb & 0xffffff;	106	((uint32_t ) dst) = rgb & 0xffffff;
107	}	107	}
108		108
109		109
110	/** ABGR 8:8:8:8 conversion	110	/** ABGR 8:8:8:8 conversion
111	*	111	*
112	*/	112	*/
113	static void bgr_0888(void *dst, uint32_t rgb)	113	static void bgr_0888(void *dst, uint32_t rgb)
114	{	114	{
115	((uint32_t ) dst)	115	((uint32_t ) dst)
116	= (BLUE(rgb, 8) << 16) \| (GREEN(rgb, 8) << 8) \| RED(rgb, 8);	116	= (BLUE(rgb, 8) << 16) \| (GREEN(rgb, 8) << 8) \| RED(rgb, 8);
117	}	117	}
118		118
119		119
120	/** RGB 8:8:8 conversion	120	/** RGB 8:8:8 conversion
121	*	121	*
122	*/	122	*/
123	static void rgb_888(void *dst, uint32_t rgb)	123	static void rgb_888(void *dst, uint32_t rgb)
124	{	124	{
125	((uint8_t *) dst)[0] = BLUE(rgb, 8);	125	((uint8_t *) dst)[0] = BLUE(rgb, 8);
126	((uint8_t *) dst)[1] = GREEN(rgb, 8);	126	((uint8_t *) dst)[1] = GREEN(rgb, 8);
127	((uint8_t *) dst)[2] = RED(rgb, 8);	127	((uint8_t *) dst)[2] = RED(rgb, 8);
128	}	128	}
129		129
130		130
131	/** BGR 8:8:8 conversion	131	/** BGR 8:8:8 conversion
132	*	132	*
133	*/	133	*/
134	static void bgr_888(void *dst, uint32_t rgb)	134	static void bgr_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		141
142	/** RGB 5:5:5 conversion	142	/** RGB 5:5:5 conversion
143	*	143	*
144	*/	144	*/
145	static void rgb_555(void *dst, uint32_t rgb)	145	static void rgb_555(void *dst, uint32_t rgb)
146	{	146	{
147	((uint16_t ) dst)	147	((uint16_t ) dst)
148	= (RED(rgb, 5) << 10) \| (GREEN(rgb, 5) << 5) \| BLUE(rgb, 5);	148	= (RED(rgb, 5) << 10) \| (GREEN(rgb, 5) << 5) \| BLUE(rgb, 5);
149	}	149	}
150		150
151		151
152	/** RGB 5:6:5 conversion	152	/** RGB 5:6:5 conversion
153	*	153	*
154	*/	154	*/
155	static void rgb_565(void *dst, uint32_t rgb)	155	static void rgb_565(void *dst, uint32_t rgb)
156	{	156	{
157	((uint16_t ) dst)	157	((uint16_t ) dst)
158	= (RED(rgb, 5) << 11) \| (GREEN(rgb, 6) << 5) \| BLUE(rgb, 5);	158	= (RED(rgb, 5) << 11) \| (GREEN(rgb, 6) << 5) \| BLUE(rgb, 5);
159	}	159	}
160		160
161		161
162	/** RGB 3:2:3	162	/** RGB 3:2:3
163	*	163	*
164	* Even though we try 3:2:3 color scheme here, an 8-bit framebuffer	164	* Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
165	* will most likely use a color palette. The color appearance	165	* will most likely use a color palette. The color appearance
166	* will be pretty random and depend on the default installed	166	* will be pretty random and depend on the default installed
167	* palette. This could be fixed by supporting custom palette	167	* palette. This could be fixed by supporting custom palette
168	* and setting it to simulate the 8-bit truecolor.	168	* and setting it to simulate the 8-bit truecolor.
169	*	169	*
170	* Currently we set the palette on the ia32, amd64 and sparc64 port.	170	* Currently we set the palette on the ia32, amd64 and sparc64 port.
171	*	171	*
172	* Note that the byte is being inverted by this function. The reason is	172	* Note that the byte is being inverted by this function. The reason is
173	* that we would like to use a color palette where the white color code	173	* that we would like to use a color palette where the white color code
174	* is 0 and the black color code is 255, as some machines (Sun Blade 1500)	174	* is 0 and the black color code is 255, as some machines (Sun Blade 1500)
175	* use these codes for black and white and prevent to set codes	175	* use these codes for black and white and prevent to set codes
176	* 0 and 255 to other colors.	176	* 0 and 255 to other colors.
177	*	177	*
178	*/	178	*/
179	static void rgb_323(void *dst, uint32_t rgb)	179	static void rgb_323(void *dst, uint32_t rgb)
180	{	180	{
181	((uint8_t ) dst)	181	((uint8_t ) dst)
182	= ~((RED(rgb, 3) << 5) \| (GREEN(rgb, 2) << 3) \| BLUE(rgb, 3));	182	= ~((RED(rgb, 3) << 5) \| (GREEN(rgb, 2) << 3) \| BLUE(rgb, 3));
183	}	183	}
184		184
185		185
186	/** Hide logo and refresh screen	186	/** Hide logo and refresh screen
187	*	187	*
188	*/	188	*/
189	static void logo_hide(bool silent)	189	static void logo_hide(bool silent)
190	{	190	{
191	ylogo = 0;	191	ylogo = 0;
192	ytrim = yres;	192	ytrim = yres;
193	rowtrim = rows;	193	rowtrim = rows;
194	if (!silent)	194	if (!silent)
195	fb_redraw();	195	fb_redraw();
196	}	196	}
197		197
198		198
199	/** Draw character at given position	199	/** Draw character at given position
200	*	200	*
201	*/	201	*/
202	static void glyph_draw(uint16_t glyph, unsigned int col, unsigned int row, bool silent, bool overlay)	202	static void glyph_draw(uint16_t glyph, unsigned int col, unsigned int row, bool silent, bool overlay)
203	{	203	{
204	unsigned int x = COL2X(col);	204	unsigned int x = COL2X(col);
205	unsigned int y = ROW2Y(row);	205	unsigned int y = ROW2Y(row);
206	unsigned int yd;	206	unsigned int yd;
207		207
208	if (y >= ytrim)	208	if (y >= ytrim)
209	logo_hide(silent);	209	logo_hide(silent);
210		210
211	if (!overlay)	211	if (!overlay)
212	backbuf[BB_POS(col, row)] = glyph;	212	backbuf[BB_POS(col, row)] = glyph;
213		213
214	if (!silent) {	214	if (!silent) {
215	for (yd = 0; yd < FONT_SCANLINES; yd++)	215	for (yd = 0; yd < FONT_SCANLINES; yd++)
216	memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],	216	memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],
217	&glyphs[GLYPH_POS(glyph, yd)], glyphscanline);	217	&glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
218	}	218	}
219	}	219	}
220		220
221		221
222	/** Scroll screen down by one row	222	/** Scroll screen down by one row
223	*	223	*
224	*	224	*
225	*/	225	*/
226	static void screen_scroll(bool silent)	226	static void screen_scroll(bool silent)
227	{	227	{
228	if (ylogo > 0) {	228	if (ylogo > 0) {
229	logo_hide(silent);	229	logo_hide(silent);
230	return;	230	return;
231	}	231	}
232		232
233	if (!silent) {	233	if (!silent) {
234	unsigned int row;	234	unsigned int row;
235		235
236	for (row = 0; row < rows; row++) {	236	for (row = 0; row < rows; row++) {
237	unsigned int y = ROW2Y(row);	237	unsigned int y = ROW2Y(row);
238	unsigned int yd;	238	unsigned int yd;
239		239
240	for (yd = 0; yd < FONT_SCANLINES; yd++) {	240	for (yd = 0; yd < FONT_SCANLINES; yd++) {
241	unsigned int x;	241	unsigned int x;
242	unsigned int col;	242	unsigned int col;
243		243
244	for (col = 0, x = 0; col < cols; col++,	244	for (col = 0, x = 0; col < cols; col++,
245	x += FONT_WIDTH) {	245	x += FONT_WIDTH) {
246	uint16_t glyph;	246	uint16_t glyph;
247		247
248	if (row < rows - 1) {	248	if (row < rows - 1) {
249	if (backbuf[BB_POS(col, row)] ==	249	if (backbuf[BB_POS(col, row)] ==
250	backbuf[BB_POS(col, row + 1)])	250	backbuf[BB_POS(col, row + 1)])
251	continue;	251	continue;
252		252
253	glyph = backbuf[BB_POS(col, row + 1)];	253	glyph = backbuf[BB_POS(col, row + 1)];
254	} else	254	} else
255	glyph = 0;	255	glyph = 0;
256		256
257	memcpy(&fb_addr[FB_POS(x, y + yd)],	257	memcpy(&fb_addr[FB_POS(x, y + yd)],
258	&glyphs[GLYPH_POS(glyph, yd)],	258	&glyphs[GLYPH_POS(glyph, yd)],
259	glyphscanline);	259	glyphscanline);
260	}	260	}
261	}	261	}
262	}	262	}
263	}	263	}
264		264
265	memmove(backbuf, &backbuf[BB_POS(0, 1)], cols * (rows - 1) * sizeof(uint16_t));	265	memmove(backbuf, &backbuf[BB_POS(0, 1)], cols * (rows - 1) * sizeof(uint16_t));
266	memsetw(&backbuf[BB_POS(0, rows - 1)], cols, 0);	266	memsetw(&backbuf[BB_POS(0, rows - 1)], cols, 0);
267	}	267	}
268		268
269		269
270	static void cursor_put(bool silent)	270	static void cursor_put(bool silent)
271	{	271	{
272	unsigned int col = position % cols;	272	unsigned int col = position % cols;
273	unsigned int row = position / cols;	273	unsigned int row = position / cols;
274		274
275	glyph_draw(fb_font_glyph(U_CURSOR), col, row, silent, true);	275	glyph_draw(fb_font_glyph(U_CURSOR), col, row, silent, true);
276	}	276	}
277		277
278		278
279	static void cursor_remove(bool silent)	279	static void cursor_remove(bool silent)
280	{	280	{
281	unsigned int col = position % cols;	281	unsigned int col = position % cols;
282	unsigned int row = position / cols;	282	unsigned int row = position / cols;
283		283
284	glyph_draw(backbuf[BB_POS(col, row)], col, row, silent, true);	284	glyph_draw(backbuf[BB_POS(col, row)], col, row, silent, true);
285	}	285	}
286		286
287		287
288	/** Print character to screen	288	/** Print character to screen
289	*	289	*
290	* Emulate basic terminal commands.	290	* Emulate basic terminal commands.
291	*	291	*
292	*/	292	*/
293	static void fb_putchar(outdev_t *dev, wchar_t ch, bool silent)	293	static void fb_putchar(outdev_t *dev, wchar_t ch, bool silent)
294	{	294	{
295	spinlock_lock(&fb_lock);	295	spinlock_lock(&fb_lock);
296		296
297	switch (ch) {	297	switch (ch) {
298	case '\n':	298	case '\n':
299	cursor_remove(silent);	299	cursor_remove(silent);
300	position += cols;	300	position += cols;
301	position -= position % cols;	301	position -= position % cols;
302	break;	302	break;
303	case '\r':	303	case '\r':
304	cursor_remove(silent);	304	cursor_remove(silent);
305	position -= position % cols;	305	position -= position % cols;
306	break;	306	break;
307	case '\b':	307	case '\b':
308	cursor_remove(silent);	308	cursor_remove(silent);
309	if (position % cols)	309	if (position % cols)
310	position--;	310	position--;
311	break;	311	break;
312	case '\t':	312	case '\t':
313	cursor_remove(silent);	313	cursor_remove(silent);
314	do {	314	do {
315	glyph_draw(fb_font_glyph(' '), position % cols,	315	glyph_draw(fb_font_glyph(' '), position % cols,
316	position / cols, silent, false);	316	position / cols, silent, false);
317	position++;	317	position++;
318	} while ((position % 8) && (position < cols * rows));	318	} while ((position % 8) && (position < cols * rows));
319	break;	319	break;
320	default:	320	default:
321	glyph_draw(fb_font_glyph(ch), position % cols,	321	glyph_draw(fb_font_glyph(ch), position % cols,
322	position / cols, silent, false);	322	position / cols, silent, false);
323	position++;	323	position++;
324	}	324	}
325		325
326	if (position >= cols * rows) {	326	if (position >= cols * rows) {
327	position -= cols;	327	position -= cols;
328	screen_scroll(silent);	328	screen_scroll(silent);
329	}	329	}
330		330
331	cursor_put(silent);	331	cursor_put(silent);
332		332
333	spinlock_unlock(&fb_lock);	333	spinlock_unlock(&fb_lock);
334	}	334	}
335		335
336	static outdev_t fb_console;	336	static outdev_t fb_console;
337	static outdev_operations_t fb_ops = {	337	static outdev_operations_t fb_ops = {
338	.write = fb_putchar	338	.write = fb_putchar
339	};	339	};
340		340
341		341
342	/** Render glyphs	342	/** Render glyphs
343	*	343	*
344	* Convert glyphs from device independent font	344	* Convert glyphs from device independent font
345	* description to current visual representation.	345	* description to current visual representation.
346	*	346	*
347	*/	347	*/
348	static void glyphs_render(void)	348	static void glyphs_render(void)
349	{	349	{
350	/* Prerender glyphs */	350	/* Prerender glyphs */
351	uint16_t glyph;	351	uint16_t glyph;
352		352
353	for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {	353	for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
354	uint32_t fg_color;	354	uint32_t fg_color;
355		355
356	if (glyph == FONT_GLYPHS - 1)	356	if (glyph == FONT_GLYPHS - 1)
357	fg_color = INV_COLOR;	357	fg_color = INV_COLOR;
358	else	358	else
359	fg_color = FG_COLOR;	359	fg_color = FG_COLOR;
360		360
361	unsigned int y;	361	unsigned int y;
362		362
363	for (y = 0; y < FONT_SCANLINES; y++) {	363	for (y = 0; y < FONT_SCANLINES; y++) {
364	unsigned int x;	364	unsigned int x;
365		365
366	for (x = 0; x < FONT_WIDTH; x++) {	366	for (x = 0; x < FONT_WIDTH; x++) {
367	void *dst = &glyphs[GLYPH_POS(glyph, y) +	367	void *dst = &glyphs[GLYPH_POS(glyph, y) +
368	x * pixelbytes];	368	x * pixelbytes];
369	uint32_t rgb = (fb_font[glyph][y] &	369	uint32_t rgb = (fb_font[glyph][y] &
370	(1 << (7 - x))) ? fg_color : BG_COLOR;	370	(1 << (7 - x))) ? fg_color : BG_COLOR;
371	rgb_conv(dst, rgb);	371	rgb_conv(dst, rgb);
372	}	372	}
373	}	373	}
374	}	374	}
375		375
376	/* Prerender background scanline */	376	/* Prerender background scanline */
377	unsigned int x;	377	unsigned int x;
378		378
379	for (x = 0; x < xres; x++)	379	for (x = 0; x < xres; x++)
380	rgb_conv(&bgscan[x * pixelbytes], BG_COLOR);	380	rgb_conv(&bgscan[x * pixelbytes], BG_COLOR);
381	}	381	}
382		382
383		383
384	/** Refresh the screen	384	/** Refresh the screen
385	*	385	*
386	*/	386	*/
387	void fb_redraw(void)	387	void fb_redraw(void)
388	{	388	{
389	if (ylogo > 0) {	389	if (ylogo > 0) {
390	unsigned int y;	390	unsigned int y;
391		391
392	for (y = 0; y < LOGO_HEIGHT; y++) {	392	for (y = 0; y < LOGO_HEIGHT; y++) {
393	unsigned int x;	393	unsigned int x;
394		394
395	for (x = 0; x < xres; x++)	395	for (x = 0; x < xres; x++)
396	rgb_conv(&fb_addr[FB_POS(x, y)],	396	rgb_conv(&fb_addr[FB_POS(x, y)],
397	(x < LOGO_WIDTH) ?	397	(x < LOGO_WIDTH) ?
398	fb_logo[y * LOGO_WIDTH + x] :	398	fb_logo[y * LOGO_WIDTH + x] :
399	LOGO_COLOR);	399	LOGO_COLOR);
400	}	400	}
401	}	401	}
402		402
403	unsigned int row;	403	unsigned int row;
404		404
405	for (row = 0; row < rowtrim; row++) {	405	for (row = 0; row < rowtrim; row++) {
406	unsigned int y = ylogo + ROW2Y(row);	406	unsigned int y = ylogo + ROW2Y(row);
407	unsigned int yd;	407	unsigned int yd;
408		408
409	for (yd = 0; yd < FONT_SCANLINES; yd++) {	409	for (yd = 0; yd < FONT_SCANLINES; yd++) {
410	unsigned int x;	410	unsigned int x;
411	unsigned int col;	411	unsigned int col;
412		412
413	for (col = 0, x = 0; col < cols;	413	for (col = 0, x = 0; col < cols;
414	col++, x += FONT_WIDTH) {	414	col++, x += FONT_WIDTH) {
415	uint16_t glyph = backbuf[BB_POS(col, row)];	415	uint16_t glyph = backbuf[BB_POS(col, row)];
416	void *dst = &fb_addr[FB_POS(x, y + yd)];	416	void *dst = &fb_addr[FB_POS(x, y + yd)];
417	void *src = &glyphs[GLYPH_POS(glyph, yd)];	417	void *src = &glyphs[GLYPH_POS(glyph, yd)];
418	memcpy(dst, src, glyphscanline);	418	memcpy(dst, src, glyphscanline);
419	}	419	}
420	}	420	}
421	}	421	}
422		422
423	if (COL2X(cols) < xres) {	423	if (COL2X(cols) < xres) {
424	unsigned int y;	424	unsigned int y;
425	unsigned int size = (xres - COL2X(cols)) * pixelbytes;	425	unsigned int size = (xres - COL2X(cols)) * pixelbytes;
426		426
427	for (y = ylogo; y < yres; y++)	427	for (y = ylogo; y < yres; y++)
428	memcpy(&fb_addr[FB_POS(COL2X(cols), y)], bgscan, size);	428	memcpy(&fb_addr[FB_POS(COL2X(cols), y)], bgscan, size);
429	}	429	}
430		430
431	if (ROW2Y(rowtrim) + ylogo < yres) {	431	if (ROW2Y(rowtrim) + ylogo < yres) {
432	unsigned int y;	432	unsigned int y;
433		433
434	for (y = ROW2Y(rowtrim) + ylogo; y < yres; y++)	434	for (y = ROW2Y(rowtrim) + ylogo; y < yres; y++)
435	memcpy(&fb_addr[FB_POS(0, y)], bgscan, bgscanbytes);	435	memcpy(&fb_addr[FB_POS(0, y)], bgscan, bgscanbytes);
436	}	436	}
437	}	437	}
438		438
439		439
440	/** Initialize framebuffer as a output character device	440	/** Initialize framebuffer as a output character device
441	*	441	*
442	* @param addr Physical address of the framebuffer	442	* @param addr Physical address of the framebuffer
443	* @param x Screen width in pixels	443	* @param x Screen width in pixels
444	* @param y Screen height in pixels	444	* @param y Screen height in pixels
445	* @param scan Bytes per one scanline	445	* @param scan Bytes per one scanline
446	* @param visual Color model	446	* @param visual Color model
447	*	447	*
448	*/	448	*/
449	void fb_init(fb_properties_t *props)	449	void fb_init(fb_properties_t *props)
450	{	450	{
451	switch (props->visual) {	451	switch (props->visual) {
452	case VISUAL_INDIRECT_8:	452	case VISUAL_INDIRECT_8:
453	rgb_conv = rgb_323;	453	rgb_conv = rgb_323;
454	pixelbytes = 1;	454	pixelbytes = 1;
455	break;	455	break;
456	case VISUAL_RGB_5_5_5:	456	case VISUAL_RGB_5_5_5:
457	rgb_conv = rgb_555;	457	rgb_conv = rgb_555;
458	pixelbytes = 2;	458	pixelbytes = 2;
459	break;	459	break;
460	case VISUAL_RGB_5_6_5:	460	case VISUAL_RGB_5_6_5:
461	rgb_conv = rgb_565;	461	rgb_conv = rgb_565;
462	pixelbytes = 2;	462	pixelbytes = 2;
463	break;	463	break;
464	case VISUAL_RGB_8_8_8:	464	case VISUAL_RGB_8_8_8:
465	rgb_conv = rgb_888;	465	rgb_conv = rgb_888;
466	pixelbytes = 3;	466	pixelbytes = 3;
467	break;	467	break;
468	case VISUAL_BGR_8_8_8:	468	case VISUAL_BGR_8_8_8:
469	rgb_conv = bgr_888;	469	rgb_conv = bgr_888;
470	pixelbytes = 3;	470	pixelbytes = 3;
471	break;	471	break;
472	case VISUAL_RGB_8_8_8_0:	472	case VISUAL_RGB_8_8_8_0:
473	rgb_conv = rgb_888;	473	rgb_conv = rgb_888;
474	pixelbytes = 4;	474	pixelbytes = 4;
475	break;	475	break;
476	case VISUAL_RGB_0_8_8_8:	476	case VISUAL_RGB_0_8_8_8:
477	rgb_conv = rgb_0888;	477	rgb_conv = rgb_0888;
478	pixelbytes = 4;	478	pixelbytes = 4;
479	break;	479	break;
480	case VISUAL_BGR_0_8_8_8:	480	case VISUAL_BGR_0_8_8_8:
481	rgb_conv = bgr_0888;	481	rgb_conv = bgr_0888;
482	pixelbytes = 4;	482	pixelbytes = 4;
483	break;	483	break;
484	default:	484	default:
485	panic("Unsupported visual.");	485	panic("Unsupported visual.");
486	}	486	}
487		487
488	xres = props->x;	488	xres = props->x;
489	yres = props->y;	489	yres = props->y;
490	scanline = props->scan;	490	scanline = props->scan;
491		491
492	cols = X2COL(xres);	492	cols = X2COL(xres);
493	rows = Y2ROW(yres);	493	rows = Y2ROW(yres);
494		494
495	if (yres > ylogo) {	495	if (yres > ylogo) {
496	ylogo = LOGO_HEIGHT;	496	ylogo = LOGO_HEIGHT;
497	rowtrim = rows - Y2ROW(ylogo);	497	rowtrim = rows - Y2ROW(ylogo);
498	if (ylogo % FONT_SCANLINES > 0)	498	if (ylogo % FONT_SCANLINES > 0)
499	rowtrim--;	499	rowtrim--;
500	ytrim = ROW2Y(rowtrim);	500	ytrim = ROW2Y(rowtrim);

Subversion Repositories HelenOS

(root)/branches/snapshot/kernel/genarch/src/fb/fb.c – Rev 4223 → 4605