Subversion Repositories HelenOS

Rev

Rev 4420 | Rev 4668 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4419 trochtova 1
/*
2
 * Copyright (c) 2006 Josef Cejka
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
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
15
 *   derived from this software without specific prior written permission.
16
 *
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
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
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
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
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup console
4439 trochtova 30
 * @{
4419 trochtova 31
 */
32
/** @file
33
 */
34
 
35
#include <libc.h>
36
#include <fb.h>
37
#include <ipc/ipc.h>
38
#include <kbd.h>
39
#include <kbd/keycode.h>
40
#include <ipc/fb.h>
41
#include <ipc/services.h>
42
#include <errno.h>
43
#include <key_buffer.h>
44
#include <ipc/console.h>
45
#include <unistd.h>
46
#include <async.h>
47
#include <libadt/fifo.h>
48
#include <screenbuffer.h>
49
#include <sys/mman.h>
50
#include <stdio.h>
51
#include <string.h>
52
#include <sysinfo.h>
53
#include <event.h>
54
 
55
#include "console.h"
56
#include "gcons.h"
57
 
4439 trochtova 58
#define NAME  "console"
4419 trochtova 59
 
4439 trochtova 60
#define MAX_KEYREQUESTS_BUFFERED  32
4419 trochtova 61
 
4439 trochtova 62
/** Size of cwrite_buf. */
63
#define CWRITE_BUF_SIZE  256
64
 
4419 trochtova 65
/** Index of currently used virtual console.
66
 */
67
int active_console = 0;
68
int prev_console = 0;
69
 
4420 trochtova 70
/** Phone to the keyboard driver. */
71
static int kbd_phone;
72
 
4419 trochtova 73
/** Information about framebuffer */
74
struct {
4439 trochtova 75
    int phone;      /**< Framebuffer phone */
76
    ipcarg_t rows;  /**< Framebuffer rows */
77
    ipcarg_t cols;  /**< Framebuffer columns */
4419 trochtova 78
} fb_info;
79
 
80
typedef struct {
4439 trochtova 81
    keybuffer_t keybuffer;        /**< Buffer for incoming keys. */
82
 
4419 trochtova 83
    /** Buffer for unsatisfied request for keys. */
84
    FIFO_CREATE_STATIC(keyrequests, ipc_callid_t,
4439 trochtova 85
        MAX_KEYREQUESTS_BUFFERED);
86
 
87
    int keyrequest_counter;       /**< Number of requests in buffer. */
88
    int client_phone;             /**< Phone to connected client. */
89
    int used;                     /**< 1 if this virtual console is
90
                                       connected to some client. */
91
    screenbuffer_t screenbuffer;  /**< Screenbuffer for saving screen
92
                                       contents and related settings. */
4419 trochtova 93
} connection_t;
94
 
4439 trochtova 95
/** Array of data for virtual consoles */
96
static connection_t connections[CONSOLE_COUNT];
4419 trochtova 97
 
4439 trochtova 98
/** Pointer to memory shared with framebufer used for
99
    faster virtual console switching */
100
static keyfield_t *interbuffer = NULL;
101
 
4419 trochtova 102
/** Information on row-span yet unsent to FB driver. */
103
struct {
4439 trochtova 104
    int row;  /**< Row where the span lies. */
105
    int col;  /**< Leftmost column of the span. */
106
    int cnt;  /**< Width of the span. */
4419 trochtova 107
} fb_pending;
108
 
109
/** Buffer for receiving data via the CONSOLE_WRITE call from the client. */
110
static char cwrite_buf[CWRITE_BUF_SIZE];
111
 
112
/** Find unused virtual console.
113
 *
114
 */
115
static int find_free_connection(void)
116
{
117
    int i;
118
 
119
    for (i = 0; i < CONSOLE_COUNT; i++) {
120
        if (!connections[i].used)
121
            return i;
122
    }
4439 trochtova 123
 
4419 trochtova 124
    return -1;
125
}
126
 
