WebSVN – HelenOS – Diff – /branches/sparc/uspace/srv/console/console.c


/*
 * Copyright (c) 2006 Josef Cejka
 * 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.
 */
 
/** @addtogroup console
 * @{
 */
/** @file
 */
 
#include <libc.h>
#include <fb.h>
#include <ipc/ipc.h>
#include <keys.h>
#include <ipc/fb.h>
#include <ipc/services.h>
#include <errno.h>
#include <key_buffer.h>
#include <console.h>
#include <unistd.h>
#include <async.h>
#include <libadt/fifo.h>
#include <screenbuffer.h>
#include <sys/mman.h>
#include <stdio.h>
 
#include "gcons.h"
 
#define MAX_KEYREQUESTS_BUFFERED 32
 
#define NAME "console"
 
/** Index of currently used virtual console.
 */
int active_console = 0;
 
/** Information about framebuffer
 */
struct {
    int phone;      /**< Framebuffer phone */
    ipcarg_t rows;      /**< Framebuffer rows */
    ipcarg_t cols;      /**< Framebuffer columns */
} fb_info;
 
typedef struct {
    keybuffer_t keybuffer;      /**< Buffer for incoming keys. */
    /** Buffer for unsatisfied request for keys. */
    FIFO_CREATE_STATIC(keyrequests, ipc_callid_t,
        MAX_KEYREQUESTS_BUFFERED); 
    int keyrequest_counter;     /**< Number of requests in buffer. */
    int client_phone;       /**< Phone to connected client. */
    int used;           /**< 1 if this virtual console is
                     * connected to some client.*/
    screenbuffer_t screenbuffer;    /**< Screenbuffer for saving screen
                     * contents and related settings. */
} connection_t;
 
static connection_t connections[CONSOLE_COUNT]; /**< Array of data for virtual
                         * consoles */
static keyfield_t *interbuffer = NULL;      /**< Pointer to memory shared
                         * with framebufer used for
                         * faster virtual console
                         * switching */
 
 
/** Find unused virtual console.
 *
 */
static int find_free_connection(void)
{
    int i;
   
    for (i = 0; i < CONSOLE_COUNT; i++) {
        if (!connections[i].used)
            return i;
    }
    return -1;
}
 
static void clrscr(void)
{
    async_msg_0(fb_info.phone, FB_CLEAR);
}
 
static void curs_visibility(bool visible)
{
    async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible);
}
 
static void curs_hide_sync(void)
{
    ipc_call_sync_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
}
 
static void curs_goto(int row, int col)
{
    async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col);
}
 
static void set_style(style_t *style)
{
    async_msg_2(fb_info.phone, FB_SET_STYLE, style->fg_color,
        style->bg_color);
}
 
static void set_style_col(int fgcolor, int bgcolor)
{
    async_msg_2(fb_info.phone, FB_SET_STYLE, fgcolor, bgcolor);
}
 
static void prtchr(char c, int row, int col)
{
    async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);
}
 
/** Check key and process special keys.
 *
 *
 */
static void write_char(int console, char key)
{
    screenbuffer_t *scr = &(connections[console].screenbuffer);
   
    switch (key) {
    case '\n':
        scr->position_y++;
        scr->position_x = 0;
        break;
    case '\r':
        break;
    case '\t':
        scr->position_x += 8;
        scr->position_x -= scr->position_x % 8;
        break;
    case '\b':
        if (scr->position_x == 0)
            break;
        scr->position_x--;
        if (console == active_console)
            prtchr(' ', scr->position_y, scr->position_x);
        screenbuffer_putchar(scr, ' ');
        break;
    default:   
        if (console == active_console)
            prtchr(key, scr->position_y, scr->position_x);
 
        screenbuffer_putchar(scr, key);
        scr->position_x++;
    }
   
    scr->position_y += (scr->position_x >= scr->size_x);
   
    if (scr->position_y >= scr->size_y) {
        scr->position_y = scr->size_y - 1;
        screenbuffer_clear_line(scr, scr->top_line);
        scr->top_line = (scr->top_line + 1) % scr->size_y;
        if (console == active_console)
            async_msg_1(fb_info.phone, FB_SCROLL, 1);
    }
   
    scr->position_x = scr->position_x % scr->size_x;
   
    if (console == active_console)
        curs_goto(scr->position_y, scr->position_x);
   
}
 
