WebSVN – HelenOS – Diff – /trunk/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 <ddi/ddi.h>
#include <arch/types.h>
 
SPINLOCK_INITIALIZE(fb_lock);
 
/**< Physical memory area for fb. */
static parea_t fb_parea;
 
static uint8_t *fb_addr;
static uint8_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 CURSOR       219
 
#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);
}
 
 
/** BGR 8:8:8 conversion
 *
 */
static void rgb_888(void *dst, uint32_t rgb)
{
#if defined(FB_INVERT_ENDIAN)
    ((uint8_t *) dst)[0] = RED(rgb, 8);
    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
    ((uint8_t *) dst)[2] = BLUE(rgb, 8);
#else
    ((uint8_t *) dst)[0] = BLUE(rgb, 8);
    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
    ((uint8_t *) dst)[2] = RED(rgb, 8);
#endif
}
 
 
/** 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(void)
{
    ylogo = 0;
    ytrim = yres;
    rowtrim = rows;
    fb_redraw();
}
 
 
/** Draw character at given position
 *
 */
static void glyph_draw(uint8_t glyph, unsigned int col, unsigned int row)
{
    unsigned int x = COL2X(col);
    unsigned int y = ROW2Y(row);
    unsigned int yd;
   
    if (y >= ytrim)
        logo_hide();
   
    backbuf[BB_POS(col, row)] = glyph;
   
    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(void)
{
    if (ylogo > 0)
        logo_hide();
   
    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) {
                uint8_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);
            }
        }
    }
   
    memcpy(backbuf, backbuf + cols, cols * (rows - 1));
    memsetb(&backbuf[BB_POS(0, rows - 1)], cols, 0);
}
 
 
static void cursor_put(void)
{
    glyph_draw(CURSOR, position % cols, position / cols);
}
 
 
static void cursor_remove(void)
{
    glyph_draw(0, position % cols, position / cols);
}
 
 
/** Print character to screen
 *
 * Emulate basic terminal commands.
 *
 */
static void fb_putchar(chardev_t *dev, char ch)
{
    spinlock_lock(&fb_lock);
   
    switch (ch) {
    case '\n':
        cursor_remove();
        position += cols;
        position -= position % cols;
        break;
    case '\r':
        cursor_remove();
        position -= position % cols;
        break;
    case '\b':
        cursor_remove();
        if (position % cols)
            position--;
        break;
    case '\t':
        cursor_remove();
        do {
            glyph_draw((uint8_t) ' ', position % cols, position / cols);
            position++;
        } while ((position % 8) && (position < cols * rows));
        break;
    default:
        glyph_draw((uint8_t) ch, position % cols, position / cols);
        position++;
    }
   
    if (position >= cols * rows) {
        position -= cols;
        screen_scroll();
    }
   
    cursor_put();
   
    spinlock_unlock(&fb_lock);
}
 
static chardev_t framebuffer;
static chardev_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 */
    unsigned int glyph;
   
    for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
        unsigned int y;
       
        for (y = 0; y < FONT_SCANLINES; y++) {
            unsigned int x;
           
            for (x = 0; x < FONT_WIDTH; x++)
                rgb_conv(&glyphs[GLYPH_POS(glyph, y) + x * pixelbytes],
                    (fb_font[ROW2Y(glyph) + y] & (1 << (7 - x))) ? FG_COLOR : BG_COLOR);
        }
    }
   
    /* 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)
                memcpy(&fb_addr[FB_POS(x, y + yd)],
                &glyphs[GLYPH_POS(backbuf[BB_POS(col, row)], yd)],
                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) < yres) {
        unsigned int y;
       
        for (y = ROW2Y(rowtrim); y < yres; y++)
 
 
 
            memcpy(&fb_addr[FB_POS(0, y)], bgscan, bgscanbytes);
 
    }
}
 
 
/** Initialize framebuffer as a chardev output 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_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.\n");
    }
   
    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;
   
    unsigned int fbsize = scanline * yres;
    unsigned int bbsize = cols * rows;
    unsigned int glyphsize = FONT_GLYPHS * glyphbytes;
   
    backbuf = (uint8_t *) malloc(bbsize, 0);
    if (!backbuf)
        panic("Unable to allocate backbuffer.\n");
   
    glyphs = (uint8_t *) malloc(glyphsize, 0);
    if (!glyphs)
        panic("Unable to allocate glyphs.\n");
   
    bgscan = malloc(bgscanbytes, 0);
    if (!bgscan)
        panic("Unable to allocate background pixel.\n");
   
    memsetb(backbuf, bbsize, 0);
 
 
   
    glyphs_render();
   
    fb_addr = (uint8_t *) hw_map((uintptr_t) props->addr, fbsize);
   
    fb_parea.pbase = (uintptr_t) props->addr + props->offset;
    fb_parea.vbase = (uintptr_t) fb_addr;
    fb_parea.frames = SIZE2FRAMES(fbsize);
    fb_parea.cacheable = false;
    ddi_parea_register(&fb_parea);
   
    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();
   
    chardev_initialize("fb", &framebuffer, &fb_ops);
    stdout = &framebuffer;
}
 
/** @}
 */
 

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

Subversion Repositories HelenOS

(root)/trunk/kernel/genarch/src/fb/fb.c @ 4685 – Rev 3709 → 3710