127
static void clrscr(void)
128
{
129
    async_msg_0(fb_info.phone, FB_CLEAR);
130
}
131
 
132
static void curs_visibility(bool visible)
133
{
134
    async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible);
135
}
136
 
137
static void curs_hide_sync(void)
138
{
139
    ipc_call_sync_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
140
}
141
 
142
static void curs_goto(int row, int col)
143
{
144
    async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col);
145
}
146
 
4420 trochtova 147
static void screen_yield(void)
148
{
149
    ipc_call_sync_0_0(fb_info.phone, FB_SCREEN_YIELD);
150
}
151
 
152
static void screen_reclaim(void)
153
{
154
    ipc_call_sync_0_0(fb_info.phone, FB_SCREEN_RECLAIM);
155
}
156
 
157
static void kbd_yield(void)
158
{
159
    ipc_call_sync_0_0(kbd_phone, KBD_YIELD);
160
}
161
 
162
static void kbd_reclaim(void)
163
{
164
    ipc_call_sync_0_0(kbd_phone, KBD_RECLAIM);
165
}
166
 
4419 trochtova 167
static void set_style(int style)
168
{
169
    async_msg_1(fb_info.phone, FB_SET_STYLE, style);
170
}
171
 
172
static void set_color(int fgcolor, int bgcolor, int flags)
173
{
174
    async_msg_3(fb_info.phone, FB_SET_COLOR, fgcolor, bgcolor, flags);
175
}
176
 
177
static void set_rgb_color(int fgcolor, int bgcolor)
178
{
179
    async_msg_2(fb_info.phone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
180
}
181
 
182
static void set_attrs(attrs_t *attrs)
183
{
184
    switch (attrs->t) {
185
    case at_style:
186
        set_style(attrs->a.s.style);
187
        break;
188
    case at_idx:
189
        set_color(attrs->a.i.fg_color, attrs->a.i.bg_color,
190
            attrs->a.i.flags);
191
        break;
192
    case at_rgb:
193
        set_rgb_color(attrs->a.r.fg_color, attrs->a.r.bg_color);
194
        break;
195
    }
196
}
197
 
198
/** Send an area of screenbuffer to the FB driver. */
199
static void fb_update_area(connection_t *conn, int x, int y, int w, int h)
200
{
4439 trochtova 201
    int i;
202
    int j;
4419 trochtova 203
    attrs_t *attrs;
204
    keyfield_t *field;
4439 trochtova 205
 
4419 trochtova 206
    if (interbuffer) {
207
        for (j = 0; j < h; j++) {
208
            for (i = 0; i < w; i++) {
209
                interbuffer[i + j * w] =
4439 trochtova 210
                    *get_field_at(&conn->screenbuffer, x + i, y + j);
4419 trochtova 211
            }
212
        }
4439 trochtova 213
 
214
        async_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
4419 trochtova 215
            x, y, w, h);
216
    }
217
}
218
 
219
/** Flush pending cells to FB. */
220
static void fb_pending_flush(void)
221
{
4439 trochtova 222
    screenbuffer_t *scr
223
        = &(connections[active_console].screenbuffer);
224
 
225
    if (fb_pending.cnt > 0) {
4419 trochtova 226
        fb_update_area(&connections[active_console], fb_pending.col,
4439 trochtova 227
            fb_pending.row, fb_pending.cnt, 1);
228
        fb_pending.cnt = 0;
4419 trochtova 229
    }
230
}
231
 
232
/** Mark a character cell as changed.
233
 *
234
 * This adds the cell to the pending rowspan if possible. Otherwise
235
 * the old span is flushed first.
4439 trochtova 236
 *
4419 trochtova 237
 */
238
static void cell_mark_changed(int row, int col)
239
{
4439 trochtova 240
    if (fb_pending.cnt != 0) {
241
        if ((row != fb_pending.row)
242
            || (col != fb_pending.col + fb_pending.cnt)) {
4419 trochtova 243
            fb_pending_flush();
244
        }
245
    }
4439 trochtova 246
 
247
    if (fb_pending.cnt == 0) {
4419 trochtova 248
        fb_pending.row = row;
249
        fb_pending.col = col;
250
    }
4439 trochtova 251
 
252
    fb_pending.cnt++;
4419 trochtova 253
}
254
 
