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 <console/style.h>
#include <console/color.h>
#include <sys/types.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_BASE ((ioport8_t *) 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;
   
    pio_write_8(EGA_IO_BASE, 0xe);
    pio_write_8(EGA_IO_BASE + 1, (ega_cursor >> 8) & 0xff);
    pio_write_8(EGA_IO_BASE, 0xf);
    pio_write_8(EGA_IO_BASE + 1, ega_cursor & 0xff);
}
 
static void cursor_disable(void)
{
    uint8_t stat;
 
    pio_write_8(EGA_IO_BASE, 0xa);
    stat = pio_read_8(EGA_IO_BASE + 1);
    pio_write_8(EGA_IO_BASE, 0xa);
    pio_write_8(EGA_IO_BASE + 1, stat | (1 << 5));
}
 
static void cursor_enable(void)
{
    uint8_t stat;
 
    pio_write_8(EGA_IO_BASE, 0xa);
    stat = pio_read_8(EGA_IO_BASE + 1);
    pio_write_8(EGA_IO_BASE, 0xa);
    pio_write_8(EGA_IO_BASE + 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_BASE, 2);
 
    sz = scr_width * scr_height * 2;
    scr_addr = as_get_mappable_page(sz);
 
    if (physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
        return -1;
 
    async_set_client_connection(ega_client_connection);
 
    return 0;
}
 
 
/**
 * @}
 */
 

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

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/srv/fb/ega.c – Rev 4343 → 4345