/** Switch to new console */
static void change_console(int newcons)
{
    connection_t *conn;
    int i, j, rc;
    keyfield_t *field;
    style_t *style;
   
    if (newcons == active_console)
        return;
   
    if (newcons == KERNEL_CONSOLE) {
        async_serialize_start();
        curs_hide_sync();
        gcons_in_kernel();
        async_serialize_end();
       
        if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE))
            active_console = KERNEL_CONSOLE;
        else
            newcons = active_console;
    }
   
    if (newcons != KERNEL_CONSOLE) {
        async_serialize_start();
       
        if (active_console == KERNEL_CONSOLE)
            gcons_redraw_console();
       
        active_console = newcons;
        gcons_change_console(newcons);
        conn = &connections[active_console];
       
        set_style(&conn->screenbuffer.style);
        curs_visibility(false);
        if (interbuffer) {
            for (i = 0; i < conn->screenbuffer.size_x; i++)
                for (j = 0; j < conn->screenbuffer.size_y; j++) {
                    unsigned int size_x;
                   
                    size_x = conn->screenbuffer.size_x;
                    interbuffer[i + j * size_x] =
                        *get_field_at(&conn->screenbuffer, i, j);
                }
            /* This call can preempt, but we are already at the end */
            rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);      
        }
       
        if ((!interbuffer) || (rc != 0)) {
            set_style(&conn->screenbuffer.style);
            clrscr();
            style = &conn->screenbuffer.style;
           
            for (j = 0; j < conn->screenbuffer.size_y; j++)
                for (i = 0; i < conn->screenbuffer.size_x; i++) {
                    field = get_field_at(&conn->screenbuffer, i, j);
                    if (!style_same(*style, field->style))
                        set_style(&field->style);
                    style = &field->style;
                    if ((field->character == ' ') &&
                        (style_same(field->style,
                        conn->screenbuffer.style)))
                        continue;
                   
                    prtchr(field->character, j, i);
                }
        }
       
        curs_goto(conn->screenbuffer.position_y,
            conn->screenbuffer.position_x);
        curs_visibility(conn->screenbuffer.is_cursor_visible);
       
        async_serialize_end();
    }
}
 
/** Handler for keyboard */
static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
{
    ipc_callid_t callid;
    ipc_call_t call;
    int retval;
    int c;
    connection_t *conn;
    int newcon;
   
    /* Ignore parameters, the connection is alread opened */
    while (1) {
        callid = async_get_call(&call);
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            /* TODO: Handle hangup */
            return;
        case KBD_MS_LEFT:
            newcon = gcons_mouse_btn(IPC_GET_ARG1(call));
            if (newcon != -1)
                change_console(newcon);
            retval = 0;
            break;
        case KBD_MS_MOVE:
            gcons_mouse_move(IPC_GET_ARG1(call),
                IPC_GET_ARG2(call));
            retval = 0;
            break;
        case KBD_PUSHCHAR:
            /* got key from keyboard driver */
            retval = 0;
            c = IPC_GET_ARG1(call);
            /* switch to another virtual console */
           
            conn = &connections[active_console];
/*
 *          if ((c >= KBD_KEY_F1) && (c < KBD_KEY_F1 +
 *              CONSOLE_COUNT)) {
 */
            if ((c >= 0x101) && (c < 0x101 + CONSOLE_COUNT)) {
                if (c == 0x112)
                    change_console(KERNEL_CONSOLE);
                else
                    change_console(c - 0x101);
                break;
            }
           
            /* if client is awaiting key, send it */
            if (conn->keyrequest_counter > 0) {    
                conn->keyrequest_counter--;
                ipc_answer_1(fifo_pop(conn->keyrequests), EOK,
                    c);
                break;
            }
           
            keybuffer_push(&conn->keybuffer, c);
            retval = 0;
           
            break;
        default:
            retval = ENOENT;
        }
        ipc_answer_0(callid, retval);
    }
}
 
/** Default thread for new connections */
static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    ipc_callid_t callid;
    ipc_call_t call;
    int consnum;
    ipcarg_t arg1, arg2;
    connection_t *conn;
 
    if ((consnum = find_free_connection()) == -1) {
        ipc_answer_0(iid, ELIMIT);
        return;
    }
    conn = &connections[consnum];
    conn->used = 1;
   
    async_serialize_start();
    gcons_notify_connect(consnum);
    conn->client_phone = IPC_GET_ARG5(*icall);
    screenbuffer_clear(&conn->screenbuffer);
   
    /* Accept the connection */
    ipc_answer_0(iid, EOK);
 
    while (1) {
        async_serialize_end();
        callid = async_get_call(&call);
        async_serialize_start();
 
        arg1 = 0;
        arg2 = 0;
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            gcons_notify_disconnect(consnum);
           
            /* Answer all pending requests */
            while (conn->keyrequest_counter > 0) {     
                conn->keyrequest_counter--;
                ipc_answer_0(fifo_pop(conn->keyrequests),
                    ENOENT);
                break;
            }
            conn->used = 0;
            return;
        case CONSOLE_PUTCHAR:
            write_char(consnum, IPC_GET_ARG1(call));
            gcons_notify_char(consnum);
            break;
        case CONSOLE_CLEAR:
            /* Send message to fb */
            if (consnum == active_console) {
                async_msg_0(fb_info.phone, FB_CLEAR);
            }
           
            screenbuffer_clear(&conn->screenbuffer);
           
            break;
        case CONSOLE_GOTO:
            screenbuffer_goto(&conn->screenbuffer,
                IPC_GET_ARG2(call), IPC_GET_ARG1(call));
            if (consnum == active_console)
                curs_goto(IPC_GET_ARG1(call),
                    IPC_GET_ARG2(call));
            break;
        case CONSOLE_GETSIZE:
            arg1 = fb_info.rows;
            arg2 = fb_info.cols;
            break;
        case CONSOLE_FLUSH:
            if (consnum == active_console)
                async_req_0_0(fb_info.phone, FB_FLUSH);
            break;
        case CONSOLE_SET_STYLE:
            arg1 = IPC_GET_ARG1(call);
            arg2 = IPC_GET_ARG2(call);
            screenbuffer_set_style(&conn->screenbuffer, arg1,
                arg2);
            if (consnum == active_console)
                set_style_col(arg1, arg2);
            break;
        case CONSOLE_CURSOR_VISIBILITY:
            arg1 = IPC_GET_ARG1(call);
            conn->screenbuffer.is_cursor_visible = arg1;
            if (consnum == active_console)
                curs_visibility(arg1);
            break;
        case CONSOLE_GETCHAR:
            if (keybuffer_empty(&conn->keybuffer)) {
                /* buffer is empty -> store request */
                if (conn->keyrequest_counter <
                    MAX_KEYREQUESTS_BUFFERED) {
                    fifo_push(conn->keyrequests, callid);
                    conn->keyrequest_counter++;
                } else {
                    /*
                     * No key available and too many
                     * requests => fail.
                    */
                    ipc_answer_0(callid, ELIMIT);
                }
                continue;
            }
            int ch;
            keybuffer_pop(&conn->keybuffer, &ch);
            arg1 = ch;
            break;
        }
        ipc_answer_2(callid, EOK, arg1, arg2);
    }
}
 