255
/** Print a character to the active VC with buffering. */
256
static void fb_putchar(wchar_t c, int row, int col)
257
{
258
    async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);
259
}
260
 
261
/** Process a character from the client (TTY emulation). */
262
static void write_char(int console, wchar_t ch)
263
{
264
    bool flush_cursor = false;
265
    screenbuffer_t *scr = &(connections[console].screenbuffer);
4439 trochtova 266
 
4419 trochtova 267
    switch (ch) {
268
    case '\n':
269
        fb_pending_flush();
270
        flush_cursor = true;
271
        scr->position_y++;
272
        scr->position_x = 0;
273
        break;
274
    case '\r':
275
        break;
276
    case '\t':
277
        scr->position_x += 8;
4439 trochtova 278
        scr->position_x -= scr->position_x % 8;
4419 trochtova 279
        break;
280
    case '\b':
281
        if (scr->position_x == 0)
282
            break;
283
        scr->position_x--;
284
        if (console == active_console)
285
            cell_mark_changed(scr->position_y, scr->position_x);
286
        screenbuffer_putchar(scr, ' ');
287
        break;
4439 trochtova 288
    default:
4419 trochtova 289
        if (console == active_console)
290
            cell_mark_changed(scr->position_y, scr->position_x);
4439 trochtova 291
 
4419 trochtova 292
        screenbuffer_putchar(scr, ch);
293
        scr->position_x++;
294
    }
4439 trochtova 295
 
4419 trochtova 296
    if (scr->position_x >= scr->size_x) {
297
        flush_cursor = true;
298
        scr->position_y++;
299
    }
300
 
301
    if (scr->position_y >= scr->size_y) {
302
        fb_pending_flush();
303
        scr->position_y = scr->size_y - 1;
304
        screenbuffer_clear_line(scr, scr->top_line);
305
        scr->top_line = (scr->top_line + 1) % scr->size_y;
306
        if (console == active_console)
307
            async_msg_1(fb_info.phone, FB_SCROLL, 1);
308
    }
4439 trochtova 309
 
4419 trochtova 310
    scr->position_x = scr->position_x % scr->size_x;
4439 trochtova 311
 
4419 trochtova 312
    if (console == active_console && flush_cursor)
313
        curs_goto(scr->position_y, scr->position_x);
314
}
315
 
316
/** Switch to new console */
317
static void change_console(int newcons)
318
{
319
    connection_t *conn;
4439 trochtova 320
    int i;
321
    int j;
322
    int rc;
4419 trochtova 323
    keyfield_t *field;
324
    attrs_t *attrs;
325
 
326
    if (newcons == active_console)
327
        return;
4439 trochtova 328
 
4419 trochtova 329
    fb_pending_flush();
4439 trochtova 330
 
4419 trochtova 331
    if (newcons == KERNEL_CONSOLE) {
332
        async_serialize_start();
333
        curs_hide_sync();
334
        gcons_in_kernel();
4420 trochtova 335
        screen_yield();
336
        kbd_yield();
4419 trochtova 337
        async_serialize_end();
338
 
4439 trochtova 339
 
4419 trochtova 340
        if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE)) {
341
            prev_console = active_console;
342
            active_console = KERNEL_CONSOLE;
343
        } else
344
            newcons = active_console;
345
    }
346
 
