WebSVN – HelenOS – Diff – /trunk/uspace/srv/fb/ega.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.
 */
 
/** @defgroup egafb EGA framebuffer
 * @brief   HelenOS EGA framebuffer.
 * @ingroup fbs
 * @{
 */
/** @file
 */
 
#include <stdlib.h>
#include <unistd.h>
#include <align.h>
#include <async.h>
#include <ipc/ipc.h>
#include <errno.h>
#include <stdio.h>
#include <ddi.h>
#include <sysinfo.h>
#include <as.h>
#include <ipc/fb.h>
#include <ipc/ipc.h>
#include <ipc/ns.h>
#include <ipc/services.h>
#include <libarch/ddi.h>
#include <console/style.h>
#include <console/color.h>
 
#include "ega.h"
#include "../console/screenbuffer.h"
#include "main.h"
 
#define MAX_SAVED_SCREENS 256
typedef struct saved_screen {
    short *data;
} saved_screen;
 
saved_screen saved_screens[MAX_SAVED_SCREENS];
 
#define EGA_IO_ADDRESS 0x3d4
#define EGA_IO_SIZE 2
 
int ega_normal_color = 0x0f;
int ega_inverted_color = 0xf0;
 
#define NORMAL_COLOR        ega_normal_color       
#define INVERTED_COLOR      ega_inverted_color
 
 
 
/* Allow only 1 connection */
static int client_connected = 0;
 
static unsigned int scr_width;
static unsigned int scr_height;
static char *scr_addr;
 
static unsigned int style;
 
static unsigned attr_to_ega_style(const attrs_t *a);
 
static void clrscr(void)
{
    int i;
   
    for (i = 0; i < scr_width * scr_height; i++) {
        scr_addr[i * 2] = ' ';
        scr_addr[i * 2 + 1] = style;
    }
}
 
static void cursor_goto(unsigned int row, unsigned int col)
{
    int ega_cursor;
 
    ega_cursor = col + scr_width * row;
   
    outb(EGA_IO_ADDRESS, 0xe);
    outb(EGA_IO_ADDRESS + 1, (ega_cursor >> 8) & 0xff);
    outb(EGA_IO_ADDRESS, 0xf);
    outb(EGA_IO_ADDRESS + 1, ega_cursor & 0xff);
}
 
static void cursor_disable(void)
{
    uint8_t stat;
 
    outb(EGA_IO_ADDRESS, 0xa);
    stat=inb(EGA_IO_ADDRESS + 1);
    outb(EGA_IO_ADDRESS, 0xa);
    outb(EGA_IO_ADDRESS + 1, stat | (1 << 5));
}
 
static void cursor_enable(void)
{
    uint8_t stat;
 
    outb(EGA_IO_ADDRESS, 0xa);
    stat=inb(EGA_IO_ADDRESS + 1);
    outb(EGA_IO_ADDRESS, 0xa);
    outb(EGA_IO_ADDRESS + 1, stat & (~(1 << 5)));
}
 
static void scroll(int rows)
{
    int i;
    if (rows > 0) {
        memmove(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
            scr_width * scr_height * 2 - rows * scr_width * 2);
        for (i = 0; i < rows * scr_width; i++)
            (((short *) scr_addr) + scr_width * scr_height - rows *
                scr_width)[i] = ((style << 8) + ' ');
    } else if (rows < 0) {
        memmove(((char *)scr_addr) - rows * scr_width * 2, scr_addr,
            scr_width * scr_height * 2 + rows * scr_width * 2);
        for (i = 0; i < -rows * scr_width; i++)
            ((short *)scr_addr)[i] = ((style << 8 ) + ' ');
    }
}
 
static void printchar(char c, unsigned int row, unsigned int col)
{
    scr_addr[(row * scr_width + col) * 2] = c;
    scr_addr[(row * scr_width + col) * 2 + 1] = style;
   
    cursor_goto(row, col + 1);
}
 
static void draw_text_data(keyfield_t *data)
{
    int i;
 
    for (i = 0; i < scr_width * scr_height; i++) {
        scr_addr[i * 2] = data[i].character;
 
        scr_addr[i * 2 + 1] = attr_to_ega_style(&data[i].attrs);
 
 
    }
}
 
