source: mainline/uspace/srv/fb/fb.c@ b74959bd

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since b74959bd was b74959bd, checked in by Jakub Jermar <jakub@…>, 18 years ago

Modify ipc_answer_*() to make use of all six syscall arguments. The recommended
means of answering calls is via the ipc_answer_m() macros (where m denotes the
number of return arguments) that automatically decide between the fast register
version or the slow universal version of ipc_answer().
  • Property mode set to 100644
File size: 31.3 KB
Line 
1/*
2 * Copyright (c) 2006 Jakub Vana
3 * Copyright (c) 2006 Ondrej Palkovsky
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/**
31 * @defgroup fb Graphical framebuffer
32 * @brief HelenOS graphical framebuffer.
33 * @ingroup fbs
34 * @{
35 */
36
37/** @file
38 */
39
40#include <stdlib.h>
41#include <unistd.h>
42#include <string.h>
43#include <ddi.h>
44#include <sysinfo.h>
45#include <align.h>
46#include <as.h>
47#include <ipc/fb.h>
48#include <ipc/ipc.h>
49#include <ipc/ns.h>
50#include <ipc/services.h>
51#include <kernel/errno.h>
52#include <kernel/genarch/fb/visuals.h>
53#include <async.h>
54#include <bool.h>
55
56#include "font-8x16.h"
57#include "fb.h"
58#include "main.h"
59#include "../console/screenbuffer.h"
60#include "ppm.h"
61
62#include "pointer.xbm"
63#include "pointer_mask.xbm"
64
65#define DEFAULT_BGCOLOR 0xf0f0f0
66#define DEFAULT_FGCOLOR 0x0
67
68/***************************************************************/
69/* Pixel specific fuctions */
70
71typedef void (*conv2scr_fn_t)(void *, int);
72typedef int (*conv2rgb_fn_t)(void *);
73
74struct {
75 uint8_t *fbaddress;
76
77 unsigned int xres;
78 unsigned int yres;
79 unsigned int scanline;
80 unsigned int pixelbytes;
81 unsigned int invert_colors;
82
83 conv2scr_fn_t rgb2scr;
84 conv2rgb_fn_t scr2rgb;
85} screen;
86
87typedef struct {
88 int initialized;
89 unsigned int x, y;
90 unsigned int width, height;
91
92 /* Text support in window */
93 unsigned int rows, cols;
94 /* Style for text printing */
95 style_t style;
96 /* Auto-cursor position */
97 int cursor_active, cur_col, cur_row;
98 int cursor_shown;
99 /* Double buffering */
100 uint8_t *dbdata;
101 unsigned int dboffset;
102 unsigned int paused;
103} viewport_t;
104
105#define MAX_ANIM_LEN 8
106#define MAX_ANIMATIONS 4
107typedef struct {
108 int initialized;
109 int enabled;
110 unsigned int vp;
111
112 unsigned int pos;
113 unsigned int animlen;
114 unsigned int pixmaps[MAX_ANIM_LEN];
115} animation_t;
116static animation_t animations[MAX_ANIMATIONS];
117static int anims_enabled;
118
119/** Maximum number of saved pixmaps
120 * Pixmap is a saved rectangle
121 */
122#define MAX_PIXMAPS 256
123typedef struct {
124 unsigned int width;
125 unsigned int height;
126 uint8_t *data;
127} pixmap_t;
128static pixmap_t pixmaps[MAX_PIXMAPS];
129
130/* Viewport is a rectangular area on the screen */
131#define MAX_VIEWPORTS 128
132static viewport_t viewports[128];
133
134/* Allow only 1 connection */
135static int client_connected = 0;
136
137#define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))
138#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
139#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))
140
141#define COL_WIDTH 8
142#define ROW_BYTES (screen.scanline * FONT_SCANLINES)
143
144#define POINTPOS(x, y) ((y) * screen.scanline + (x) * screen.pixelbytes)
145
146static inline int COLOR(int color)
147{
148 return screen.invert_colors ? ~color : color;
149}
150
151/* Conversion routines between different color representations */
152static void
153rgb_byte0888(void *dst, int rgb)
154{
155 *(int *)dst = rgb;
156}
157
158static int
159byte0888_rgb(void *src)
160{
161 return (*(int *)src) & 0xffffff;
162}
163
164static void
165bgr_byte0888(void *dst, int rgb)
166{
167 *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
168 RED(rgb, 8);
169}
170
171static int
172byte0888_bgr(void *src)
173{
174 int color = *(uint32_t *)(src);
175 return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
176 ((color >> 16) & 0xff);
177}
178
179static void
180rgb_byte888(void *dst, int rgb)
181{
182 uint8_t *scr = dst;
183#if defined(FB_INVERT_ENDIAN)
184 scr[0] = RED(rgb, 8);
185 scr[1] = GREEN(rgb, 8);
186 scr[2] = BLUE(rgb, 8);
187#else
188 scr[2] = RED(rgb, 8);
189 scr[1] = GREEN(rgb, 8);
190 scr[0] = BLUE(rgb, 8);
191#endif
192}
193
194static int
195byte888_rgb(void *src)
196{
197 uint8_t *scr = src;
198#if defined(FB_INVERT_ENDIAN)
199 return scr[0] << 16 | scr[1] << 8 | scr[2];
200#else
201 return scr[2] << 16 | scr[1] << 8 | scr[0];
202#endif
203}
204
205/** 16-bit depth (5:5:5) */
206static void
207rgb_byte555(void *dst, int rgb)
208{
209 /* 5-bit, 5-bits, 5-bits */
210 *((uint16_t *)(dst)) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
211 BLUE(rgb, 5);
212}
213
214/** 16-bit depth (5:5:5) */
215static int
216byte555_rgb(void *src)
217{
218 int color = *(uint16_t *)(src);
219 return (((color >> 10) & 0x1f) << (16 + 3)) |
220 (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
221}
222
223/** 16-bit depth (5:6:5) */
224static void
225rgb_byte565(void *dst, int rgb)
226{
227 /* 5-bit, 6-bits, 5-bits */
228 *((uint16_t *)(dst)) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
229 BLUE(rgb, 5);
230}
231
232/** 16-bit depth (5:6:5) */
233static int
234byte565_rgb(void *src)
235{
236 int color = *(uint16_t *)(src);
237 return (((color >> 11) & 0x1f) << (16 + 3)) |
238 (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
239}
240
241/** Put pixel - 8-bit depth (3:2:3) */
242static void
243rgb_byte8(void *dst, int rgb)
244{
245 *(uint8_t *)dst = RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 | BLUE(rgb, 3);
246}
247
248/** Return pixel color - 8-bit depth (3:2:3) */
249static int
250byte8_rgb(void *src)
251{
252 int color = *(uint8_t *)src;
253 return (((color >> 5) & 0x7) << (16 + 5)) |
254 (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
255}
256
257/** Put pixel into viewport
258 *
259 * @param vport Viewport identification
260 * @param x X coord relative to viewport
261 * @param y Y coord relative to viewport
262 * @param color RGB color
263 */
264static void
265putpixel(viewport_t *vport, unsigned int x, unsigned int y, int color)
266{
267 int dx = vport->x + x;
268 int dy = vport->y + y;
269
270 if (! (vport->paused && vport->dbdata))
271 (*screen.rgb2scr)(&screen.fbaddress[POINTPOS(dx,dy)],
272 COLOR(color));
273
274 if (vport->dbdata) {
275 int dline = (y + vport->dboffset) % vport->height;
276 int doffset = screen.pixelbytes * (dline * vport->width + x);
277 (*screen.rgb2scr)(&vport->dbdata[doffset], COLOR(color));
278 }
279}
280
281/** Get pixel from viewport */
282static int
283getpixel(viewport_t *vport, unsigned int x, unsigned int y)
284{
285 int dx = vport->x + x;
286 int dy = vport->y + y;
287
288 return COLOR((*screen.scr2rgb)(&screen.fbaddress[POINTPOS(dx, dy)]));
289}
290
291static inline void
292putpixel_mem(char *mem, unsigned int x, unsigned int y, int color)
293{
294 (*screen.rgb2scr)(&mem[POINTPOS(x, y)], COLOR(color));
295}
296
297static void
298draw_rectangle(viewport_t *vport, unsigned int sx, unsigned int sy,
299 unsigned int width, unsigned int height, int color)
300{
301 unsigned int x, y;
302 static void *tmpline;
303
304 if (!tmpline)
305 tmpline = malloc(screen.scanline * screen.pixelbytes);
306
307 /* Clear first line */
308 for (x = 0; x < width; x++)
309 putpixel_mem(tmpline, x, 0, color);
310
311 if (!vport->paused) {
312 /* Recompute to screen coords */
313 sx += vport->x;
314 sy += vport->y;
315 /* Copy the rest */
316 for (y = sy;y < sy+height; y++)
317 memcpy(&screen.fbaddress[POINTPOS(sx,y)], tmpline,
318 screen.pixelbytes * width);
319 }
320 if (vport->dbdata) {
321 for (y = sy; y < sy + height; y++) {
322 int rline = (y + vport->dboffset) % vport->height;
323 int rpos = (rline * vport->width + sx) *
324 screen.pixelbytes;
325 memcpy(&vport->dbdata[rpos], tmpline,
326 screen.pixelbytes * width);
327 }
328 }
329
330}
331
332/** Fill viewport with background color */
333static void
334clear_port(viewport_t *vport)
335{
336 draw_rectangle(vport, 0, 0, vport->width, vport->height,
337 vport->style.bg_color);
338}
339
340/** Scroll unbuffered viewport up/down
341 *
342 * @param vport Viewport to scroll
343 * @param lines Positive number - scroll up, negative - scroll down
344 */
345static void
346scroll_port_nodb(viewport_t *vport, int lines)
347{
348 int y;
349
350 if (lines > 0) {
351 for (y = vport->y; y < vport->y+vport->height - lines; y++)
352 memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
353 &screen.fbaddress[POINTPOS(vport->x,y + lines)],
354 screen.pixelbytes * vport->width);
355 draw_rectangle(vport, 0, vport->height - lines, vport->width,
356 lines, vport->style.bg_color);
357 } else if (lines < 0) {
358 lines = -lines;
359 for (y = vport->y + vport->height-1; y >= vport->y + lines; y--)
360 memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
361 &screen.fbaddress[POINTPOS(vport->x,y - lines)],
362 screen.pixelbytes * vport->width);
363 draw_rectangle(vport, 0, 0, vport->width, lines,
364 vport->style.bg_color);
365 }
366}
367
368/** Refresh given viewport from double buffer */
369static void
370refresh_viewport_db(viewport_t *vport)
371{
372 unsigned int y, srcy, srcoff, dsty, dstx;
373
374 for (y = 0; y < vport->height; y++) {
375 srcy = (y + vport->dboffset) % vport->height;
376 srcoff = (vport->width * srcy) * screen.pixelbytes;
377
378 dstx = vport->x;
379 dsty = vport->y + y;
380
381 memcpy(&screen.fbaddress[POINTPOS(dstx,dsty)],
382 &vport->dbdata[srcoff], vport->width * screen.pixelbytes);
383 }
384}
385
386/** Scroll viewport that has double buffering enabled */
387static void
388scroll_port_db(viewport_t *vport, int lines)
389{
390 ++vport->paused;
391 if (lines > 0) {
392 draw_rectangle(vport, 0, 0, vport->width, lines,
393 vport->style.bg_color);
394 vport->dboffset += lines;
395 vport->dboffset %= vport->height;
396 } else if (lines < 0) {
397 lines = -lines;
398 draw_rectangle(vport, 0, vport->height-lines, vport->width,
399 lines, vport->style.bg_color);
400
401 if (vport->dboffset < lines)
402 vport->dboffset += vport->height;
403 vport->dboffset -= lines;
404 }
405
406 --vport->paused;
407
408 refresh_viewport_db(vport);
409}
410
411/** Scrolls viewport given number of lines */
412static void
413scroll_port(viewport_t *vport, int lines)
414{
415 if (vport->dbdata)
416 scroll_port_db(vport, lines);
417 else
418 scroll_port_nodb(vport, lines);
419
420}
421
422static void
423invert_pixel(viewport_t *vport, unsigned int x, unsigned int y)
424{
425 putpixel(vport, x, y, ~getpixel(vport, x, y));
426}
427
428
429/***************************************************************/
430/* Character-console functions */
431
432/** Draw character at given position
433 *
434 * @param vport Viewport where the character is printed
435 * @param sx Coordinates of top-left of the character
436 * @param sy Coordinates of top-left of the character
437 * @param style Color of the character
438 * @param transparent If false, print background color
439 */
440static void
441draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx, unsigned int sy,
442 style_t style, int transparent)
443{
444 int i;
445 unsigned int y;
446 unsigned int glline;
447
448 for (y = 0; y < FONT_SCANLINES; y++) {
449 glline = fb_font[glyph * FONT_SCANLINES + y];
450 for (i = 0; i < 8; i++) {
451 if (glline & (1 << (7 - i)))
452 putpixel(vport, sx + i, sy + y, style.fg_color);
453 else if (!transparent)
454 putpixel(vport, sx + i, sy + y, style.bg_color);
455 }
456 }
457}
458
459/** Invert character at given position */
460static void
461invert_char(viewport_t *vport,unsigned int row, unsigned int col)
462{
463 unsigned int x;
464 unsigned int y;
465
466 for (x = 0; x < COL_WIDTH; x++)
467 for (y = 0; y < FONT_SCANLINES; y++)
468 invert_pixel(vport, col * COL_WIDTH + x, row *
469 FONT_SCANLINES + y);
470}
471
472/***************************************************************/
473/* Stdout specific functions */
474
475
476/** Create new viewport
477 *
478 * @return New viewport number
479 */
480static int
481viewport_create(unsigned int x, unsigned int y,unsigned int width,
482 unsigned int height)
483{
484 int i;
485
486 for (i = 0; i < MAX_VIEWPORTS; i++) {
487 if (!viewports[i].initialized)
488 break;
489 }
490 if (i == MAX_VIEWPORTS)
491 return ELIMIT;
492
493 viewports[i].x = x;
494 viewports[i].y = y;
495 viewports[i].width = width;
496 viewports[i].height = height;
497
498 viewports[i].rows = height / FONT_SCANLINES;
499 viewports[i].cols = width / COL_WIDTH;
500
501 viewports[i].style.bg_color = DEFAULT_BGCOLOR;
502 viewports[i].style.fg_color = DEFAULT_FGCOLOR;
503
504 viewports[i].cur_col = 0;
505 viewports[i].cur_row = 0;
506 viewports[i].cursor_active = 0;
507
508 viewports[i].initialized = 1;
509
510 return i;
511}
512
513/** Initialize framebuffer as a chardev output device
514 *
515 * @param addr Address of theframebuffer
516 * @param xres Screen width in pixels
517 * @param yres Screen height in pixels
518 * @param visual Bits per pixel (8, 16, 24, 32)
519 * @param scan Bytes per one scanline
520 * @param invert_colors Inverted colors.
521 *
522 */
523static bool
524screen_init(void *addr, unsigned int xres, unsigned int yres,
525 unsigned int scan, unsigned int visual, bool invert_colors)
526{
527 switch (visual) {
528 case VISUAL_INDIRECT_8:
529 screen.rgb2scr = rgb_byte8;
530 screen.scr2rgb = byte8_rgb;
531 screen.pixelbytes = 1;
532 break;
533 case VISUAL_RGB_5_5_5:
534 screen.rgb2scr = rgb_byte555;
535 screen.scr2rgb = byte555_rgb;
536 screen.pixelbytes = 2;
537 break;
538 case VISUAL_RGB_5_6_5:
539 screen.rgb2scr = rgb_byte565;
540 screen.scr2rgb = byte565_rgb;
541 screen.pixelbytes = 2;
542 break;
543 case VISUAL_RGB_8_8_8:
544 screen.rgb2scr = rgb_byte888;
545 screen.scr2rgb = byte888_rgb;
546 screen.pixelbytes = 3;
547 break;
548 case VISUAL_RGB_8_8_8_0:
549 screen.rgb2scr = rgb_byte888;
550 screen.scr2rgb = byte888_rgb;
551 screen.pixelbytes = 4;
552 break;
553 case VISUAL_RGB_0_8_8_8:
554 screen.rgb2scr = rgb_byte0888;
555 screen.scr2rgb = byte0888_rgb;
556 screen.pixelbytes = 4;
557 break;
558 case VISUAL_BGR_0_8_8_8:
559 screen.rgb2scr = bgr_byte0888;
560 screen.scr2rgb = byte0888_bgr;
561 screen.pixelbytes = 4;
562 break;
563 default:
564 return false;
565 }
566
567 screen.fbaddress = (unsigned char *) addr;
568 screen.xres = xres;
569 screen.yres = yres;
570 screen.scanline = scan;
571 screen.invert_colors = invert_colors;
572
573 /* Create first viewport */
574 viewport_create(0, 0, xres, yres);
575
576 return true;
577}
578
579/** Hide cursor if it is shown */
580static void
581cursor_hide(viewport_t *vport)
582{
583 if (vport->cursor_active && vport->cursor_shown) {
584 invert_char(vport, vport->cur_row, vport->cur_col);
585 vport->cursor_shown = 0;
586 }
587}
588
589/** Show cursor if cursor showing is enabled */
590static void
591cursor_print(viewport_t *vport)
592{
593 /* Do not check for cursor_shown */
594 if (vport->cursor_active) {
595 invert_char(vport, vport->cur_row, vport->cur_col);
596 vport->cursor_shown = 1;
597 }
598}
599
600/** Invert cursor, if it is enabled */
601static void
602cursor_blink(viewport_t *vport)
603{
604 if (vport->cursor_shown)
605 cursor_hide(vport);
606 else
607 cursor_print(vport);
608}
609
610/** Draw character at given position relative to viewport
611 *
612 * @param vport Viewport identification
613 * @param c Character to print
614 * @param row Screen position relative to viewport
615 * @param col Screen position relative to viewport
616 * @param transparent If false, print background color with character
617 */
618static void
619draw_char(viewport_t *vport, char c, unsigned int row, unsigned int col,
620 style_t style, int transparent)
621{
622 /* Optimize - do not hide cursor if we are going to overwrite it */
623 if (vport->cursor_active && vport->cursor_shown &&
624 (vport->cur_col != col || vport->cur_row != row))
625 invert_char(vport, vport->cur_row, vport->cur_col);
626
627 draw_glyph(vport, c, col * COL_WIDTH, row * FONT_SCANLINES, style,
628 transparent);
629
630 vport->cur_col = col;
631 vport->cur_row = row;
632
633 vport->cur_col++;
634 if (vport->cur_col >= vport->cols) {
635 vport->cur_col = 0;
636 vport->cur_row++;
637 if (vport->cur_row >= vport->rows)
638 vport->cur_row--;
639 }
640 cursor_print(vport);
641}
642
643/** Draw text data to viewport
644 *
645 * @param vport Viewport id
646 * @param data Text data fitting exactly into viewport
647 */
648static void
649draw_text_data(viewport_t *vport, keyfield_t *data)
650{
651 int i;
652 int col,row;
653
654 clear_port(vport);
655 for (i = 0; i < vport->cols * vport->rows; i++) {
656 if (data[i].character == ' ' && style_same(data[i].style,
657 vport->style))
658 continue;
659 col = i % vport->cols;
660 row = i / vport->cols;
661 draw_glyph(vport, data[i].character, col * COL_WIDTH, row *
662 FONT_SCANLINES, data[i].style, style_same(data[i].style,
663 vport->style));
664 }
665 cursor_print(vport);
666}
667
668/** Return first free pixmap */
669static int
670find_free_pixmap(void)
671{
672 int i;
673
674 for (i = 0;i < MAX_PIXMAPS;i++)
675 if (!pixmaps[i].data)
676 return i;
677 return -1;
678}
679
680static void
681putpixel_pixmap(int pm, unsigned int x, unsigned int y, int color)
682{
683 pixmap_t *pmap = &pixmaps[pm];
684 int pos = (y * pmap->width + x) * screen.pixelbytes;
685
686 (*screen.rgb2scr)(&pmap->data[pos],COLOR(color));
687}
688
689/** Create a new pixmap and return appropriate ID */
690static int
691shm2pixmap(unsigned char *shm, size_t size)
692{
693 int pm;
694 pixmap_t *pmap;
695
696 pm = find_free_pixmap();
697 if (pm == -1)
698 return ELIMIT;
699 pmap = &pixmaps[pm];
700
701 if (ppm_get_data(shm, size, &pmap->width, &pmap->height))
702 return EINVAL;
703
704 pmap->data = malloc(pmap->width * pmap->height * screen.pixelbytes);
705 if (!pmap->data)
706 return ENOMEM;
707
708 ppm_draw(shm, size, 0, 0, pmap->width, pmap->height,
709 (putpixel_cb_t)putpixel_pixmap, (void *)pm);
710
711 return pm;
712}
713
714/** Handle shared memory communication calls
715 *
716 * Protocol for drawing pixmaps:
717 * - FB_PREPARE_SHM(client shm identification)
718 * - IPC_M_AS_AREA_SEND
719 * - FB_DRAW_PPM(startx,starty)
720 * - FB_DROP_SHM
721 *
722 * Protocol for text drawing
723 * - IPC_M_AS_AREA_SEND
724 * - FB_DRAW_TEXT_DATA
725 *
726 * @param callid Callid of the current call
727 * @param call Current call data
728 * @param vp Active viewport
729 * @return 0 if the call was not handled byt this function, 1 otherwise
730 *
731 * note: this function is not threads safe, you would have
732 * to redefine static variables with __thread
733 */
734static int
735shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
736{
737 static keyfield_t *interbuffer = NULL;
738 static size_t intersize = 0;
739
740 static unsigned char *shm = NULL;
741 static ipcarg_t shm_id = 0;
742 static size_t shm_size;
743
744 int handled = 1;
745 int retval = 0;
746 viewport_t *vport = &viewports[vp];
747 unsigned int x, y;
748
749 switch (IPC_GET_METHOD(*call)) {
750 case IPC_M_AS_AREA_SEND:
751 /* We accept one area for data interchange */
752 if (IPC_GET_ARG1(*call) == shm_id) {
753 void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
754 shm_size = IPC_GET_ARG2(*call);
755 if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
756 shm = dest;
757 else
758 shm_id = 0;
759 if (shm[0] != 'P')
760 while (1)
761 ;
762 return 1;
763 } else {
764 intersize = IPC_GET_ARG2(*call);
765 receive_comm_area(callid, call, (void *) &interbuffer);
766 }
767 return 1;
768 case FB_PREPARE_SHM:
769 if (shm_id)
770 retval = EBUSY;
771 else
772 shm_id = IPC_GET_ARG1(*call);
773 break;
774
775 case FB_DROP_SHM:
776 if (shm) {
777 as_area_destroy(shm);
778 shm = NULL;
779 }
780 shm_id = 0;
781 break;
782
783 case FB_SHM2PIXMAP:
784 if (!shm) {
785 retval = EINVAL;
786 break;
787 }
788 retval = shm2pixmap(shm, shm_size);
789 break;
790 case FB_DRAW_PPM:
791 if (!shm) {
792 retval = EINVAL;
793 break;
794 }
795 x = IPC_GET_ARG1(*call);
796 y = IPC_GET_ARG2(*call);
797 if (x > vport->width || y > vport->height) {
798 retval = EINVAL;
799 break;
800 }
801
802 ppm_draw(shm, shm_size, IPC_GET_ARG1(*call),
803 IPC_GET_ARG2(*call), vport->width - x, vport->height - y,
804 (putpixel_cb_t)putpixel, vport);
805 break;
806 case FB_DRAW_TEXT_DATA:
807 if (!interbuffer) {
808 retval = EINVAL;
809 break;
810 }
811 if (intersize < vport->cols * vport->rows *
812 sizeof(*interbuffer)) {
813 retval = EINVAL;
814 break;
815 }
816 draw_text_data(vport, interbuffer);
817 break;
818 default:
819 handled = 0;
820 }
821
822 if (handled)
823 ipc_answer_0(callid, retval);
824 return handled;
825}
826
827static void
828copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
829{
830 int y;
831 int tmp, srcrowsize;
832 int realwidth, realheight, realrowsize;
833 int width = vport->width;
834 int height = vport->height;
835
836 if (width + vport->x > screen.xres)
837 width = screen.xres - vport->x;
838 if (height + vport->y > screen.yres)
839 height = screen.yres - vport->y;
840
841 realwidth = pmap->width <= width ? pmap->width : width;
842 realheight = pmap->height <= height ? pmap->height : height;
843
844 srcrowsize = vport->width * screen.pixelbytes;
845 realrowsize = realwidth * screen.pixelbytes;
846
847 for (y = 0; y < realheight; y++) {
848 tmp = (vport->y + y) * screen.scanline +
849 vport->x * screen.pixelbytes;
850 memcpy(pmap->data + srcrowsize * y, screen.fbaddress + tmp,
851 realrowsize);
852 }
853}
854
855/** Save viewport to pixmap */
856static int
857save_vp_to_pixmap(viewport_t *vport)
858{
859 int pm;
860 pixmap_t *pmap;
861
862 pm = find_free_pixmap();
863 if (pm == -1)
864 return ELIMIT;
865
866 pmap = &pixmaps[pm];
867 pmap->data = malloc(screen.pixelbytes * vport->width * vport->height);
868 if (!pmap->data)
869 return ENOMEM;
870
871 pmap->width = vport->width;
872 pmap->height = vport->height;
873
874 copy_vp_to_pixmap(vport, pmap);
875
876 return pm;
877}
878
879/** Draw pixmap on screen
880 *
881 * @param vp Viewport to draw on
882 * @param pm Pixmap identifier
883 */
884static int draw_pixmap(int vp, int pm)
885{
886 pixmap_t *pmap = &pixmaps[pm];
887 viewport_t *vport = &viewports[vp];
888 int y;
889 int tmp, srcrowsize;
890 int realwidth, realheight, realrowsize;
891 int width = vport->width;
892 int height = vport->height;
893
894 if (width + vport->x > screen.xres)
895 width = screen.xres - vport->x;
896 if (height + vport->y > screen.yres)
897 height = screen.yres - vport->y;
898
899 if (!pmap->data)
900 return EINVAL;
901
902 realwidth = pmap->width <= width ? pmap->width : width;
903 realheight = pmap->height <= height ? pmap->height : height;
904
905 srcrowsize = vport->width * screen.pixelbytes;
906 realrowsize = realwidth * screen.pixelbytes;
907
908 for (y = 0; y < realheight; y++) {
909 tmp = (vport->y + y) * screen.scanline +
910 vport->x * screen.pixelbytes;
911 memcpy(screen.fbaddress + tmp, pmap->data + y * srcrowsize,
912 realrowsize);
913 }
914 return 0;
915}
916
917/** Tick animation one step forward */
918static void
919anims_tick(void)
920{
921 int i;
922 static int counts = 0;
923
924 /* Limit redrawing */
925 counts = (counts + 1) % 8;
926 if (counts)
927 return;
928
929 for (i = 0; i < MAX_ANIMATIONS; i++) {
930 if (!animations[i].animlen || !animations[i].initialized ||
931 !animations[i].enabled)
932 continue;
933 draw_pixmap(animations[i].vp,
934 animations[i].pixmaps[animations[i].pos]);
935 animations[i].pos = (animations[i].pos + 1) %
936 animations[i].animlen;
937 }
938}
939
940
941static int pointer_x, pointer_y;
942static int pointer_shown, pointer_enabled;
943static int pointer_vport = -1;
944static int pointer_pixmap = -1;
945
946static void
947mouse_show(void)
948{
949 int i, j;
950 int visibility;
951 int color;
952 int bytepos;
953
954 if (pointer_shown || !pointer_enabled)
955 return;
956
957 /* Save image under the cursor */
958 if (pointer_vport == -1) {
959 pointer_vport = viewport_create(pointer_x, pointer_y,
960 pointer_width, pointer_height);
961 if (pointer_vport < 0)
962 return;
963 } else {
964 viewports[pointer_vport].x = pointer_x;
965 viewports[pointer_vport].y = pointer_y;
966 }
967
968 if (pointer_pixmap == -1)
969 pointer_pixmap = save_vp_to_pixmap(&viewports[pointer_vport]);
970 else
971 copy_vp_to_pixmap(&viewports[pointer_vport],
972 &pixmaps[pointer_pixmap]);
973
974 /* Draw cursor */
975 for (i = 0; i < pointer_height; i++)
976 for (j = 0; j < pointer_width; j++) {
977 bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8;
978 visibility = pointer_mask_bits[bytepos] &
979 (1 << (j % 8));
980 if (visibility) {
981 color = pointer_bits[bytepos] &
982 (1 << (j % 8)) ? 0 : 0xffffff;
983 if (pointer_x + j < screen.xres && pointer_y +
984 i < screen.yres)
985 putpixel(&viewports[0], pointer_x + j,
986 pointer_y + i, color);
987 }
988 }
989 pointer_shown = 1;
990}
991
992static void
993mouse_hide(void)
994{
995 /* Restore image under the cursor */
996 if (pointer_shown) {
997 draw_pixmap(pointer_vport, pointer_pixmap);
998 pointer_shown = 0;
999 }
1000}
1001
1002static void
1003mouse_move(unsigned int x, unsigned int y)
1004{
1005 mouse_hide();
1006 pointer_x = x;
1007 pointer_y = y;
1008 mouse_show();
1009}
1010
1011static int
1012anim_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
1013{
1014 int handled = 1;
1015 int retval = 0;
1016 int i,nvp;
1017 int newval;
1018
1019 switch (IPC_GET_METHOD(*call)) {
1020 case FB_ANIM_CREATE:
1021 nvp = IPC_GET_ARG1(*call);
1022 if (nvp == -1)
1023 nvp = vp;
1024 if (nvp >= MAX_VIEWPORTS || nvp < 0 ||
1025 !viewports[nvp].initialized) {
1026 retval = EINVAL;
1027 break;
1028 }
1029 for (i = 0; i < MAX_ANIMATIONS; i++) {
1030 if (!animations[i].initialized)
1031 break;
1032 }
1033 if (i == MAX_ANIMATIONS) {
1034 retval = ELIMIT;
1035 break;
1036 }
1037 animations[i].initialized = 1;
1038 animations[i].animlen = 0;
1039 animations[i].pos = 0;
1040 animations[i].enabled = 0;
1041 animations[i].vp = nvp;
1042 retval = i;
1043 break;
1044 case FB_ANIM_DROP:
1045 i = IPC_GET_ARG1(*call);
1046 if (i >= MAX_ANIMATIONS || i < 0) {
1047 retval = EINVAL;
1048 break;
1049 }
1050 animations[i].initialized = 0;
1051 break;
1052 case FB_ANIM_ADDPIXMAP:
1053 i = IPC_GET_ARG1(*call);
1054 if (i >= MAX_ANIMATIONS || i < 0 ||
1055 !animations[i].initialized) {
1056 retval = EINVAL;
1057 break;
1058 }
1059 if (animations[i].animlen == MAX_ANIM_LEN) {
1060 retval = ELIMIT;
1061 break;
1062 }
1063 newval = IPC_GET_ARG2(*call);
1064 if (newval < 0 || newval > MAX_PIXMAPS ||
1065 !pixmaps[newval].data) {
1066 retval = EINVAL;
1067 break;
1068 }
1069 animations[i].pixmaps[animations[i].animlen++] = newval;
1070 break;
1071 case FB_ANIM_CHGVP:
1072 i = IPC_GET_ARG1(*call);
1073 if (i >= MAX_ANIMATIONS || i < 0) {
1074 retval = EINVAL;
1075 break;
1076 }
1077 nvp = IPC_GET_ARG2(*call);
1078 if (nvp == -1)
1079 nvp = vp;
1080 if (nvp >= MAX_VIEWPORTS || nvp < 0 ||
1081 !viewports[nvp].initialized) {
1082 retval = EINVAL;
1083 break;
1084 }
1085 animations[i].vp = nvp;
1086 break;
1087 case FB_ANIM_START:
1088 case FB_ANIM_STOP:
1089 i = IPC_GET_ARG1(*call);
1090 if (i >= MAX_ANIMATIONS || i < 0) {
1091 retval = EINVAL;
1092 break;
1093 }
1094 newval = (IPC_GET_METHOD(*call) == FB_ANIM_START);
1095 if (newval ^ animations[i].enabled) {
1096 animations[i].enabled = newval;
1097 anims_enabled += newval ? 1 : -1;
1098 }
1099 break;
1100 default:
1101 handled = 0;
1102 }
1103 if (handled)
1104 ipc_answer_0(callid, retval);
1105 return handled;
1106}
1107
1108/** Handler for messages concerning pixmap handling */
1109static int
1110pixmap_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
1111{
1112 int handled = 1;
1113 int retval = 0;
1114 int i,nvp;
1115
1116 switch (IPC_GET_METHOD(*call)) {
1117 case FB_VP_DRAW_PIXMAP:
1118 nvp = IPC_GET_ARG1(*call);
1119 if (nvp == -1)
1120 nvp = vp;
1121 if (nvp < 0 || nvp >= MAX_VIEWPORTS ||
1122 !viewports[nvp].initialized) {
1123 retval = EINVAL;
1124 break;
1125 }
1126 i = IPC_GET_ARG2(*call);
1127 retval = draw_pixmap(nvp, i);
1128 break;
1129 case FB_VP2PIXMAP:
1130 nvp = IPC_GET_ARG1(*call);
1131 if (nvp == -1)
1132 nvp = vp;
1133 if (nvp < 0 || nvp >= MAX_VIEWPORTS ||
1134 !viewports[nvp].initialized)
1135 retval = EINVAL;
1136 else
1137 retval = save_vp_to_pixmap(&viewports[nvp]);
1138 break;
1139 case FB_DROP_PIXMAP:
1140 i = IPC_GET_ARG1(*call);
1141 if (i >= MAX_PIXMAPS) {
1142 retval = EINVAL;
1143 break;
1144 }
1145 if (pixmaps[i].data) {
1146 free(pixmaps[i].data);
1147 pixmaps[i].data = NULL;
1148 }
1149 break;
1150 default:
1151 handled = 0;
1152 }
1153
1154 if (handled)
1155 ipc_answer_0(callid, retval);
1156 return handled;
1157
1158}
1159
1160/** Function for handling connections to FB
1161 *
1162 */
1163static void
1164fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
1165{
1166 ipc_callid_t callid;
1167 ipc_call_t call;
1168 int retval;
1169 int i;
1170 unsigned int row,col;
1171 char c;
1172
1173 int vp = 0;
1174 viewport_t *vport = &viewports[0];
1175
1176 if (client_connected) {
1177 ipc_answer_0(iid, ELIMIT);
1178 return;
1179 }
1180 client_connected = 1;
1181 ipc_answer_0(iid, EOK); /* Accept connection */
1182
1183 while (1) {
1184 if (vport->cursor_active || anims_enabled)
1185 callid = async_get_call_timeout(&call, 250000);
1186 else
1187 callid = async_get_call(&call);
1188
1189 mouse_hide();
1190 if (!callid) {
1191 cursor_blink(vport);
1192 anims_tick();
1193 mouse_show();
1194 continue;
1195 }
1196 if (shm_handle(callid, &call, vp))
1197 continue;
1198 if (pixmap_handle(callid, &call, vp))
1199 continue;
1200 if (anim_handle(callid, &call, vp))
1201 continue;
1202
1203 switch (IPC_GET_METHOD(call)) {
1204 case IPC_M_PHONE_HUNGUP:
1205 client_connected = 0;
1206 /* cleanup other viewports */
1207 for (i = 1; i < MAX_VIEWPORTS; i++)
1208 vport->initialized = 0;
1209 return; /* Exit thread */
1210
1211 case FB_PUTCHAR:
1212 case FB_TRANS_PUTCHAR:
1213 c = IPC_GET_ARG1(call);
1214 row = IPC_GET_ARG2(call);
1215 col = IPC_GET_ARG3(call);
1216 if (row >= vport->rows || col >= vport->cols) {
1217 retval = EINVAL;
1218 break;
1219 }
1220 ipc_answer_0(callid, EOK);
1221
1222 draw_char(vport, c, row, col, vport->style,
1223 IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR);
1224 continue; /* msg already answered */
1225 case FB_CLEAR:
1226 clear_port(vport);
1227 cursor_print(vport);
1228 retval = 0;
1229 break;
1230 case FB_CURSOR_GOTO:
1231 row = IPC_GET_ARG1(call);
1232 col = IPC_GET_ARG2(call);
1233 if (row >= vport->rows || col >= vport->cols) {
1234 retval = EINVAL;
1235 break;
1236 }
1237 retval = 0;
1238 cursor_hide(vport);
1239 vport->cur_col = col;
1240 vport->cur_row = row;
1241 cursor_print(vport);
1242 break;
1243 case FB_CURSOR_VISIBILITY:
1244 cursor_hide(vport);
1245 vport->cursor_active = IPC_GET_ARG1(call);
1246 cursor_print(vport);
1247 retval = 0;
1248 break;
1249 case FB_GET_CSIZE:
1250 ipc_answer_2(callid, EOK, vport->rows, vport->cols);
1251 continue;
1252 case FB_SCROLL:
1253 i = IPC_GET_ARG1(call);
1254 if (i > vport->rows || i < (- (int)vport->rows)) {
1255 retval = EINVAL;
1256 break;
1257 }
1258 cursor_hide(vport);
1259 scroll_port(vport, i*FONT_SCANLINES);
1260 cursor_print(vport);
1261 retval = 0;
1262 break;
1263 case FB_VIEWPORT_DB:
1264 /* Enable double buffering */
1265 i = IPC_GET_ARG1(call);
1266 if (i == -1)
1267 i = vp;
1268 if (i < 0 || i >= MAX_VIEWPORTS) {
1269 retval = EINVAL;
1270 break;
1271 }
1272 if (!viewports[i].initialized ) {
1273 retval = EADDRNOTAVAIL;
1274 break;
1275 }
1276 viewports[i].dboffset = 0;
1277 if (IPC_GET_ARG2(call) == 1 && !viewports[i].dbdata)
1278 viewports[i].dbdata =
1279 malloc(screen.pixelbytes *
1280 viewports[i].width * viewports[i].height);
1281 else if (IPC_GET_ARG2(call) == 0 &&
1282 viewports[i].dbdata) {
1283 free(viewports[i].dbdata);
1284 viewports[i].dbdata = NULL;
1285 }
1286 retval = 0;
1287 break;
1288 case FB_VIEWPORT_SWITCH:
1289 i = IPC_GET_ARG1(call);
1290 if (i < 0 || i >= MAX_VIEWPORTS) {
1291 retval = EINVAL;
1292 break;
1293 }
1294 if (! viewports[i].initialized ) {
1295 retval = EADDRNOTAVAIL;
1296 break;
1297 }
1298 cursor_hide(vport);
1299 vp = i;
1300 vport = &viewports[vp];
1301 cursor_print(vport);
1302 retval = 0;
1303 break;
1304 case FB_VIEWPORT_CREATE:
1305 retval = viewport_create(IPC_GET_ARG1(call) >> 16,
1306 IPC_GET_ARG1(call) & 0xffff,
1307 IPC_GET_ARG2(call) >> 16,
1308 IPC_GET_ARG2(call) & 0xffff);
1309 break;
1310 case FB_VIEWPORT_DELETE:
1311 i = IPC_GET_ARG1(call);
1312 if (i < 0 || i >= MAX_VIEWPORTS) {
1313 retval = EINVAL;
1314 break;
1315 }
1316 if (! viewports[i].initialized ) {
1317 retval = EADDRNOTAVAIL;
1318 break;
1319 }
1320 viewports[i].initialized = 0;
1321 if (viewports[i].dbdata) {
1322 free(viewports[i].dbdata);
1323 viewports[i].dbdata = NULL;
1324 }
1325 retval = 0;
1326 break;
1327 case FB_SET_STYLE:
1328 vport->style.fg_color = IPC_GET_ARG1(call);
1329 vport->style.bg_color = IPC_GET_ARG2(call);
1330 retval = 0;
1331 break;
1332 case FB_GET_RESOLUTION:
1333 ipc_answer_2(callid, EOK, screen.xres, screen.yres);
1334 continue;
1335 case FB_POINTER_MOVE:
1336 pointer_enabled = 1;
1337 mouse_move(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
1338 retval = 0;
1339 break;
1340 default:
1341 retval = ENOENT;
1342 }
1343 ipc_answer_0(callid, retval);
1344 }
1345}
1346
1347/** Initialization of framebuffer */
1348int
1349fb_init(void)
1350{
1351 void *fb_ph_addr;
1352 unsigned int fb_width;
1353 unsigned int fb_height;
1354 unsigned int fb_scanline;
1355 unsigned int fb_visual;
1356 bool fb_invert_colors;
1357 void *fb_addr;
1358 size_t asz;
1359
1360 async_set_client_connection(fb_client_connection);
1361
1362 fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
1363 fb_width = sysinfo_value("fb.width");
1364 fb_height = sysinfo_value("fb.height");
1365 fb_scanline = sysinfo_value("fb.scanline");
1366 fb_visual = sysinfo_value("fb.visual");
1367 fb_invert_colors = sysinfo_value("fb.invert-colors");
1368
1369 asz = fb_scanline * fb_height;
1370 fb_addr = as_get_mappable_page(asz);
1371
1372 physmem_map(fb_ph_addr, fb_addr, ALIGN_UP(asz, PAGE_SIZE) >>
1373 PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
1374
1375 if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual,
1376 fb_invert_colors))
1377 return 0;
1378
1379 return -1;
1380}
1381
1382/**
1383 * @}
1384 */
Note: See TracBrowser for help on using the repository browser.