source: mainline/uspace/console/console.c@ 06e1e95

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 06e1e95 was 2def788, checked in by Jakub Jermar <jakub@…>, 19 years ago

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