WebSVN – HelenOS-historic – Diff – /kernel/trunk/genarch/src/fb/fb.c


/*
 * 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.
 */
 
#include <genarch/fb/font-8x16.h>
#include <genarch/fb/fb.h>
#include <console/chardev.h>
#include <console/console.h>
#include <panic.h>
#include <memstr.h>
 
#include "helenos.xbm"
 
SPINLOCK_INITIALIZE(fb_lock);
 
static __u8 *fbaddress = NULL;
 
static unsigned int xres = 0;
static unsigned int yres = 0;
static unsigned int scanline = 0;
static unsigned int pixelbytes = 0;
 
static unsigned int position = 0;
static unsigned int columns = 0;
static unsigned int rows = 0;
 
 
#define COL_WIDTH   8
#define ROW_BYTES   (scanline * FONT_SCANLINES)
 
#define BGCOLOR     0x000080
#define FGCOLOR     0xffff00
#define LOGOCOLOR   0x2020b0
 
#define RED(x, bits)    ((x >> (16 + 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 POINTPOS(x, y)  (y * scanline + x * pixelbytes)
 
/***************************************************************/
/* Pixel specific fuctions */
 
static void (*putpixel)(unsigned int x, unsigned int y, int color);
static int (*getpixel)(unsigned int x, unsigned int y);
 
/** Put pixel - 24-bit depth, 1 free byte */
static void putpixel_4byte(unsigned int x, unsigned int y, int color)
{
    *((__u32 *)(fbaddress + POINTPOS(x, y))) = color;
}
 
/** Return pixel color - 24-bit depth, 1 free byte */
static int getpixel_4byte(unsigned int x, unsigned int y)
{
    return *((__u32 *)(fbaddress + POINTPOS(x, y))) & 0xffffff;
}
 
/** Put pixel - 24-bit depth */
static void putpixel_3byte(unsigned int x, unsigned int y, int color)
{
    unsigned int startbyte = POINTPOS(x, y);
 
    fbaddress[startbyte] = RED(color, 8);
    fbaddress[startbyte + 1] = GREEN(color, 8);
    fbaddress[startbyte + 2] = BLUE(color, 8);
}
 
/** Return pixel color - 24-bit depth */
static int getpixel_3byte(unsigned int x, unsigned int y)
{
    unsigned int startbyte = POINTPOS(x, y);
 
    return fbaddress[startbyte] << 16 | fbaddress[startbyte + 1] << 8 | fbaddress[startbyte + 2];
}
 
/** Put pixel - 16-bit depth (5:6:6) */
static void putpixel_2byte(unsigned int x, unsigned int y, int color)
{
    /* 5-bit, 5-bits, 5-bits */
    *((__u16 *)(fbaddress + POINTPOS(x, y))) = RED(color, 5) << 11 | GREEN(color, 6) << 5 | BLUE(color, 5);
}
 
