WebSVN – HelenOS – Diff – /branches/network/uspace/srv/fb/serial_console.c


/*
 * Copyright (c) 2006 Ondrej Palkovsky
 * Copyright (c) 2008 Martin Decky
 * Copyright (c) 2008 Pavel Rimsky
 * 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 serial Serial console
 * @brief    Serial console services (putc, puts, clear screen, cursor goto,...)
 * @{
 */
 
/** @file
 */
 
#include <stdio.h>
#include <ipc/ipc.h>
#include <async.h>
#include <ipc/fb.h>
#include <bool.h>
#include <errno.h>
#include <console/color.h>
#include <console/style.h>
 
#include "../console/screenbuffer.h"
#include "main.h"
#include "serial_console.h"
 
#define MAX_CONTROL 20
 
static void serial_sgr(const unsigned int mode);
void serial_putchar(wchar_t ch);
 
static int scr_width;
static int scr_height;
static bool color = true;   /** True if producing color output. */
static bool utf8 = false;   /** True if producing UTF8 output. */
static putc_function_t putc_function;
 
/* Allow only 1 connection */
static int client_connected = 0;
 
enum sgr_color_index {
    CI_BLACK    = 0,
    CI_RED      = 1,
    CI_GREEN    = 2,
    CI_BROWN    = 3,
    CI_BLUE     = 4,
    CI_MAGENTA  = 5,
    CI_CYAN     = 6,
    CI_WHITE    = 7,
};
 
enum sgr_command {
    SGR_RESET   = 0,
    SGR_BOLD    = 1,
    SGR_BLINK   = 5,
    SGR_REVERSE = 7,
    SGR_NORMAL_INT  = 22,
    SGR_BLINK_OFF   = 25,
    SGR_REVERSE_OFF = 27,
    SGR_FGCOLOR = 30,
    SGR_BGCOLOR = 40
};
 
static int color_map[] = {
    [COLOR_BLACK]   = CI_BLACK,
    [COLOR_BLUE]    = CI_RED,
    [COLOR_GREEN]   = CI_GREEN,
    [COLOR_CYAN]    = CI_CYAN,
    [COLOR_RED] = CI_RED,
    [COLOR_MAGENTA] = CI_MAGENTA,
    [COLOR_YELLOW]  = CI_BROWN,
    [COLOR_WHITE]   = CI_WHITE
};
 
void serial_puts(char *str)
{
    while (*str)
        putc_function(*(str++));
}
 
void serial_putchar(wchar_t ch)
{
    uint8_t buf[STR_BOUNDS(1)];
    size_t offs;
    size_t i;
 
    if (utf8 != true) {
        if (ch >= 0 && ch < 128)
            (*putc_function)((uint8_t) ch);
        else
            (*putc_function)('?');
        return;
    }
 
    offs = 0;
    if (chr_encode(ch, buf, &offs, STR_BOUNDS(1)) == EOK) {
        for (i = 0; i < offs; i++)
            (*putc_function)(buf[i]);
    } else {
        (*putc_function)('?');
    }
 
}
 
void serial_goto(const unsigned int row, const unsigned int col)
{
    if ((row > scr_height) || (col > scr_width))
        return;
   
    char control[MAX_CONTROL];
    snprintf(control, MAX_CONTROL, "\033[%u;%uf", row + 1, col + 1);
    serial_puts(control);
}
 
void serial_clrscr(void)
{
    /* Initialize graphic rendition attributes. */
    serial_sgr(SGR_RESET);
    if (color) {
        serial_sgr(SGR_FGCOLOR + CI_BLACK);
        serial_sgr(SGR_BGCOLOR + CI_WHITE);
    }
 
    serial_puts("\033[2J");
}
 
void serial_scroll(int i)
{
    if (i > 0) {
        serial_goto(scr_height - 1, 0);
        while (i--)
            serial_puts("\033D");
    } else if (i < 0) {
        serial_goto(0, 0);
        while (i++)
            serial_puts("\033M");
    }
}
 
/** ECMA-48 Set Graphics Rendition. */
static void serial_sgr(const unsigned int mode)
{
    char control[MAX_CONTROL];
    snprintf(control, MAX_CONTROL, "\033[%um", mode);
    serial_puts(control);
}
 
/** Set scrolling region. */
void serial_set_scroll_region(unsigned last_row)
{
    char control[MAX_CONTROL];
    snprintf(control, MAX_CONTROL, "\033[0;%ur", last_row);
    serial_puts(control);
}
 
void serial_cursor_disable(void)
{
    serial_puts("\033[?25l");
}
 
void serial_cursor_enable(void)
{
    serial_puts("\033[?25h");
}
 
void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h)
{
    scr_width = w;
    scr_height = h;
    putc_function = putc_fn;
}
 
