source: mainline/uspace/srv/hid/output/output.c@ ca48672

Last change on this file since ca48672 was ca48672, checked in by Jiri Svoboda <jiri@…>, 7 days ago

loc_service_register() needs to take a port ID argument.
  • Property mode set to 100644
File size: 11.4 KB
Line 
1/*
2 * Copyright (c) 2025 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 output
31 * @{
32 */
33
34#include <errno.h>
35#include <stddef.h>
36#include <stdlib.h>
37#include <macros.h>
38#include <as.h>
39#include <task.h>
40#include <ipc/output.h>
41#include <config.h>
42#include <vt/vt100.h>
43#include "port/ega.h"
44#include "port/chardev.h"
45#include "port/ddev.h"
46#include "output.h"
47
48typedef struct {
49 link_t link;
50
51 size_t size;
52 unsigned int flags;
53 void *data;
54} frontbuf_t;
55
56static LIST_INITIALIZE(outdevs);
57static LIST_INITIALIZE(frontbufs);
58
59outdev_t *outdev_register(outdev_ops_t *ops, void *data)
60{
61 assert(ops->get_dimensions);
62
63 outdev_t *dev = (outdev_t *) malloc(sizeof(outdev_t));
64 if (dev == NULL)
65 return NULL;
66
67 link_initialize(&dev->link);
68
69 dev->ops = *ops;
70 dev->data = data;
71
72 ops->get_dimensions(dev, &dev->cols, &dev->rows);
73 dev->backbuf = chargrid_create(dev->cols, dev->rows,
74 CHARGRID_FLAG_NONE);
75 if (dev->backbuf == NULL) {
76 free(dev);
77 return NULL;
78 }
79
80 list_append(&dev->link, &outdevs);
81 return dev;
82}
83
84static void srv_yield(ipc_call_t *icall)
85{
86 errno_t ret = EOK;
87
88 list_foreach(outdevs, link, outdev_t, dev) {
89 assert(dev->ops.yield);
90
91 errno_t rc = dev->ops.yield(dev);
92 if (rc != EOK)
93 ret = rc;
94 }
95
96 async_answer_0(icall, ret);
97}
98
99static void srv_claim(ipc_call_t *icall)
100{
101 errno_t ret = EOK;
102
103 list_foreach(outdevs, link, outdev_t, dev) {
104 assert(dev->ops.claim);
105
106 errno_t rc = dev->ops.claim(dev);
107 if (rc != EOK)
108 ret = rc;
109 }
110
111 async_answer_0(icall, ret);
112}
113
114static void srv_get_dimensions(ipc_call_t *icall)
115{
116 sysarg_t cols = 0;
117 sysarg_t rows = 0;
118 bool first;
119
120 first = true;
121 list_foreach(outdevs, link, outdev_t, dev) {
122 if (first) {
123 cols = dev->cols;
124 rows = dev->rows;
125 first = false;
126 } else {
127 cols = min(cols, dev->cols);
128 rows = min(rows, dev->rows);
129 }
130 }
131
132 async_answer_2(icall, EOK, cols, rows);
133}
134
135static void srv_get_caps(ipc_call_t *icall)
136{
137 console_caps_t caps = 0;
138
139 list_foreach(outdevs, link, outdev_t, dev) {
140 assert(dev->ops.get_caps);
141
142 caps |= dev->ops.get_caps(dev);
143 }
144
145 async_answer_1(icall, EOK, caps);
146}
147
148static frontbuf_t *resolve_frontbuf(sysarg_t handle, ipc_call_t *icall)
149{
150 frontbuf_t *frontbuf = NULL;
151 list_foreach(frontbufs, link, frontbuf_t, cur) {
152 if (cur == (frontbuf_t *) handle) {
153 frontbuf = cur;
154 break;
155 }
156 }
157
158 if (frontbuf == NULL) {
159 async_answer_0(icall, ENOENT);
160 return NULL;
161 }
162
163 return frontbuf;
164}
165
166static void srv_frontbuf_create(ipc_call_t *icall)
167{
168 frontbuf_t *frontbuf = (frontbuf_t *) malloc(sizeof(frontbuf_t));
169 if (frontbuf == NULL) {
170 async_answer_0(icall, ENOMEM);
171 return;
172 }
173
174 link_initialize(&frontbuf->link);
175
176 ipc_call_t call;
177 if (!async_share_out_receive(&call, &frontbuf->size,
178 &frontbuf->flags)) {
179 free(frontbuf);
180 async_answer_0(icall, EINVAL);
181 return;
182 }
183
184 errno_t rc = async_share_out_finalize(&call, &frontbuf->data);
185 if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
186 free(frontbuf);
187 async_answer_0(icall, ENOMEM);
188 return;
189 }
190
191 list_append(&frontbuf->link, &frontbufs);
192 async_answer_1(icall, EOK, (sysarg_t) frontbuf);
193}
194
195static void srv_frontbuf_destroy(ipc_call_t *icall)
196{
197 frontbuf_t *frontbuf = resolve_frontbuf(ipc_get_arg1(icall), icall);
198 if (frontbuf == NULL)
199 return;
200
201 list_remove(&frontbuf->link);
202 as_area_destroy(frontbuf->data);
203 free(frontbuf);
204
205 async_answer_0(icall, EOK);
206}
207
208static void srv_cursor_update(ipc_call_t *icall)
209{
210 frontbuf_t *frontbuf = resolve_frontbuf(ipc_get_arg1(icall), icall);
211 if (frontbuf == NULL)
212 return;
213
214 chargrid_t *buf = (chargrid_t *) frontbuf->data;
215 bool visible = chargrid_get_cursor_visibility(buf);
216
217 sysarg_t col;
218 sysarg_t row;
219 chargrid_get_cursor(buf, &col, &row);
220
221 list_foreach(outdevs, link, outdev_t, dev) {
222 assert(dev->ops.cursor_update);
223
224 sysarg_t prev_col;
225 sysarg_t prev_row;
226 chargrid_get_cursor(dev->backbuf, &prev_col, &prev_row);
227
228 chargrid_set_cursor(dev->backbuf, col, row);
229 chargrid_set_cursor_visibility(dev->backbuf, visible);
230
231 dev->ops.cursor_update(dev, prev_col, prev_row, col, row,
232 visible);
233 dev->ops.flush(dev);
234
235 }
236
237 async_answer_0(icall, EOK);
238}
239
240static void srv_set_style(ipc_call_t *icall)
241{
242 list_foreach(outdevs, link, outdev_t, dev) {
243 dev->attrs.type = CHAR_ATTR_STYLE;
244 dev->attrs.val.style =
245 (console_style_t) ipc_get_arg1(icall);
246 }
247
248 async_answer_0(icall, EOK);
249}
250
251static void srv_set_color(ipc_call_t *icall)
252{
253 list_foreach(outdevs, link, outdev_t, dev) {
254 dev->attrs.type = CHAR_ATTR_INDEX;
255 dev->attrs.val.index.bgcolor =
256 (console_color_t) ipc_get_arg1(icall);
257 dev->attrs.val.index.fgcolor =
258 (console_color_t) ipc_get_arg2(icall);
259 dev->attrs.val.index.attr =
260 (console_color_attr_t) ipc_get_arg3(icall);
261 }
262
263 async_answer_0(icall, EOK);
264}
265
266static void srv_set_rgb_color(ipc_call_t *icall)
267{
268 list_foreach(outdevs, link, outdev_t, dev) {
269 dev->attrs.type = CHAR_ATTR_RGB;
270 dev->attrs.val.rgb.bgcolor = ipc_get_arg1(icall);
271 dev->attrs.val.rgb.fgcolor = ipc_get_arg2(icall);
272 }
273
274 async_answer_0(icall, EOK);
275}
276
277static bool srv_update_scroll(outdev_t *dev, chargrid_t *buf)
278{
279 assert(dev->ops.char_update);
280
281 sysarg_t top_row = chargrid_get_top_row(buf);
282
283 if (dev->top_row == top_row)
284 return false;
285
286 dev->top_row = top_row;
287
288 for (sysarg_t y = 0; y < dev->rows; y++) {
289 for (sysarg_t x = 0; x < dev->cols; x++) {
290 charfield_t *front_field =
291 chargrid_charfield_at(buf, x, y);
292 charfield_t *back_field =
293 chargrid_charfield_at(dev->backbuf, x, y);
294 bool update = false;
295
296 if (front_field->ch != back_field->ch) {
297 back_field->ch = front_field->ch;
298 update = true;
299 }
300
301 if (!attrs_same(front_field->attrs, back_field->attrs)) {
302 back_field->attrs = front_field->attrs;
303 update = true;
304 }
305
306 front_field->flags &= ~CHAR_FLAG_DIRTY;
307
308 if (update)
309 dev->ops.char_update(dev, x, y);
310 }
311 }
312
313 return true;
314}
315
316static void srv_update(ipc_call_t *icall)
317{
318 frontbuf_t *frontbuf = resolve_frontbuf(ipc_get_arg1(icall), icall);
319 if (frontbuf == NULL)
320 return;
321
322 chargrid_t *buf = (chargrid_t *) frontbuf->data;
323
324 list_foreach(outdevs, link, outdev_t, dev) {
325 assert(dev->ops.char_update);
326
327 if (srv_update_scroll(dev, buf))
328 continue;
329
330 for (sysarg_t y = 0; y < dev->rows; y++) {
331 for (sysarg_t x = 0; x < dev->cols; x++) {
332 charfield_t *front_field =
333 chargrid_charfield_at(buf, x, y);
334 charfield_t *back_field =
335 chargrid_charfield_at(dev->backbuf, x, y);
336 bool update = false;
337
338 if ((front_field->flags & CHAR_FLAG_DIRTY) ==
339 CHAR_FLAG_DIRTY) {
340 if (front_field->ch != back_field->ch) {
341 back_field->ch = front_field->ch;
342 update = true;
343 }
344
345 if (!attrs_same(front_field->attrs,
346 back_field->attrs)) {
347 back_field->attrs = front_field->attrs;
348 update = true;
349 }
350
351 front_field->flags &= ~CHAR_FLAG_DIRTY;
352 }
353
354 if (update)
355 dev->ops.char_update(dev, x, y);
356 }
357 }
358
359 dev->ops.flush(dev);
360 }
361
362 async_answer_0(icall, EOK);
363}
364
365static void srv_damage(ipc_call_t *icall)
366{
367 frontbuf_t *frontbuf = resolve_frontbuf(ipc_get_arg1(icall), icall);
368 if (frontbuf == NULL)
369 return;
370
371 chargrid_t *buf = (chargrid_t *) frontbuf->data;
372
373 list_foreach(outdevs, link, outdev_t, dev) {
374 assert(dev->ops.char_update);
375
376 if (srv_update_scroll(dev, buf))
377 continue;
378
379 sysarg_t col = ipc_get_arg2(icall);
380 sysarg_t row = ipc_get_arg3(icall);
381
382 sysarg_t cols = ipc_get_arg4(icall);
383 sysarg_t rows = ipc_get_arg5(icall);
384
385 for (sysarg_t y = 0; y < rows; y++) {
386 for (sysarg_t x = 0; x < cols; x++) {
387 charfield_t *front_field =
388 chargrid_charfield_at(buf, col + x, row + y);
389 charfield_t *back_field =
390 chargrid_charfield_at(dev->backbuf, col + x, row + y);
391
392 back_field->ch = front_field->ch;
393 back_field->attrs = front_field->attrs;
394 front_field->flags &= ~CHAR_FLAG_DIRTY;
395 dev->ops.char_update(dev, col + x, row + y);
396 }
397 }
398 dev->ops.flush(dev);
399
400 }
401
402 async_answer_0(icall, EOK);
403}
404
405static void client_connection(ipc_call_t *icall, void *arg)
406{
407 /* Accept the connection */
408 async_accept_0(icall);
409
410 while (true) {
411 ipc_call_t call;
412 async_get_call(&call);
413
414 if (!ipc_get_imethod(&call)) {
415 async_answer_0(&call, EOK);
416 break;
417 }
418
419 switch (ipc_get_imethod(&call)) {
420 case OUTPUT_YIELD:
421 srv_yield(&call);
422 break;
423 case OUTPUT_CLAIM:
424 srv_claim(&call);
425 break;
426 case OUTPUT_GET_DIMENSIONS:
427 srv_get_dimensions(&call);
428 break;
429 case OUTPUT_GET_CAPS:
430 srv_get_caps(&call);
431 break;
432
433 case OUTPUT_FRONTBUF_CREATE:
434 srv_frontbuf_create(&call);
435 break;
436 case OUTPUT_FRONTBUF_DESTROY:
437 srv_frontbuf_destroy(&call);
438 break;
439
440 case OUTPUT_CURSOR_UPDATE:
441 srv_cursor_update(&call);
442 break;
443 case OUTPUT_SET_STYLE:
444 srv_set_style(&call);
445 break;
446 case OUTPUT_SET_COLOR:
447 srv_set_color(&call);
448 break;
449 case OUTPUT_SET_RGB_COLOR:
450 srv_set_rgb_color(&call);
451 break;
452 case OUTPUT_UPDATE:
453 srv_update(&call);
454 break;
455 case OUTPUT_DAMAGE:
456 srv_damage(&call);
457 break;
458
459 default:
460 async_answer_0(&call, EINVAL);
461 }
462 }
463}
464
465static void usage(char *name)
466{
467 printf("Usage: %s <service_name>\n", name);
468}
469
470int main(int argc, char *argv[])
471{
472 loc_srv_t *srv;
473
474 if (argc < 2) {
475 usage(argv[0]);
476 return 1;
477 }
478
479 printf("%s: HelenOS output service\n", NAME);
480
481 /* Register server */
482 async_set_fallback_port_handler(client_connection, NULL);
483 errno_t rc = loc_server_register(NAME, &srv);
484 if (rc != EOK) {
485 printf("%s: Unable to register driver\n", NAME);
486 return rc;
487 }
488
489 service_id_t service_id;
490 rc = loc_service_register(srv, argv[1], fallback_port_id, &service_id);
491 if (rc != EOK) {
492 loc_server_unregister(srv);
493
494 printf("%s: Unable to register service %s\n", NAME, argv[1]);
495 return rc;
496 }
497
498 if (!config_key_exists("console")) {
499 ega_init();
500#if defined(CONFIG_FB) && !defined(CONFIG_WINSYS)
501 /*
502 * NOTE: We don't have a good way of detecting the absence
503 * of a KFB display device at run time because of the
504 * asunchronous nature of device discovery
505 */
506 output_ddev_init();
507#endif
508 }
509
510 chardev_init();
511
512 printf("%s: Accepting connections\n", NAME);
513 task_retval(0);
514 async_manager();
515
516 /* Never reached */
517 return 0;
518}
519
520/** @}
521 */
Note: See TracBrowser for help on using the repository browser.