/** Return pixel color - 16-bit depth (5:6:6) */
static int getpixel_2byte(unsigned int x, unsigned int y)
{
    int color = *((__u16 *)(fbaddress + POINTPOS(x, y)));
    return (((color >> 11) & 0x1f) << (16 + 3)) | (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
}
 
/** Put pixel - 8-bit depth (3:2:3) */
static void putpixel_1byte(unsigned int x, unsigned int y, int color)
{
    fbaddress[POINTPOS(x, y)] = RED(color, 3) << 5 | GREEN(color, 2) << 3 | BLUE(color, 3);
}
 
/** Return pixel color - 8-bit depth (3:2:3) */
static int getpixel_1byte(unsigned int x, unsigned int y)
{
    int color = fbaddress[POINTPOS(x, y)];
    return (((color >> 5) & 0x7) << (16 + 5)) | (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
}
 
/** Fill line with color BGCOLOR */
static void clear_line(unsigned int y)
{
    unsigned int x;
   
    for (x = 0; x < xres; x++)
        (*putpixel)(x, y, BGCOLOR);
}
 
 
/** Fill screen with background color */
static void clear_screen(void)
{
    unsigned int y;
 
    for (y = 0; y < yres; y++)
        clear_line(y);
}
 
 
/** Scroll screen one row up */
static void scroll_screen(void)
{
    unsigned int i;
 
    memcpy((void *) fbaddress, (void *) &fbaddress[ROW_BYTES], scanline * yres - ROW_BYTES);
 
    /* Clear last row */
    for (i = 0; i < FONT_SCANLINES; i++)
        clear_line((rows - 1) * FONT_SCANLINES + i);
}
 
 
static void invert_pixel(unsigned int x, unsigned int y)
{
    (*putpixel)(x, y, ~(*getpixel)(x, y));
}
 
 
/** Draw one line of glyph at a given position */
static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)
{
    unsigned int i;
 
    for (i = 0; i < 8; i++)
        if (glline & (1 << (7 - i))) {
            (*putpixel)(x + i, y, FGCOLOR);
        } else
            (*putpixel)(x + i, y, BGCOLOR);
}
 
/***************************************************************/
/* Character-console functions */
 
/** Draw character at given position */
static void draw_glyph(__u8 glyph, unsigned int col, unsigned int row)
{
    unsigned int y;
 
    for (y = 0; y < FONT_SCANLINES; y++)
        draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y], col * COL_WIDTH, row * FONT_SCANLINES + y);
}
 
/** Invert character at given position */
static void invert_char(unsigned int col, unsigned int row)
{
    unsigned int x;
    unsigned int y;
 
    for (x = 0; x < COL_WIDTH; x++)
        for (y = 0; y < FONT_SCANLINES; y++)
            invert_pixel(col * COL_WIDTH + x, row * FONT_SCANLINES + y);
}
 
/** Draw character at default position */
static void draw_char(char chr)
{
    draw_glyph(chr, position % columns, position / columns);
}
 
static void draw_logo(unsigned int startx, unsigned int starty)
{
    unsigned int x;
    unsigned int y;
    unsigned int byte;
    unsigned int rowbytes;
 
    rowbytes = (helenos_width - 1) / 8 + 1;
 
    for (y = 0; y < helenos_height; y++)
        for (x = 0; x < helenos_width; x++) {
            byte = helenos_bits[rowbytes * y + x / 8];
            byte >>= x % 8;
            if (byte & 1)
                (*putpixel)(startx + x, starty + y, LOGOCOLOR);
        }
}
 
/***************************************************************/
/* Stdout specific functions */
 
static void invert_cursor(void)
{
    invert_char(position % columns, position / columns);
}
 
/** 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':
            invert_cursor();
            position += columns;
            position -= position % columns;
            break;
        case '\r':
            invert_cursor();
            position -= position % columns;
            break;
        case '\b':
            invert_cursor();
            if (position % columns)
                position--;
            break;
        case '\t':
            invert_cursor();
            do {
                draw_char(' ');
                position++;
            } while (position % 8);
            break;
        default:
            draw_char(ch);
            position++;
    }
   
    if (position >= columns * rows) {
        position -= columns;
        scroll_screen();
    }
   
    invert_cursor();
   
    spinlock_unlock(&fb_lock);
}
 
static chardev_t framebuffer;
static chardev_operations_t fb_ops = {
    .write = fb_putchar,
};
 
 
/** Initialize framebuffer as a chardev output device
 *
 * @param addr Address of theframebuffer
 * @param x    Screen width in pixels
 * @param y    Screen height in pixels
 * @param bpp  Bits per pixel (8, 16, 24, 32)
 * @param scan Bytes per one scanline
 *
 */
void fb_init(__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan)
{
    switch (bpp) {
        case 8:
            putpixel = putpixel_1byte;
            getpixel = getpixel_1byte;
            pixelbytes = 1;
            break;
        case 16:
            putpixel = putpixel_2byte;
            getpixel = getpixel_2byte;
            pixelbytes = 2;
            break;
        case 24:
            putpixel = putpixel_3byte;
            getpixel = getpixel_3byte;
            pixelbytes = 3;
            break;
        case 32:
            putpixel = putpixel_4byte;
            getpixel = getpixel_4byte;
            pixelbytes = 4;
            break;
        default:
            panic("Unsupported bpp");
    }
       
    fbaddress = (unsigned char *) addr;
    xres = x;
    yres = y;
    scanline = scan;
   
    rows = y / FONT_SCANLINES;
    columns = x / COL_WIDTH;
 
    clear_screen();
    draw_logo(xres - helenos_width, 0);
    invert_cursor();
 
    chardev_initialize("fb", &framebuffer, &fb_ops);
    stdout = &framebuffer;
}
 