347
    if (newcons != KERNEL_CONSOLE) {
348
        async_serialize_start();
349
 
4420 trochtova 350
        if (active_console == KERNEL_CONSOLE) {
351
            screen_reclaim();
352
            kbd_reclaim();
4419 trochtova 353
            gcons_redraw_console();
4420 trochtova 354
        }
4419 trochtova 355
 
356
        active_console = newcons;
357
        gcons_change_console(newcons);
358
        conn = &connections[active_console];
359
 
360
        set_attrs(&conn->screenbuffer.attrs);
361
        curs_visibility(false);
362
        if (interbuffer) {
363
            for (j = 0; j < conn->screenbuffer.size_y; j++) {
364
                for (i = 0; i < conn->screenbuffer.size_x; i++) {
365
                    unsigned int size_x;
366
 
367
                    size_x = conn->screenbuffer.size_x;
368
                    interbuffer[j * size_x + i] =
369
                        *get_field_at(&conn->screenbuffer, i, j);
370
                }
371
            }
372
            /* This call can preempt, but we are already at the end */
373
            rc = async_req_4_0(fb_info.phone, FB_DRAW_TEXT_DATA,
374
                0, 0, conn->screenbuffer.size_x,
375
                conn->screenbuffer.size_y);
376
        }
377
 
378
        if ((!interbuffer) || (rc != 0)) {
379
            set_attrs(&conn->screenbuffer.attrs);
380
            clrscr();
381
            attrs = &conn->screenbuffer.attrs;
382
 
383
            for (j = 0; j < conn->screenbuffer.size_y; j++)
384
                for (i = 0; i < conn->screenbuffer.size_x; i++) {
385
                    field = get_field_at(&conn->screenbuffer, i, j);
386
                    if (!attrs_same(*attrs, field->attrs))
387
                        set_attrs(&field->attrs);
388
                    attrs = &field->attrs;
389
                    if ((field->character == ' ') &&
4439 trochtova 390
                        (attrs_same(field->attrs, conn->screenbuffer.attrs)))
4419 trochtova 391
                        continue;
4439 trochtova 392
 
4419 trochtova 393
                    fb_putchar(field->character, j, i);
394
                }
395
        }
396
 
397
        curs_goto(conn->screenbuffer.position_y,
398
            conn->screenbuffer.position_x);
399
        curs_visibility(conn->screenbuffer.is_cursor_visible);
400
 
401
        async_serialize_end();
402
    }
403
}
404
 
405
/** Handler for keyboard */
406
static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
407
{
408
    ipc_callid_t callid;
409
    ipc_call_t call;
410
    int retval;
411
    kbd_event_t ev;
412
    connection_t *conn;
413
    int newcon;
414
 
415
    /* Ignore parameters, the connection is alread opened */
4439 trochtova 416
    while (true) {
4419 trochtova 417
        callid = async_get_call(&call);
418
        switch (IPC_GET_METHOD(call)) {
419
        case IPC_M_PHONE_HUNGUP:
420
            /* TODO: Handle hangup */
421
            return;
422
        case KBD_MS_LEFT:
423
            newcon = gcons_mouse_btn(IPC_GET_ARG1(call));
424
            if (newcon != -1)
425
                change_console(newcon);
426
            retval = 0;
427
            break;
428
        case KBD_MS_MOVE:
429
            gcons_mouse_move(IPC_GET_ARG1(call),
430
                IPC_GET_ARG2(call));
431
            retval = 0;
432
            break;
433
        case KBD_EVENT:
434
            /* Got event from keyboard driver. */
435
            retval = 0;
436
            ev.type = IPC_GET_ARG1(call);
437
            ev.key = IPC_GET_ARG2(call);
438
            ev.mods = IPC_GET_ARG3(call);
439
            ev.c = IPC_GET_ARG4(call);
440
 
4439 trochtova 441
            /* Switch to another virtual console */
442
            conn = &connections[active_console];
4419 trochtova 443
 
444
            if ((ev.key >= KC_F1) && (ev.key < KC_F1 +
445
                CONSOLE_COUNT) && ((ev.mods & KM_CTRL) == 0)) {
446
                if (ev.key == KC_F12)
447
                    change_console(KERNEL_CONSOLE);
448
                else
449
                    change_console(ev.key - KC_F1);
450
                break;
451
            }
452
 
4439 trochtova 453
            /* If client is awaiting key, send it */
454
            if (conn->keyrequest_counter > 0) {
4419 trochtova 455
                conn->keyrequest_counter--;
456
                ipc_answer_4(fifo_pop(conn->keyrequests), EOK,
457
                    ev.type, ev.key, ev.mods, ev.c);
458
                break;
459
            }
4439 trochtova 460
 
4419 trochtova 461
            keybuffer_push(&conn->keybuffer, &ev);
462
            retval = 0;
4439 trochtova 463
 
4419 trochtova 464
            break;
465
        default:
466
            retval = ENOENT;
467
        }
468
        ipc_answer_0(callid, retval);
469
    }
470
}
471
 
