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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since eb13ef8 was eb13ef8, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 6 years ago

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