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

Last change on this file since dd495c9 was 49aaa0e, checked in by Jiri Svoboda <jiri@…>, 18 months ago

Switch virtual consoles using Alt-Fn or Shift-Fn

Shift-Fn is useful because Alt-Fn is usually taken by desktop
environment when running in an emulator.
  • Property mode set to 100644
File size: 23.8 KB
Line 
1/*
2 * Copyright (c) 2024 Jiri Svoboda
3 * Copyright (c) 2011 Martin Decky
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup console
31 * @{
32 */
33/** @file
34 */
35
36#include <async.h>
37#include <stdio.h>
38#include <adt/prodcons.h>
39#include <io/console.h>
40#include <io/input.h>
41#include <ipc/vfs.h>
42#include <errno.h>
43#include <str_error.h>
44#include <loc.h>
45#include <io/con_srv.h>
46#include <io/kbd_event.h>
47#include <io/keycode.h>
48#include <io/chargrid.h>
49#include <io/output.h>
50#include <align.h>
51#include <as.h>
52#include <task.h>
53#include <fibril_synch.h>
54#include <stdatomic.h>
55#include <stdlib.h>
56#include <str.h>
57#include "console.h"
58
59#define NAME "console"
60#define NAMESPACE "term"
61
62#define UTF8_CHAR_BUFFER_SIZE (STR_BOUNDS(1) + 1)
63
64typedef struct {
65 atomic_flag refcnt; /**< Connection reference count */
66 prodcons_t input_pc; /**< Incoming console events */
67
68 /**
69 * Not yet sent bytes of last char event.
70 */
71 char char_remains[UTF8_CHAR_BUFFER_SIZE];
72 size_t char_remains_len; /**< Number of not yet sent bytes. */
73
74 fibril_mutex_t mtx; /**< Lock protecting mutable fields */
75
76 size_t index; /**< Console index */
77 service_id_t dsid; /**< Service handle */
78
79 sysarg_t cols; /**< Number of columns */
80 sysarg_t rows; /**< Number of rows */
81 console_caps_t ccaps; /**< Console capabilities */
82
83 sysarg_t ucols; /**< Number of columns in user buffer */
84 sysarg_t urows; /**< Number of rows in user buffer */
85 charfield_t *ubuf; /**< User buffer */
86
87 chargrid_t *frontbuf; /**< Front buffer */
88 frontbuf_handle_t fbid; /**< Front buffer handle */
89 con_srvs_t srvs; /**< Console service setup */
90} console_t;
91
92static loc_srv_t *console_srv;
93
94/** Input server proxy */
95static input_t *input;
96static bool active = false;
97
98/** Session to the output server */
99static async_sess_t *output_sess;
100
101/** Output dimensions */
102static sysarg_t cols;
103static sysarg_t rows;
104
105/** Mouse pointer X coordinate */
106static int pointer_x;
107/** Mouse pointer Y coordinate */
108static int pointer_y;
109/** Character under mouse cursor */
110static charfield_t pointer_bg;
111
112static int mouse_scale_x = 4;
113static int mouse_scale_y = 8;
114
115/** Array of data for virtual consoles */
116static console_t consoles[CONSOLE_COUNT];
117
118/** Mutex for console switching */
119static FIBRIL_MUTEX_INITIALIZE(switch_mtx);
120
121static console_t *active_console = &consoles[0];
122
123static errno_t input_ev_active(input_t *);
124static errno_t input_ev_deactive(input_t *);
125static errno_t input_ev_key(input_t *, unsigned, kbd_event_type_t, keycode_t,
126 keymod_t, char32_t);
127static errno_t input_ev_move(input_t *, unsigned, int, int);
128static errno_t input_ev_abs_move(input_t *, unsigned, unsigned, unsigned,
129 unsigned, unsigned);
130static errno_t input_ev_button(input_t *, unsigned, int, int);
131static errno_t input_ev_dclick(input_t *, unsigned, int);
132
133static input_ev_ops_t input_ev_ops = {
134 .active = input_ev_active,
135 .deactive = input_ev_deactive,
136 .key = input_ev_key,
137 .move = input_ev_move,
138 .abs_move = input_ev_abs_move,
139 .button = input_ev_button,
140 .dclick = input_ev_dclick
141};
142
143static errno_t cons_open(con_srvs_t *, con_srv_t *);
144static errno_t cons_close(con_srv_t *);
145static errno_t cons_read(con_srv_t *, void *, size_t, size_t *);
146static errno_t cons_write(con_srv_t *, void *, size_t, size_t *);
147static void cons_sync(con_srv_t *);
148static void cons_clear(con_srv_t *);
149static void cons_set_pos(con_srv_t *, sysarg_t col, sysarg_t row);
150static errno_t cons_get_pos(con_srv_t *, sysarg_t *, sysarg_t *);
151static errno_t cons_get_size(con_srv_t *, sysarg_t *, sysarg_t *);
152static errno_t cons_get_color_cap(con_srv_t *, console_caps_t *);
153static void cons_set_style(con_srv_t *, console_style_t);
154static void cons_set_color(con_srv_t *, console_color_t, console_color_t,
155 console_color_attr_t);
156static void cons_set_rgb_color(con_srv_t *, pixel_t, pixel_t);
157static void cons_set_cursor_visibility(con_srv_t *, bool);
158static errno_t cons_set_caption(con_srv_t *, const char *);
159static errno_t cons_get_event(con_srv_t *, cons_event_t *);
160static errno_t cons_map(con_srv_t *, sysarg_t, sysarg_t, charfield_t **);
161static void cons_unmap(con_srv_t *);
162static void cons_buf_update(con_srv_t *, sysarg_t, sysarg_t, sysarg_t,
163 sysarg_t);
164
165static con_ops_t con_ops = {
166 .open = cons_open,
167 .close = cons_close,
168 .read = cons_read,
169 .write = cons_write,
170 .sync = cons_sync,
171 .clear = cons_clear,
172 .set_pos = cons_set_pos,
173 .get_pos = cons_get_pos,
174 .get_size = cons_get_size,
175 .get_color_cap = cons_get_color_cap,
176 .set_style = cons_set_style,
177 .set_color = cons_set_color,
178 .set_rgb_color = cons_set_rgb_color,
179 .set_cursor_visibility = cons_set_cursor_visibility,
180 .set_caption = cons_set_caption,
181 .get_event = cons_get_event,
182 .map = cons_map,
183 .unmap = cons_unmap,
184 .update = cons_buf_update
185};
186
187static void pointer_draw(void);
188static void pointer_undraw(void);
189
190static console_t *srv_to_console(con_srv_t *srv)
191{
192 return srv->srvs->sarg;
193}
194
195static void cons_update(console_t *cons)
196{
197 fibril_mutex_lock(&switch_mtx);
198 fibril_mutex_lock(&cons->mtx);
199
200 if ((active) && (cons == active_console)) {
201 output_update(output_sess, cons->fbid);
202 output_cursor_update(output_sess, cons->fbid);
203 }
204
205 fibril_mutex_unlock(&cons->mtx);
206 fibril_mutex_unlock(&switch_mtx);
207}
208
209static void cons_update_cursor(console_t *cons)
210{
211 fibril_mutex_lock(&switch_mtx);
212 fibril_mutex_lock(&cons->mtx);
213
214 if ((active) && (cons == active_console))
215 output_cursor_update(output_sess, cons->fbid);
216
217 fibril_mutex_unlock(&cons->mtx);
218 fibril_mutex_unlock(&switch_mtx);
219}
220
221static void cons_damage(console_t *cons)
222{
223 fibril_mutex_lock(&switch_mtx);
224 fibril_mutex_lock(&cons->mtx);
225
226 if ((active) && (cons == active_console)) {
227 output_damage(output_sess, cons->fbid, 0, 0, cons->cols,
228 cons->rows);
229 output_cursor_update(output_sess, cons->fbid);
230 }
231
232 fibril_mutex_unlock(&cons->mtx);
233 fibril_mutex_unlock(&switch_mtx);
234}
235
236static void cons_switch(unsigned int index)
237{
238 /*
239 * The first undefined index is reserved
240 * for switching to the kernel console.
241 */
242 if (index == CONSOLE_COUNT) {
243 if (console_kcon())
244 active = false;
245
246 return;
247 }
248
249 if (index > CONSOLE_COUNT)
250 return;
251
252 console_t *cons = &consoles[index];
253
254 fibril_mutex_lock(&switch_mtx);
255 pointer_undraw();
256
257 if (cons == active_console) {
258 fibril_mutex_unlock(&switch_mtx);
259 return;
260 }
261
262 active_console = cons;
263
264 pointer_draw();
265 fibril_mutex_unlock(&switch_mtx);
266
267 cons_damage(cons);
268}
269
270/** Draw mouse pointer. */
271static void pointer_draw(void)
272{
273 charfield_t *ch;
274 int col, row;
275
276 /* Downscale coordinates to text resolution */
277 col = pointer_x / mouse_scale_x;
278 row = pointer_y / mouse_scale_y;
279
280 /* Make sure they are in range */
281 if (col < 0 || row < 0 || col >= (int)cols || row >= (int)rows)
282 return;
283
284 ch = chargrid_charfield_at(active_console->frontbuf, col, row);
285
286 /*
287 * Store background attributes for undrawing the pointer.
288 * This is necessary as styles cannot be inverted with
289 * round trip (unlike RGB or INDEX)
290 */
291 pointer_bg = *ch;
292
293 /* In general the color should be a one's complement of the background */
294 if (ch->attrs.type == CHAR_ATTR_INDEX) {
295 ch->attrs.val.index.bgcolor ^= 0xf;
296 ch->attrs.val.index.fgcolor ^= 0xf;
297 } else if (ch->attrs.type == CHAR_ATTR_RGB) {
298 ch->attrs.val.rgb.fgcolor ^= 0xffffff;
299 ch->attrs.val.rgb.bgcolor ^= 0xffffff;
300 } else if (ch->attrs.type == CHAR_ATTR_STYLE) {
301 /* Don't have a proper inverse for each style */
302 if (ch->attrs.val.style == STYLE_INVERTED)
303 ch->attrs.val.style = STYLE_NORMAL;
304 else
305 ch->attrs.val.style = STYLE_INVERTED;
306 }
307
308 /* Make sure the cell gets updated */
309 ch->flags |= CHAR_FLAG_DIRTY;
310}
311
312/** Undraw mouse pointer. */
313static void pointer_undraw(void)
314{
315 charfield_t *ch;
316 int col, row;
317
318 col = pointer_x / mouse_scale_x;
319 row = pointer_y / mouse_scale_y;
320 if (col < 0 || row < 0 || col >= (int)cols || row >= (int)rows)
321 return;
322
323 ch = chargrid_charfield_at(active_console->frontbuf, col, row);
324 *ch = pointer_bg;
325 ch->flags |= CHAR_FLAG_DIRTY;
326}
327
328/** Queue console event.
329 *
330 * @param cons Console
331 * @param ev Console event
332 */
333static void console_queue_cons_event(console_t *cons, cons_event_t *ev)
334{
335 /* Got key press/release event */
336 cons_event_t *event =
337 (cons_event_t *) malloc(sizeof(cons_event_t));
338 if (event == NULL)
339 return;
340
341 *event = *ev;
342 link_initialize(&event->link);
343
344 prodcons_produce(&cons->input_pc, &event->link);
345}
346
347static errno_t input_ev_active(input_t *input)
348{
349 active = true;
350 output_claim(output_sess);
351 cons_damage(active_console);
352
353 return EOK;
354}
355
356static errno_t input_ev_deactive(input_t *input)
357{
358 active = false;
359 output_yield(output_sess);
360
361 return EOK;
362}
363
364static errno_t input_ev_key(input_t *input, unsigned kbd_id,
365 kbd_event_type_t type, keycode_t key, keymod_t mods, char32_t c)
366{
367 cons_event_t event;
368 bool alt;
369 bool shift;
370
371 alt = (mods & KM_ALT) != 0 && (mods & (KM_CTRL | KM_SHIFT)) == 0;
372 shift = (mods & KM_SHIFT) != 0 && (mods & (KM_CTRL | KM_ALT)) == 0;
373
374 /* Switch console on Alt+Fn or Shift+Fn */
375 if ((key >= KC_F1) && (key <= KC_F1 + CONSOLE_COUNT) &&
376 (alt || shift)) {
377 cons_switch(key - KC_F1);
378 } else {
379 /* Got key press/release event */
380 event.type = CEV_KEY;
381
382 (void)kbd_id;
383 event.ev.key.type = type;
384 event.ev.key.key = key;
385 event.ev.key.mods = mods;
386 event.ev.key.c = c;
387
388 console_queue_cons_event(active_console, &event);
389 }
390
391 return EOK;
392}
393
394/** Update pointer position.
395 *
396 * @param new_x New X coordinate (in pixels)
397 * @param new_y New Y coordinate (in pixels)
398 */
399static void pointer_update(int new_x, int new_y)
400{
401 bool upd_pointer;
402
403 /* Make sure coordinates are in range */
404
405 if (new_x < 0)
406 new_x = 0;
407 if (new_x >= (int)cols * mouse_scale_x)
408 new_x = cols * mouse_scale_x - 1;
409 if (new_y < 0)
410 new_y = 0;
411 if (new_y >= (int)rows * mouse_scale_y)
412 new_y = rows * mouse_scale_y - 1;
413
414 /* Determine if pointer moved to a different character cell */
415 upd_pointer = (new_x / mouse_scale_x != pointer_x / mouse_scale_x) ||
416 (new_y / mouse_scale_y != pointer_y / mouse_scale_y);
417
418 if (upd_pointer)
419 pointer_undraw();
420
421 /* Store new pointer position */
422 pointer_x = new_x;
423 pointer_y = new_y;
424
425 if (upd_pointer) {
426 pointer_draw();
427 cons_update(active_console);
428 }
429}
430
431static errno_t input_ev_move(input_t *input, unsigned pos_id, int dx, int dy)
432{
433 (void) pos_id;
434 pointer_update(pointer_x + dx, pointer_y + dy);
435 return EOK;
436}
437
438static errno_t input_ev_abs_move(input_t *input, unsigned pos_id, unsigned x,
439 unsigned y, unsigned max_x, unsigned max_y)
440{
441 (void)pos_id;
442 pointer_update(mouse_scale_x * cols * x / max_x, mouse_scale_y * rows * y / max_y);
443 return EOK;
444}
445
446static errno_t input_ev_button(input_t *input, unsigned pos_id, int bnum,
447 int bpress)
448{
449 cons_event_t event;
450
451 (void)pos_id;
452
453 event.type = CEV_POS;
454 event.ev.pos.type = bpress ? POS_PRESS : POS_RELEASE;
455 event.ev.pos.btn_num = bnum;
456 event.ev.pos.hpos = pointer_x / mouse_scale_x;
457 event.ev.pos.vpos = pointer_y / mouse_scale_y;
458
459 console_queue_cons_event(active_console, &event);
460 return EOK;
461}
462
463static errno_t input_ev_dclick(input_t *input, unsigned pos_id, int bnum)
464{
465 cons_event_t event;
466
467 (void)pos_id;
468
469 event.type = CEV_POS;
470 event.ev.pos.type = POS_DCLICK;
471 event.ev.pos.btn_num = bnum;
472 event.ev.pos.hpos = pointer_x / mouse_scale_x;
473 event.ev.pos.vpos = pointer_y / mouse_scale_y;
474
475 console_queue_cons_event(active_console, &event);
476 return EOK;
477}
478
479/** Process a character from the client (TTY emulation). */
480static void cons_write_char(console_t *cons, char32_t ch)
481{
482 sysarg_t updated = 0;
483
484 fibril_mutex_lock(&cons->mtx);
485 pointer_undraw();
486
487 switch (ch) {
488 case '\n':
489 updated = chargrid_newline(cons->frontbuf);
490 break;
491 case '\r':
492 break;
493 case '\t':
494 updated = chargrid_tabstop(cons->frontbuf, 8);
495 break;
496 case '\b':
497 updated = chargrid_backspace(cons->frontbuf);
498 break;
499 default:
500 updated = chargrid_putuchar(cons->frontbuf, ch, true);
501 }
502
503 pointer_draw();
504 fibril_mutex_unlock(&cons->mtx);
505
506 if (updated > 1)
507 cons_update(cons);
508}
509
510static void cons_set_cursor_vis(console_t *cons, bool visible)
511{
512 fibril_mutex_lock(&cons->mtx);
513 pointer_undraw();
514 chargrid_set_cursor_visibility(cons->frontbuf, visible);
515 pointer_draw();
516 fibril_mutex_unlock(&cons->mtx);
517
518 cons_update_cursor(cons);
519}
520
521static errno_t cons_open(con_srvs_t *srvs, con_srv_t *srv)
522{
523 return EOK;
524}
525
526static errno_t cons_close(con_srv_t *srv)
527{
528 return EOK;
529}
530
531static errno_t cons_read(con_srv_t *srv, void *buf, size_t size, size_t *nread)
532{
533 uint8_t *bbuf = buf;
534 console_t *cons = srv_to_console(srv);
535 size_t pos = 0;
536
537 /*
538 * Read input from keyboard and copy it to the buffer.
539 * We need to handle situation when wchar is split by 2 following
540 * reads.
541 */
542 while (pos < size) {
543 /* Copy to the buffer remaining characters. */
544 while ((pos < size) && (cons->char_remains_len > 0)) {
545 bbuf[pos] = cons->char_remains[0];
546 pos++;
547
548 /* Unshift the array. */
549 for (size_t i = 1; i < cons->char_remains_len; i++)
550 cons->char_remains[i - 1] = cons->char_remains[i];
551
552 cons->char_remains_len--;
553 }
554
555 /* Still not enough? Then get another key from the queue. */
556 if (pos < size) {
557 link_t *link = prodcons_consume(&cons->input_pc);
558 cons_event_t *event = list_get_instance(link,
559 cons_event_t, link);
560
561 /* Accept key presses of printable chars only. */
562 if (event->type == CEV_KEY && event->ev.key.type == KEY_PRESS &&
563 (event->ev.key.c != 0)) {
564 char32_t tmp[2] = { event->ev.key.c, 0 };
565 wstr_to_str(cons->char_remains, UTF8_CHAR_BUFFER_SIZE, tmp);
566 cons->char_remains_len = str_size(cons->char_remains);
567 }
568
569 free(event);
570 }
571 }
572
573 *nread = size;
574 return EOK;
575}
576
577static errno_t cons_write(con_srv_t *srv, void *data, size_t size, size_t *nwritten)
578{
579 console_t *cons = srv_to_console(srv);
580
581 size_t off = 0;
582 while (off < size)
583 cons_write_char(cons, str_decode(data, &off, size));
584
585 *nwritten = size;
586 return EOK;
587}
588
589static void cons_sync(con_srv_t *srv)
590{
591 console_t *cons = srv_to_console(srv);
592
593 cons_update(cons);
594}
595
596static void cons_clear(con_srv_t *srv)
597{
598 console_t *cons = srv_to_console(srv);
599
600 fibril_mutex_lock(&cons->mtx);
601 pointer_undraw();
602 chargrid_clear(cons->frontbuf);
603 pointer_draw();
604 fibril_mutex_unlock(&cons->mtx);
605
606 cons_update(cons);
607}
608
609static void cons_set_pos(con_srv_t *srv, sysarg_t col, sysarg_t row)
610{
611 console_t *cons = srv_to_console(srv);
612
613 fibril_mutex_lock(&cons->mtx);
614 pointer_undraw();
615 chargrid_set_cursor(cons->frontbuf, col, row);
616 pointer_draw();
617 fibril_mutex_unlock(&cons->mtx);
618
619 cons_update_cursor(cons);
620}
621
622static errno_t cons_get_pos(con_srv_t *srv, sysarg_t *col, sysarg_t *row)
623{
624 console_t *cons = srv_to_console(srv);
625
626 fibril_mutex_lock(&cons->mtx);
627 chargrid_get_cursor(cons->frontbuf, col, row);
628 fibril_mutex_unlock(&cons->mtx);
629
630 return EOK;
631}
632
633static errno_t cons_get_size(con_srv_t *srv, sysarg_t *cols, sysarg_t *rows)
634{
635 console_t *cons = srv_to_console(srv);
636
637 fibril_mutex_lock(&cons->mtx);
638 *cols = cons->cols;
639 *rows = cons->rows;
640 fibril_mutex_unlock(&cons->mtx);
641
642 return EOK;
643}
644
645static errno_t cons_get_color_cap(con_srv_t *srv, console_caps_t *ccaps)
646{
647 console_t *cons = srv_to_console(srv);
648
649 fibril_mutex_lock(&cons->mtx);
650 *ccaps = cons->ccaps;
651 fibril_mutex_unlock(&cons->mtx);
652
653 return EOK;
654}
655
656static void cons_set_style(con_srv_t *srv, console_style_t style)
657{
658 console_t *cons = srv_to_console(srv);
659
660 fibril_mutex_lock(&cons->mtx);
661 chargrid_set_style(cons->frontbuf, style);
662 fibril_mutex_unlock(&cons->mtx);
663}
664
665static void cons_set_color(con_srv_t *srv, console_color_t bgcolor,
666 console_color_t fgcolor, console_color_attr_t attr)
667{
668 console_t *cons = srv_to_console(srv);
669
670 fibril_mutex_lock(&cons->mtx);
671 chargrid_set_color(cons->frontbuf, bgcolor, fgcolor, attr);
672 fibril_mutex_unlock(&cons->mtx);
673}
674
675static void cons_set_rgb_color(con_srv_t *srv, pixel_t bgcolor,
676 pixel_t fgcolor)
677{
678 console_t *cons = srv_to_console(srv);
679
680 fibril_mutex_lock(&cons->mtx);
681 chargrid_set_rgb_color(cons->frontbuf, bgcolor, fgcolor);
682 fibril_mutex_unlock(&cons->mtx);
683}
684
685static void cons_set_cursor_visibility(con_srv_t *srv, bool visible)
686{
687 console_t *cons = srv_to_console(srv);
688
689 cons_set_cursor_vis(cons, visible);
690}
691
692static errno_t cons_set_caption(con_srv_t *srv, const char *caption)
693{
694 console_t *cons = srv_to_console(srv);
695
696 (void) cons;
697 (void) caption;
698 return EOK;
699}
700
701static errno_t cons_get_event(con_srv_t *srv, cons_event_t *event)
702{
703 console_t *cons = srv_to_console(srv);
704 link_t *link = prodcons_consume(&cons->input_pc);
705 cons_event_t *cevent = list_get_instance(link, cons_event_t, link);
706
707 *event = *cevent;
708 free(cevent);
709 return EOK;
710}
711
712/** Create shared buffer for efficient rendering.
713 *
714 * @param srv Console server
715 * @param cols Number of columns in buffer
716 * @param rows Number of rows in buffer
717 * @param rbuf Place to store pointer to new sharable buffer
718 *
719 * @return EOK on sucess or an error code
720 */
721static errno_t cons_map(con_srv_t *srv, sysarg_t cols, sysarg_t rows,
722 charfield_t **rbuf)
723{
724 console_t *cons = srv_to_console(srv);
725 void *buf;
726
727 fibril_mutex_lock(&cons->mtx);
728
729 if (cons->ubuf != NULL) {
730 fibril_mutex_unlock(&cons->mtx);
731 return EBUSY;
732 }
733
734 buf = as_area_create(AS_AREA_ANY, cols * rows * sizeof(charfield_t),
735 AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
736 if (buf == AS_MAP_FAILED) {
737 fibril_mutex_unlock(&cons->mtx);
738 return ENOMEM;
739 }
740
741 cons->ucols = cols;
742 cons->urows = rows;
743 cons->ubuf = buf;
744 fibril_mutex_unlock(&cons->mtx);
745
746 *rbuf = buf;
747 return EOK;
748}
749
750/** Delete shared buffer.
751 *
752 * @param srv Console server
753 */
754static void cons_unmap(con_srv_t *srv)
755{
756 console_t *cons = srv_to_console(srv);
757 void *buf;
758
759 fibril_mutex_lock(&cons->mtx);
760
761 buf = cons->ubuf;
762 cons->ubuf = NULL;
763
764 if (buf != NULL)
765 as_area_destroy(buf);
766
767 fibril_mutex_unlock(&cons->mtx);
768}
769
770/** Update area of console from shared buffer.
771 *
772 * @param srv Console server
773 * @param c0 Column coordinate of top-left corner (inclusive)
774 * @param r0 Row coordinate of top-left corner (inclusive)
775 * @param c1 Column coordinate of bottom-right corner (exclusive)
776 * @param r1 Row coordinate of bottom-right corner (exclusive)
777 */
778static void cons_buf_update(con_srv_t *srv, sysarg_t c0, sysarg_t r0,
779 sysarg_t c1, sysarg_t r1)
780{
781 console_t *cons = srv_to_console(srv);
782 charfield_t *ch;
783 sysarg_t col, row;
784
785 fibril_mutex_lock(&cons->mtx);
786
787 if (cons->ubuf == NULL) {
788 fibril_mutex_unlock(&cons->mtx);
789 return;
790 }
791
792 /* Make sure we have meaningful coordinates, within bounds */
793
794 if (c1 > cons->ucols)
795 c1 = cons->ucols;
796 if (c1 > cons->cols)
797 c1 = cons->cols;
798 if (c0 >= c1) {
799 fibril_mutex_unlock(&cons->mtx);
800 return;
801 }
802 if (r1 > cons->urows)
803 r1 = cons->urows;
804 if (r1 > cons->rows)
805 r1 = cons->rows;
806 if (r0 >= r1) {
807 fibril_mutex_unlock(&cons->mtx);
808 return;
809 }
810
811 /* Update front buffer from user buffer */
812
813 pointer_undraw();
814
815 for (row = r0; row < r1; row++) {
816 for (col = c0; col < c1; col++) {
817 ch = chargrid_charfield_at(cons->frontbuf, col, row);
818 *ch = cons->ubuf[row * cons->ucols + col];
819 }
820 }
821
822 pointer_draw();
823 fibril_mutex_unlock(&cons->mtx);
824
825 /* Update console */
826 cons_update(cons);
827}
828
829static void client_connection(ipc_call_t *icall, void *arg)
830{
831 console_t *cons = NULL;
832
833 for (size_t i = 0; i < CONSOLE_COUNT; i++) {
834 if (consoles[i].dsid == (service_id_t) ipc_get_arg2(icall)) {
835 cons = &consoles[i];
836 break;
837 }
838 }
839
840 if (cons == NULL) {
841 async_answer_0(icall, ENOENT);
842 return;
843 }
844
845 if (!atomic_flag_test_and_set(&cons->refcnt))
846 cons_set_cursor_vis(cons, true);
847
848 con_conn(icall, &cons->srvs);
849}
850
851static errno_t input_connect(const char *svc)
852{
853 async_sess_t *sess;
854 service_id_t dsid;
855
856 errno_t rc = loc_service_get_id(svc, &dsid, 0);
857 if (rc != EOK) {
858 printf("%s: Input service %s not found\n", NAME, svc);
859 return rc;
860 }
861
862 sess = loc_service_connect(dsid, INTERFACE_INPUT, 0);
863 if (sess == NULL) {
864 printf("%s: Unable to connect to input service %s\n", NAME,
865 svc);
866 return EIO;
867 }
868
869 rc = input_open(sess, &input_ev_ops, NULL, &input);
870 if (rc != EOK) {
871 async_hangup(sess);
872 printf("%s: Unable to communicate with service %s (%s)\n",
873 NAME, svc, str_error(rc));
874 return rc;
875 }
876
877 return EOK;
878}
879
880static async_sess_t *output_connect(const char *svc)
881{
882 async_sess_t *sess;
883 service_id_t dsid;
884
885 errno_t rc = loc_service_get_id(svc, &dsid, 0);
886 if (rc == EOK) {
887 sess = loc_service_connect(dsid, INTERFACE_OUTPUT, 0);
888 if (sess == NULL) {
889 printf("%s: Unable to connect to output service %s\n",
890 NAME, svc);
891 return NULL;
892 }
893 } else
894 return NULL;
895
896 return sess;
897}
898
899static bool console_srv_init(char *input_svc, char *output_svc)
900{
901 /* Connect to input service */
902 errno_t rc = input_connect(input_svc);
903 if (rc != EOK)
904 return false;
905
906 /* Connect to output service */
907 output_sess = output_connect(output_svc);
908 if (output_sess == NULL)
909 return false;
910
911 /* Register server */
912 async_set_fallback_port_handler(client_connection, NULL);
913 rc = loc_server_register(NAME, &console_srv);
914 if (rc != EOK) {
915 printf("%s: Unable to register server (%s)\n", NAME,
916 str_error(rc));
917 return false;
918 }
919
920 output_get_dimensions(output_sess, &cols, &rows);
921 output_set_style(output_sess, STYLE_NORMAL);
922
923 console_caps_t ccaps;
924 output_get_caps(output_sess, &ccaps);
925
926 /*
927 * Inititalize consoles only if there are
928 * actually some output devices.
929 */
930 if (ccaps != 0) {
931 for (size_t i = 0; i < CONSOLE_COUNT; i++) {
932 consoles[i].index = i;
933 atomic_flag_clear(&consoles[i].refcnt);
934 fibril_mutex_initialize(&consoles[i].mtx);
935 prodcons_initialize(&consoles[i].input_pc);
936 consoles[i].char_remains_len = 0;
937
938 consoles[i].cols = cols;
939 consoles[i].rows = rows;
940 consoles[i].ccaps = ccaps;
941 consoles[i].frontbuf =
942 chargrid_create(cols, rows, CHARGRID_FLAG_SHARED);
943
944 if (consoles[i].frontbuf == NULL) {
945 printf("%s: Unable to allocate frontbuffer %zu\n", NAME, i);
946 return false;
947 }
948
949 consoles[i].fbid = output_frontbuf_create(output_sess,
950 consoles[i].frontbuf);
951 if (consoles[i].fbid == 0) {
952 printf("%s: Unable to create frontbuffer %zu\n", NAME, i);
953 return false;
954 }
955
956 con_srvs_init(&consoles[i].srvs);
957 consoles[i].srvs.ops = &con_ops;
958 consoles[i].srvs.sarg = &consoles[i];
959
960 char vc[LOC_NAME_MAXLEN + 1];
961 snprintf(vc, LOC_NAME_MAXLEN, "%s/vc%zu", NAMESPACE, i);
962
963 if (loc_service_register(console_srv, vc,
964 &consoles[i].dsid) != EOK) {
965 printf("%s: Unable to register device %s\n", NAME, vc);
966 return false;
967 }
968 }
969
970 input_activate(input);
971 active = true;
972 cons_damage(active_console);
973 }
974
975 return true;
976}
977
978static void usage(char *name)
979{
980 printf("Usage: %s <input_dev> <output_dev>\n", name);
981}
982
983int main(int argc, char *argv[])
984{
985 if (argc < 3) {
986 usage(argv[0]);
987 return -1;
988 }
989
990 printf("%s: HelenOS Console service\n", NAME);
991
992 if (!console_srv_init(argv[1], argv[2]))
993 return -1;
994
995 printf("%s: Accepting connections\n", NAME);
996 task_retval(0);
997 async_manager();
998
999 /* Never reached */
1000 return 0;
1001}
1002
1003/** @}
1004 */
Note: See TracBrowser for help on using the repository browser.