Rev 1135	Rev 1287
1	/*	1	/*
2	* Copyright (C) 2006 Ondrej Palkovsky	2	* Copyright (C) 2006 Ondrej Palkovsky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	#include <genarch/fb/font-8x16.h>	29	#include <genarch/fb/font-8x16.h>
30	#include <genarch/fb/fb.h>	30	#include <genarch/fb/fb.h>
31	#include <console/chardev.h>	31	#include <console/chardev.h>
32	#include <console/console.h>	32	#include <console/console.h>
33	#include <panic.h>	33	#include <panic.h>
34	#include <memstr.h>	34	#include <memstr.h>
35		35
36	#include "helenos.xbm"	36	#include "helenos.xbm"
37		37
38	SPINLOCK_INITIALIZE(fb_lock);	38	SPINLOCK_INITIALIZE(fb_lock);
39		39
40	static __u8 *fbaddress = NULL;	40	static __u8 *fbaddress = NULL;
41		41
42	static unsigned int xres = 0;	42	static unsigned int xres = 0;
43	static unsigned int yres = 0;	43	static unsigned int yres = 0;
44	static unsigned int scanline = 0;	44	static unsigned int scanline = 0;
45	static unsigned int pixelbytes = 0;	45	static unsigned int pixelbytes = 0;
46		46
47	static unsigned int position = 0;	47	static unsigned int position = 0;
48	static unsigned int columns = 0;	48	static unsigned int columns = 0;
49	static unsigned int rows = 0;	49	static unsigned int rows = 0;
50		50
51		51
52	#define COL_WIDTH 8	52	#define COL_WIDTH 8
53	#define ROW_BYTES (scanline * FONT_SCANLINES)	53	#define ROW_BYTES (scanline * FONT_SCANLINES)
54		54
55	#define BGCOLOR 0x000080	55	#define BGCOLOR 0x000080
56	#define FGCOLOR 0xffff00	56	#define FGCOLOR 0xffff00
57	#define LOGOCOLOR 0x2020b0	57	#define LOGOCOLOR 0x2020b0
58		58
59	#define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))	59	#define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))
60	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))	60	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
61	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))	61	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))
62		62
63	#define POINTPOS(x, y) (y * scanline + x * pixelbytes)	63	#define POINTPOS(x, y) (y * scanline + x * pixelbytes)
64		64
65	/***************************************************************/	65	/***************************************************************/
66	/* Pixel specific fuctions */	66	/* Pixel specific fuctions */
67		67
68	static void (*putpixel)(unsigned int x, unsigned int y, int color);	68	static void (*putpixel)(unsigned int x, unsigned int y, int color);
69	static int (*getpixel)(unsigned int x, unsigned int y);	69	static int (*getpixel)(unsigned int x, unsigned int y);
70		70
71	/** Put pixel - 24-bit depth, 1 free byte */	71	/** Put pixel - 24-bit depth, 1 free byte */
72	static void putpixel_4byte(unsigned int x, unsigned int y, int color)	72	static void putpixel_4byte(unsigned int x, unsigned int y, int color)
73	{	73	{
74	((__u32 )(fbaddress + POINTPOS(x, y))) = color;	74	((__u32 )(fbaddress + POINTPOS(x, y))) = color;
75	}	75	}
76		76
77	/** Return pixel color - 24-bit depth, 1 free byte */	77	/** Return pixel color - 24-bit depth, 1 free byte */
78	static int getpixel_4byte(unsigned int x, unsigned int y)	78	static int getpixel_4byte(unsigned int x, unsigned int y)
79	{	79	{
80	return ((__u32 )(fbaddress + POINTPOS(x, y))) & 0xffffff;	80	return ((__u32 )(fbaddress + POINTPOS(x, y))) & 0xffffff;
81	}	81	}
82		82
83	/** Put pixel - 24-bit depth */	83	/** Put pixel - 24-bit depth */
84	static void putpixel_3byte(unsigned int x, unsigned int y, int color)	84	static void putpixel_3byte(unsigned int x, unsigned int y, int color)
85	{	85	{
86	unsigned int startbyte = POINTPOS(x, y);	86	unsigned int startbyte = POINTPOS(x, y);
87		87
88	fbaddress[startbyte] = RED(color, 8);	88	fbaddress[startbyte] = RED(color, 8);
89	fbaddress[startbyte + 1] = GREEN(color, 8);	89	fbaddress[startbyte + 1] = GREEN(color, 8);
90	fbaddress[startbyte + 2] = BLUE(color, 8);	90	fbaddress[startbyte + 2] = BLUE(color, 8);
91	}	91	}
92		92
93	/** Return pixel color - 24-bit depth */	93	/** Return pixel color - 24-bit depth */
94	static int getpixel_3byte(unsigned int x, unsigned int y)	94	static int getpixel_3byte(unsigned int x, unsigned int y)
95	{	95	{
96	unsigned int startbyte = POINTPOS(x, y);	96	unsigned int startbyte = POINTPOS(x, y);
97		97
98	return fbaddress[startbyte] << 16 \| fbaddress[startbyte + 1] << 8 \| fbaddress[startbyte + 2];	98	return fbaddress[startbyte] << 16 \| fbaddress[startbyte + 1] << 8 \| fbaddress[startbyte + 2];
99	}	99	}
100		100
101	/** Put pixel - 16-bit depth (5:6:6) */	101	/** Put pixel - 16-bit depth (5:6:6) */
102	static void putpixel_2byte(unsigned int x, unsigned int y, int color)	102	static void putpixel_2byte(unsigned int x, unsigned int y, int color)
103	{	103	{
104	/* 5-bit, 5-bits, 5-bits */	104	/* 5-bit, 5-bits, 5-bits */
105	((__u16 )(fbaddress + POINTPOS(x, y))) = RED(color, 5) << 11 \| GREEN(color, 6) << 5 \| BLUE(color, 5);	105	((__u16 )(fbaddress + POINTPOS(x, y))) = RED(color, 5) << 11 \| GREEN(color, 6) << 5 \| BLUE(color, 5);
106	}	106	}
107		107
108	/** Return pixel color - 16-bit depth (5:6:6) */	108	/** Return pixel color - 16-bit depth (5:6:6) */
109	static int getpixel_2byte(unsigned int x, unsigned int y)	109	static int getpixel_2byte(unsigned int x, unsigned int y)
110	{	110	{
111	int color = ((__u16 )(fbaddress + POINTPOS(x, y)));	111	int color = ((__u16 )(fbaddress + POINTPOS(x, y)));
112	return (((color >> 11) & 0x1f) << (16 + 3)) \| (((color >> 5) & 0x3f) << (8 + 2)) \| ((color & 0x1f) << 3);	112	return (((color >> 11) & 0x1f) << (16 + 3)) \| (((color >> 5) & 0x3f) << (8 + 2)) \| ((color & 0x1f) << 3);
113	}	113	}
114		114
115	/** Put pixel - 8-bit depth (3:2:3) */	115	/** Put pixel - 8-bit depth (3:2:3) */
116	static void putpixel_1byte(unsigned int x, unsigned int y, int color)	116	static void putpixel_1byte(unsigned int x, unsigned int y, int color)
117	{	117	{
118	fbaddress[POINTPOS(x, y)] = RED(color, 3) << 5 \| GREEN(color, 2) << 3 \| BLUE(color, 3);	118	fbaddress[POINTPOS(x, y)] = RED(color, 3) << 5 \| GREEN(color, 2) << 3 \| BLUE(color, 3);
119	}	119	}
120		120
121	/** Return pixel color - 8-bit depth (3:2:3) */	121	/** Return pixel color - 8-bit depth (3:2:3) */
122	static int getpixel_1byte(unsigned int x, unsigned int y)	122	static int getpixel_1byte(unsigned int x, unsigned int y)
123	{	123	{
124	int color = fbaddress[POINTPOS(x, y)];	124	int color = fbaddress[POINTPOS(x, y)];
125	return (((color >> 5) & 0x7) << (16 + 5)) \| (((color >> 3) & 0x3) << (8 + 6)) \| ((color & 0x7) << 5);	125	return (((color >> 5) & 0x7) << (16 + 5)) \| (((color >> 3) & 0x3) << (8 + 6)) \| ((color & 0x7) << 5);
126	}	126	}
127		127
128	/** Fill line with color BGCOLOR */	128	/** Fill line with color BGCOLOR */
129	static void clear_line(unsigned int y)	129	static void clear_line(unsigned int y)
130	{	130	{
131	unsigned int x;	131	unsigned int x;
132		132
133	for (x = 0; x < xres; x++)	133	for (x = 0; x < xres; x++)
134	(*putpixel)(x, y, BGCOLOR);	134	(*putpixel)(x, y, BGCOLOR);
135	}	135	}
136		136
137		137
138	/** Fill screen with background color */	138	/** Fill screen with background color */
139	static void clear_screen(void)	139	static void clear_screen(void)
140	{	140	{
141	unsigned int y;	141	unsigned int y;
142		142
143	for (y = 0; y < yres; y++)	143	for (y = 0; y < yres; y++)
144	clear_line(y);	144	clear_line(y);
145	}	145	}
146		146
147		147
148	/** Scroll screen one row up */	148	/** Scroll screen one row up */
149	static void scroll_screen(void)	149	static void scroll_screen(void)
150	{	150	{
151	unsigned int i;	151	unsigned int i;
152		152
153	memcpy((void ) fbaddress, (void ) &fbaddress[ROW_BYTES], scanline * yres - ROW_BYTES);	153	memcpy((void ) fbaddress, (void ) &fbaddress[ROW_BYTES], scanline * yres - ROW_BYTES);
154		154
155	/* Clear last row */	155	/* Clear last row */
156	for (i = 0; i < FONT_SCANLINES; i++)	156	for (i = 0; i < FONT_SCANLINES; i++)
157	clear_line((rows - 1) * FONT_SCANLINES + i);	157	clear_line((rows - 1) * FONT_SCANLINES + i);
158	}	158	}
159		159
160		160
161	static void invert_pixel(unsigned int x, unsigned int y)	161	static void invert_pixel(unsigned int x, unsigned int y)
162	{	162	{
163	(putpixel)(x, y, ~(getpixel)(x, y));	163	(putpixel)(x, y, ~(getpixel)(x, y));
164	}	164	}
165		165
166		166
167	/** Draw one line of glyph at a given position */	167	/** Draw one line of glyph at a given position */
168	static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)	168	static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)
169	{	169	{
170	unsigned int i;	170	unsigned int i;
171		171
172	for (i = 0; i < 8; i++)	172	for (i = 0; i < 8; i++)
173	if (glline & (1 << (7 - i))) {	173	if (glline & (1 << (7 - i))) {
174	(*putpixel)(x + i, y, FGCOLOR);	174	(*putpixel)(x + i, y, FGCOLOR);
175	} else	175	} else
176	(*putpixel)(x + i, y, BGCOLOR);	176	(*putpixel)(x + i, y, BGCOLOR);
177	}	177	}
178		178
179	/***************************************************************/	179	/***************************************************************/
180	/* Character-console functions */	180	/* Character-console functions */
181		181
182	/** Draw character at given position */	182	/** Draw character at given position */
183	static void draw_glyph(__u8 glyph, unsigned int col, unsigned int row)	183	static void draw_glyph(__u8 glyph, unsigned int col, unsigned int row)
184	{	184	{
185	unsigned int y;	185	unsigned int y;
186		186
187	for (y = 0; y < FONT_SCANLINES; y++)	187	for (y = 0; y < FONT_SCANLINES; y++)
188	draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y], col * COL_WIDTH, row * FONT_SCANLINES + y);	188	draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y], col * COL_WIDTH, row * FONT_SCANLINES + y);
189	}	189	}
190		190
191	/** Invert character at given position */	191	/** Invert character at given position */
192	static void invert_char(unsigned int col, unsigned int row)	192	static void invert_char(unsigned int col, unsigned int row)
193	{	193	{
194	unsigned int x;	194	unsigned int x;
195	unsigned int y;	195	unsigned int y;
196		196
197	for (x = 0; x < COL_WIDTH; x++)	197	for (x = 0; x < COL_WIDTH; x++)
198	for (y = 0; y < FONT_SCANLINES; y++)	198	for (y = 0; y < FONT_SCANLINES; y++)
199	invert_pixel(col * COL_WIDTH + x, row * FONT_SCANLINES + y);	199	invert_pixel(col * COL_WIDTH + x, row * FONT_SCANLINES + y);
200	}	200	}
201		201
202	/** Draw character at default position */	202	/** Draw character at default position */
203	static void draw_char(char chr)	203	static void draw_char(char chr)
204	{	204	{
205	draw_glyph(chr, position % columns, position / columns);	205	draw_glyph(chr, position % columns, position / columns);
206	}	206	}
207		207
208	static void draw_logo(unsigned int startx, unsigned int starty)	208	static void draw_logo(unsigned int startx, unsigned int starty)
209	{	209	{
210	unsigned int x;	210	unsigned int x;
211	unsigned int y;	211	unsigned int y;
212	unsigned int byte;	212	unsigned int byte;
213	unsigned int rowbytes;	213	unsigned int rowbytes;
214		214
215	rowbytes = (helenos_width - 1) / 8 + 1;	215	rowbytes = (helenos_width - 1) / 8 + 1;
216		216
217	for (y = 0; y < helenos_height; y++)	217	for (y = 0; y < helenos_height; y++)
218	for (x = 0; x < helenos_width; x++) {	218	for (x = 0; x < helenos_width; x++) {
219	byte = helenos_bits[rowbytes * y + x / 8];	219	byte = helenos_bits[rowbytes * y + x / 8];
220	byte >>= x % 8;	220	byte >>= x % 8;
221	if (byte & 1)	221	if (byte & 1)
222	(*putpixel)(startx + x, starty + y, LOGOCOLOR);	222	(*putpixel)(startx + x, starty + y, LOGOCOLOR);
223	}	223	}
224	}	224	}
225		225
226	/***************************************************************/	226	/***************************************************************/
227	/* Stdout specific functions */	227	/* Stdout specific functions */
228		228
229	static void invert_cursor(void)	229	static void invert_cursor(void)
230	{	230	{
231	invert_char(position % columns, position / columns);	231	invert_char(position % columns, position / columns);
232	}	232	}
233		233
234	/** Print character to screen	234	/** Print character to screen
235	*	235	*
236	* Emulate basic terminal commands	236	* Emulate basic terminal commands
237	*/	237	*/
238	static void fb_putchar(chardev_t *dev, char ch)	238	static void fb_putchar(chardev_t *dev, char ch)
239	{	239	{
240	spinlock_lock(&fb->lock);	240	spinlock_lock(&fb_lock);
241		241
242	switch (ch) {	242	switch (ch) {
243	case '\n':	243	case '\n':
244	invert_cursor();	244	invert_cursor();
245	position += columns;	245	position += columns;
246	position -= position % columns;	246	position -= position % columns;
247	break;	247	break;
248	case '\r':	248	case '\r':
249	invert_cursor();	249	invert_cursor();
250	position -= position % columns;	250	position -= position % columns;
251	break;	251	break;
252	case '\b':	252	case '\b':
253	invert_cursor();	253	invert_cursor();
254	if (position % columns)	254	if (position % columns)
255	position--;	255	position--;
256	break;	256	break;
257	case '\t':	257	case '\t':
258	invert_cursor();	258	invert_cursor();
259	do {	259	do {
260	draw_char(' ');	260	draw_char(' ');
261	position++;	261	position++;
262	} while (position % 8);	262	} while (position % 8);
263	break;	263	break;
264	default:	264	default:
265	draw_char(ch);	265	draw_char(ch);
266	position++;	266	position++;
267	}	267	}
268		268
269	if (position >= columns * rows) {	269	if (position >= columns * rows) {
270	position -= columns;	270	position -= columns;
271	scroll_screen();	271	scroll_screen();
272	}	272	}
273		273
274	invert_cursor();	274	invert_cursor();
275		275
276	spinlock_unlock(&fb->lock);	276	spinlock_unlock(&fb_lock);
277	}	277	}
278		278
279	static chardev_t framebuffer;	279	static chardev_t framebuffer;
280	static chardev_operations_t fb_ops = {	280	static chardev_operations_t fb_ops = {
281	.write = fb_putchar,	281	.write = fb_putchar,
282	};	282	};
283		283
284		284
285	/** Initialize framebuffer as a chardev output device	285	/** Initialize framebuffer as a chardev output device
286	*	286	*
287	* @param addr Address of theframebuffer	287	* @param addr Address of theframebuffer
288	* @param x Screen width in pixels	288	* @param x Screen width in pixels
289	* @param y Screen height in pixels	289	* @param y Screen height in pixels
290	* @param bpp Bits per pixel (8, 16, 24, 32)	290	* @param bpp Bits per pixel (8, 16, 24, 32)
291	* @param scan Bytes per one scanline	291	* @param scan Bytes per one scanline
292	*	292	*
293	*/	293	*/
294	void fb_init(__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan)	294	void fb_init(__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan)
295	{	295	{
296	switch (bpp) {	296	switch (bpp) {
297	case 8:	297	case 8:
298	putpixel = putpixel_1byte;	298	putpixel = putpixel_1byte;
299	getpixel = getpixel_1byte;	299	getpixel = getpixel_1byte;
300	pixelbytes = 1;	300	pixelbytes = 1;
301	break;	301	break;
302	case 16:	302	case 16:
303	putpixel = putpixel_2byte;	303	putpixel = putpixel_2byte;
304	getpixel = getpixel_2byte;	304	getpixel = getpixel_2byte;
305	pixelbytes = 2;	305	pixelbytes = 2;
306	break;	306	break;
307	case 24:	307	case 24:
308	putpixel = putpixel_3byte;	308	putpixel = putpixel_3byte;
309	getpixel = getpixel_3byte;	309	getpixel = getpixel_3byte;
310	pixelbytes = 3;	310	pixelbytes = 3;
311	break;	311	break;
312	case 32:	312	case 32:
313	putpixel = putpixel_4byte;	313	putpixel = putpixel_4byte;
314	getpixel = getpixel_4byte;	314	getpixel = getpixel_4byte;
315	pixelbytes = 4;	315	pixelbytes = 4;
316	break;	316	break;
317	default:	317	default:
318	panic("Unsupported bpp");	318	panic("Unsupported bpp");
319	}	319	}
320		320
321	fbaddress = (unsigned char *) addr;	321	fbaddress = (unsigned char *) addr;
322	xres = x;	322	xres = x;
323	yres = y;	323	yres = y;
324	scanline = scan;	324	scanline = scan;
325		325
326	rows = y / FONT_SCANLINES;	326	rows = y / FONT_SCANLINES;
327	columns = x / COL_WIDTH;	327	columns = x / COL_WIDTH;
328		328
329	clear_screen();	329	clear_screen();
330	draw_logo(xres - helenos_width, 0);	330	draw_logo(xres - helenos_width, 0);
331	invert_cursor();	331	invert_cursor();
332		332
333	chardev_initialize("fb", &framebuffer, &fb_ops);	333	chardev_initialize("fb", &framebuffer, &fb_ops);
334	stdout = &framebuffer;	334	stdout = &framebuffer;
335	}	335	}
336		336

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/genarch/src/fb/fb.c @ 1671 – Rev 1135 → 1287