source: mainline/uspace/srv/hid/console/console.c@ ce3efa0

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since ce3efa0 was ce3efa0, checked in by Martin Decky <martin@…>, 11 years ago

cstyle
(no change in functionality)
  • Property mode set to 100644
File size: 16.7 KB
Line 
1/*
2 * Copyright (c) 2011 Martin Decky
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#include <async.h>
36#include <stdio.h>
37#include <adt/prodcons.h>
38#include <io/input.h>
39#include <ipc/vfs.h>
40#include <errno.h>
41#include <str_error.h>
42#include <loc.h>
43#include <event.h>
44#include <io/con_srv.h>
45#include <io/kbd_event.h>
46#include <io/keycode.h>
47#include <io/chargrid.h>
48#include <io/output.h>
49#include <align.h>
50#include <malloc.h>
51#include <as.h>
52#include <fibril_synch.h>
53#include "console.h"
54
55#define NAME "console"
56#define NAMESPACE "term"
57
58#define UTF8_CHAR_BUFFER_SIZE (STR_BOUNDS(1) + 1)
59
60typedef struct {
61 atomic_t refcnt; /**< Connection reference count */
62 prodcons_t input_pc; /**< Incoming keyboard events */
63
64 /**
65 * Not yet sent bytes of last char event.
66 */
67 char char_remains[UTF8_CHAR_BUFFER_SIZE];
68 size_t char_remains_len; /**< Number of not yet sent bytes. */
69
70 fibril_mutex_t mtx; /**< Lock protecting mutable fields */
71
72 size_t index; /**< Console index */
73 service_id_t dsid; /**< Service handle */
74
75 sysarg_t cols; /**< Number of columns */
76 sysarg_t rows; /**< Number of rows */
77 console_caps_t ccaps; /**< Console capabilities */
78
79 chargrid_t *frontbuf; /**< Front buffer */
80 frontbuf_handle_t fbid; /**< Front buffer handle */
81 con_srvs_t srvs; /**< Console service setup */
82} console_t;
83
84/** Input server proxy */
85static input_t *input;
86
87/** Session to the output server */
88static async_sess_t *output_sess;
89
90/** Output dimensions */
91static sysarg_t cols;
92static sysarg_t rows;
93
94/** Array of data for virtual consoles */
95static console_t consoles[CONSOLE_COUNT];
96
97/** Mutex for console switching */
98static FIBRIL_MUTEX_INITIALIZE(switch_mtx);
99
100static console_t *prev_console = &consoles[0];
101static console_t *active_console = &consoles[0];
102static console_t *kernel_console = &consoles[KERNEL_CONSOLE];
103
104static int input_ev_key(input_t *, kbd_event_type_t, keycode_t, keymod_t, wchar_t);
105static int input_ev_move(input_t *, int, int);
106static int input_ev_abs_move(input_t *, unsigned, unsigned, unsigned, unsigned);
107static int input_ev_button(input_t *, int, int);
108
109static input_ev_ops_t input_ev_ops = {
110 .key = input_ev_key,
111 .move = input_ev_move,
112 .abs_move = input_ev_abs_move,
113 .button = input_ev_button
114};
115
116static int cons_open(con_srvs_t *, con_srv_t *);
117static int cons_close(con_srv_t *);
118static int cons_read(con_srv_t *, void *, size_t);
119static int cons_write(con_srv_t *, void *, size_t);
120static void cons_sync(con_srv_t *);
121static void cons_clear(con_srv_t *);
122static void cons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
123static int cons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
124static int cons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
125static int cons_get_color_cap(con_srv_t *, console_caps_t *);
126static void cons_set_style(con_srv_t *, console_style_t);
127static void cons_set_color(con_srv_t *, console_color_t, console_color_t,
128 console_color_attr_t);
129static void cons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
130static void cons_set_cursor_visibility(con_srv_t *, bool);
131static int cons_get_event(con_srv_t *, cons_event_t *);
132
133static con_ops_t con_ops = {
134 .open = cons_open,
135 .close = cons_close,
136 .read = cons_read,
137 .write = cons_write,
138 .sync = cons_sync,
139 .clear = cons_clear,
140 .set_pos = cons_set_pos,
141 .get_pos = cons_get_pos,
142 .get_size = cons_get_size,
143 .get_color_cap = cons_get_color_cap,
144 .set_style = cons_set_style,
145 .set_color = cons_set_color,
146 .set_rgb_color = cons_set_rgb_color,
147 .set_cursor_visibility = cons_set_cursor_visibility,
148 .get_event = cons_get_event
149};
150
151static console_t *srv_to_console(con_srv_t *srv)
152{
153 return srv->srvs->sarg;
154}
155
156static void cons_update(console_t *cons)
157{
158 fibril_mutex_lock(&switch_mtx);
159 fibril_mutex_lock(&cons->mtx);
160
161 if ((cons == active_console) && (active_console != kernel_console)) {
162 output_update(output_sess, cons->fbid);
163 output_cursor_update(output_sess, cons->fbid);
164 }
165
166 fibril_mutex_unlock(&cons->mtx);
167 fibril_mutex_unlock(&switch_mtx);
168}
169
170static void cons_update_cursor(console_t *cons)
171{
172 fibril_mutex_lock(&switch_mtx);
173 fibril_mutex_lock(&cons->mtx);
174
175 if ((cons == active_console) && (active_console != kernel_console))
176 output_cursor_update(output_sess, cons->fbid);
177
178 fibril_mutex_unlock(&cons->mtx);
179 fibril_mutex_unlock(&switch_mtx);
180}
181
182static void cons_damage(console_t *cons)
183{
184 fibril_mutex_lock(&switch_mtx);
185 fibril_mutex_lock(&cons->mtx);
186
187 if ((cons == active_console) && (active_console != kernel_console)) {
188 output_damage(output_sess, cons->fbid, 0, 0, cons->cols,
189 cons->rows);
190 output_cursor_update(output_sess, cons->fbid);
191 }
192
193 fibril_mutex_unlock(&cons->mtx);
194 fibril_mutex_unlock(&switch_mtx);
195}
196
197static void cons_switch(console_t *cons)
198{
199 fibril_mutex_lock(&switch_mtx);
200
201 if (cons == active_console) {
202 fibril_mutex_unlock(&switch_mtx);
203 return;
204 }
205
206 if (cons == kernel_console) {
207 output_yield(output_sess);
208 if (!console_kcon()) {
209 output_claim(output_sess);
210 fibril_mutex_unlock(&switch_mtx);
211 return;
212 }
213 }
214
215 if (active_console == kernel_console)
216 output_claim(output_sess);
217
218 prev_console = active_console;
219 active_console = cons;
220
221 fibril_mutex_unlock(&switch_mtx);
222
223 cons_damage(cons);
224}
225
226static console_t *cons_get_active_uspace(void)
227{
228 fibril_mutex_lock(&switch_mtx);
229
230 console_t *active_uspace = active_console;
231 if (active_uspace == kernel_console)
232 active_uspace = prev_console;
233
234 assert(active_uspace != kernel_console);
235
236 fibril_mutex_unlock(&switch_mtx);
237
238 return active_uspace;
239}
240
241static int input_ev_key(input_t *input, kbd_event_type_t type, keycode_t key,
242 keymod_t mods, wchar_t c)
243{
244 if ((key >= KC_F1) && (key < KC_F1 + CONSOLE_COUNT) &&
245 ((mods & KM_CTRL) == 0)) {
246 cons_switch(&consoles[key - KC_F1]);
247 } else {
248 /* Got key press/release event */
249 kbd_event_t *event =
250 (kbd_event_t *) malloc(sizeof(kbd_event_t));
251 if (event == NULL) {
252 return ENOMEM;
253 }
254
255 link_initialize(&event->link);
256 event->type = type;
257 event->key = key;
258 event->mods = mods;
259 event->c = c;
260
261 /*
262 * Kernel console does not read events
263 * from us, so we will redirect them
264 * to the (last) active userspace console
265 * if necessary.
266 */
267 console_t *target_console = cons_get_active_uspace();
268
269 prodcons_produce(&target_console->input_pc,
270 &event->link);
271 }
272
273 return EOK;
274}
275
276static int input_ev_move(input_t *input, int dx, int dy)
277{
278 return EOK;
279}
280
281static int input_ev_abs_move(input_t *input, unsigned x , unsigned y,
282 unsigned max_x, unsigned max_y)
283{
284 return EOK;
285}
286
287static int input_ev_button(input_t *input, int bnum, int bpress)
288{
289 return EOK;
290}
291
292/** Process a character from the client (TTY emulation). */
293static void cons_write_char(console_t *cons, wchar_t ch)
294{
295 sysarg_t updated = 0;
296
297 fibril_mutex_lock(&cons->mtx);
298
299 switch (ch) {
300 case '\n':
301 updated = chargrid_newline(cons->frontbuf);
302 break;
303 case '\r':
304 break;
305 case '\t':
306 updated = chargrid_tabstop(cons->frontbuf, 8);
307 break;
308 case '\b':
309 updated = chargrid_backspace(cons->frontbuf);
310 break;
311 default:
312 updated = chargrid_putchar(cons->frontbuf, ch, true);
313 }
314
315 fibril_mutex_unlock(&cons->mtx);
316
317 if (updated > 1)
318 cons_update(cons);
319}
320
321static void cons_set_cursor_vis(console_t *cons, bool visible)
322{
323 fibril_mutex_lock(&cons->mtx);
324 chargrid_set_cursor_visibility(cons->frontbuf, visible);
325 fibril_mutex_unlock(&cons->mtx);
326
327 cons_update_cursor(cons);
328}
329
330static int cons_open(con_srvs_t *srvs, con_srv_t *srv)
331{
332 return EOK;
333}
334
335static int cons_close(con_srv_t *srv)
336{
337 return EOK;
338}
339
340static int cons_read(con_srv_t *srv, void *buf, size_t size)
341{
342 uint8_t *bbuf = buf;
343 console_t *cons = srv_to_console(srv);
344 size_t pos = 0;
345
346 /*
347 * Read input from keyboard and copy it to the buffer.
348 * We need to handle situation when wchar is split by 2 following
349 * reads.
350 */
351 while (pos < size) {
352 /* Copy to the buffer remaining characters. */
353 while ((pos < size) && (cons->char_remains_len > 0)) {
354 bbuf[pos] = cons->char_remains[0];
355 pos++;
356
357 /* Unshift the array. */
358 for (size_t i = 1; i < cons->char_remains_len; i++)
359 cons->char_remains[i - 1] = cons->char_remains[i];
360
361 cons->char_remains_len--;
362 }
363
364 /* Still not enough? Then get another key from the queue. */
365 if (pos < size) {
366 link_t *link = prodcons_consume(&cons->input_pc);
367 kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
368
369 /* Accept key presses of printable chars only. */
370 if ((event->type == KEY_PRESS) && (event->c != 0)) {
371 wchar_t tmp[2] = { event->c, 0 };
372 wstr_to_str(cons->char_remains, UTF8_CHAR_BUFFER_SIZE, tmp);
373 cons->char_remains_len = str_size(cons->char_remains);
374 }
375
376 free(event);
377 }
378 }
379
380 return size;
381}
382
383static int cons_write(con_srv_t *srv, void *data, size_t size)
384{
385 console_t *cons = srv_to_console(srv);
386
387 size_t off = 0;
388 while (off < size)
389 cons_write_char(cons, str_decode(data, &off, size));
390
391 return size;
392}
393
394static void cons_sync(con_srv_t *srv)
395{
396 console_t *cons = srv_to_console(srv);
397
398 cons_update(cons);
399}
400
401static void cons_clear(con_srv_t *srv)
402{
403 console_t *cons = srv_to_console(srv);
404
405 fibril_mutex_lock(&cons->mtx);
406 chargrid_clear(cons->frontbuf);
407 fibril_mutex_unlock(&cons->mtx);
408
409 cons_update(cons);
410}
411
412static void cons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
413{
414 console_t *cons = srv_to_console(srv);
415
416 fibril_mutex_lock(&cons->mtx);
417 chargrid_set_cursor(cons->frontbuf, col, row);
418 fibril_mutex_unlock(&cons->mtx);
419
420 cons_update_cursor(cons);
421}
422
423static int cons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
424{
425 console_t *cons = srv_to_console(srv);
426
427 fibril_mutex_lock(&cons->mtx);
428 chargrid_get_cursor(cons->frontbuf, col, row);
429 fibril_mutex_unlock(&cons->mtx);
430
431 return EOK;
432}
433
434static int cons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
435{
436 console_t *cons = srv_to_console(srv);
437
438 fibril_mutex_lock(&cons->mtx);
439 *cols = cons->cols;
440 *rows = cons->rows;
441 fibril_mutex_unlock(&cons->mtx);
442
443 return EOK;
444}
445
446static int cons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
447{
448 console_t *cons = srv_to_console(srv);
449
450 fibril_mutex_lock(&cons->mtx);
451 *ccaps = cons->ccaps;
452 fibril_mutex_unlock(&cons->mtx);
453
454 return EOK;
455}
456
457static void cons_set_style(con_srv_t *srv, console_style_t style)
458{
459 console_t *cons = srv_to_console(srv);
460
461 fibril_mutex_lock(&cons->mtx);
462 chargrid_set_style(cons->frontbuf, style);
463 fibril_mutex_unlock(&cons->mtx);
464}
465
466static void cons_set_color(con_srv_t *srv, console_color_t bgcolor,
467 console_color_t fgcolor, console_color_attr_t attr)
468{
469 console_t *cons = srv_to_console(srv);
470
471 fibril_mutex_lock(&cons->mtx);
472 chargrid_set_color(cons->frontbuf, bgcolor, fgcolor, attr);
473 fibril_mutex_unlock(&cons->mtx);
474}
475
476static void cons_set_rgb_color(con_srv_t *srv, pixel_t bgcolor,
477 pixel_t fgcolor)
478{
479 console_t *cons = srv_to_console(srv);
480
481 fibril_mutex_lock(&cons->mtx);
482 chargrid_set_rgb_color(cons->frontbuf, bgcolor, fgcolor);
483 fibril_mutex_unlock(&cons->mtx);
484}
485
486static void cons_set_cursor_visibility(con_srv_t *srv, bool visible)
487{
488 console_t *cons = srv_to_console(srv);
489
490 cons_set_cursor_vis(cons, visible);
491}
492
493static int cons_get_event(con_srv_t *srv, cons_event_t *event)
494{
495 console_t *cons = srv_to_console(srv);
496 link_t *link = prodcons_consume(&cons->input_pc);
497 kbd_event_t *kevent = list_get_instance(link, kbd_event_t, link);
498
499 event->type = CEV_KEY;
500 event->ev.key = *kevent;
501
502 free(kevent);
503 return EOK;
504}
505
506static void client_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
507{
508 console_t *cons = NULL;
509
510 for (size_t i = 0; i < CONSOLE_COUNT; i++) {
511 if (i == KERNEL_CONSOLE)
512 continue;
513
514 if (consoles[i].dsid == (service_id_t) IPC_GET_ARG1(*icall)) {
515 cons = &consoles[i];
516 break;
517 }
518 }
519
520 if (cons == NULL) {
521 async_answer_0(iid, ENOENT);
522 return;
523 }
524
525 if (atomic_postinc(&cons->refcnt) == 0)
526 cons_set_cursor_vis(cons, true);
527
528 con_conn(iid, icall, &cons->srvs);
529}
530
531static int input_connect(const char *svc)
532{
533 async_sess_t *sess;
534 service_id_t dsid;
535
536 int rc = loc_service_get_id(svc, &dsid, 0);
537 if (rc != EOK) {
538 printf("%s: Input service %s not found\n", NAME, svc);
539 return rc;
540 }
541
542 sess = loc_service_connect(EXCHANGE_ATOMIC, dsid, 0);
543 if (sess == NULL) {
544 printf("%s: Unable to connect to input service %s\n", NAME,
545 svc);
546 return EIO;
547 }
548
549 rc = input_open(sess, &input_ev_ops, NULL, &input);
550 if (rc != EOK) {
551 async_hangup(sess);
552 printf("%s: Unable to communicate with service %s (%s)\n",
553 NAME, svc, str_error(rc));
554 return rc;
555 }
556
557 return EOK;
558}
559
560static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
561{
562 cons_switch(prev_console);
563}
564
565static async_sess_t *output_connect(const char *svc)
566{
567 async_sess_t *sess;
568 service_id_t dsid;
569
570 int rc = loc_service_get_id(svc, &dsid, 0);
571 if (rc == EOK) {
572 sess = loc_service_connect(EXCHANGE_SERIALIZE, dsid, 0);
573 if (sess == NULL) {
574 printf("%s: Unable to connect to output service %s\n",
575 NAME, svc);
576 return NULL;
577 }
578 } else
579 return NULL;
580
581 return sess;
582}
583
584static bool console_srv_init(char *input_svc, char *output_svc)
585{
586 /* Connect to input service */
587 int rc = input_connect(input_svc);
588 if (rc != EOK)
589 return false;
590
591 /* Connect to output service */
592 output_sess = output_connect(output_svc);
593 if (output_sess == NULL)
594 return false;
595
596 /* Register server */
597 async_set_client_connection(client_connection);
598 rc = loc_server_register(NAME);
599 if (rc != EOK) {
600 printf("%s: Unable to register server (%s)\n", NAME,
601 str_error(rc));
602 return false;
603 }
604
605 output_get_dimensions(output_sess, &cols, &rows);
606 output_set_style(output_sess, STYLE_NORMAL);
607
608 console_caps_t ccaps;
609 output_get_caps(output_sess, &ccaps);
610
611 /* Inititalize consoles */
612 for (size_t i = 0; i < CONSOLE_COUNT; i++) {
613 consoles[i].index = i;
614 atomic_set(&consoles[i].refcnt, 0);
615 fibril_mutex_initialize(&consoles[i].mtx);
616 prodcons_initialize(&consoles[i].input_pc);
617 consoles[i].char_remains_len = 0;
618
619 if (i == KERNEL_CONSOLE)
620 continue;
621
622 consoles[i].cols = cols;
623 consoles[i].rows = rows;
624 consoles[i].ccaps = ccaps;
625 consoles[i].frontbuf =
626 chargrid_create(cols, rows, CHARGRID_FLAG_SHARED);
627
628 if (consoles[i].frontbuf == NULL) {
629 printf("%s: Unable to allocate frontbuffer %zu\n", NAME, i);
630 return false;
631 }
632
633 consoles[i].fbid = output_frontbuf_create(output_sess,
634 consoles[i].frontbuf);
635 if (consoles[i].fbid == 0) {
636 printf("%s: Unable to create frontbuffer %zu\n", NAME, i);
637 return false;
638 }
639
640 con_srvs_init(&consoles[i].srvs);
641 consoles[i].srvs.ops = &con_ops;
642 consoles[i].srvs.sarg = &consoles[i];
643
644 char vc[LOC_NAME_MAXLEN + 1];
645 snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
646
647 if (loc_service_register(vc, &consoles[i].dsid) != EOK) {
648 printf("%s: Unable to register device %s\n", NAME, vc);
649 return false;
650 }
651 }
652
653 cons_damage(active_console);
654
655 /* Receive kernel notifications */
656 async_set_interrupt_received(interrupt_received);
657 rc = event_subscribe(EVENT_KCONSOLE, 0);
658 if (rc != EOK)
659 printf("%s: Failed to register kconsole notifications (%s)\n",
660 NAME, str_error(rc));
661
662 return true;
663}
664
665static void usage(char *name)
666{
667 printf("Usage: %s <input_dev> <output_dev>\n", name);
668}
669
670int main(int argc, char *argv[])
671{
672 if (argc < 3) {
673 usage(argv[0]);
674 return -1;
675 }
676
677 printf("%s: HelenOS Console service\n", NAME);
678
679 if (!console_srv_init(argv[1], argv[2]))
680 return -1;
681
682 printf("%s: Accepting connections\n", NAME);
683 task_retval(0);
684 async_manager();
685
686 /* Never reached */
687 return 0;
688}
689
690/** @}
691 */
Note: See TracBrowser for help on using the repository browser.