static int save_screen(void)
{
    int i;
 
    for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
        ;
    if (i == MAX_SAVED_SCREENS)
        return EINVAL;
    if (!(saved_screens[i].data = malloc(2 * scr_width * scr_height)))
        return ENOMEM;
    memcpy(saved_screens[i].data, scr_addr, 2 * scr_width * scr_height);
 
    return i;
}
 
static int print_screen(int i)
{
    if (saved_screens[i].data)
        memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *
            scr_height);
    else
        return EINVAL;
    return i;
}
 
static int style_to_ega_style(int style)
{
    unsigned int ega_style;
 
    switch (style) {
    case STYLE_NORMAL:
        ega_style = INVERTED_COLOR;
        break;
    case STYLE_EMPHASIS:
        ega_style = INVERTED_COLOR | 4;
        break;
    default:
        return INVERTED_COLOR;
    }
 
    return ega_style;
}
 
static unsigned int color_to_ega_style(int fg_color, int bg_color, int attr)
{
    unsigned int style;
 
    style = (fg_color & 7) | ((bg_color & 7) << 4);
    if (attr & CATTR_BRIGHT)
        style = style | 0x08;
 
    return style;
}
 
static unsigned int rgb_to_ega_style(uint32_t fg, uint32_t bg)
{
    return (fg > bg) ? NORMAL_COLOR : INVERTED_COLOR;
}
 
static unsigned attr_to_ega_style(const attrs_t *a)
{
    switch (a->t) {
    case at_style: return style_to_ega_style(a->a.s.style);
    case at_rgb: return rgb_to_ega_style(a->a.r.fg_color, a->a.r.bg_color);
    case at_idx: return color_to_ega_style(a->a.i.fg_color,
        a->a.i.bg_color, a->a.i.flags);
    default: return INVERTED_COLOR;
    }
}
 
static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    int retval;
    ipc_callid_t callid;
    ipc_call_t call;
    char c;
    unsigned int row, col;
    int bg_color, fg_color, attr;
    uint32_t bg_rgb, fg_rgb;
    keyfield_t *interbuf = NULL;
    size_t intersize = 0;
    int i;
 
    if (client_connected) {
        ipc_answer_0(iid, ELIMIT);
        return;
    }
    client_connected = 1;
    ipc_answer_0(iid, EOK); /* Accept connection */
 
    while (1) {
        callid = async_get_call(&call);
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            client_connected = 0;
            ipc_answer_0(callid, EOK);
            return; /* Exit thread */
        case IPC_M_SHARE_OUT:
            /* We accept one area for data interchange */
            intersize = IPC_GET_ARG2(call);
            if (intersize >= scr_width * scr_height *
                sizeof(*interbuf)) {
                receive_comm_area(callid, &call,
                    (void *) &interbuf);
                continue;
            }
            retval = EINVAL;
            break;
        case FB_DRAW_TEXT_DATA:
            if (!interbuf) {
                retval = EINVAL;
                break;
            }
            draw_text_data(interbuf);
            retval = 0;
            break;
        case FB_GET_CSIZE:
            ipc_answer_2(callid, EOK, scr_height, scr_width);
            continue;
        case FB_CLEAR:
            clrscr();
            retval = 0;
            break;
        case FB_PUTCHAR:
            c = IPC_GET_ARG1(call);
            row = IPC_GET_ARG2(call);
            col = IPC_GET_ARG3(call);
            if (col >= scr_width || row >= scr_height) {
                retval = EINVAL;
                break;
            }
            printchar(c, row, col);
            retval = 0;
            break;
        case FB_CURSOR_GOTO:
            row = IPC_GET_ARG1(call);
            col = IPC_GET_ARG2(call);
            if (row >= scr_height || col >= scr_width) {
                retval = EINVAL;
                break;
            }
            cursor_goto(row, col);
            retval = 0;
            break;
        case FB_SCROLL:
            i = IPC_GET_ARG1(call);
            if (i > scr_height || i < -((int) scr_height)) {
                retval = EINVAL;
                break;
            }
            scroll(i);
            retval = 0;
            break;
        case FB_CURSOR_VISIBILITY:
            if(IPC_GET_ARG1(call))
                cursor_enable();
            else
                cursor_disable();
            retval = 0;
            break;
        case FB_SET_STYLE:
            style = style_to_ega_style(IPC_GET_ARG1(call));
            retval = 0;
 
 
 
 
 
            break;
        case FB_SET_COLOR:
            fg_color = IPC_GET_ARG1(call);
            bg_color = IPC_GET_ARG2(call);
 
            attr = IPC_GET_ARG3(call);
            style = color_to_ega_style(fg_color, bg_color, attr);
            retval = 0;
            break;
        case FB_SET_RGB_COLOR:
            fg_rgb = IPC_GET_ARG1(call);
            bg_rgb = IPC_GET_ARG2(call);
            style = rgb_to_ega_style(fg_rgb, bg_rgb);
            retval = 0;
            break;
        case FB_VP_DRAW_PIXMAP:
            i = IPC_GET_ARG2(call);
            retval = print_screen(i);
            break;
        case FB_VP2PIXMAP:
            retval = save_screen();
            break;
        case FB_DROP_PIXMAP:
            i = IPC_GET_ARG1(call);
            if (i >= MAX_SAVED_SCREENS) {
                retval = EINVAL;
                break;
            }
            if (saved_screens[i].data) {
                free(saved_screens[i].data);
                saved_screens[i].data = NULL;
            }
            retval = 0;
            break;
 
        default:
            retval = ENOENT;
        }
        ipc_answer_0(callid, retval);
    }
}
 
