source: mainline/uspace/lib/graph/graph.c@ 4e2d387

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 4e2d387 was 7c3fb9b, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix block comment formatting (ccheck).
  • Property mode set to 100644
File size: 15.1 KB
Line 
1/*
2 * Copyright (c) 2011 Petr Koupy
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 graph
30 * @{
31 */
32/**
33 * @file
34 */
35
36#include <assert.h>
37#include <errno.h>
38#include <inttypes.h>
39#include <stdio.h>
40#include <as.h>
41#include <stdlib.h>
42#include "graph.h"
43
44#define NAMESPACE "graphemu"
45#define VISUALIZER_NAME "vsl"
46#define RENDERER_NAME "rnd"
47
48static sysarg_t namespace_idx = 0;
49static sysarg_t visualizer_idx = 0;
50static sysarg_t renderer_idx = 0;
51
52static LIST_INITIALIZE(visualizer_list);
53static LIST_INITIALIZE(renderer_list);
54
55static FIBRIL_MUTEX_INITIALIZE(visualizer_list_mtx);
56static FIBRIL_MUTEX_INITIALIZE(renderer_list_mtx);
57
58visualizer_t *graph_alloc_visualizer(void)
59{
60 return ((visualizer_t *) malloc(sizeof(visualizer_t)));
61}
62
63renderer_t *graph_alloc_renderer(void)
64{
65 // TODO
66 return ((renderer_t *) malloc(sizeof(renderer_t)));
67}
68
69void graph_init_visualizer(visualizer_t *vs)
70{
71 link_initialize(&vs->link);
72 atomic_set(&vs->ref_cnt, 0);
73 vs->notif_sess = NULL;
74 fibril_mutex_initialize(&vs->mode_mtx);
75 list_initialize(&vs->modes);
76 vs->mode_set = false;
77 vs->cells.data = NULL;
78 vs->dev_ctx = NULL;
79}
80
81void graph_init_renderer(renderer_t *rnd)
82{
83 // TODO
84 link_initialize(&rnd->link);
85 atomic_set(&rnd->ref_cnt, 0);
86}
87
88errno_t graph_register_visualizer(visualizer_t *vs)
89{
90 char node[LOC_NAME_MAXLEN + 1];
91 snprintf(node, LOC_NAME_MAXLEN, "%s%zu/%s%zu", NAMESPACE,
92 namespace_idx, VISUALIZER_NAME, visualizer_idx++);
93
94 category_id_t cat;
95 errno_t rc = loc_category_get_id("visualizer", &cat, 0);
96 if (rc != EOK)
97 return rc;
98
99 rc = loc_service_register(node, &vs->reg_svc_handle);
100 if (rc != EOK)
101 return rc;
102
103 rc = loc_service_add_to_cat(vs->reg_svc_handle, cat);
104 if (rc != EOK) {
105 loc_service_unregister(vs->reg_svc_handle);
106 return rc;
107 }
108
109 fibril_mutex_lock(&visualizer_list_mtx);
110 list_append(&vs->link, &visualizer_list);
111 fibril_mutex_unlock(&visualizer_list_mtx);
112
113 return rc;
114}
115
116errno_t graph_register_renderer(renderer_t *rnd)
117{
118 char node[LOC_NAME_MAXLEN + 1];
119 snprintf(node, LOC_NAME_MAXLEN, "%s%zu/%s%zu", NAMESPACE,
120 namespace_idx, RENDERER_NAME, renderer_idx++);
121
122 category_id_t cat;
123 errno_t rc = loc_category_get_id("renderer", &cat, 0);
124 if (rc != EOK)
125 return rc;
126
127 rc = loc_service_register(node, &rnd->reg_svc_handle);
128 if (rc != EOK)
129 return rc;
130
131 rc = loc_service_add_to_cat(rnd->reg_svc_handle, cat);
132 if (rc != EOK) {
133 loc_service_unregister(rnd->reg_svc_handle);
134 return rc;
135 }
136
137 fibril_mutex_lock(&renderer_list_mtx);
138 list_append(&rnd->link, &renderer_list);
139 fibril_mutex_unlock(&renderer_list_mtx);
140
141 return rc;
142}
143
144visualizer_t *graph_get_visualizer(sysarg_t handle)
145{
146 visualizer_t *vs = NULL;
147
148 fibril_mutex_lock(&visualizer_list_mtx);
149
150 list_foreach(visualizer_list, link, visualizer_t, vcur) {
151 if (vcur->reg_svc_handle == handle) {
152 vs = vcur;
153 break;
154 }
155 }
156
157 fibril_mutex_unlock(&visualizer_list_mtx);
158
159 return vs;
160}
161
162renderer_t *graph_get_renderer(sysarg_t handle)
163{
164 renderer_t *rnd = NULL;
165
166 fibril_mutex_lock(&renderer_list_mtx);
167
168 list_foreach(renderer_list, link, renderer_t, rcur) {
169 if (rcur->reg_svc_handle == handle) {
170 rnd = rcur;
171 break;
172 }
173 }
174
175 fibril_mutex_unlock(&renderer_list_mtx);
176
177 return rnd;
178}
179
180errno_t graph_unregister_visualizer(visualizer_t *vs)
181{
182 fibril_mutex_lock(&visualizer_list_mtx);
183 errno_t rc = loc_service_unregister(vs->reg_svc_handle);
184 list_remove(&vs->link);
185 fibril_mutex_unlock(&visualizer_list_mtx);
186
187 return rc;
188}
189
190errno_t graph_unregister_renderer(renderer_t *rnd)
191{
192 fibril_mutex_lock(&renderer_list_mtx);
193 errno_t rc = loc_service_unregister(rnd->reg_svc_handle);
194 list_remove(&rnd->link);
195 fibril_mutex_unlock(&renderer_list_mtx);
196
197 return rc;
198}
199
200void graph_destroy_visualizer(visualizer_t *vs)
201{
202 assert(atomic_get(&vs->ref_cnt) == 0);
203 assert(vs->notif_sess == NULL);
204 assert(!fibril_mutex_is_locked(&vs->mode_mtx));
205 assert(list_empty(&vs->modes));
206 assert(vs->mode_set == false);
207 assert(vs->cells.data == NULL);
208 assert(vs->dev_ctx == NULL);
209
210 free(vs);
211}
212
213void graph_destroy_renderer(renderer_t *rnd)
214{
215 // TODO
216 assert(atomic_get(&rnd->ref_cnt) == 0);
217
218 free(rnd);
219}
220
221errno_t graph_notify_mode_change(async_sess_t *sess, sysarg_t handle, sysarg_t mode_idx)
222{
223 async_exch_t *exch = async_exchange_begin(sess);
224 errno_t ret = async_req_2_0(exch, VISUALIZER_MODE_CHANGE, handle, mode_idx);
225 async_exchange_end(exch);
226
227 return ret;
228}
229
230errno_t graph_notify_disconnect(async_sess_t *sess, sysarg_t handle)
231{
232 async_exch_t *exch = async_exchange_begin(sess);
233 errno_t ret = async_req_1_0(exch, VISUALIZER_DISCONNECT, handle);
234 async_exchange_end(exch);
235
236 async_hangup(sess);
237
238 return ret;
239}
240
241static void vs_claim(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
242{
243 vs->client_side_handle = IPC_GET_ARG1(*icall);
244 errno_t rc = vs->ops.claim(vs);
245 async_answer_0(icall_handle, rc);
246}
247
248static void vs_yield(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
249{
250 /* Deallocate resources for the current mode. */
251 if (vs->mode_set) {
252 if (vs->cells.data != NULL) {
253 as_area_destroy((void *) vs->cells.data);
254 vs->cells.data = NULL;
255 }
256 }
257
258 /* Driver might also deallocate resources for the current mode. */
259 errno_t rc = vs->ops.yield(vs);
260
261 /*
262 * Now that the driver was given a chance to deallocate resources,
263 * current mode can be unset.
264 */
265 if (vs->mode_set)
266 vs->mode_set = false;
267
268 async_answer_0(icall_handle, rc);
269}
270
271static void vs_enumerate_modes(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
272{
273 cap_call_handle_t chandle;
274 size_t len;
275
276 if (!async_data_read_receive(&chandle, &len)) {
277 async_answer_0(chandle, EREFUSED);
278 async_answer_0(icall_handle, EREFUSED);
279 return;
280 }
281
282 fibril_mutex_lock(&vs->mode_mtx);
283 link_t *link = list_nth(&vs->modes, IPC_GET_ARG1(*icall));
284
285 if (link != NULL) {
286 vslmode_list_element_t *mode_elem =
287 list_get_instance(link, vslmode_list_element_t, link);
288
289 errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
290 async_answer_0(icall_handle, rc);
291 } else {
292 async_answer_0(chandle, ENOENT);
293 async_answer_0(icall_handle, ENOENT);
294 }
295
296 fibril_mutex_unlock(&vs->mode_mtx);
297}
298
299static void vs_get_default_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
300{
301 cap_call_handle_t chandle;
302 size_t len;
303
304 if (!async_data_read_receive(&chandle, &len)) {
305 async_answer_0(chandle, EREFUSED);
306 async_answer_0(icall_handle, EREFUSED);
307 return;
308 }
309
310 fibril_mutex_lock(&vs->mode_mtx);
311 vslmode_list_element_t *mode_elem = NULL;
312
313 list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
314 if (cur->mode.index == vs->def_mode_idx) {
315 mode_elem = cur;
316 break;
317 }
318 }
319
320 if (mode_elem != NULL) {
321 errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
322 async_answer_0(icall_handle, rc);
323 } else {
324 fibril_mutex_unlock(&vs->mode_mtx);
325 async_answer_0(chandle, ENOENT);
326 async_answer_0(icall_handle, ENOENT);
327 }
328
329 fibril_mutex_unlock(&vs->mode_mtx);
330}
331
332static void vs_get_current_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
333{
334 cap_call_handle_t chandle;
335 size_t len;
336
337 if (!async_data_read_receive(&chandle, &len)) {
338 async_answer_0(chandle, EREFUSED);
339 async_answer_0(icall_handle, EREFUSED);
340 return;
341 }
342
343 if (vs->mode_set) {
344 errno_t rc = async_data_read_finalize(chandle, &vs->cur_mode, len);
345 async_answer_0(icall_handle, rc);
346 } else {
347 async_answer_0(chandle, ENOENT);
348 async_answer_0(icall_handle, ENOENT);
349 }
350}
351
352static void vs_get_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
353{
354 cap_call_handle_t chandle;
355 size_t len;
356
357 if (!async_data_read_receive(&chandle, &len)) {
358 async_answer_0(chandle, EREFUSED);
359 async_answer_0(icall_handle, EREFUSED);
360 return;
361 }
362
363 sysarg_t mode_idx = IPC_GET_ARG1(*icall);
364
365 fibril_mutex_lock(&vs->mode_mtx);
366 vslmode_list_element_t *mode_elem = NULL;
367
368 list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
369 if (cur->mode.index == mode_idx) {
370 mode_elem = cur;
371 break;
372 }
373 }
374
375 if (mode_elem != NULL) {
376 errno_t rc = async_data_read_finalize(chandle, &mode_elem->mode, len);
377 async_answer_0(icall_handle, rc);
378 } else {
379 async_answer_0(chandle, ENOENT);
380 async_answer_0(icall_handle, ENOENT);
381 }
382
383 fibril_mutex_unlock(&vs->mode_mtx);
384}
385
386static void vs_set_mode(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
387{
388 cap_call_handle_t chandle;
389 size_t size;
390 unsigned int flags;
391
392 /* Retrieve the shared cell storage for the new mode. */
393 if (!async_share_out_receive(&chandle, &size, &flags)) {
394 async_answer_0(chandle, EREFUSED);
395 async_answer_0(icall_handle, EREFUSED);
396 return;
397 }
398
399 /* Retrieve mode index and version. */
400 sysarg_t mode_idx = IPC_GET_ARG1(*icall);
401 sysarg_t mode_version = IPC_GET_ARG2(*icall);
402
403 /* Find mode in the list. */
404 fibril_mutex_lock(&vs->mode_mtx);
405 vslmode_list_element_t *mode_elem = NULL;
406
407 list_foreach(vs->modes, link, vslmode_list_element_t, cur) {
408 if (cur->mode.index == mode_idx) {
409 mode_elem = cur;
410 break;
411 }
412 }
413
414 if (mode_elem == NULL) {
415 fibril_mutex_unlock(&vs->mode_mtx);
416 async_answer_0(chandle, ENOENT);
417 async_answer_0(icall_handle, ENOENT);
418 return;
419 }
420
421 /* Extract mode description from the list node. */
422 vslmode_t new_mode = mode_elem->mode;
423 fibril_mutex_unlock(&vs->mode_mtx);
424
425 /* Check whether the mode is still up-to-date. */
426 if (new_mode.version != mode_version) {
427 async_answer_0(chandle, EINVAL);
428 async_answer_0(icall_handle, EINVAL);
429 return;
430 }
431
432 void *new_cell_storage;
433 errno_t rc = async_share_out_finalize(chandle, &new_cell_storage);
434 if ((rc != EOK) || (new_cell_storage == AS_MAP_FAILED)) {
435 async_answer_0(icall_handle, ENOMEM);
436 return;
437 }
438
439 /* Change device internal state. */
440 rc = vs->ops.change_mode(vs, new_mode);
441
442 /* Device driver could not establish new mode. Rollback. */
443 if (rc != EOK) {
444 as_area_destroy(new_cell_storage);
445 async_answer_0(icall_handle, ENOMEM);
446 return;
447 }
448
449 /*
450 * Because resources for the new mode were successfully
451 * claimed, it is finally possible to free resources
452 * allocated for the old mode.
453 */
454 if (vs->mode_set) {
455 if (vs->cells.data != NULL) {
456 as_area_destroy((void *) vs->cells.data);
457 vs->cells.data = NULL;
458 }
459 }
460
461 /* Insert new mode into the visualizer. */
462 vs->cells.width = new_mode.screen_width;
463 vs->cells.height = new_mode.screen_height;
464 vs->cells.data = (pixel_t *) new_cell_storage;
465 vs->cur_mode = new_mode;
466 vs->mode_set = true;
467
468 async_answer_0(icall_handle, EOK);
469}
470
471static void vs_update_damaged_region(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
472{
473 sysarg_t x_offset = (IPC_GET_ARG5(*icall) >> 16);
474 sysarg_t y_offset = (IPC_GET_ARG5(*icall) & 0x0000ffff);
475
476 errno_t rc = vs->ops.handle_damage(vs,
477 IPC_GET_ARG1(*icall), IPC_GET_ARG2(*icall),
478 IPC_GET_ARG3(*icall), IPC_GET_ARG4(*icall),
479 x_offset, y_offset);
480 async_answer_0(icall_handle, rc);
481}
482
483static void vs_suspend(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
484{
485 errno_t rc = vs->ops.suspend(vs);
486 async_answer_0(icall_handle, rc);
487}
488
489static void vs_wakeup(visualizer_t *vs, cap_call_handle_t icall_handle, ipc_call_t *icall)
490{
491 errno_t rc = vs->ops.wakeup(vs);
492 async_answer_0(icall_handle, rc);
493}
494
495void graph_visualizer_connection(visualizer_t *vs,
496 cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
497{
498 ipc_call_t call;
499 cap_call_handle_t chandle;
500
501 /* Claim the visualizer. */
502 if (!cas(&vs->ref_cnt, 0, 1)) {
503 async_answer_0(icall_handle, ELIMIT);
504 return;
505 }
506
507 /* Accept the connection. */
508 async_answer_0(icall_handle, EOK);
509
510 /* Establish callback session. */
511 chandle = async_get_call(&call);
512 vs->notif_sess = async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
513 if (vs->notif_sess != NULL)
514 async_answer_0(chandle, EOK);
515 else
516 async_answer_0(chandle, ELIMIT);
517
518 /* Enter command loop. */
519 while (true) {
520 chandle = async_get_call(&call);
521
522 if (!IPC_GET_IMETHOD(call)) {
523 async_answer_0(chandle, EINVAL);
524 break;
525 }
526
527 switch (IPC_GET_IMETHOD(call)) {
528 case VISUALIZER_CLAIM:
529 vs_claim(vs, chandle, &call);
530 break;
531 case VISUALIZER_YIELD:
532 vs_yield(vs, chandle, &call);
533 goto terminate;
534 case VISUALIZER_ENUMERATE_MODES:
535 vs_enumerate_modes(vs, chandle, &call);
536 break;
537 case VISUALIZER_GET_DEFAULT_MODE:
538 vs_get_default_mode(vs, chandle, &call);
539 break;
540 case VISUALIZER_GET_CURRENT_MODE:
541 vs_get_current_mode(vs, chandle, &call);
542 break;
543 case VISUALIZER_GET_MODE:
544 vs_get_mode(vs, chandle, &call);
545 break;
546 case VISUALIZER_SET_MODE:
547 vs_set_mode(vs, chandle, &call);
548 break;
549 case VISUALIZER_UPDATE_DAMAGED_REGION:
550 vs_update_damaged_region(vs, chandle, &call);
551 break;
552 case VISUALIZER_SUSPEND:
553 vs_suspend(vs, chandle, &call);
554 break;
555 case VISUALIZER_WAKE_UP:
556 vs_wakeup(vs, chandle, &call);
557 break;
558 default:
559 async_answer_0(chandle, EINVAL);
560 goto terminate;
561 }
562 }
563
564terminate:
565 async_hangup(vs->notif_sess);
566 vs->notif_sess = NULL;
567 atomic_set(&vs->ref_cnt, 0);
568}
569
570void graph_renderer_connection(renderer_t *rnd,
571 cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
572{
573 // TODO
574
575 ipc_call_t call;
576 cap_call_handle_t chandle;
577
578 /* Accept the connection. */
579 atomic_inc(&rnd->ref_cnt);
580 async_answer_0(icall_handle, EOK);
581
582 /* Enter command loop. */
583 while (true) {
584 chandle = async_get_call(&call);
585
586 if (!IPC_GET_IMETHOD(call)) {
587 async_answer_0(chandle, EINVAL);
588 break;
589 }
590
591 switch (IPC_GET_IMETHOD(call)) {
592 default:
593 async_answer_0(chandle, EINVAL);
594 goto terminate;
595 }
596 }
597
598terminate:
599 atomic_dec(&rnd->ref_cnt);
600}
601
602void graph_client_connection(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
603{
604 /* Find the visualizer or renderer with the given service ID. */
605 visualizer_t *vs = graph_get_visualizer(IPC_GET_ARG2(*icall));
606 renderer_t *rnd = graph_get_renderer(IPC_GET_ARG2(*icall));
607
608 if (vs != NULL)
609 graph_visualizer_connection(vs, icall_handle, icall, arg);
610 else if (rnd != NULL)
611 graph_renderer_connection(rnd, icall_handle, icall, arg);
612 else
613 async_answer_0(icall_handle, ENOENT);
614}
615
616/** @}
617 */
Note: See TracBrowser for help on using the repository browser.