472
/** Handle CONSOLE_WRITE call. */
473
static void cons_write(int consnum, ipc_callid_t rid, ipc_call_t *request)
474
{
475
    ipc_callid_t callid;
476
    size_t size;
477
    wchar_t ch;
478
    size_t off;
4439 trochtova 479
 
4419 trochtova 480
    if (!ipc_data_write_receive(&callid, &size)) {
481
        ipc_answer_0(callid, EINVAL);
482
        ipc_answer_0(rid, EINVAL);
4420 trochtova 483
        return;
4419 trochtova 484
    }
4439 trochtova 485
 
4419 trochtova 486
    if (size > CWRITE_BUF_SIZE)
487
        size = CWRITE_BUF_SIZE;
4439 trochtova 488
 
4419 trochtova 489
    (void) ipc_data_write_finalize(callid, cwrite_buf, size);
4439 trochtova 490
 
4420 trochtova 491
    async_serialize_start();
4439 trochtova 492
 
4419 trochtova 493
    off = 0;
494
    while (off < size) {
495
        ch = str_decode(cwrite_buf, &off, size);
496
        write_char(consnum, ch);
497
    }
4439 trochtova 498
 
4420 trochtova 499
    async_serialize_end();
4439 trochtova 500
 
4419 trochtova 501
    gcons_notify_char(consnum);
502
    ipc_answer_1(rid, EOK, size);
503
}
504
 