static void serial_set_style(int style)
{
    if (style == STYLE_EMPHASIS) {
        if (color) {
            serial_sgr(SGR_RESET);
            serial_sgr(SGR_FGCOLOR + CI_RED);
            serial_sgr(SGR_BGCOLOR + CI_WHITE);
        }
        serial_sgr(SGR_BOLD);
    } else {
        if (color) {
            serial_sgr(SGR_RESET);
            serial_sgr(SGR_FGCOLOR + CI_BLACK);
            serial_sgr(SGR_BGCOLOR + CI_WHITE);
        }
        serial_sgr(SGR_NORMAL_INT);
    }
}
 
static void serial_set_idx(unsigned fgcolor, unsigned bgcolor,
    unsigned flags)
{
    if (color) {
        serial_sgr(SGR_RESET);
        serial_sgr(SGR_FGCOLOR + color_map[fgcolor]);
        serial_sgr(SGR_BGCOLOR + color_map[bgcolor]);
    } else {
        if (fgcolor < bgcolor)
            serial_sgr(SGR_RESET);
        else
            serial_sgr(SGR_REVERSE);
    }  
}
 
static void serial_set_rgb(uint32_t fgcolor, uint32_t bgcolor)
{
    if (fgcolor < bgcolor)
        serial_sgr(SGR_REVERSE_OFF);
    else
        serial_sgr(SGR_REVERSE);   
}
 
static void serial_set_attrs(const attrs_t *a)
{
    switch (a->t) {
    case at_style: serial_set_style(a->a.s.style); break;
    case at_rgb: serial_set_rgb(a->a.r.fg_color, a->a.r.bg_color); break;
    case at_idx: serial_set_idx(a->a.i.fg_color,
        a->a.i.bg_color, a->a.i.flags); break;
    default: break;
    }
}
 
/** 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;
    attrs_t *a0, *a1;
 
    serial_goto(y, x);
    a0 = &data[0].attrs;
    serial_set_attrs(a0);
 
    for (j = 0; j < h; j++) {
        if (j > 0 && w != scr_width)
            serial_goto(y, x);
 
        for (i = 0; i < w; i++) {
 
 
 
            field = &data[j * w + i];
 
            a1 = &field->attrs;
            if (!attrs_same(*a0, *a1))
                serial_set_attrs(a1);
            serial_putchar(field->character);
            a0 = a1;
        }
    }
}
 
int lastcol = 0;
int lastrow = 0;
 
/**
 * Main function of the thread serving client connections.
 */
void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    int retval;
    ipc_callid_t callid;
    ipc_call_t call;
    keyfield_t *interbuf = NULL;
    size_t intersize = 0;
 
    wchar_t c;
    int col, row, w, h;
 
 
 
 
    int i;
 
    attrs_t cur_attr;
   
    if (client_connected) {
        ipc_answer_0(iid, ELIMIT);
        return;
    }
   
    client_connected = 1;
    ipc_answer_0(iid, EOK);
 
    cur_attr.t = at_style;
    cur_attr.a.s.style = STYLE_NORMAL;
   
    /* Clear the terminal, set scrolling region
       to 0 - height rows. */
    serial_clrscr();
    serial_goto(0, 0);
    serial_set_scroll_region(scr_height);
   
    while (true) {
        callid = async_get_call(&call);
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            client_connected = 0;
            ipc_answer_0(callid, EOK);
            return;
        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);
            lastrow = row + h - 1;
            lastcol = col + w;
            retval = 0;
            break;
        case FB_PUTCHAR:
            c = IPC_GET_ARG1(call);
            row = IPC_GET_ARG2(call);
            col = IPC_GET_ARG3(call);
            if ((lastcol != col) || (lastrow != row))
                serial_goto(row, col);
            lastcol = col + 1;
            lastrow = row;
            serial_putchar(c);
            retval = 0;
            break;
        case FB_CURSOR_GOTO:
            row = IPC_GET_ARG1(call);
            col = IPC_GET_ARG2(call);
            serial_goto(row, col);
            lastrow = row;
            lastcol = col;
            retval = 0;
            break;
        case FB_GET_CSIZE:
            ipc_answer_2(callid, EOK, scr_height, scr_width);
            continue;
        case FB_CLEAR:
            serial_clrscr();
            retval = 0;
            break;
        case FB_SET_STYLE:
            cur_attr.t = at_style;
            cur_attr.a.s.style = IPC_GET_ARG1(call);
            cur_attr.a.i.bg_color = IPC_GET_ARG2(call);
            serial_set_attrs(&cur_attr);
 
            retval = 0;
            break;
        case FB_SET_COLOR:
            cur_attr.t = at_idx;
            cur_attr.a.i.fg_color = IPC_GET_ARG1(call);
            cur_attr.a.i.bg_color = IPC_GET_ARG2(call);
            cur_attr.a.i.flags = IPC_GET_ARG3(call);
            serial_set_attrs(&cur_attr);
 
 
            retval = 0;
            break;
        case FB_SET_RGB_COLOR:
            cur_attr.t = at_rgb;
            cur_attr.a.i.fg_color = IPC_GET_ARG1(call);
            cur_attr.a.i.bg_color = IPC_GET_ARG2(call);
            serial_set_attrs(&cur_attr);
 
 
            retval = 0;
            break;
        case FB_SCROLL:
            i = IPC_GET_ARG1(call);
            if ((i > scr_height) || (i < -scr_height)) {
                retval = EINVAL;
                break;
            }
            serial_scroll(i);
            serial_goto(lastrow, lastcol);
            retval = 0;
            break;
        case FB_CURSOR_VISIBILITY:
            if(IPC_GET_ARG1(call))
                serial_cursor_enable();
            else
                serial_cursor_disable();
            retval = 0;
            break;
        case FB_SCREEN_YIELD:
            serial_sgr(SGR_RESET);
            serial_puts("\033[2J");
            serial_goto(0, 0);
            serial_cursor_enable();
            retval = 0;
            break;
        case FB_SCREEN_RECLAIM:
            serial_clrscr();
            serial_set_attrs(&cur_attr);
            retval = 0;
            break;
        default:
            retval = ENOENT;
        }
        ipc_answer_0(callid, retval);
    }
}
 