int ega_init(void)
{
    void *ega_ph_addr;
    size_t sz;
 
    ega_ph_addr = (void *) sysinfo_value("fb.address.physical");
    scr_width = sysinfo_value("fb.width");
    scr_height = sysinfo_value("fb.height");
 
    if(sysinfo_value("fb.blinking")) {
 
        ega_normal_color &= 0x77;
        ega_inverted_color &= 0x77;
    }
 
    style = NORMAL_COLOR;
 
    iospace_enable(task_get_id(), (void *) EGA_IO_ADDRESS, 2);
 
    sz = scr_width * scr_height * 2;
    scr_addr = as_get_mappable_page(sz);
 
    physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
 
    async_set_client_connection(ega_client_connection);
 
    return 0;
}
 
 
/**
 * @}
 */
 

Rev 3767	Rev 3866
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	/** @defgroup egafb EGA framebuffer	29	/** @defgroup egafb EGA framebuffer
30	* @brief HelenOS EGA framebuffer.	30	* @brief HelenOS EGA framebuffer.
31	* @ingroup fbs	31	* @ingroup fbs
32	* @{	32	* @{
33	*/	33	*/
34	/** @file	34	/** @file
35	*/	35	*/
36		36
37	#include <stdlib.h>	37	#include <stdlib.h>
38	#include <unistd.h>	38	#include <unistd.h>
39	#include <align.h>	39	#include <align.h>
40	#include <async.h>	40	#include <async.h>
41	#include <ipc/ipc.h>	41	#include <ipc/ipc.h>
42	#include <errno.h>	42	#include <errno.h>
43	#include <stdio.h>	43	#include <stdio.h>
44	#include <ddi.h>	44	#include <ddi.h>
45	#include <sysinfo.h>	45	#include <sysinfo.h>
46	#include <as.h>	46	#include <as.h>
47	#include <ipc/fb.h>	47	#include <ipc/fb.h>
48	#include <ipc/ipc.h>	48	#include <ipc/ipc.h>
49	#include <ipc/ns.h>	49	#include <ipc/ns.h>
50	#include <ipc/services.h>	50	#include <ipc/services.h>
51	#include <libarch/ddi.h>	51	#include <libarch/ddi.h>
52	#include <console/style.h>	52	#include <console/style.h>
53	#include <console/color.h>	53	#include <console/color.h>
54		54
55	#include "ega.h"	55	#include "ega.h"
56	#include "../console/screenbuffer.h"	56	#include "../console/screenbuffer.h"
57	#include "main.h"	57	#include "main.h"
58		58
59	#define MAX_SAVED_SCREENS 256	59	#define MAX_SAVED_SCREENS 256
60	typedef struct saved_screen {	60	typedef struct saved_screen {
61	short *data;	61	short *data;
62	} saved_screen;	62	} saved_screen;
63		63
64	saved_screen saved_screens[MAX_SAVED_SCREENS];	64	saved_screen saved_screens[MAX_SAVED_SCREENS];
65		65
66	#define EGA_IO_ADDRESS 0x3d4	66	#define EGA_IO_ADDRESS 0x3d4
67	#define EGA_IO_SIZE 2	67	#define EGA_IO_SIZE 2
68		68
69	int ega_normal_color = 0x0f;	69	int ega_normal_color = 0x0f;
70	int ega_inverted_color = 0xf0;	70	int ega_inverted_color = 0xf0;
71		71
72	#define NORMAL_COLOR ega_normal_color	72	#define NORMAL_COLOR ega_normal_color
73	#define INVERTED_COLOR ega_inverted_color	73	#define INVERTED_COLOR ega_inverted_color
74		74
75	#define EGA_STYLE(fg,bg) ((fg) > (bg) ? NORMAL_COLOR : INVERTED_COLOR)	-
76		-
77	/* Allow only 1 connection */	75	/* Allow only 1 connection */
78	static int client_connected = 0;	76	static int client_connected = 0;
79		77
80	static unsigned int scr_width;	78	static unsigned int scr_width;
81	static unsigned int scr_height;	79	static unsigned int scr_height;
82	static char *scr_addr;	80	static char *scr_addr;
83		81
84	static unsigned int style;	82	static unsigned int style;
85		83
-		84	static unsigned attr_to_ega_style(const attrs_t *a);
-		85
86	static void clrscr(void)	86	static void clrscr(void)
87	{	87	{
88	int i;	88	int i;
89		89
90	for (i = 0; i < scr_width * scr_height; i++) {	90	for (i = 0; i < scr_width * scr_height; i++) {
91	scr_addr[i * 2] = ' ';	91	scr_addr[i * 2] = ' ';
92	scr_addr[i * 2 + 1] = style;	92	scr_addr[i * 2 + 1] = style;
93	}	93	}
94	}	94	}
95		95
96	static void cursor_goto(unsigned int row, unsigned int col)	96	static void cursor_goto(unsigned int row, unsigned int col)
97	{	97	{
98	int ega_cursor;	98	int ega_cursor;
99		99
100	ega_cursor = col + scr_width * row;	100	ega_cursor = col + scr_width * row;
101		101
102	outb(EGA_IO_ADDRESS, 0xe);	102	outb(EGA_IO_ADDRESS, 0xe);
103	outb(EGA_IO_ADDRESS + 1, (ega_cursor >> 8) & 0xff);	103	outb(EGA_IO_ADDRESS + 1, (ega_cursor >> 8) & 0xff);
104	outb(EGA_IO_ADDRESS, 0xf);	104	outb(EGA_IO_ADDRESS, 0xf);
105	outb(EGA_IO_ADDRESS + 1, ega_cursor & 0xff);	105	outb(EGA_IO_ADDRESS + 1, ega_cursor & 0xff);
106	}	106	}
107		107
108	static void cursor_disable(void)	108	static void cursor_disable(void)
109	{	109	{
110	uint8_t stat;	110	uint8_t stat;
111		111
112	outb(EGA_IO_ADDRESS, 0xa);	112	outb(EGA_IO_ADDRESS, 0xa);
113	stat=inb(EGA_IO_ADDRESS + 1);	113	stat=inb(EGA_IO_ADDRESS + 1);
114	outb(EGA_IO_ADDRESS, 0xa);	114	outb(EGA_IO_ADDRESS, 0xa);
115	outb(EGA_IO_ADDRESS + 1, stat \| (1 << 5));	115	outb(EGA_IO_ADDRESS + 1, stat \| (1 << 5));
116	}	116	}
117		117
118	static void cursor_enable(void)	118	static void cursor_enable(void)
119	{	119	{
120	uint8_t stat;	120	uint8_t stat;
121		121
122	outb(EGA_IO_ADDRESS, 0xa);	122	outb(EGA_IO_ADDRESS, 0xa);
123	stat=inb(EGA_IO_ADDRESS + 1);	123	stat=inb(EGA_IO_ADDRESS + 1);
124	outb(EGA_IO_ADDRESS, 0xa);	124	outb(EGA_IO_ADDRESS, 0xa);
125	outb(EGA_IO_ADDRESS + 1, stat & (~(1 << 5)));	125	outb(EGA_IO_ADDRESS + 1, stat & (~(1 << 5)));
126	}	126	}
127		127
128	static void scroll(int rows)	128	static void scroll(int rows)
129	{	129	{
130	int i;	130	int i;
131	if (rows > 0) {	131	if (rows > 0) {
132	memmove(scr_addr, ((char ) scr_addr) + rows scr_width * 2,	132	memmove(scr_addr, ((char ) scr_addr) + rows scr_width * 2,
133	scr_width * scr_height * 2 - rows * scr_width * 2);	133	scr_width * scr_height * 2 - rows * scr_width * 2);
134	for (i = 0; i < rows * scr_width; i++)	134	for (i = 0; i < rows * scr_width; i++)
135	(((short ) scr_addr) + scr_width scr_height - rows *	135	(((short ) scr_addr) + scr_width scr_height - rows *
136	scr_width)[i] = ((style << 8) + ' ');	136	scr_width)[i] = ((style << 8) + ' ');
137	} else if (rows < 0) {	137	} else if (rows < 0) {
138	memmove(((char )scr_addr) - rows scr_width * 2, scr_addr,	138	memmove(((char )scr_addr) - rows scr_width * 2, scr_addr,
139	scr_width * scr_height * 2 + rows * scr_width * 2);	139	scr_width * scr_height * 2 + rows * scr_width * 2);
140	for (i = 0; i < -rows * scr_width; i++)	140	for (i = 0; i < -rows * scr_width; i++)
141	((short *)scr_addr)[i] = ((style << 8 ) + ' ');	141	((short *)scr_addr)[i] = ((style << 8 ) + ' ');
142	}	142	}
143	}	143	}
144		144
145	static void printchar(char c, unsigned int row, unsigned int col)	145	static void printchar(char c, unsigned int row, unsigned int col)
146	{	146	{
147	scr_addr[(row * scr_width + col) * 2] = c;	147	scr_addr[(row * scr_width + col) * 2] = c;
148	scr_addr[(row * scr_width + col) * 2 + 1] = style;	148	scr_addr[(row * scr_width + col) * 2 + 1] = style;
149		149
150	cursor_goto(row, col + 1);	150	cursor_goto(row, col + 1);
151	}	151	}
152		152
153	static void draw_text_data(keyfield_t *data)	153	static void draw_text_data(keyfield_t *data)
154	{	154	{
155	int i;	155	int i;
156		156
157	for (i = 0; i < scr_width * scr_height; i++) {	157	for (i = 0; i < scr_width * scr_height; i++) {
158	scr_addr[i * 2] = data[i].character;	158	scr_addr[i * 2] = data[i].character;
159	/* FIXME	-
160	scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color,	159	scr_addr[i * 2 + 1] = attr_to_ega_style(&data[i].attrs);
161	data[i].style.bg_color);	-
162	*/	-
163	}	160	}
164	}	161	}
165		162
166	static int save_screen(void)	163	static int save_screen(void)
167	{	164	{
168	int i;	165	int i;
169		166
170	for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)	167	for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
171	;	168	;
172	if (i == MAX_SAVED_SCREENS)	169	if (i == MAX_SAVED_SCREENS)
173	return EINVAL;	170	return EINVAL;
174	if (!(saved_screens[i].data = malloc(2 * scr_width * scr_height)))	171	if (!(saved_screens[i].data = malloc(2 * scr_width * scr_height)))
175	return ENOMEM;	172	return ENOMEM;
176	memcpy(saved_screens[i].data, scr_addr, 2 * scr_width * scr_height);	173	memcpy(saved_screens[i].data, scr_addr, 2 * scr_width * scr_height);
177		174
178	return i;	175	return i;
179	}	176	}
180		177
181	static int print_screen(int i)	178	static int print_screen(int i)
182	{	179	{
183	if (saved_screens[i].data)	180	if (saved_screens[i].data)
184	memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *	181	memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *
185	scr_height);	182	scr_height);
186	else	183	else
187	return EINVAL;	184	return EINVAL;
188	return i;	185	return i;
189	}	186	}
190		187
-		188	static int style_to_ega_style(int style)
-		189	{
-		190	unsigned int ega_style;
-		191
-		192	switch (style) {
-		193	case STYLE_NORMAL:
-		194	ega_style = INVERTED_COLOR;
-		195	break;
-		196	case STYLE_EMPHASIS:
-		197	ega_style = INVERTED_COLOR \| 4;
-		198	break;
-		199	default:
-		200	return INVERTED_COLOR;
-		201	}
-		202
-		203	return ega_style;
-		204	}
-		205
-		206	static unsigned int color_to_ega_style(int fg_color, int bg_color, int attr)
-		207	{
-		208	unsigned int style;
-		209
-		210	style = (fg_color & 7) \| ((bg_color & 7) << 4);
-		211	if (attr & CATTR_BRIGHT)
-		212	style = style \| 0x08;
-		213
-		214	return style;
-		215	}
-		216
-		217	static unsigned int rgb_to_ega_style(uint32_t fg, uint32_t bg)
-		218	{
-		219	return (fg > bg) ? NORMAL_COLOR : INVERTED_COLOR;
-		220	}
-		221
-		222	static unsigned attr_to_ega_style(const attrs_t *a)
-		223	{
-		224	switch (a->t) {
-		225	case at_style: return style_to_ega_style(a->a.s.style);
-		226	case at_rgb: return rgb_to_ega_style(a->a.r.fg_color, a->a.r.bg_color);
-		227	case at_idx: return color_to_ega_style(a->a.i.fg_color,
-		228	a->a.i.bg_color, a->a.i.flags);
-		229	default: return INVERTED_COLOR;
-		230	}
-		231	}
191		232
192	static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)	233	static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)
193	{	234	{
194	int retval;	235	int retval;
195	ipc_callid_t callid;	236	ipc_callid_t callid;
196	ipc_call_t call;	237	ipc_call_t call;
197	char c;	238	char c;
198	unsigned int row, col;	239	unsigned int row, col;
199	int bgcolor,fgcolor;	240	int bg_color, fg_color, attr;
-		241	uint32_t bg_rgb, fg_rgb;
200	keyfield_t *interbuf = NULL;	242	keyfield_t *interbuf = NULL;
201	size_t intersize = 0;	243	size_t intersize = 0;
202	int i;	244	int i;
203		245
204	if (client_connected) {	246	if (client_connected) {
205	ipc_answer_0(iid, ELIMIT);	247	ipc_answer_0(iid, ELIMIT);
206	return;	248	return;
207	}	249	}
208	client_connected = 1;	250	client_connected = 1;
209	ipc_answer_0(iid, EOK); /* Accept connection */	251	ipc_answer_0(iid, EOK); /* Accept connection */
210		252
211	while (1) {	253	while (1) {
212	callid = async_get_call(&call);	254	callid = async_get_call(&call);
213	switch (IPC_GET_METHOD(call)) {	255	switch (IPC_GET_METHOD(call)) {
214	case IPC_M_PHONE_HUNGUP:	256	case IPC_M_PHONE_HUNGUP:
215	client_connected = 0;	257	client_connected = 0;
216	ipc_answer_0(callid, EOK);	258	ipc_answer_0(callid, EOK);
217	return; /* Exit thread */	259	return; /* Exit thread */
218	case IPC_M_SHARE_OUT:	260	case IPC_M_SHARE_OUT:
219	/* We accept one area for data interchange */	261	/* We accept one area for data interchange */
220	intersize = IPC_GET_ARG2(call);	262	intersize = IPC_GET_ARG2(call);
221	if (intersize >= scr_width * scr_height *	263	if (intersize >= scr_width * scr_height *
222	sizeof(*interbuf)) {	264	sizeof(*interbuf)) {
223	receive_comm_area(callid, &call,	265	receive_comm_area(callid, &call,
224	(void *) &interbuf);	266	(void *) &interbuf);
225	continue;	267	continue;
226	}	268	}
227	retval = EINVAL;	269	retval = EINVAL;
228	break;	270	break;
229	case FB_DRAW_TEXT_DATA:	271	case FB_DRAW_TEXT_DATA:
230	if (!interbuf) {	272	if (!interbuf) {
231	retval = EINVAL;	273	retval = EINVAL;
232	break;	274	break;
233	}	275	}
234	draw_text_data(interbuf);	276	draw_text_data(interbuf);
235	retval = 0;	277	retval = 0;
236	break;	278	break;
237	case FB_GET_CSIZE:	279	case FB_GET_CSIZE:
238	ipc_answer_2(callid, EOK, scr_height, scr_width);	280	ipc_answer_2(callid, EOK, scr_height, scr_width);
239	continue;	281	continue;
240	case FB_CLEAR:	282	case FB_CLEAR:
241	clrscr();	283	clrscr();
242	retval = 0;	284	retval = 0;
243	break;	285	break;
244	case FB_PUTCHAR:	286	case FB_PUTCHAR:
245	c = IPC_GET_ARG1(call);	287	c = IPC_GET_ARG1(call);
246	row = IPC_GET_ARG2(call);	288	row = IPC_GET_ARG2(call);
247	col = IPC_GET_ARG3(call);	289	col = IPC_GET_ARG3(call);
248	if (col >= scr_width \|\| row >= scr_height) {	290	if (col >= scr_width \|\| row >= scr_height) {
249	retval = EINVAL;	291	retval = EINVAL;
250	break;	292	break;
251	}	293	}
252	printchar(c, row, col);	294	printchar(c, row, col);
253	retval = 0;	295	retval = 0;
254	break;	296	break;
255	case FB_CURSOR_GOTO:	297	case FB_CURSOR_GOTO:
256	row = IPC_GET_ARG1(call);	298	row = IPC_GET_ARG1(call);
257	col = IPC_GET_ARG2(call);	299	col = IPC_GET_ARG2(call);
258	if (row >= scr_height \|\| col >= scr_width) {	300	if (row >= scr_height \|\| col >= scr_width) {
259	retval = EINVAL;	301	retval = EINVAL;
260	break;	302	break;
261	}	303	}
262	cursor_goto(row, col);	304	cursor_goto(row, col);
263	retval = 0;	305	retval = 0;
264	break;	306	break;
265	case FB_SCROLL:	307	case FB_SCROLL:
266	i = IPC_GET_ARG1(call);	308	i = IPC_GET_ARG1(call);
267	if (i > scr_height \|\| i < -((int) scr_height)) {	309	if (i > scr_height \|\| i < -((int) scr_height)) {
268	retval = EINVAL;	310	retval = EINVAL;
269	break;	311	break;
270	}	312	}
271	scroll(i);	313	scroll(i);
272	retval = 0;	314	retval = 0;
273	break;	315	break;
274	case FB_CURSOR_VISIBILITY:	316	case FB_CURSOR_VISIBILITY:
275	if(IPC_GET_ARG1(call))	317	if(IPC_GET_ARG1(call))
276	cursor_enable();	318	cursor_enable();
277	else	319	else
278	cursor_disable();	320	cursor_disable();
279	retval = 0;	321	retval = 0;
280	break;	322	break;
281	case FB_SET_STYLE:	323	case FB_SET_STYLE:
-		324	style = style_to_ega_style(IPC_GET_ARG1(call));
282	retval = 0;	325	retval = 0;
283	switch (IPC_GET_ARG1(call)) {	-
284	case STYLE_NORMAL: style = INVERTED_COLOR; break;	-
285	case STYLE_EMPHASIS: style = INVERTED_COLOR \| 4; break;	-
286	default: retval = EINVAL;	-
287	}	-
288	break;	326	break;
289	case FB_SET_COLOR:	327	case FB_SET_COLOR:
290	fgcolor = IPC_GET_ARG1(call);	328	fg_color = IPC_GET_ARG1(call);
291	bgcolor = IPC_GET_ARG2(call);	329	bg_color = IPC_GET_ARG2(call);
292	style = (fgcolor & 7) \| ((bgcolor & 7) << 4);	-
293	if (IPC_GET_ARG3(call) & CATTR_BRIGHT)	330	attr = IPC_GET_ARG3(call);
294	style = style \| 0x08;	331	style = color_to_ega_style(fg_color, bg_color, attr);
295	retval = 0;	332	retval = 0;
296	break;	333	break;
297	case FB_SET_RGB_COLOR:	334	case FB_SET_RGB_COLOR:
298	fgcolor = IPC_GET_ARG1(call);	335	fg_rgb = IPC_GET_ARG1(call);
299	bgcolor = IPC_GET_ARG2(call);	336	bg_rgb = IPC_GET_ARG2(call);
300	style = EGA_STYLE(fgcolor, bgcolor);	337	style = rgb_to_ega_style(fg_rgb, bg_rgb);
301	retval = 0;	338	retval = 0;
302	break;	339	break;
303	case FB_VP_DRAW_PIXMAP:	340	case FB_VP_DRAW_PIXMAP:
304	i = IPC_GET_ARG2(call);	341	i = IPC_GET_ARG2(call);
305	retval = print_screen(i);	342	retval = print_screen(i);
306	break;	343	break;
307	case FB_VP2PIXMAP:	344	case FB_VP2PIXMAP:
308	retval = save_screen();	345	retval = save_screen();
309	break;	346	break;
310	case FB_DROP_PIXMAP:	347	case FB_DROP_PIXMAP:
311	i = IPC_GET_ARG1(call);	348	i = IPC_GET_ARG1(call);
312	if (i >= MAX_SAVED_SCREENS) {	349	if (i >= MAX_SAVED_SCREENS) {
313	retval = EINVAL;	350	retval = EINVAL;
314	break;	351	break;
315	}	352	}
316	if (saved_screens[i].data) {	353	if (saved_screens[i].data) {
317	free(saved_screens[i].data);	354	free(saved_screens[i].data);
318	saved_screens[i].data = NULL;	355	saved_screens[i].data = NULL;
319	}	356	}
320	retval = 0;	357	retval = 0;
321	break;	358	break;
322		359
323	default:	360	default:
324	retval = ENOENT;	361	retval = ENOENT;
325	}	362	}
326	ipc_answer_0(callid, retval);	363	ipc_answer_0(callid, retval);
327	}	364	}
328	}	365	}
329		366
330	int ega_init(void)	367	int ega_init(void)
331	{	368	{
332	void *ega_ph_addr;	369	void *ega_ph_addr;
333	size_t sz;	370	size_t sz;
334		371
335	ega_ph_addr = (void *) sysinfo_value("fb.address.physical");	372	ega_ph_addr = (void *) sysinfo_value("fb.address.physical");
336	scr_width = sysinfo_value("fb.width");	373	scr_width = sysinfo_value("fb.width");
337	scr_height = sysinfo_value("fb.height");	374	scr_height = sysinfo_value("fb.height");
-		375
338	if(sysinfo_value("fb.blinking"))	376	if(sysinfo_value("fb.blinking")) {
339	{	-
340	ega_normal_color &= 0x77;	377	ega_normal_color &= 0x77;
341	ega_inverted_color &= 0x77;	378	ega_inverted_color &= 0x77;
342	}	379	}
-		380
343	style = NORMAL_COLOR;	381	style = NORMAL_COLOR;
344		382
345	iospace_enable(task_get_id(), (void *) EGA_IO_ADDRESS, 2);	383	iospace_enable(task_get_id(), (void *) EGA_IO_ADDRESS, 2);
346		384
347	sz = scr_width * scr_height * 2;	385	sz = scr_width * scr_height * 2;
348	scr_addr = as_get_mappable_page(sz);	386	scr_addr = as_get_mappable_page(sz);
349		387
350	physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>	388	physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
351	PAGE_WIDTH, AS_AREA_READ \| AS_AREA_WRITE);	389	PAGE_WIDTH, AS_AREA_READ \| AS_AREA_WRITE);
352		390
353	async_set_client_connection(ega_client_connection);	391	async_set_client_connection(ega_client_connection);
354		392
355	return 0;	393	return 0;
356	}	394	}
357		395
358		396
359	/**	397	/**
360	* @}	398	* @}
361	*/	399	*/
362		400

Subversion Repositories HelenOS

(root)/trunk/uspace/srv/fb/ega.c – Rev 3767 → 3866