505
/** Default thread for new connections */
506
static void client_connection(ipc_callid_t iid, ipc_call_t *icall)
507
{
508
    ipc_callid_t callid;
509
    ipc_call_t call;
510
    int consnum;
511
    ipcarg_t arg1, arg2, arg3, arg4;
512
    connection_t *conn;
513
    screenbuffer_t *scr;
514
 
515
    if ((consnum = find_free_connection()) == -1) {
516
        ipc_answer_0(iid, ELIMIT);
517
        return;
518
    }
519
    conn = &connections[consnum];
520
    conn->used = 1;
521
 
522
    async_serialize_start();
523
    gcons_notify_connect(consnum);
524
    conn->client_phone = IPC_GET_ARG5(*icall);
525
    screenbuffer_clear(&conn->screenbuffer);
4420 trochtova 526
    if (consnum == active_console)
527
        clrscr();
4419 trochtova 528
 
529
    /* Accept the connection */
530
    ipc_answer_0(iid, EOK);
531
 
4439 trochtova 532
    while (true) {
4419 trochtova 533
        async_serialize_end();
534
        callid = async_get_call(&call);
535
        async_serialize_start();
536
 
537
        arg1 = 0;
538
        arg2 = 0;
539
        arg3 = 0;
540
        arg4 = 0;
4439 trochtova 541
 
4419 trochtova 542
        switch (IPC_GET_METHOD(call)) {
543
        case IPC_M_PHONE_HUNGUP:
544
            gcons_notify_disconnect(consnum);
545
 
546
            /* Answer all pending requests */
547
            while (conn->keyrequest_counter > 0) {
548
                conn->keyrequest_counter--;
549
                ipc_answer_0(fifo_pop(conn->keyrequests),
550
                    ENOENT);
551
                break;
552
            }
553
            conn->used = 0;
554
            return;
555
        case CONSOLE_PUTCHAR:
556
            write_char(consnum, IPC_GET_ARG1(call));
557
            gcons_notify_char(consnum);
558
            break;
559
        case CONSOLE_WRITE:
4420 trochtova 560
            async_serialize_end();
4419 trochtova 561
            cons_write(consnum, callid, &call);
4420 trochtova 562
            async_serialize_start();
4419 trochtova 563
            continue;
564
        case CONSOLE_CLEAR:
565
            /* Send message to fb */
566
            if (consnum == active_console) {
567
                async_msg_0(fb_info.phone, FB_CLEAR);
568
            }
569
 
570
            screenbuffer_clear(&conn->screenbuffer);
571
 
572
            break;
573
        case CONSOLE_GOTO:
574
            screenbuffer_goto(&conn->screenbuffer,
575
                IPC_GET_ARG2(call), IPC_GET_ARG1(call));
576
            if (consnum == active_console)
577
                curs_goto(IPC_GET_ARG1(call),
578
                    IPC_GET_ARG2(call));
579
            break;
580
        case CONSOLE_GETSIZE:
581
            arg1 = fb_info.rows;
582
            arg2 = fb_info.cols;
583
            break;
584
        case CONSOLE_FLUSH:
585
            fb_pending_flush();
586
            if (consnum == active_console) {
587
                async_req_0_0(fb_info.phone, FB_FLUSH);
4439 trochtova 588
 
4419 trochtova 589
                scr = &(connections[consnum].screenbuffer);
590
                curs_goto(scr->position_y, scr->position_x);
591
            }
592
            break;
593
        case CONSOLE_SET_STYLE:
594
            fb_pending_flush();
595
            arg1 = IPC_GET_ARG1(call);
596
            screenbuffer_set_style(&conn->screenbuffer, arg1);
597
            if (consnum == active_console)
598
                set_style(arg1);
599
            break;
600
        case CONSOLE_SET_COLOR:
601
            fb_pending_flush();
602
            arg1 = IPC_GET_ARG1(call);
603
            arg2 = IPC_GET_ARG2(call);
604
            arg3 = IPC_GET_ARG3(call);
605
            screenbuffer_set_color(&conn->screenbuffer, arg1,
606
                arg2, arg3);
607
            if (consnum == active_console)
608
                set_color(arg1, arg2, arg3);
609
            break;
610
        case CONSOLE_SET_RGB_COLOR:
611
            fb_pending_flush();
612
            arg1 = IPC_GET_ARG1(call);
613
            arg2 = IPC_GET_ARG2(call);
614
            screenbuffer_set_rgb_color(&conn->screenbuffer, arg1,
615
                arg2);
616
            if (consnum == active_console)
617
                set_rgb_color(arg1, arg2);
618
            break;
619
        case CONSOLE_CURSOR_VISIBILITY:
620
            fb_pending_flush();
621
            arg1 = IPC_GET_ARG1(call);
622
            conn->screenbuffer.is_cursor_visible = arg1;
623
            if (consnum == active_console)
624
                curs_visibility(arg1);
625
            break;
626
        case CONSOLE_GETKEY:
627
            if (keybuffer_empty(&conn->keybuffer)) {
628
                /* buffer is empty -> store request */
629
                if (conn->keyrequest_counter <
4439 trochtova 630
                    MAX_KEYREQUESTS_BUFFERED) {
4419 trochtova 631
                    fifo_push(conn->keyrequests, callid);
632
                    conn->keyrequest_counter++;
633
                } else {
634
                    /*
635
                     * No key available and too many
636
                     * requests => fail.
637
                    */
638
                    ipc_answer_0(callid, ELIMIT);
639
                }
640
                continue;
641
            }
642
            kbd_event_t ev;
643
            keybuffer_pop(&conn->keybuffer, &ev);
644
            arg1 = ev.type;
645
            arg2 = ev.key;
646
            arg3 = ev.mods;
647
            arg4 = ev.c;
648
            break;
649
        case CONSOLE_KCON_ENABLE:
650
            change_console(KERNEL_CONSOLE);
651
            break;
652
        }
653
        ipc_answer_4(callid, EOK, arg1, arg2, arg3, arg4);
654
    }
655
}
656
 