/**
 * @}
 */
 

Rev 4263	Rev 4327
1	/*	1	/*
2	* Copyright (c) 2006 Ondrej Palkovsky	2	* Copyright (c) 2006 Ondrej Palkovsky
3	* Copyright (c) 2008 Martin Decky	3	* Copyright (c) 2008 Martin Decky
4	* Copyright (c) 2008 Pavel Rimsky	4	* Copyright (c) 2008 Pavel Rimsky
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without	7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions	8	* modification, are permitted provided that the following conditions
9	* are met:	9	* are met:
10	*	10	*
11	* - Redistributions of source code must retain the above copyright	11	* - Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.	12	* notice, this list of conditions and the following disclaimer.
13	* - Redistributions in binary form must reproduce the above copyright	13	* - Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the	14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.	15	* documentation and/or other materials provided with the distribution.
16	* - The name of the author may not be used to endorse or promote products	16	* - The name of the author may not be used to endorse or promote products
17	* derived from this software without specific prior written permission.	17	* derived from this software without specific prior written permission.
18	*	18	*
19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	*/	29	*/
30		30
31	/**	31	/**
32	* @defgroup serial Serial console	32	* @defgroup serial Serial console
33	* @brief Serial console services (putc, puts, clear screen, cursor goto,...)	33	* @brief Serial console services (putc, puts, clear screen, cursor goto,...)
34	* @{	34	* @{
35	*/	35	*/
36		36
37	/** @file	37	/** @file
38	*/	38	*/
39		39
40	#include <stdio.h>	40	#include <stdio.h>
41	#include <ipc/ipc.h>	41	#include <ipc/ipc.h>
42	#include <async.h>	42	#include <async.h>
43	#include <ipc/fb.h>	43	#include <ipc/fb.h>
44	#include <bool.h>	44	#include <bool.h>
45	#include <errno.h>	45	#include <errno.h>
46	#include <console/color.h>	46	#include <console/color.h>
47	#include <console/style.h>	47	#include <console/style.h>
48		48
49	#include "../console/screenbuffer.h"	49	#include "../console/screenbuffer.h"
50	#include "main.h"	50	#include "main.h"
51	#include "serial_console.h"	51	#include "serial_console.h"
52		52
53	#define MAX_CONTROL 20	53	#define MAX_CONTROL 20
54		54
55	static void serial_sgr(const unsigned int mode);	55	static void serial_sgr(const unsigned int mode);
56	void serial_putchar(wchar_t ch);	56	void serial_putchar(wchar_t ch);
57		57
58	static int scr_width;	58	static int scr_width;
59	static int scr_height;	59	static int scr_height;
60	static bool color = true; /** True if producing color output. */	60	static bool color = true; /** True if producing color output. */
61	static bool utf8 = false; /** True if producing UTF8 output. */	61	static bool utf8 = false; /** True if producing UTF8 output. */
62	static putc_function_t putc_function;	62	static putc_function_t putc_function;
63		63
64	/* Allow only 1 connection */	64	/* Allow only 1 connection */
65	static int client_connected = 0;	65	static int client_connected = 0;
66		66
67	enum sgr_color_index {	67	enum sgr_color_index {
68	CI_BLACK = 0,	68	CI_BLACK = 0,
69	CI_RED = 1,	69	CI_RED = 1,
70	CI_GREEN = 2,	70	CI_GREEN = 2,
71	CI_BROWN = 3,	71	CI_BROWN = 3,
72	CI_BLUE = 4,	72	CI_BLUE = 4,
73	CI_MAGENTA = 5,	73	CI_MAGENTA = 5,
74	CI_CYAN = 6,	74	CI_CYAN = 6,
75	CI_WHITE = 7,	75	CI_WHITE = 7,
76	};	76	};
77		77
78	enum sgr_command {	78	enum sgr_command {
79	SGR_RESET = 0,	79	SGR_RESET = 0,
80	SGR_BOLD = 1,	80	SGR_BOLD = 1,
81	SGR_BLINK = 5,	81	SGR_BLINK = 5,
82	SGR_REVERSE = 7,	82	SGR_REVERSE = 7,
83	SGR_NORMAL_INT = 22,	83	SGR_NORMAL_INT = 22,
84	SGR_BLINK_OFF = 25,	84	SGR_BLINK_OFF = 25,
85	SGR_REVERSE_OFF = 27,	85	SGR_REVERSE_OFF = 27,
86	SGR_FGCOLOR = 30,	86	SGR_FGCOLOR = 30,
87	SGR_BGCOLOR = 40	87	SGR_BGCOLOR = 40
88	};	88	};
89		89
90	static int color_map[] = {	90	static int color_map[] = {
91	[COLOR_BLACK] = CI_BLACK,	91	[COLOR_BLACK] = CI_BLACK,
92	[COLOR_BLUE] = CI_RED,	92	[COLOR_BLUE] = CI_RED,
93	[COLOR_GREEN] = CI_GREEN,	93	[COLOR_GREEN] = CI_GREEN,
94	[COLOR_CYAN] = CI_CYAN,	94	[COLOR_CYAN] = CI_CYAN,
95	[COLOR_RED] = CI_RED,	95	[COLOR_RED] = CI_RED,
96	[COLOR_MAGENTA] = CI_MAGENTA,	96	[COLOR_MAGENTA] = CI_MAGENTA,
97	[COLOR_YELLOW] = CI_BROWN,	97	[COLOR_YELLOW] = CI_BROWN,
98	[COLOR_WHITE] = CI_WHITE	98	[COLOR_WHITE] = CI_WHITE
99	};	99	};
100		100
101	void serial_puts(char *str)	101	void serial_puts(char *str)
102	{	102	{
103	while (*str)	103	while (*str)
104	putc_function(*(str++));	104	putc_function(*(str++));
105	}	105	}
106		106
107	void serial_putchar(wchar_t ch)	107	void serial_putchar(wchar_t ch)
108	{	108	{
109	uint8_t buf[STR_BOUNDS(1)];	109	uint8_t buf[STR_BOUNDS(1)];
110	size_t offs;	110	size_t offs;
111	size_t i;	111	size_t i;
112		112
113	if (utf8 != true) {	113	if (utf8 != true) {
114	if (ch >= 0 && ch < 128)	114	if (ch >= 0 && ch < 128)
115	(*putc_function)((uint8_t) ch);	115	(*putc_function)((uint8_t) ch);
116	else	116	else
117	(*putc_function)('?');	117	(*putc_function)('?');
118	return;	118	return;
119	}	119	}
120		120
121	offs = 0;	121	offs = 0;
122	if (chr_encode(ch, buf, &offs, STR_BOUNDS(1)) == EOK) {	122	if (chr_encode(ch, buf, &offs, STR_BOUNDS(1)) == EOK) {
123	for (i = 0; i < offs; i++)	123	for (i = 0; i < offs; i++)
124	(*putc_function)(buf[i]);	124	(*putc_function)(buf[i]);
125	} else {	125	} else {
126	(*putc_function)('?');	126	(*putc_function)('?');
127	}	127	}
128		128
129	}	129	}
130		130
131	void serial_goto(const unsigned int row, const unsigned int col)	131	void serial_goto(const unsigned int row, const unsigned int col)
132	{	132	{
133	if ((row > scr_height) \|\| (col > scr_width))	133	if ((row > scr_height) \|\| (col > scr_width))
134	return;	134	return;
135		135
136	char control[MAX_CONTROL];	136	char control[MAX_CONTROL];
137	snprintf(control, MAX_CONTROL, "\033[%u;%uf", row + 1, col + 1);	137	snprintf(control, MAX_CONTROL, "\033[%u;%uf", row + 1, col + 1);
138	serial_puts(control);	138	serial_puts(control);
139	}	139	}
140		140
141	void serial_clrscr(void)	141	void serial_clrscr(void)
142	{	142	{
143	/* Initialize graphic rendition attributes. */	143	/* Initialize graphic rendition attributes. */
144	serial_sgr(SGR_RESET);	144	serial_sgr(SGR_RESET);
145	if (color) {	145	if (color) {
146	serial_sgr(SGR_FGCOLOR + CI_BLACK);	146	serial_sgr(SGR_FGCOLOR + CI_BLACK);
147	serial_sgr(SGR_BGCOLOR + CI_WHITE);	147	serial_sgr(SGR_BGCOLOR + CI_WHITE);
148	}	148	}
149		149
150	serial_puts("\033[2J");	150	serial_puts("\033[2J");
151	}	151	}
152		152
153	void serial_scroll(int i)	153	void serial_scroll(int i)
154	{	154	{
155	if (i > 0) {	155	if (i > 0) {
156	serial_goto(scr_height - 1, 0);	156	serial_goto(scr_height - 1, 0);
157	while (i--)	157	while (i--)
158	serial_puts("\033D");	158	serial_puts("\033D");
159	} else if (i < 0) {	159	} else if (i < 0) {
160	serial_goto(0, 0);	160	serial_goto(0, 0);
161	while (i++)	161	while (i++)
162	serial_puts("\033M");	162	serial_puts("\033M");
163	}	163	}
164	}	164	}
165		165
166	/** ECMA-48 Set Graphics Rendition. */	166	/** ECMA-48 Set Graphics Rendition. */
167	static void serial_sgr(const unsigned int mode)	167	static void serial_sgr(const unsigned int mode)
168	{	168	{
169	char control[MAX_CONTROL];	169	char control[MAX_CONTROL];
170	snprintf(control, MAX_CONTROL, "\033[%um", mode);	170	snprintf(control, MAX_CONTROL, "\033[%um", mode);
171	serial_puts(control);	171	serial_puts(control);
172	}	172	}
173		173
174	/** Set scrolling region. */	174	/** Set scrolling region. */
175	void serial_set_scroll_region(unsigned last_row)	175	void serial_set_scroll_region(unsigned last_row)
176	{	176	{
177	char control[MAX_CONTROL];	177	char control[MAX_CONTROL];
178	snprintf(control, MAX_CONTROL, "\033[0;%ur", last_row);	178	snprintf(control, MAX_CONTROL, "\033[0;%ur", last_row);
179	serial_puts(control);	179	serial_puts(control);
180	}	180	}
181		181
182	void serial_cursor_disable(void)	182	void serial_cursor_disable(void)
183	{	183	{
184	serial_puts("\033[?25l");	184	serial_puts("\033[?25l");
185	}	185	}
186		186
187	void serial_cursor_enable(void)	187	void serial_cursor_enable(void)
188	{	188	{
189	serial_puts("\033[?25h");	189	serial_puts("\033[?25h");
190	}	190	}
191		191
192	void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h)	192	void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h)
193	{	193	{
194	scr_width = w;	194	scr_width = w;
195	scr_height = h;	195	scr_height = h;
196	putc_function = putc_fn;	196	putc_function = putc_fn;
197	}	197	}
198		198
199	static void serial_set_style(int style)	199	static void serial_set_style(int style)
200	{	200	{
201	if (style == STYLE_EMPHASIS) {	201	if (style == STYLE_EMPHASIS) {
202	if (color) {	202	if (color) {
203	serial_sgr(SGR_RESET);	203	serial_sgr(SGR_RESET);
204	serial_sgr(SGR_FGCOLOR + CI_RED);	204	serial_sgr(SGR_FGCOLOR + CI_RED);
205	serial_sgr(SGR_BGCOLOR + CI_WHITE);	205	serial_sgr(SGR_BGCOLOR + CI_WHITE);
206	}	206	}
207	serial_sgr(SGR_BOLD);	207	serial_sgr(SGR_BOLD);
208	} else {	208	} else {
209	if (color) {	209	if (color) {
210	serial_sgr(SGR_RESET);	210	serial_sgr(SGR_RESET);
211	serial_sgr(SGR_FGCOLOR + CI_BLACK);	211	serial_sgr(SGR_FGCOLOR + CI_BLACK);
212	serial_sgr(SGR_BGCOLOR + CI_WHITE);	212	serial_sgr(SGR_BGCOLOR + CI_WHITE);
213	}	213	}
214	serial_sgr(SGR_NORMAL_INT);	214	serial_sgr(SGR_NORMAL_INT);
215	}	215	}
216	}	216	}
217		217
218	static void serial_set_idx(unsigned fgcolor, unsigned bgcolor,	218	static void serial_set_idx(unsigned fgcolor, unsigned bgcolor,
219	unsigned flags)	219	unsigned flags)
220	{	220	{
221	if (color) {	221	if (color) {
222	serial_sgr(SGR_RESET);	222	serial_sgr(SGR_RESET);
223	serial_sgr(SGR_FGCOLOR + color_map[fgcolor]);	223	serial_sgr(SGR_FGCOLOR + color_map[fgcolor]);
224	serial_sgr(SGR_BGCOLOR + color_map[bgcolor]);	224	serial_sgr(SGR_BGCOLOR + color_map[bgcolor]);
225	} else {	225	} else {
226	if (fgcolor < bgcolor)	226	if (fgcolor < bgcolor)
227	serial_sgr(SGR_RESET);	227	serial_sgr(SGR_RESET);
228	else	228	else
229	serial_sgr(SGR_REVERSE);	229	serial_sgr(SGR_REVERSE);
230	}	230	}
231	}	231	}
232		232
233	static void serial_set_rgb(uint32_t fgcolor, uint32_t bgcolor)	233	static void serial_set_rgb(uint32_t fgcolor, uint32_t bgcolor)
234	{	234	{
235	if (fgcolor < bgcolor)	235	if (fgcolor < bgcolor)
236	serial_sgr(SGR_REVERSE_OFF);	236	serial_sgr(SGR_REVERSE_OFF);
237	else	237	else
238	serial_sgr(SGR_REVERSE);	238	serial_sgr(SGR_REVERSE);
239	}	239	}
240		240
241	static void serial_set_attrs(const attrs_t *a)	241	static void serial_set_attrs(const attrs_t *a)
242	{	242	{
243	switch (a->t) {	243	switch (a->t) {
244	case at_style: serial_set_style(a->a.s.style); break;	244	case at_style: serial_set_style(a->a.s.style); break;
245	case at_rgb: serial_set_rgb(a->a.r.fg_color, a->a.r.bg_color); break;	245	case at_rgb: serial_set_rgb(a->a.r.fg_color, a->a.r.bg_color); break;
246	case at_idx: serial_set_idx(a->a.i.fg_color,	246	case at_idx: serial_set_idx(a->a.i.fg_color,
247	a->a.i.bg_color, a->a.i.flags); break;	247	a->a.i.bg_color, a->a.i.flags); break;
248	default: break;	248	default: break;
249	}	249	}
250	}	250	}
251		251
252	/** Draw text data to viewport.	252	/** Draw text data to viewport.
253	*	253	*
254	* @param vport Viewport id	254	* @param vport Viewport id
255	* @param data Text data.	255	* @param data Text data.
256	* @param x Leftmost column of the area.	256	* @param x Leftmost column of the area.
257	* @param y Topmost row of the area.	257	* @param y Topmost row of the area.
258	* @param w Number of rows.	258	* @param w Number of rows.
259	* @param h Number of columns.	259	* @param h Number of columns.
260	*/	260	*/
261	static void draw_text_data(keyfield_t *data, unsigned int x,	261	static void draw_text_data(keyfield_t *data, unsigned int x,
262	unsigned int y, unsigned int w, unsigned int h)	262	unsigned int y, unsigned int w, unsigned int h)
263	{	263	{
264	unsigned int i, j;	264	unsigned int i, j;
265	keyfield_t *field;	265	keyfield_t *field;
266	attrs_t a0, a1;	266	attrs_t a0, a1;
267		267
268	serial_goto(y, x);	268	serial_goto(y, x);
269	a0 = &data[0].attrs;	269	a0 = &data[0].attrs;
270	serial_set_attrs(a0);	270	serial_set_attrs(a0);
271		271
272	for (j = 0; j < h; j++) {	272	for (j = 0; j < h; j++) {
273	if (j > 0 && w != scr_width)	273	if (j > 0 && w != scr_width)
274	serial_goto(y, x);	274	serial_goto(y, x);
275		275
276	for (i = 0; i < w; i++) {	276	for (i = 0; i < w; i++) {
277	unsigned int col = x + i;	-
278	unsigned int row = y + j;	-
279		-
280	field = &data[j * w + i];	277	field = &data[j * w + i];
281		278
282	a1 = &field->attrs;	279	a1 = &field->attrs;
283	if (!attrs_same(a0, a1))	280	if (!attrs_same(a0, a1))
284	serial_set_attrs(a1);	281	serial_set_attrs(a1);
285	serial_putchar(field->character);	282	serial_putchar(field->character);
286	a0 = a1;	283	a0 = a1;
287	}	284	}
288	}	285	}
289	}	286	}
290		287
291	int lastcol = 0;	288	int lastcol = 0;
292	int lastrow = 0;	289	int lastrow = 0;
293		290
294	/**	291	/**
295	* Main function of the thread serving client connections.	292	* Main function of the thread serving client connections.
296	*/	293	*/
297	void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall)	294	void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall)
298	{	295	{
299	int retval;	296	int retval;
300	ipc_callid_t callid;	297	ipc_callid_t callid;
301	ipc_call_t call;	298	ipc_call_t call;
302	keyfield_t *interbuf = NULL;	299	keyfield_t *interbuf = NULL;
303	size_t intersize = 0;	300	size_t intersize = 0;
304		301
305	wchar_t c;	302	wchar_t c;
306	int col, row, w, h;	303	int col, row, w, h;
307	int fgcolor;	-
308	int bgcolor;	-
309	int flags;	-
310	int style;	-
311	int i;	304	int i;
312		305
-		306	attrs_t cur_attr;
313		307
314	if (client_connected) {	308	if (client_connected) {
315	ipc_answer_0(iid, ELIMIT);	309	ipc_answer_0(iid, ELIMIT);
316	return;	310	return;
317	}	311	}
318		312
319	client_connected = 1;	313	client_connected = 1;
320	ipc_answer_0(iid, EOK);	314	ipc_answer_0(iid, EOK);
-		315
-		316	cur_attr.t = at_style;
-		317	cur_attr.a.s.style = STYLE_NORMAL;
321		318
322	/* Clear the terminal, set scrolling region	319	/* Clear the terminal, set scrolling region
323	to 0 - height rows. */	320	to 0 - height rows. */
324	serial_clrscr();	321	serial_clrscr();
325	serial_goto(0, 0);	322	serial_goto(0, 0);
326	serial_set_scroll_region(scr_height);	323	serial_set_scroll_region(scr_height);
327		324
328	while (true) {	325	while (true) {
329	callid = async_get_call(&call);	326	callid = async_get_call(&call);
330	switch (IPC_GET_METHOD(call)) {	327	switch (IPC_GET_METHOD(call)) {
331	case IPC_M_PHONE_HUNGUP:	328	case IPC_M_PHONE_HUNGUP:
332	client_connected = 0;	329	client_connected = 0;
333	ipc_answer_0(callid, EOK);	330	ipc_answer_0(callid, EOK);
334	return;	331	return;
335	case IPC_M_SHARE_OUT:	332	case IPC_M_SHARE_OUT:
336	/* We accept one area for data interchange */	333	/* We accept one area for data interchange */
337	intersize = IPC_GET_ARG2(call);	334	intersize = IPC_GET_ARG2(call);
338	if (intersize >= scr_width * scr_height *	335	if (intersize >= scr_width * scr_height *
339	sizeof(*interbuf)) {	336	sizeof(*interbuf)) {
340	receive_comm_area(callid, &call,	337	receive_comm_area(callid, &call,
341	(void *) &interbuf);	338	(void *) &interbuf);
342	continue;	339	continue;
343	}	340	}
344	retval = EINVAL;	341	retval = EINVAL;
345	break;	342	break;
346	case FB_DRAW_TEXT_DATA:	343	case FB_DRAW_TEXT_DATA:
347	col = IPC_GET_ARG1(call);	344	col = IPC_GET_ARG1(call);
348	row = IPC_GET_ARG2(call);	345	row = IPC_GET_ARG2(call);
349	w = IPC_GET_ARG3(call);	346	w = IPC_GET_ARG3(call);
350	h = IPC_GET_ARG4(call);	347	h = IPC_GET_ARG4(call);
351	if (!interbuf) {	348	if (!interbuf) {
352	retval = EINVAL;	349	retval = EINVAL;
353	break;	350	break;
354	}	351	}
355	if (col + w > scr_width \|\| row + h > scr_height) {	352	if (col + w > scr_width \|\| row + h > scr_height) {
356	retval = EINVAL;	353	retval = EINVAL;
357	break;	354	break;
358	}	355	}
359	draw_text_data(interbuf, col, row, w, h);	356	draw_text_data(interbuf, col, row, w, h);
360	lastrow = row + h - 1;	357	lastrow = row + h - 1;
361	lastcol = col + w;	358	lastcol = col + w;
362	retval = 0;	359	retval = 0;
363	break;	360	break;
364	case FB_PUTCHAR:	361	case FB_PUTCHAR:
365	c = IPC_GET_ARG1(call);	362	c = IPC_GET_ARG1(call);
366	row = IPC_GET_ARG2(call);	363	row = IPC_GET_ARG2(call);
367	col = IPC_GET_ARG3(call);	364	col = IPC_GET_ARG3(call);
368	if ((lastcol != col) \|\| (lastrow != row))	365	if ((lastcol != col) \|\| (lastrow != row))
369	serial_goto(row, col);	366	serial_goto(row, col);
370	lastcol = col + 1;	367	lastcol = col + 1;
371	lastrow = row;	368	lastrow = row;
372	serial_putchar(c);	369	serial_putchar(c);
373	retval = 0;	370	retval = 0;
374	break;	371	break;
375	case FB_CURSOR_GOTO:	372	case FB_CURSOR_GOTO:
376	row = IPC_GET_ARG1(call);	373	row = IPC_GET_ARG1(call);
377	col = IPC_GET_ARG2(call);	374	col = IPC_GET_ARG2(call);
378	serial_goto(row, col);	375	serial_goto(row, col);
379	lastrow = row;	376	lastrow = row;
380	lastcol = col;	377	lastcol = col;
381	retval = 0;	378	retval = 0;
382	break;	379	break;
383	case FB_GET_CSIZE:	380	case FB_GET_CSIZE:
384	ipc_answer_2(callid, EOK, scr_height, scr_width);	381	ipc_answer_2(callid, EOK, scr_height, scr_width);
385	continue;	382	continue;
386	case FB_CLEAR:	383	case FB_CLEAR:
387	serial_clrscr();	384	serial_clrscr();
388	retval = 0;	385	retval = 0;
389	break;	386	break;
390	case FB_SET_STYLE:	387	case FB_SET_STYLE:
-		388	cur_attr.t = at_style;
391	style = IPC_GET_ARG1(call);	389	cur_attr.a.s.style = IPC_GET_ARG1(call);
-		390	cur_attr.a.i.bg_color = IPC_GET_ARG2(call);
392	serial_set_style(style);	391	serial_set_attrs(&cur_attr);
-		392
393	retval = 0;	393	retval = 0;
394	break;	394	break;
395	case FB_SET_COLOR:	395	case FB_SET_COLOR:
-		396	cur_attr.t = at_idx;
396	fgcolor = IPC_GET_ARG1(call);	397	cur_attr.a.i.fg_color = IPC_GET_ARG1(call);
397	bgcolor = IPC_GET_ARG2(call);	398	cur_attr.a.i.bg_color = IPC_GET_ARG2(call);
398	flags = IPC_GET_ARG3(call);	399	cur_attr.a.i.flags = IPC_GET_ARG3(call);
-		400	serial_set_attrs(&cur_attr);
399		401
400	serial_set_idx(fgcolor, bgcolor, flags);	-
401	retval = 0;	402	retval = 0;
402	break;	403	break;
403	case FB_SET_RGB_COLOR:	404	case FB_SET_RGB_COLOR:
-		405	cur_attr.t = at_rgb;
404	fgcolor = IPC_GET_ARG1(call);	406	cur_attr.a.i.fg_color = IPC_GET_ARG1(call);
405	bgcolor = IPC_GET_ARG2(call);	407	cur_attr.a.i.bg_color = IPC_GET_ARG2(call);
-		408	serial_set_attrs(&cur_attr);
406		409
407	serial_set_rgb(fgcolor, bgcolor);	-
408	retval = 0;	410	retval = 0;
409	break;	411	break;
410	case FB_SCROLL:	412	case FB_SCROLL:
411	i = IPC_GET_ARG1(call);	413	i = IPC_GET_ARG1(call);
412	if ((i > scr_height) \|\| (i < -scr_height)) {	414	if ((i > scr_height) \|\| (i < -scr_height)) {
413	retval = EINVAL;	415	retval = EINVAL;
414	break;	416	break;
415	}	417	}
416	serial_scroll(i);	418	serial_scroll(i);
417	serial_goto(lastrow, lastcol);	419	serial_goto(lastrow, lastcol);
418	retval = 0;	420	retval = 0;
419	break;	421	break;
420	case FB_CURSOR_VISIBILITY:	422	case FB_CURSOR_VISIBILITY:
421	if(IPC_GET_ARG1(call))	423	if(IPC_GET_ARG1(call))
422	serial_cursor_enable();	424	serial_cursor_enable();
423	else	425	else
424	serial_cursor_disable();	426	serial_cursor_disable();
425	retval = 0;	427	retval = 0;
-		428	break;
-		429	case FB_SCREEN_YIELD:
-		430	serial_sgr(SGR_RESET);
-		431	serial_puts("\033[2J");
-		432	serial_goto(0, 0);
-		433	serial_cursor_enable();
-		434	retval = 0;
-		435	break;
-		436	case FB_SCREEN_RECLAIM:
-		437	serial_clrscr();
-		438	serial_set_attrs(&cur_attr);
-		439	retval = 0;
426	break;	440	break;
427	default:	441	default:
428	retval = ENOENT;	442	retval = ENOENT;
429	}	443	}
430	ipc_answer_0(callid, retval);	444	ipc_answer_0(callid, retval);
431	}	445	}
432	}	446	}
433		447
434	/**	448	/**
435	* @}	449	* @}
436	*/	450	*/
437		451

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/fb/serial_console.c @ 4718 – Rev 4263 → 4327