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

Subversion Repositories HelenOS

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