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

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/fb/ega.c – Rev 4581 → 4718