int main(int argc, char *argv[])
{
    printf(NAME ": HelenOS Console service\n");
   
    ipcarg_t phonehash;
    int kbd_phone;
    int i;
 
    async_set_client_connection(client_connection);
   
    /* Connect to keyboard driver */
 
    kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
    while (kbd_phone < 0) {
        usleep(10000);
        kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
    }
   
    if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
        return -1;
    async_new_connection(phonehash, 0, NULL, keyboard_events);
   
    /* Connect to framebuffer driver */
    fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
    while (fb_info.phone < 0) {
        usleep(10000);
        fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
    }
   
    /* Initialize gcons */
    gcons_init(fb_info.phone);
    /* Synchronize, the gcons can have something in queue */
    async_req_0_0(fb_info.phone, FB_FLUSH);
   
    async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.rows,
        &fb_info.cols);
    set_style_col(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
    clrscr();
   
    /* Init virtual consoles */
    for (i = 0; i < CONSOLE_COUNT; i++) {
        connections[i].used = 0;
        keybuffer_init(&connections[i].keybuffer);
       
        connections[i].keyrequests.head = 0;
        connections[i].keyrequests.tail = 0;
        connections[i].keyrequests.items = MAX_KEYREQUESTS_BUFFERED;
        connections[i].keyrequest_counter = 0;
       
        if (screenbuffer_init(&connections[i].screenbuffer,
            fb_info.cols, fb_info.rows) == NULL) {
            /* FIXME: handle error */
            return -1;
        }
    }
    connections[KERNEL_CONSOLE].used = 1;
   
    interbuffer = mmap(NULL,
        sizeof(keyfield_t) * fb_info.cols * fb_info.rows,
        PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    if (!interbuffer) {
        if (ipc_share_out_start(fb_info.phone, interbuffer,
            AS_AREA_READ) != EOK) {
            munmap(interbuffer,
                sizeof(keyfield_t) * fb_info.cols * fb_info.rows);
            interbuffer = NULL;
        }
    }
 
    curs_goto(0, 0);
    curs_visibility(
        connections[active_console].screenbuffer.is_cursor_visible);
 
    /* Register at NS */
    if (ipc_connect_to_me(PHONE_NS, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
        return -1;
   
    // FIXME: avoid connectiong to itself, keep using klog
    // printf(NAME ": Accepting connections\n");
    async_manager();
 
    return 0;  
}
 
/** @}
 */
 

Rev 3742	Rev 3745
1	/*	1	/*
2	* Copyright (c) 2006 Josef Cejka	2	* Copyright (c) 2006 Josef Cejka
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	/** @addtogroup console	29	/** @addtogroup console
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <libc.h>	35	#include <libc.h>
36	#include <fb.h>	36	#include <fb.h>
37	#include <ipc/ipc.h>	37	#include <ipc/ipc.h>
38	#include <keys.h>	38	#include <keys.h>
39	#include <ipc/fb.h>	39	#include <ipc/fb.h>
40	#include <ipc/services.h>	40	#include <ipc/services.h>
41	#include <errno.h>	41	#include <errno.h>
42	#include <key_buffer.h>	42	#include <key_buffer.h>
43	#include <console.h>	43	#include <console.h>
44	#include <unistd.h>	44	#include <unistd.h>
45	#include <async.h>	45	#include <async.h>
46	#include <libadt/fifo.h>	46	#include <libadt/fifo.h>
47	#include <screenbuffer.h>	47	#include <screenbuffer.h>
48	#include <sys/mman.h>	48	#include <sys/mman.h>
49	#include <stdio.h>	49	#include <stdio.h>
50		50
51	#include "gcons.h"	51	#include "gcons.h"
52		52
53	#define MAX_KEYREQUESTS_BUFFERED 32	53	#define MAX_KEYREQUESTS_BUFFERED 32
54		54
55	#define NAME "console"	55	#define NAME "console"
56		56
57	/** Index of currently used virtual console.	57	/** Index of currently used virtual console.
58	*/	58	*/
59	int active_console = 0;	59	int active_console = 0;
60		60
61	/** Information about framebuffer	61	/** Information about framebuffer
62	*/	62	*/
63	struct {	63	struct {
64	int phone; /*< Framebuffer phone /	64	int phone; /*< Framebuffer phone /
65	ipcarg_t rows; /*< Framebuffer rows /	65	ipcarg_t rows; /*< Framebuffer rows /
66	ipcarg_t cols; /*< Framebuffer columns /	66	ipcarg_t cols; /*< Framebuffer columns /
67	} fb_info;	67	} fb_info;
68		68
69	typedef struct {	69	typedef struct {
70	keybuffer_t keybuffer; /*< Buffer for incoming keys. /	70	keybuffer_t keybuffer; /*< Buffer for incoming keys. /
71	/** Buffer for unsatisfied request for keys. */	71	/** Buffer for unsatisfied request for keys. */
72	FIFO_CREATE_STATIC(keyrequests, ipc_callid_t,	72	FIFO_CREATE_STATIC(keyrequests, ipc_callid_t,
73	MAX_KEYREQUESTS_BUFFERED);	73	MAX_KEYREQUESTS_BUFFERED);
74	int keyrequest_counter; /*< Number of requests in buffer. /	74	int keyrequest_counter; /*< Number of requests in buffer. /
75	int client_phone; /*< Phone to connected client. /	75	int client_phone; /*< Phone to connected client. /
76	int used; /**< 1 if this virtual console is	76	int used; /**< 1 if this virtual console is
77	* connected to some client.*/	77	* connected to some client.*/
78	screenbuffer_t screenbuffer; /**< Screenbuffer for saving screen	78	screenbuffer_t screenbuffer; /**< Screenbuffer for saving screen
79	* contents and related settings. */	79	* contents and related settings. */
80	} connection_t;	80	} connection_t;
81		81
82	static connection_t connections[CONSOLE_COUNT]; /**< Array of data for virtual	82	static connection_t connections[CONSOLE_COUNT]; /**< Array of data for virtual
83	* consoles */	83	* consoles */
84	static keyfield_t interbuffer = NULL; /*< Pointer to memory shared	84	static keyfield_t interbuffer = NULL; /*< Pointer to memory shared
85	* with framebufer used for	85	* with framebufer used for
86	* faster virtual console	86	* faster virtual console
87	* switching */	87	* switching */
88		88
89		89
90	/** Find unused virtual console.	90	/** Find unused virtual console.
91	*	91	*
92	*/	92	*/
93	static int find_free_connection(void)	93	static int find_free_connection(void)
94	{	94	{
95	int i;	95	int i;
96		96
97	for (i = 0; i < CONSOLE_COUNT; i++) {	97	for (i = 0; i < CONSOLE_COUNT; i++) {
98	if (!connections[i].used)	98	if (!connections[i].used)
99	return i;	99	return i;
100	}	100	}
101	return -1;	101	return -1;
102	}	102	}
103		103
104	static void clrscr(void)	104	static void clrscr(void)
105	{	105	{
106	async_msg_0(fb_info.phone, FB_CLEAR);	106	async_msg_0(fb_info.phone, FB_CLEAR);
107	}	107	}
108		108
109	static void curs_visibility(int v)	109	static void curs_visibility(bool visible)
110	{	110	{
111	async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, v);	111	async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible);
-		112	}
-		113
-		114	static void curs_hide_sync(void)
-		115	{
-		116	ipc_call_sync_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
112	}	117	}
113		118
114	static void curs_goto(int row, int col)	119	static void curs_goto(int row, int col)
115	{	120	{
116	async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col);	121	async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col);
117	}	122	}
118		123
119	static void set_style(style_t *style)	124	static void set_style(style_t *style)
120	{	125	{
121	async_msg_2(fb_info.phone, FB_SET_STYLE, style->fg_color,	126	async_msg_2(fb_info.phone, FB_SET_STYLE, style->fg_color,
122	style->bg_color);	127	style->bg_color);
123	}	128	}
124		129
125	static void set_style_col(int fgcolor, int bgcolor)	130	static void set_style_col(int fgcolor, int bgcolor)
126	{	131	{
127	async_msg_2(fb_info.phone, FB_SET_STYLE, fgcolor, bgcolor);	132	async_msg_2(fb_info.phone, FB_SET_STYLE, fgcolor, bgcolor);
128	}	133	}
129		134
130	static void prtchr(char c, int row, int col)	135	static void prtchr(char c, int row, int col)
131	{	136	{
132	async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);	137	async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);
133	}	138	}
134		139
135	/** Check key and process special keys.	140	/** Check key and process special keys.
136	*	141	*
137	*	142	*
138	*/	143	*/
139	static void write_char(int console, char key)	144	static void write_char(int console, char key)
140	{	145	{
141	screenbuffer_t *scr = &(connections[console].screenbuffer);	146	screenbuffer_t *scr = &(connections[console].screenbuffer);
142		147
143	switch (key) {	148	switch (key) {
144	case '\n':	149	case '\n':
145	scr->position_y++;	150	scr->position_y++;
146	scr->position_x = 0;	151	scr->position_x = 0;
147	break;	152	break;
148	case '\r':	153	case '\r':
149	break;	154	break;
150	case '\t':	155	case '\t':
151	scr->position_x += 8;	156	scr->position_x += 8;
152	scr->position_x -= scr->position_x % 8;	157	scr->position_x -= scr->position_x % 8;
153	break;	158	break;
154	case '\b':	159	case '\b':
155	if (scr->position_x == 0)	160	if (scr->position_x == 0)
156	break;	161	break;
157	scr->position_x--;	162	scr->position_x--;
158	if (console == active_console)	163	if (console == active_console)
159	prtchr(' ', scr->position_y, scr->position_x);	164	prtchr(' ', scr->position_y, scr->position_x);
160	screenbuffer_putchar(scr, ' ');	165	screenbuffer_putchar(scr, ' ');
161	break;	166	break;
162	default:	167	default:
163	if (console == active_console)	168	if (console == active_console)
164	prtchr(key, scr->position_y, scr->position_x);	169	prtchr(key, scr->position_y, scr->position_x);
165		170
166	screenbuffer_putchar(scr, key);	171	screenbuffer_putchar(scr, key);
167	scr->position_x++;	172	scr->position_x++;
168	}	173	}
169		174
170	scr->position_y += (scr->position_x >= scr->size_x);	175	scr->position_y += (scr->position_x >= scr->size_x);
171		176
172	if (scr->position_y >= scr->size_y) {	177	if (scr->position_y >= scr->size_y) {
173	scr->position_y = scr->size_y - 1;	178	scr->position_y = scr->size_y - 1;
174	screenbuffer_clear_line(scr, scr->top_line);	179	screenbuffer_clear_line(scr, scr->top_line);
175	scr->top_line = (scr->top_line + 1) % scr->size_y;	180	scr->top_line = (scr->top_line + 1) % scr->size_y;
176	if (console == active_console)	181	if (console == active_console)
177	async_msg_1(fb_info.phone, FB_SCROLL, 1);	182	async_msg_1(fb_info.phone, FB_SCROLL, 1);
178	}	183	}
179		184
180	scr->position_x = scr->position_x % scr->size_x;	185	scr->position_x = scr->position_x % scr->size_x;
181		186
182	if (console == active_console)	187	if (console == active_console)
183	curs_goto(scr->position_y, scr->position_x);	188	curs_goto(scr->position_y, scr->position_x);
184		189
185	}	190	}
186		191
187	/** Switch to new console */	192	/** Switch to new console */
188	static void change_console(int newcons)	193	static void change_console(int newcons)
189	{	194	{
190	connection_t *conn;	195	connection_t *conn;
191	int i, j, rc;	196	int i, j, rc;
192	keyfield_t *field;	197	keyfield_t *field;
193	style_t *style;	198	style_t *style;
194		199
195	if (newcons == active_console)	200	if (newcons == active_console)
196	return;	201	return;
197		202
198	if (newcons == KERNEL_CONSOLE) {	203	if (newcons == KERNEL_CONSOLE) {
199	async_serialize_start();	204	async_serialize_start();
200	curs_visibility(0);	205	curs_hide_sync();
201	gcons_in_kernel();	206	gcons_in_kernel();
202	async_serialize_end();	207	async_serialize_end();
203		208
204	if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE))	209	if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE))
205	active_console = KERNEL_CONSOLE;	210	active_console = KERNEL_CONSOLE;
206	else	211	else
207	newcons == active_console;	212	newcons = active_console;
208	}	213	}
209		214
210	if (newcons != KERNEL_CONSOLE) {	215	if (newcons != KERNEL_CONSOLE) {
211	async_serialize_start();	216	async_serialize_start();
212		217
213	if (active_console == KERNEL_CONSOLE)	218	if (active_console == KERNEL_CONSOLE)
214	gcons_redraw_console();	219	gcons_redraw_console();
215		220
216	active_console = newcons;	221	active_console = newcons;
217	gcons_change_console(newcons);	222	gcons_change_console(newcons);
218	conn = &connections[active_console];	223	conn = &connections[active_console];
219		224
220	set_style(&conn->screenbuffer.style);	225	set_style(&conn->screenbuffer.style);
221	curs_visibility(0);	226	curs_visibility(false);
222	if (interbuffer) {	227	if (interbuffer) {
223	for (i = 0; i < conn->screenbuffer.size_x; i++)	228	for (i = 0; i < conn->screenbuffer.size_x; i++)
224	for (j = 0; j < conn->screenbuffer.size_y; j++) {	229	for (j = 0; j < conn->screenbuffer.size_y; j++) {
225	unsigned int size_x;	230	unsigned int size_x;
226		231
227	size_x = conn->screenbuffer.size_x;	232	size_x = conn->screenbuffer.size_x;
228	interbuffer[i + j * size_x] =	233	interbuffer[i + j * size_x] =
229	*get_field_at(&conn->screenbuffer, i, j);	234	*get_field_at(&conn->screenbuffer, i, j);
230	}	235	}
231	/* This call can preempt, but we are already at the end */	236	/* This call can preempt, but we are already at the end */
232	rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);	237	rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);
233	}	238	}
234		239
235	if ((!interbuffer) \|\| (rc != 0)) {	240	if ((!interbuffer) \|\| (rc != 0)) {
236	set_style(&conn->screenbuffer.style);	241	set_style(&conn->screenbuffer.style);
237	clrscr();	242	clrscr();
238	style = &conn->screenbuffer.style;	243	style = &conn->screenbuffer.style;
239		244
240	for (j = 0; j < conn->screenbuffer.size_y; j++)	245	for (j = 0; j < conn->screenbuffer.size_y; j++)
241	for (i = 0; i < conn->screenbuffer.size_x; i++) {	246	for (i = 0; i < conn->screenbuffer.size_x; i++) {
242	field = get_field_at(&conn->screenbuffer, i, j);	247	field = get_field_at(&conn->screenbuffer, i, j);
243	if (!style_same(*style, field->style))	248	if (!style_same(*style, field->style))
244	set_style(&field->style);	249	set_style(&field->style);
245	style = &field->style;	250	style = &field->style;
246	if ((field->character == ' ') &&	251	if ((field->character == ' ') &&
247	(style_same(field->style,	252	(style_same(field->style,
248	conn->screenbuffer.style)))	253	conn->screenbuffer.style)))
249	continue;	254	continue;
250		255
251	prtchr(field->character, j, i);	256	prtchr(field->character, j, i);
252	}	257	}
253	}	258	}
254		259
255	curs_goto(conn->screenbuffer.position_y,	260	curs_goto(conn->screenbuffer.position_y,
256	conn->screenbuffer.position_x);	261	conn->screenbuffer.position_x);
257	curs_visibility(conn->screenbuffer.is_cursor_visible);	262	curs_visibility(conn->screenbuffer.is_cursor_visible);
258		263
259	async_serialize_end();	264	async_serialize_end();
260	}	265	}
261	}	266	}
262		267
263	/** Handler for keyboard */	268	/** Handler for keyboard */
264	static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)	269	static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
265	{	270	{
266	ipc_callid_t callid;	271	ipc_callid_t callid;
267	ipc_call_t call;	272	ipc_call_t call;
268	int retval;	273	int retval;
269	int c;	274	int c;
270	connection_t *conn;	275	connection_t *conn;
271	int newcon;	276	int newcon;
272		277
273	/* Ignore parameters, the connection is alread opened */	278	/* Ignore parameters, the connection is alread opened */
274	while (1) {	279	while (1) {
275	callid = async_get_call(&call);	280	callid = async_get_call(&call);
276	switch (IPC_GET_METHOD(call)) {	281	switch (IPC_GET_METHOD(call)) {
277	case IPC_M_PHONE_HUNGUP:	282	case IPC_M_PHONE_HUNGUP:
278	/* TODO: Handle hangup */	283	/* TODO: Handle hangup */
279	return;	284	return;
280	case KBD_MS_LEFT:	285	case KBD_MS_LEFT:
281	newcon = gcons_mouse_btn(IPC_GET_ARG1(call));	286	newcon = gcons_mouse_btn(IPC_GET_ARG1(call));
282	if (newcon != -1)	287	if (newcon != -1)
283	change_console(newcon);	288	change_console(newcon);
284	retval = 0;	289	retval = 0;
285	break;	290	break;
286	case KBD_MS_MOVE:	291	case KBD_MS_MOVE:
287	gcons_mouse_move(IPC_GET_ARG1(call),	292	gcons_mouse_move(IPC_GET_ARG1(call),
288	IPC_GET_ARG2(call));	293	IPC_GET_ARG2(call));
289	retval = 0;	294	retval = 0;
290	break;	295	break;
291	case KBD_PUSHCHAR:	296	case KBD_PUSHCHAR:
292	/* got key from keyboard driver */	297	/* got key from keyboard driver */
293	retval = 0;	298	retval = 0;
294	c = IPC_GET_ARG1(call);	299	c = IPC_GET_ARG1(call);
295	/* switch to another virtual console */	300	/* switch to another virtual console */
296		301
297	conn = &connections[active_console];	302	conn = &connections[active_console];
298	/*	303	/*
299	* if ((c >= KBD_KEY_F1) && (c < KBD_KEY_F1 +	304	* if ((c >= KBD_KEY_F1) && (c < KBD_KEY_F1 +
300	* CONSOLE_COUNT)) {	305	* CONSOLE_COUNT)) {
301	*/	306	*/
302	if ((c >= 0x101) && (c < 0x101 + CONSOLE_COUNT)) {	307	if ((c >= 0x101) && (c < 0x101 + CONSOLE_COUNT)) {
303	if (c == 0x112)	308	if (c == 0x112)
304	change_console(KERNEL_CONSOLE);	309	change_console(KERNEL_CONSOLE);
305	else	310	else
306	change_console(c - 0x101);	311	change_console(c - 0x101);
307	break;	312	break;
308	}	313	}
309		314
310	/* if client is awaiting key, send it */	315	/* if client is awaiting key, send it */
311	if (conn->keyrequest_counter > 0) {	316	if (conn->keyrequest_counter > 0) {
312	conn->keyrequest_counter--;	317	conn->keyrequest_counter--;
313	ipc_answer_1(fifo_pop(conn->keyrequests), EOK,	318	ipc_answer_1(fifo_pop(conn->keyrequests), EOK,
314	c);	319	c);
315	break;	320	break;
316	}	321	}
317		322
318	keybuffer_push(&conn->keybuffer, c);	323	keybuffer_push(&conn->keybuffer, c);
319	retval = 0;	324	retval = 0;
320		325
321	break;	326	break;
322	default:	327	default:
323	retval = ENOENT;	328	retval = ENOENT;
324	}	329	}
325	ipc_answer_0(callid, retval);	330	ipc_answer_0(callid, retval);
326	}	331	}
327	}	332	}
328		333
329	/** Default thread for new connections */	334	/** Default thread for new connections */
330	static void client_connection(ipc_callid_t iid, ipc_call_t *icall)	335	static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
331	{	336	{
332	ipc_callid_t callid;	337	ipc_callid_t callid;
333	ipc_call_t call;	338	ipc_call_t call;
334	int consnum;	339	int consnum;
335	ipcarg_t arg1, arg2;	340	ipcarg_t arg1, arg2;
336	connection_t *conn;	341	connection_t *conn;
337		342
338	if ((consnum = find_free_connection()) == -1) {	343	if ((consnum = find_free_connection()) == -1) {
339	ipc_answer_0(iid, ELIMIT);	344	ipc_answer_0(iid, ELIMIT);
340	return;	345	return;
341	}	346	}
342	conn = &connections[consnum];	347	conn = &connections[consnum];
343	conn->used = 1;	348	conn->used = 1;
344		349
345	async_serialize_start();	350	async_serialize_start();
346	gcons_notify_connect(consnum);	351	gcons_notify_connect(consnum);
347	conn->client_phone = IPC_GET_ARG5(*icall);	352	conn->client_phone = IPC_GET_ARG5(*icall);
348	screenbuffer_clear(&conn->screenbuffer);	353	screenbuffer_clear(&conn->screenbuffer);
349		354
350	/* Accept the connection */	355	/* Accept the connection */
351	ipc_answer_0(iid, EOK);	356	ipc_answer_0(iid, EOK);
352		357
353	while (1) {	358	while (1) {
354	async_serialize_end();	359	async_serialize_end();
355	callid = async_get_call(&call);	360	callid = async_get_call(&call);
356	async_serialize_start();	361	async_serialize_start();
357		362
358	arg1 = 0;	363	arg1 = 0;
359	arg2 = 0;	364	arg2 = 0;
360	switch (IPC_GET_METHOD(call)) {	365	switch (IPC_GET_METHOD(call)) {
361	case IPC_M_PHONE_HUNGUP:	366	case IPC_M_PHONE_HUNGUP:
362	gcons_notify_disconnect(consnum);	367	gcons_notify_disconnect(consnum);
363		368
364	/* Answer all pending requests */	369	/* Answer all pending requests */
365	while (conn->keyrequest_counter > 0) {	370	while (conn->keyrequest_counter > 0) {
366	conn->keyrequest_counter--;	371	conn->keyrequest_counter--;
367	ipc_answer_0(fifo_pop(conn->keyrequests),	372	ipc_answer_0(fifo_pop(conn->keyrequests),
368	ENOENT);	373	ENOENT);
369	break;	374	break;
370	}	375	}
371	conn->used = 0;	376	conn->used = 0;
372	return;	377	return;
373	case CONSOLE_PUTCHAR:	378	case CONSOLE_PUTCHAR:
374	write_char(consnum, IPC_GET_ARG1(call));	379	write_char(consnum, IPC_GET_ARG1(call));
375	gcons_notify_char(consnum);	380	gcons_notify_char(consnum);
376	break;	381	break;
377	case CONSOLE_CLEAR:	382	case CONSOLE_CLEAR:
378	/* Send message to fb */	383	/* Send message to fb */
379	if (consnum == active_console) {	384	if (consnum == active_console) {
380	async_msg_0(fb_info.phone, FB_CLEAR);	385	async_msg_0(fb_info.phone, FB_CLEAR);
381	}	386	}
382		387
383	screenbuffer_clear(&conn->screenbuffer);	388	screenbuffer_clear(&conn->screenbuffer);
384		389
385	break;	390	break;
386	case CONSOLE_GOTO:	391	case CONSOLE_GOTO:
387	screenbuffer_goto(&conn->screenbuffer,	392	screenbuffer_goto(&conn->screenbuffer,
388	IPC_GET_ARG2(call), IPC_GET_ARG1(call));	393	IPC_GET_ARG2(call), IPC_GET_ARG1(call));
389	if (consnum == active_console)	394	if (consnum == active_console)
390	curs_goto(IPC_GET_ARG1(call),	395	curs_goto(IPC_GET_ARG1(call),
391	IPC_GET_ARG2(call));	396	IPC_GET_ARG2(call));
392	break;	397	break;
393	case CONSOLE_GETSIZE:	398	case CONSOLE_GETSIZE:
394	arg1 = fb_info.rows;	399	arg1 = fb_info.rows;
395	arg2 = fb_info.cols;	400	arg2 = fb_info.cols;
396	break;	401	break;
397	case CONSOLE_FLUSH:	402	case CONSOLE_FLUSH:
398	if (consnum == active_console)	403	if (consnum == active_console)
399	async_req_0_0(fb_info.phone, FB_FLUSH);	404	async_req_0_0(fb_info.phone, FB_FLUSH);
400	break;	405	break;
401	case CONSOLE_SET_STYLE:	406	case CONSOLE_SET_STYLE:
402	arg1 = IPC_GET_ARG1(call);	407	arg1 = IPC_GET_ARG1(call);
403	arg2 = IPC_GET_ARG2(call);	408	arg2 = IPC_GET_ARG2(call);
404	screenbuffer_set_style(&conn->screenbuffer, arg1,	409	screenbuffer_set_style(&conn->screenbuffer, arg1,
405	arg2);	410	arg2);
406	if (consnum == active_console)	411	if (consnum == active_console)
407	set_style_col(arg1, arg2);	412	set_style_col(arg1, arg2);
408	break;	413	break;
409	case CONSOLE_CURSOR_VISIBILITY:	414	case CONSOLE_CURSOR_VISIBILITY:
410	arg1 = IPC_GET_ARG1(call);	415	arg1 = IPC_GET_ARG1(call);
411	conn->screenbuffer.is_cursor_visible = arg1;	416	conn->screenbuffer.is_cursor_visible = arg1;
412	if (consnum == active_console)	417	if (consnum == active_console)
413	curs_visibility(arg1);	418	curs_visibility(arg1);
414	break;	419	break;
415	case CONSOLE_GETCHAR:	420	case CONSOLE_GETCHAR:
416	if (keybuffer_empty(&conn->keybuffer)) {	421	if (keybuffer_empty(&conn->keybuffer)) {
417	/* buffer is empty -> store request */	422	/* buffer is empty -> store request */
418	if (conn->keyrequest_counter <	423	if (conn->keyrequest_counter <
419	MAX_KEYREQUESTS_BUFFERED) {	424	MAX_KEYREQUESTS_BUFFERED) {
420	fifo_push(conn->keyrequests, callid);	425	fifo_push(conn->keyrequests, callid);
421	conn->keyrequest_counter++;	426	conn->keyrequest_counter++;
422	} else {	427	} else {
423	/*	428	/*
424	* No key available and too many	429	* No key available and too many
425	* requests => fail.	430	* requests => fail.
426	*/	431	*/
427	ipc_answer_0(callid, ELIMIT);	432	ipc_answer_0(callid, ELIMIT);
428	}	433	}
429	continue;	434	continue;
430	}	435	}
431	int ch;	436	int ch;
432	keybuffer_pop(&conn->keybuffer, &ch);	437	keybuffer_pop(&conn->keybuffer, &ch);
433	arg1 = ch;	438	arg1 = ch;
434	break;	439	break;
435	}	440	}
436	ipc_answer_2(callid, EOK, arg1, arg2);	441	ipc_answer_2(callid, EOK, arg1, arg2);
437	}	442	}
438	}	443	}
439		444
440	int main(int argc, char *argv[])	445	int main(int argc, char *argv[])
441	{	446	{
442	printf(NAME ": HelenOS Console service\n");	447	printf(NAME ": HelenOS Console service\n");
443		448
444	ipcarg_t phonehash;	449	ipcarg_t phonehash;
445	int kbd_phone;	450	int kbd_phone;
446	int i;	451	int i;
447		452
448	async_set_client_connection(client_connection);	453	async_set_client_connection(client_connection);
449		454
450	/* Connect to keyboard driver */	455	/* Connect to keyboard driver */
451		456
452	kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);	457	kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
453	while (kbd_phone < 0) {	458	while (kbd_phone < 0) {
454	usleep(10000);	459	usleep(10000);
455	kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);	460	kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
456	}	461	}
457		462
458	if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)	463	if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
459	return -1;	464	return -1;
460	async_new_connection(phonehash, 0, NULL, keyboard_events);	465	async_new_connection(phonehash, 0, NULL, keyboard_events);
461		466
462	/* Connect to framebuffer driver */	467	/* Connect to framebuffer driver */
463	fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);	468	fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
464	while (fb_info.phone < 0) {	469	while (fb_info.phone < 0) {
465	usleep(10000);	470	usleep(10000);
466	fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);	471	fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
467	}	472	}
468		473
469	/* Initialize gcons */	474	/* Initialize gcons */
470	gcons_init(fb_info.phone);	475	gcons_init(fb_info.phone);
471	/* Synchronize, the gcons can have something in queue */	476	/* Synchronize, the gcons can have something in queue */
472	async_req_0_0(fb_info.phone, FB_FLUSH);	477	async_req_0_0(fb_info.phone, FB_FLUSH);
473		478
474	async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.rows,	479	async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.rows,
475	&fb_info.cols);	480	&fb_info.cols);
476	set_style_col(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);	481	set_style_col(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
477	clrscr();	482	clrscr();
478		483
479	/* Init virtual consoles */	484	/* Init virtual consoles */
480	for (i = 0; i < CONSOLE_COUNT; i++) {	485	for (i = 0; i < CONSOLE_COUNT; i++) {
481	connections[i].used = 0;	486	connections[i].used = 0;
482	keybuffer_init(&connections[i].keybuffer);	487	keybuffer_init(&connections[i].keybuffer);
483		488
484	connections[i].keyrequests.head = 0;	489	connections[i].keyrequests.head = 0;
485	connections[i].keyrequests.tail = 0;	490	connections[i].keyrequests.tail = 0;
486	connections[i].keyrequests.items = MAX_KEYREQUESTS_BUFFERED;	491	connections[i].keyrequests.items = MAX_KEYREQUESTS_BUFFERED;
487	connections[i].keyrequest_counter = 0;	492	connections[i].keyrequest_counter = 0;
488		493
489	if (screenbuffer_init(&connections[i].screenbuffer,	494	if (screenbuffer_init(&connections[i].screenbuffer,
490	fb_info.cols, fb_info.rows) == NULL) {	495	fb_info.cols, fb_info.rows) == NULL) {
491	/* FIXME: handle error */	496	/* FIXME: handle error */
492	return -1;	497	return -1;
493	}	498	}
494	}	499	}
495	connections[KERNEL_CONSOLE].used = 1;	500	connections[KERNEL_CONSOLE].used = 1;

Subversion Repositories HelenOS

(root)/branches/sparc/uspace/srv/console/console.c – Rev 3742 → 3745