657
static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
658
{
659
    change_console(prev_console);
660
}
661
 
662
int main(int argc, char *argv[])
663
{
664
    printf(NAME ": HelenOS Console service\n");
665
 
666
    ipcarg_t phonehash;
667
    size_t ib_size;
668
    int i;
669
 
670
    async_set_client_connection(client_connection);
671
 
672
    /* Connect to keyboard driver */
673
    kbd_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
674
    if (kbd_phone < 0) {
675
        printf(NAME ": Failed to connect to keyboard service\n");
676
        return -1;
677
    }
678
 
679
    if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
680
        printf(NAME ": Failed to create callback from keyboard service\n");
681
        return -1;
682
    }
683
 
684
    async_new_connection(phonehash, 0, NULL, keyboard_events);
685
 
686
    /* Connect to framebuffer driver */
687
    fb_info.phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VIDEO, 0, 0);
688
    if (fb_info.phone < 0) {
689
        printf(NAME ": Failed to connect to video service\n");
690
        return -1;
691
    }
692
 
693
    /* Disable kernel output to the console */
694
    __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
695
 
696
    /* Initialize gcons */
697
    gcons_init(fb_info.phone);
698
    /* Synchronize, the gcons can have something in queue */
699
    async_req_0_0(fb_info.phone, FB_FLUSH);
700
 
701
    async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.rows,
702
        &fb_info.cols);
703
    set_rgb_color(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
704
    clrscr();
705
 
706
    /* Init virtual consoles */
707
    for (i = 0; i < CONSOLE_COUNT; i++) {
708
        connections[i].used = 0;
709
        keybuffer_init(&connections[i].keybuffer);
710
 
711
        connections[i].keyrequests.head = 0;
712
        connections[i].keyrequests.tail = 0;
713
        connections[i].keyrequests.items = MAX_KEYREQUESTS_BUFFERED;
714
        connections[i].keyrequest_counter = 0;
715
 
716
        if (screenbuffer_init(&connections[i].screenbuffer,
717
            fb_info.cols, fb_info.rows) == NULL) {
718
            /* FIXME: handle error */
719
            return -1;
720
        }
721
    }
722
    connections[KERNEL_CONSOLE].used = 1;
4439 trochtova 723
 
4419 trochtova 724
    /* Set up shared memory buffer. */
725
    ib_size = sizeof(keyfield_t) * fb_info.cols * fb_info.rows;
726
    interbuffer = as_get_mappable_page(ib_size);
4439 trochtova 727
 
728
    fb_pending.cnt = 0;
729
 
4419 trochtova 730
    if (as_area_create(interbuffer, ib_size, AS_AREA_READ |
731
        AS_AREA_WRITE | AS_AREA_CACHEABLE) != interbuffer) {
732
        interbuffer = NULL;
733
    }
4439 trochtova 734
 
4419 trochtova 735
    if (interbuffer) {
736
        if (ipc_share_out_start(fb_info.phone, interbuffer,
737
            AS_AREA_READ) != EOK) {
738
            as_area_destroy(interbuffer);
739
            interbuffer = NULL;
740
        }
741
    }
742
 
743
    curs_goto(0, 0);
744
    curs_visibility(
745
        connections[active_console].screenbuffer.is_cursor_visible);
746
 
747
    /* Register at NS */
748
    if (ipc_connect_to_me(PHONE_NS, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
749
        return -1;
750
 
751
    /* Receive kernel notifications */
752
    if (event_subscribe(EVENT_KCONSOLE, 0) != EOK)
753
        printf(NAME ": Error registering kconsole notifications\n");
4439 trochtova 754
 
4419 trochtova 755
    async_set_interrupt_received(interrupt_received);
756
 
757
    // FIXME: avoid connectiong to itself, keep using klog
758
    // printf(NAME ": Accepting connections\n");
759
    async_manager();
760
 
761
    return 0;
762
}
763
 
764
/** @}
765
 */