WebSVN – HelenOS – Diff – /branches/dynload/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 "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
 
#define EGA_STYLE(fg,bg) ((fg) > (bg) ? NORMAL_COLOR : 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 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) {
        memcpy(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) {
        memcpy(((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] = EGA_STYLE(data[i].style.fg_color,
            data[i].style.bg_color);
    }
}
 
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 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 bgcolor,fgcolor;
    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:
            fgcolor = IPC_GET_ARG1(call);
            bgcolor = IPC_GET_ARG2(call);
            style = EGA_STYLE(fgcolor, bgcolor);
            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 2927	Rev 3674
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		52
53	#include "ega.h"	53	#include "ega.h"
54	#include "../console/screenbuffer.h"	54	#include "../console/screenbuffer.h"
55	#include "main.h"	55	#include "main.h"
56		56
57	#define MAX_SAVED_SCREENS 256	57	#define MAX_SAVED_SCREENS 256
58	typedef struct saved_screen {	58	typedef struct saved_screen {
59	short *data;	59	short *data;
60	} saved_screen;	60	} saved_screen;
61		61
62	saved_screen saved_screens[MAX_SAVED_SCREENS];	62	saved_screen saved_screens[MAX_SAVED_SCREENS];
63		63
64	#define EGA_IO_ADDRESS 0x3d4	64	#define EGA_IO_ADDRESS 0x3d4
65	#define EGA_IO_SIZE 2	65	#define EGA_IO_SIZE 2
66		66
-		67	int ega_normal_color=0x0f;
-		68	int ega_inverted_color=0xf0;
-		69
67	#define NORMAL_COLOR 0x0f	70	#define NORMAL_COLOR ega_normal_color
68	#define INVERTED_COLOR 0xf0	71	#define INVERTED_COLOR ega_inverted_color
69		72
70	#define EGA_STYLE(fg,bg) ((fg) > (bg) ? NORMAL_COLOR : INVERTED_COLOR)	73	#define EGA_STYLE(fg,bg) ((fg) > (bg) ? NORMAL_COLOR : INVERTED_COLOR)
71		74
72	/* Allow only 1 connection */	75	/* Allow only 1 connection */
73	static int client_connected = 0;	76	static int client_connected = 0;
74		77
75	static unsigned int scr_width;	78	static unsigned int scr_width;
76	static unsigned int scr_height;	79	static unsigned int scr_height;
77	static char *scr_addr;	80	static char *scr_addr;
78		81
79	static unsigned int style = NORMAL_COLOR;	82	static unsigned int style;
80		83
81	static void clrscr(void)	84	static void clrscr(void)
82	{	85	{
83	int i;	86	int i;
84		87
85	for (i = 0; i < scr_width * scr_height; i++) {	88	for (i = 0; i < scr_width * scr_height; i++) {
86	scr_addr[i * 2] = ' ';	89	scr_addr[i * 2] = ' ';
87	scr_addr[i * 2 + 1] = style;	90	scr_addr[i * 2 + 1] = style;
88	}	91	}
89	}	92	}
90		93
91	static void cursor_goto(unsigned int row, unsigned int col)	94	static void cursor_goto(unsigned int row, unsigned int col)
92	{	95	{
93	int ega_cursor;	96	int ega_cursor;
94		97
95	ega_cursor = col + scr_width * row;	98	ega_cursor = col + scr_width * row;
96		99
97	outb(EGA_IO_ADDRESS, 0xe);	100	outb(EGA_IO_ADDRESS, 0xe);
98	outb(EGA_IO_ADDRESS + 1, (ega_cursor >> 8) & 0xff);	101	outb(EGA_IO_ADDRESS + 1, (ega_cursor >> 8) & 0xff);
99	outb(EGA_IO_ADDRESS, 0xf);	102	outb(EGA_IO_ADDRESS, 0xf);
100	outb(EGA_IO_ADDRESS + 1, ega_cursor & 0xff);	103	outb(EGA_IO_ADDRESS + 1, ega_cursor & 0xff);
101	}	104	}
102		105
103	static void cursor_disable(void)	106	static void cursor_disable(void)
104	{	107	{
105	uint8_t stat;	108	uint8_t stat;
106		109
107	outb(EGA_IO_ADDRESS, 0xa);	110	outb(EGA_IO_ADDRESS, 0xa);
108	stat=inb(EGA_IO_ADDRESS + 1);	111	stat=inb(EGA_IO_ADDRESS + 1);
109	outb(EGA_IO_ADDRESS, 0xa);	112	outb(EGA_IO_ADDRESS, 0xa);
110	outb(EGA_IO_ADDRESS + 1, stat \| (1 << 5));	113	outb(EGA_IO_ADDRESS + 1, stat \| (1 << 5));
111	}	114	}
112		115
113	static void cursor_enable(void)	116	static void cursor_enable(void)
114	{	117	{
115	uint8_t stat;	118	uint8_t stat;
116		119
117	outb(EGA_IO_ADDRESS, 0xa);	120	outb(EGA_IO_ADDRESS, 0xa);
118	stat=inb(EGA_IO_ADDRESS + 1);	121	stat=inb(EGA_IO_ADDRESS + 1);
119	outb(EGA_IO_ADDRESS, 0xa);	122	outb(EGA_IO_ADDRESS, 0xa);
120	outb(EGA_IO_ADDRESS + 1, stat & (~(1 << 5)));	123	outb(EGA_IO_ADDRESS + 1, stat & (~(1 << 5)));
121	}	124	}
122		125
123	static void scroll(int rows)	126	static void scroll(int rows)
124	{	127	{
125	int i;	128	int i;
126	if (rows > 0) {	129	if (rows > 0) {
127	memcpy(scr_addr, ((char ) scr_addr) + rows scr_width * 2,	130	memcpy(scr_addr, ((char ) scr_addr) + rows scr_width * 2,
128	scr_width * scr_height * 2 - rows * scr_width * 2);	131	scr_width * scr_height * 2 - rows * scr_width * 2);
129	for (i = 0; i < rows * scr_width; i++)	132	for (i = 0; i < rows * scr_width; i++)
130	(((short ) scr_addr) + scr_width scr_height - rows *	133	(((short ) scr_addr) + scr_width scr_height - rows *
131	scr_width)[i] = ((style << 8) + ' ');	134	scr_width)[i] = ((style << 8) + ' ');
132	} else if (rows < 0) {	135	} else if (rows < 0) {
133	memcpy(((char )scr_addr) - rows scr_width * 2, scr_addr,	136	memcpy(((char )scr_addr) - rows scr_width * 2, scr_addr,
134	scr_width * scr_height * 2 + rows * scr_width * 2);	137	scr_width * scr_height * 2 + rows * scr_width * 2);
135	for (i = 0; i < -rows * scr_width; i++)	138	for (i = 0; i < -rows * scr_width; i++)
136	((short *)scr_addr)[i] = ((style << 8 ) + ' ');	139	((short *)scr_addr)[i] = ((style << 8 ) + ' ');
137	}	140	}
138	}	141	}
139		142
140	static void printchar(char c, unsigned int row, unsigned int col)	143	static void printchar(char c, unsigned int row, unsigned int col)
141	{	144	{
142	scr_addr[(row * scr_width + col) * 2] = c;	145	scr_addr[(row * scr_width + col) * 2] = c;
143	scr_addr[(row * scr_width + col) * 2 + 1] = style;	146	scr_addr[(row * scr_width + col) * 2 + 1] = style;
144		147
145	cursor_goto(row, col + 1);	148	cursor_goto(row, col + 1);
146	}	149	}
147		150
148	static void draw_text_data(keyfield_t *data)	151	static void draw_text_data(keyfield_t *data)
149	{	152	{
150	int i;	153	int i;
151		154
152	for (i = 0; i < scr_width * scr_height; i++) {	155	for (i = 0; i < scr_width * scr_height; i++) {
153	scr_addr[i * 2] = data[i].character;	156	scr_addr[i * 2] = data[i].character;
154	scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color,	157	scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color,
155	data[i].style.bg_color);	158	data[i].style.bg_color);
156	}	159	}
157	}	160	}
158		161
159	static int save_screen(void)	162	static int save_screen(void)
160	{	163	{
161	int i;	164	int i;
162		165
163	for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)	166	for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
164	;	167	;
165	if (i == MAX_SAVED_SCREENS)	168	if (i == MAX_SAVED_SCREENS)
166	return EINVAL;	169	return EINVAL;
167	if (!(saved_screens[i].data = malloc(2 * scr_width * scr_height)))	170	if (!(saved_screens[i].data = malloc(2 * scr_width * scr_height)))
168	return ENOMEM;	171	return ENOMEM;
169	memcpy(saved_screens[i].data, scr_addr, 2 * scr_width * scr_height);	172	memcpy(saved_screens[i].data, scr_addr, 2 * scr_width * scr_height);
170		173
171	return i;	174	return i;
172	}	175	}
173		176
174	static int print_screen(int i)	177	static int print_screen(int i)
175	{	178	{
176	if (saved_screens[i].data)	179	if (saved_screens[i].data)
177	memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *	180	memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *
178	scr_height);	181	scr_height);
179	else	182	else
180	return EINVAL;	183	return EINVAL;
181	return i;	184	return i;
182	}	185	}
183		186
184		187
185	static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)	188	static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)
186	{	189	{
187	int retval;	190	int retval;
188	ipc_callid_t callid;	191	ipc_callid_t callid;
189	ipc_call_t call;	192	ipc_call_t call;
190	char c;	193	char c;
191	unsigned int row, col;	194	unsigned int row, col;
192	int bgcolor,fgcolor;	195	int bgcolor,fgcolor;
193	keyfield_t *interbuf = NULL;	196	keyfield_t *interbuf = NULL;
194	size_t intersize = 0;	197	size_t intersize = 0;
195	int i;	198	int i;
196		199
197	if (client_connected) {	200	if (client_connected) {
198	ipc_answer_0(iid, ELIMIT);	201	ipc_answer_0(iid, ELIMIT);
199	return;	202	return;
200	}	203	}
201	client_connected = 1;	204	client_connected = 1;
202	ipc_answer_0(iid, EOK); /* Accept connection */	205	ipc_answer_0(iid, EOK); /* Accept connection */
203		206
204	while (1) {	207	while (1) {
205	callid = async_get_call(&call);	208	callid = async_get_call(&call);
206	switch (IPC_GET_METHOD(call)) {	209	switch (IPC_GET_METHOD(call)) {
207	case IPC_M_PHONE_HUNGUP:	210	case IPC_M_PHONE_HUNGUP:
208	client_connected = 0;	211	client_connected = 0;
209	ipc_answer_0(callid, EOK);	212	ipc_answer_0(callid, EOK);
210	return; /* Exit thread */	213	return; /* Exit thread */
211	case IPC_M_SHARE_OUT:	214	case IPC_M_SHARE_OUT:
212	/* We accept one area for data interchange */	215	/* We accept one area for data interchange */
213	intersize = IPC_GET_ARG2(call);	216	intersize = IPC_GET_ARG2(call);
214	if (intersize >= scr_width * scr_height *	217	if (intersize >= scr_width * scr_height *
215	sizeof(*interbuf)) {	218	sizeof(*interbuf)) {
216	receive_comm_area(callid, &call,	219	receive_comm_area(callid, &call,
217	(void *) &interbuf);	220	(void *) &interbuf);
218	continue;	221	continue;
219	}	222	}
220	retval = EINVAL;	223	retval = EINVAL;
221	break;	224	break;
222	case FB_DRAW_TEXT_DATA:	225	case FB_DRAW_TEXT_DATA:
223	if (!interbuf) {	226	if (!interbuf) {
224	retval = EINVAL;	227	retval = EINVAL;
225	break;	228	break;
226	}	229	}
227	draw_text_data(interbuf);	230	draw_text_data(interbuf);
228	retval = 0;	231	retval = 0;
229	break;	232	break;
230	case FB_GET_CSIZE:	233	case FB_GET_CSIZE:
231	ipc_answer_2(callid, EOK, scr_height, scr_width);	234	ipc_answer_2(callid, EOK, scr_height, scr_width);
232	continue;	235	continue;
233	case FB_CLEAR:	236	case FB_CLEAR:
234	clrscr();	237	clrscr();
235	retval = 0;	238	retval = 0;
236	break;	239	break;
237	case FB_PUTCHAR:	240	case FB_PUTCHAR:
238	c = IPC_GET_ARG1(call);	241	c = IPC_GET_ARG1(call);
239	row = IPC_GET_ARG2(call);	242	row = IPC_GET_ARG2(call);
240	col = IPC_GET_ARG3(call);	243	col = IPC_GET_ARG3(call);
241	if (col >= scr_width \|\| row >= scr_height) {	244	if (col >= scr_width \|\| row >= scr_height) {
242	retval = EINVAL;	245	retval = EINVAL;
243	break;	246	break;
244	}	247	}
245	printchar(c, row, col);	248	printchar(c, row, col);
246	retval = 0;	249	retval = 0;
247	break;	250	break;
248	case FB_CURSOR_GOTO:	251	case FB_CURSOR_GOTO:
249	row = IPC_GET_ARG1(call);	252	row = IPC_GET_ARG1(call);
250	col = IPC_GET_ARG2(call);	253	col = IPC_GET_ARG2(call);
251	if (row >= scr_height \|\| col >= scr_width) {	254	if (row >= scr_height \|\| col >= scr_width) {
252	retval = EINVAL;	255	retval = EINVAL;
253	break;	256	break;
254	}	257	}
255	cursor_goto(row, col);	258	cursor_goto(row, col);
256	retval = 0;	259	retval = 0;
257	break;	260	break;
258	case FB_SCROLL:	261	case FB_SCROLL:
259	i = IPC_GET_ARG1(call);	262	i = IPC_GET_ARG1(call);
260	if (i > scr_height \|\| i < -((int) scr_height)) {	263	if (i > scr_height \|\| i < -((int) scr_height)) {
261	retval = EINVAL;	264	retval = EINVAL;
262	break;	265	break;
263	}	266	}
264	scroll(i);	267	scroll(i);
265	retval = 0;	268	retval = 0;
266	break;	269	break;
267	case FB_CURSOR_VISIBILITY:	270	case FB_CURSOR_VISIBILITY:
268	if(IPC_GET_ARG1(call))	271	if(IPC_GET_ARG1(call))
269	cursor_enable();	272	cursor_enable();
270	else	273	else
271	cursor_disable();	274	cursor_disable();
272	retval = 0;	275	retval = 0;
273	break;	276	break;
274	case FB_SET_STYLE:	277	case FB_SET_STYLE:
275	fgcolor = IPC_GET_ARG1(call);	278	fgcolor = IPC_GET_ARG1(call);
276	bgcolor = IPC_GET_ARG2(call);	279	bgcolor = IPC_GET_ARG2(call);
277	style = EGA_STYLE(fgcolor, bgcolor);	280	style = EGA_STYLE(fgcolor, bgcolor);
278	retval = 0;	281	retval = 0;
279	break;	282	break;
280	case FB_VP_DRAW_PIXMAP:	283	case FB_VP_DRAW_PIXMAP:
281	i = IPC_GET_ARG2(call);	284	i = IPC_GET_ARG2(call);
282	retval = print_screen(i);	285	retval = print_screen(i);
283	break;	286	break;
284	case FB_VP2PIXMAP:	287	case FB_VP2PIXMAP:
285	retval = save_screen();	288	retval = save_screen();
286	break;	289	break;
287	case FB_DROP_PIXMAP:	290	case FB_DROP_PIXMAP:
288	i = IPC_GET_ARG1(call);	291	i = IPC_GET_ARG1(call);
289	if (i >= MAX_SAVED_SCREENS) {	292	if (i >= MAX_SAVED_SCREENS) {
290	retval = EINVAL;	293	retval = EINVAL;
291	break;	294	break;
292	}	295	}
293	if (saved_screens[i].data) {	296	if (saved_screens[i].data) {
294	free(saved_screens[i].data);	297	free(saved_screens[i].data);
295	saved_screens[i].data = NULL;	298	saved_screens[i].data = NULL;
296	}	299	}
297	retval = 0;	300	retval = 0;
298	break;	301	break;
299		302
300	default:	303	default:
301	retval = ENOENT;	304	retval = ENOENT;
302	}	305	}
303	ipc_answer_0(callid, retval);	306	ipc_answer_0(callid, retval);
304	}	307	}
305	}	308	}
306		309
307	int ega_init(void)	310	int ega_init(void)
308	{	311	{
309	void *ega_ph_addr;	312	void *ega_ph_addr;
310	size_t sz;	313	size_t sz;
311		314
312	ega_ph_addr = (void *) sysinfo_value("fb.address.physical");	315	ega_ph_addr = (void *) sysinfo_value("fb.address.physical");
313	scr_width = sysinfo_value("fb.width");	316	scr_width = sysinfo_value("fb.width");
314	scr_height = sysinfo_value("fb.height");	317	scr_height = sysinfo_value("fb.height");
-		318	if(sysinfo_value("fb.blinking"))
-		319	{
-		320	ega_normal_color&=0x77;
-		321	ega_inverted_color&=0x77;
-		322	}
-		323	style = NORMAL_COLOR;
-		324
315	iospace_enable(task_get_id(), (void *) EGA_IO_ADDRESS, 2);	325	iospace_enable(task_get_id(), (void *) EGA_IO_ADDRESS, 2);
316		326
317	sz = scr_width * scr_height * 2;	327	sz = scr_width * scr_height * 2;
318	scr_addr = as_get_mappable_page(sz);	328	scr_addr = as_get_mappable_page(sz);
319		329
320	physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>	330	physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
321	PAGE_WIDTH, AS_AREA_READ \| AS_AREA_WRITE);	331	PAGE_WIDTH, AS_AREA_READ \| AS_AREA_WRITE);
322		332
323	async_set_client_connection(ega_client_connection);	333	async_set_client_connection(ega_client_connection);
324		334
325	return 0;	335	return 0;
326	}	336	}
327		337
328		338
329	/**	339	/**
330	* @}	340	* @}
331	*/	341	*/
332		342

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fb/ega.c – Rev 2927 → 3674