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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a85aebd was 171f9a1, checked in by Jiri Svoboda <jirik.svoboda@…>, 17 years ago

Character encoding/decoding un uspace. Partially fix klog application.
  • Property mode set to 100644
File size: 39.6 KB
Line 
1/*
2 * Copyright (c) 2008 Martin Decky
3 * Copyright (c) 2006 Jakub Vana
4 * Copyright (c) 2006 Ondrej Palkovsky
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * - Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * - The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/**
32 * @defgroup fb Graphical framebuffer
33 * @brief HelenOS graphical framebuffer.
34 * @ingroup fbs
35 * @{
36 */
37
38/** @file
39 */
40
41#include <stdlib.h>
42#include <unistd.h>
43#include <string.h>
44#include <ddi.h>
45#include <sysinfo.h>
46#include <align.h>
47#include <as.h>
48#include <ipc/fb.h>
49#include <ipc/ipc.h>
50#include <ipc/ns.h>
51#include <ipc/services.h>
52#include <kernel/errno.h>
53#include <kernel/genarch/fb/visuals.h>
54#include <console/color.h>
55#include <console/style.h>
56#include <async.h>
57#include <bool.h>
58
59#include "font-8x16.h"
60#include "fb.h"
61#include "main.h"
62#include "../console/screenbuffer.h"
63#include "ppm.h"
64
65#include "pointer.xbm"
66#include "pointer_mask.xbm"
67
68#define DEFAULT_BGCOLOR 0xf0f0f0
69#define DEFAULT_FGCOLOR 0x000000
70
71#define GLYPH_UNAVAIL '?'
72
73#define MAX_ANIM_LEN 8
74#define MAX_ANIMATIONS 4
75#define MAX_PIXMAPS 256 /**< Maximum number of saved pixmaps */
76#define MAX_VIEWPORTS 128 /**< Viewport is a rectangular area on the screen */
77
78/** Function to render a pixel from a RGB value. */
79typedef void (*rgb_conv_t)(void *, uint32_t);
80
81/** Function to draw a glyph. */
82typedef void (*dg_t)(unsigned int x, unsigned int y, bool cursor,
83 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color);
84
85struct {
86 uint8_t *fb_addr;
87
88 unsigned int xres;
89 unsigned int yres;
90
91 unsigned int scanline;
92 unsigned int glyphscanline;
93
94 unsigned int pixelbytes;
95 unsigned int glyphbytes;
96
97 rgb_conv_t rgb_conv;
98} screen;
99
100/** Backbuffer character cell. */
101typedef struct {
102 uint32_t glyph;
103 uint32_t fg_color;
104 uint32_t bg_color;
105} bb_cell_t;
106
107typedef struct {
108 bool initialized;
109 unsigned int x;
110 unsigned int y;
111 unsigned int width;
112 unsigned int height;
113
114 /* Text support in window */
115 unsigned int cols;
116 unsigned int rows;
117
118 /*
119 * Style and glyphs for text printing
120 */
121
122 /** Current attributes. */
123 attr_rgb_t attr;
124
125 /** Pre-rendered mask for rendering glyphs. Different viewports
126 * might use different drawing functions depending on whether their
127 * scanlines are aligned on a word boundary.*/
128 uint8_t *glyphs;
129
130 uint8_t *bgpixel;
131
132 /** Glyph drawing function for this viewport. */
133 dg_t dglyph;
134
135 /* Auto-cursor position */
136 bool cursor_active;
137 unsigned int cur_col;
138 unsigned int cur_row;
139 bool cursor_shown;
140
141 /* Back buffer */
142 bb_cell_t *backbuf;
143 unsigned int bbsize;
144} viewport_t;
145
146typedef struct {
147 bool initialized;
148 bool enabled;
149 unsigned int vp;
150
151 unsigned int pos;
152 unsigned int animlen;
153 unsigned int pixmaps[MAX_ANIM_LEN];
154} animation_t;
155
156static animation_t animations[MAX_ANIMATIONS];
157static bool anims_enabled;
158
159typedef struct {
160 unsigned int width;
161 unsigned int height;
162 uint8_t *data;
163} pixmap_t;
164
165static pixmap_t pixmaps[MAX_PIXMAPS];
166static viewport_t viewports[128];
167
168static bool client_connected = false; /**< Allow only 1 connection */
169
170static uint32_t color_table[16] = {
171 [COLOR_BLACK] = 0x000000,
172 [COLOR_BLUE] = 0x0000f0,
173 [COLOR_GREEN] = 0x00f000,
174 [COLOR_CYAN] = 0x00f0f0,
175 [COLOR_RED] = 0xf00000,
176 [COLOR_MAGENTA] = 0xf000f0,
177 [COLOR_YELLOW] = 0xf0f000,
178 [COLOR_WHITE] = 0xf0f0f0,
179
180 [8 + COLOR_BLACK] = 0x000000,
181 [8 + COLOR_BLUE] = 0x0000ff,
182 [8 + COLOR_GREEN] = 0x00ff00,
183 [8 + COLOR_CYAN] = 0x00ffff,
184 [8 + COLOR_RED] = 0xff0000,
185 [8 + COLOR_MAGENTA] = 0xff00ff,
186 [8 + COLOR_YELLOW] = 0xffff00,
187 [8 + COLOR_WHITE] = 0xffffff,
188};
189
190static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a);
191static int rgb_from_style(attr_rgb_t *rgb, int style);
192static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
193 ipcarg_t bg_color, ipcarg_t flags);
194
195static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
196 ipcarg_t bg_color, ipcarg_t attr);
197
198static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
199 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color);
200static void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
201 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color);
202
203static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
204 unsigned int row);
205
206
207#define RED(x, bits) ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
208#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
209#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))
210
211#define COL2X(col) ((col) * FONT_WIDTH)
212#define ROW2Y(row) ((row) * FONT_SCANLINES)
213
214#define X2COL(x) ((x) / FONT_WIDTH)
215#define Y2ROW(y) ((y) / FONT_SCANLINES)
216
217#define FB_POS(x, y) ((y) * screen.scanline + (x) * screen.pixelbytes)
218#define BB_POS(vport, col, row) ((row) * vport->cols + (col))
219#define GLYPH_POS(glyph, y, cursor) (((glyph) + (cursor) * FONT_GLYPHS) * screen.glyphbytes + (y) * screen.glyphscanline)
220
221
222/** ARGB 8:8:8:8 conversion
223 *
224 */
225static void rgb_0888(void *dst, uint32_t rgb)
226{
227 *((uint32_t *) dst) = rgb & 0xffffff;
228}
229
230
231/** ABGR 8:8:8:8 conversion
232 *
233 */
234static void bgr_0888(void *dst, uint32_t rgb)
235{
236 *((uint32_t *) dst)
237 = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
238}
239
240
241/** RGB 8:8:8 conversion
242 *
243 */
244static void rgb_888(void *dst, uint32_t rgb)
245{
246 ((uint8_t *) dst)[0] = BLUE(rgb, 8);
247 ((uint8_t *) dst)[1] = GREEN(rgb, 8);
248 ((uint8_t *) dst)[2] = RED(rgb, 8);
249}
250
251
252/** BGR 8:8:8 conversion
253 *
254 */
255static void bgr_888(void *dst, uint32_t rgb)
256{
257 ((uint8_t *) dst)[0] = RED(rgb, 8);
258 ((uint8_t *) dst)[1] = GREEN(rgb, 8);
259 ((uint8_t *) dst)[2] = BLUE(rgb, 8);
260}
261
262
263/** RGB 5:5:5 conversion
264 *
265 */
266static void rgb_555(void *dst, uint32_t rgb)
267{
268 *((uint16_t *) dst)
269 = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
270}
271
272
273/** RGB 5:6:5 conversion
274 *
275 */
276static void rgb_565(void *dst, uint32_t rgb)
277{
278 *((uint16_t *) dst)
279 = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
280}
281
282
283/** RGB 3:2:3
284 *
285 */
286static void rgb_323(void *dst, uint32_t rgb)
287{
288 *((uint8_t *) dst)
289 = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
290}
291
292/** Draw a filled rectangle.
293 *
294 * @note Need real implementation that does not access VRAM twice.
295 */
296static void draw_filled_rect(unsigned int x0, unsigned int y0, unsigned int x1,
297 unsigned int y1, uint32_t color)
298{
299 unsigned int x, y;
300 unsigned int copy_bytes;
301
302 uint8_t *sp, *dp;
303 uint8_t cbuf[4];
304
305 if (y0 >= y1 || x0 >= x1) return;
306 screen.rgb_conv(cbuf, color);
307
308 sp = &screen.fb_addr[FB_POS(x0, y0)];
309 dp = sp;
310
311 /* Draw the first line. */
312 for (x = x0; x < x1; x++) {
313 memcpy(dp, cbuf, screen.pixelbytes);
314 dp += screen.pixelbytes;
315 }
316
317 dp = sp + screen.scanline;
318 copy_bytes = (x1 - x0) * screen.pixelbytes;
319
320 /* Draw the remaining lines by copying. */
321 for (y = y0 + 1; y < y1; y++) {
322 memcpy(dp, sp, copy_bytes);
323 dp += screen.scanline;
324 }
325}
326
327/** Redraw viewport.
328 *
329 * @param vport Viewport to redraw
330 *
331 */
332static void vport_redraw(viewport_t *vport)
333{
334 unsigned int row, col;
335
336 for (row = 0; row < vport->rows; row++) {
337 for (col = 0; col < vport->cols; col++) {
338 draw_vp_glyph(vport, false, col, row);
339 }
340 }
341
342 if (COL2X(vport->cols) < vport->width) {
343 draw_filled_rect(
344 vport->x + COL2X(vport->cols), vport->y,
345 vport->x + vport->width, vport->y + vport->height,
346 vport->attr.bg_color);
347 }
348
349 if (ROW2Y(vport->rows) < vport->height) {
350 draw_filled_rect(
351 vport->x, vport->y + ROW2Y(vport->rows),
352 vport->x + vport->width, vport->y + vport->height,
353 vport->attr.bg_color);
354 }
355}
356
357static void backbuf_clear(bb_cell_t *backbuf, size_t len, uint32_t fg_color,
358 uint32_t bg_color)
359{
360 unsigned i;
361
362 for (i = 0; i < len; i++) {
363 backbuf[i].glyph = 0;
364 backbuf[i].fg_color = fg_color;
365 backbuf[i].bg_color = bg_color;
366 }
367}
368
369/** Clear viewport.
370 *
371 * @param vport Viewport to clear
372 *
373 */
374static void vport_clear(viewport_t *vport)
375{
376 backbuf_clear(vport->backbuf, vport->cols * vport->rows,
377 vport->attr.fg_color, vport->attr.bg_color);
378 vport_redraw(vport);
379}
380
381/** Scroll viewport by the specified number of lines.
382 *
383 * @param vport Viewport to scroll
384 * @param lines Number of lines to scroll
385 *
386 */
387static void vport_scroll(viewport_t *vport, int lines)
388{
389 unsigned int row, col;
390 unsigned int x, y;
391 uint8_t glyph;
392 uint32_t fg_color;
393 uint32_t bg_color;
394 bb_cell_t *bbp, *xbp;
395
396 /*
397 * Redraw.
398 */
399
400 y = vport->y;
401 for (row = 0; row < vport->rows; row++) {
402 x = vport->x;
403 for (col = 0; col < vport->cols; col++) {
404 if ((row + lines >= 0) && (row + lines < vport->rows)) {
405 xbp = &vport->backbuf[BB_POS(vport, col, row + lines)];
406 bbp = &vport->backbuf[BB_POS(vport, col, row)];
407
408 glyph = xbp->glyph;
409 fg_color = xbp->fg_color;
410 bg_color = xbp->bg_color;
411
412 if (bbp->glyph == glyph &&
413 bbp->fg_color == xbp->fg_color &&
414 bbp->bg_color == xbp->bg_color) {
415 x += FONT_WIDTH;
416 continue;
417 }
418 } else {
419 glyph = 0;
420 fg_color = vport->attr.fg_color;
421 bg_color = vport->attr.bg_color;
422 }
423
424 (*vport->dglyph)(x, y, false, vport->glyphs, glyph,
425 fg_color, bg_color);
426 x += FONT_WIDTH;
427 }
428 y += FONT_SCANLINES;
429 }
430
431 /*
432 * Scroll backbuffer.
433 */
434
435 if (lines > 0) {
436 memmove(vport->backbuf, vport->backbuf + vport->cols * lines,
437 vport->cols * (vport->rows - lines) * sizeof(bb_cell_t));
438 backbuf_clear(&vport->backbuf[BB_POS(vport, 0, vport->rows - lines)],
439 vport->cols * lines, vport->attr.fg_color, vport->attr.bg_color);
440 } else {
441 memmove(vport->backbuf - vport->cols * lines, vport->backbuf,
442 vport->cols * (vport->rows + lines) * sizeof(bb_cell_t));
443 backbuf_clear(vport->backbuf, - vport->cols * lines,
444 vport->attr.fg_color, vport->attr.bg_color);
445 }
446}
447
448/** Render glyphs
449 *
450 * Convert glyphs from device independent font
451 * description to current visual representation.
452 *
453 * @param vport Viewport
454 *
455 */
456static void render_glyphs(viewport_t* vport)
457{
458 unsigned int glyph;
459
460 for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
461 unsigned int y;
462
463 for (y = 0; y < FONT_SCANLINES; y++) {
464 unsigned int x;
465
466 for (x = 0; x < FONT_WIDTH; x++) {
467 screen.rgb_conv(&vport->glyphs[GLYPH_POS(glyph, y, false) + x * screen.pixelbytes],
468 (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x)))
469 ? 0xffffff : 0x000000);
470
471 screen.rgb_conv(&vport->glyphs[GLYPH_POS(glyph, y, true) + x * screen.pixelbytes],
472 (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x)))
473 ? 0x000000 : 0xffffff);
474 }
475 }
476 }
477
478 screen.rgb_conv(vport->bgpixel, vport->attr.bg_color);
479}
480
481
482/** Create new viewport
483 *
484 * @param x Origin of the viewport (x).
485 * @param y Origin of the viewport (y).
486 * @param width Width of the viewport.
487 * @param height Height of the viewport.
488 *
489 * @return New viewport number.
490 *
491 */
492static int vport_create(unsigned int x, unsigned int y,
493 unsigned int width, unsigned int height)
494{
495 unsigned int i;
496
497 for (i = 0; i < MAX_VIEWPORTS; i++) {
498 if (!viewports[i].initialized)
499 break;
500 }
501 if (i == MAX_VIEWPORTS)
502 return ELIMIT;
503
504 unsigned int cols = width / FONT_WIDTH;
505 unsigned int rows = height / FONT_SCANLINES;
506 unsigned int bbsize = cols * rows * sizeof(bb_cell_t);
507 unsigned int glyphsize = 2 * FONT_GLYPHS * screen.glyphbytes;
508 unsigned int word_size = sizeof(unsigned long);
509
510 bb_cell_t *backbuf = (bb_cell_t *) malloc(bbsize);
511 if (!backbuf)
512 return ENOMEM;
513
514 uint8_t *glyphs = (uint8_t *) malloc(glyphsize);
515 if (!glyphs) {
516 free(backbuf);
517 return ENOMEM;
518 }
519
520 uint8_t *bgpixel = (uint8_t *) malloc(screen.pixelbytes);
521 if (!bgpixel) {
522 free(glyphs);
523 free(backbuf);
524 return ENOMEM;
525 }
526
527 backbuf_clear(backbuf, cols * rows, DEFAULT_FGCOLOR, DEFAULT_BGCOLOR);
528 memset(glyphs, 0, glyphsize);
529 memset(bgpixel, 0, screen.pixelbytes);
530
531 viewports[i].x = x;
532 viewports[i].y = y;
533 viewports[i].width = width;
534 viewports[i].height = height;
535
536 viewports[i].cols = cols;
537 viewports[i].rows = rows;
538
539 viewports[i].attr.bg_color = DEFAULT_BGCOLOR;
540 viewports[i].attr.fg_color = DEFAULT_FGCOLOR;
541
542 viewports[i].glyphs = glyphs;
543 viewports[i].bgpixel = bgpixel;
544
545 /*
546 * Conditions necessary to select aligned version:
547 *
548 * - word size is divisible by pixelbytes
549 * - cell scanline size is divisible by word size
550 * - cell scanlines are word-aligned
551 */
552 if ((word_size % screen.pixelbytes) == 0 &&
553 (FONT_WIDTH * screen.pixelbytes) % word_size == 0 &&
554 (x * screen.pixelbytes) % word_size == 0 &&
555 screen.scanline % word_size == 0) {
556
557 viewports[i].dglyph = draw_glyph_aligned;
558 } else {
559 viewports[i].dglyph = draw_glyph_fallback;
560 }
561
562 viewports[i].cur_col = 0;
563 viewports[i].cur_row = 0;
564 viewports[i].cursor_active = false;
565 viewports[i].cursor_shown = false;
566
567 viewports[i].bbsize = bbsize;
568 viewports[i].backbuf = backbuf;
569
570 viewports[i].initialized = true;
571
572 render_glyphs(&viewports[i]);
573
574 return i;
575}
576
577
578/** Initialize framebuffer as a chardev output device
579 *
580 * @param addr Address of the framebuffer
581 * @param xres Screen width in pixels
582 * @param yres Screen height in pixels
583 * @param visual Bits per pixel (8, 16, 24, 32)
584 * @param scan Bytes per one scanline
585 *
586 */
587static bool screen_init(void *addr, unsigned int xres, unsigned int yres,
588 unsigned int scan, unsigned int visual)
589{
590 switch (visual) {
591 case VISUAL_INDIRECT_8:
592 screen.rgb_conv = rgb_323;
593 screen.pixelbytes = 1;
594 break;
595 case VISUAL_RGB_5_5_5:
596 screen.rgb_conv = rgb_555;
597 screen.pixelbytes = 2;
598 break;
599 case VISUAL_RGB_5_6_5:
600 screen.rgb_conv = rgb_565;
601 screen.pixelbytes = 2;
602 break;
603 case VISUAL_RGB_8_8_8:
604 screen.rgb_conv = rgb_888;
605 screen.pixelbytes = 3;
606 break;
607 case VISUAL_BGR_8_8_8:
608 screen.rgb_conv = bgr_888;
609 screen.pixelbytes = 3;
610 break;
611 case VISUAL_RGB_8_8_8_0:
612 screen.rgb_conv = rgb_888;
613 screen.pixelbytes = 4;
614 break;
615 case VISUAL_RGB_0_8_8_8:
616 screen.rgb_conv = rgb_0888;
617 screen.pixelbytes = 4;
618 break;
619 case VISUAL_BGR_0_8_8_8:
620 screen.rgb_conv = bgr_0888;
621 screen.pixelbytes = 4;
622 break;
623 default:
624 return false;
625 }
626
627 screen.fb_addr = (unsigned char *) addr;
628 screen.xres = xres;
629 screen.yres = yres;
630 screen.scanline = scan;
631
632 screen.glyphscanline = FONT_WIDTH * screen.pixelbytes;
633 screen.glyphbytes = screen.glyphscanline * FONT_SCANLINES;
634
635 /* Create first viewport */
636 vport_create(0, 0, xres, yres);
637
638 return true;
639}
640
641
642/** Draw a glyph, takes advantage of alignment.
643 *
644 * This version can only be used if the following conditions are met:
645 *
646 * - word size is divisible by pixelbytes
647 * - cell scanline size is divisible by word size
648 * - cell scanlines are word-aligned
649 *
650 * It makes use of the pre-rendered mask to process (possibly) several
651 * pixels at once (word size / pixelbytes pixels at a time are processed)
652 * making it very fast. Most notably this version is not applicable at 24 bits
653 * per pixel.
654 *
655 * @param x x coordinate of top-left corner on screen.
656 * @param y y coordinate of top-left corner on screen.
657 * @param cursor Draw glyph with cursor
658 * @param glyphs Pointer to font bitmap.
659 * @param glyph Code of the glyph to draw.
660 * @param fg_color Foreground color.
661 * @param bg_color Backgroudn color.
662 */
663static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
664 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color)
665{
666 unsigned int i, yd;
667 unsigned long fg_buf, bg_buf;
668 unsigned long *maskp, *dp;
669 unsigned long mask;
670 unsigned int ww, d_add;
671
672 /* Check glyph range. */
673 if (glyph >= FONT_GLYPHS)
674 glyph = GLYPH_UNAVAIL;
675
676 /*
677 * Prepare a pair of words, one filled with foreground-color
678 * pattern and the other filled with background-color pattern.
679 */
680 for (i = 0; i < sizeof(unsigned long) / screen.pixelbytes; i++) {
681 screen.rgb_conv(&((uint8_t *)&fg_buf)[i * screen.pixelbytes],
682 fg_color);
683 screen.rgb_conv(&((uint8_t *)&bg_buf)[i * screen.pixelbytes],
684 bg_color);
685 }
686
687 /* Pointer to the current position in the mask. */
688 maskp = (unsigned long *) &glyphs[GLYPH_POS(glyph, 0, cursor)];
689
690 /* Pointer to the current position on the screen. */
691 dp = (unsigned long *) &screen.fb_addr[FB_POS(x, y)];
692
693 /* Width of the character cell in words. */
694 ww = FONT_WIDTH * screen.pixelbytes / sizeof(unsigned long);
695
696 /* Offset to add when moving to another screen scanline. */
697 d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
698
699 for (yd = 0; yd < FONT_SCANLINES; yd++) {
700 /*
701 * Now process the cell scanline, combining foreground
702 * and background color patters using the pre-rendered mask.
703 */
704 for (i = 0; i < ww; i++) {
705 mask = *maskp++;
706 *dp++ = (fg_buf & mask) | (bg_buf & ~mask);
707 }
708
709 /* Move to the beginning of the next scanline of the cell. */
710 dp = (unsigned long *) ((uint8_t *) dp + d_add);
711 }
712}
713
714/** Draw a glyph, fallback version.
715 *
716 * This version does not make use of the pre-rendered mask, it uses
717 * the font bitmap directly. It works always, but it is slower.
718 *
719 * @param x x coordinate of top-left corner on screen.
720 * @param y y coordinate of top-left corner on screen.
721 * @param cursor Draw glyph with cursor
722 * @param glyphs Pointer to font bitmap.
723 * @param glyph Code of the glyph to draw.
724 * @param fg_color Foreground color.
725 * @param bg_color Backgroudn color.
726 */
727void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
728 uint8_t *glyphs, uint32_t glyph, uint32_t fg_color, uint32_t bg_color)
729{
730 unsigned int i, j, yd;
731 uint8_t fg_buf[4], bg_buf[4];
732 uint8_t *dp, *sp;
733 unsigned int d_add;
734 uint8_t b;
735
736 /* Check glyph range. */
737 if (glyph >= FONT_GLYPHS)
738 glyph = GLYPH_UNAVAIL;
739
740 /* Pre-render 1x the foreground and background color pixels. */
741 if (cursor) {
742 screen.rgb_conv(fg_buf, bg_color);
743 screen.rgb_conv(bg_buf, fg_color);
744 } else {
745 screen.rgb_conv(fg_buf, fg_color);
746 screen.rgb_conv(bg_buf, bg_color);
747 }
748
749 /* Pointer to the current position on the screen. */
750 dp = (uint8_t *) &screen.fb_addr[FB_POS(x, y)];
751
752 /* Offset to add when moving to another screen scanline. */
753 d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
754
755 for (yd = 0; yd < FONT_SCANLINES; yd++) {
756 /* Byte containing bits of the glyph scanline. */
757 b = fb_font[glyph * FONT_SCANLINES + yd];
758
759 for (i = 0; i < FONT_WIDTH; i++) {
760 /* Choose color based on the current bit. */
761 sp = (b & 0x80) ? fg_buf : bg_buf;
762
763 /* Copy the pixel. */
764 for (j = 0; j < screen.pixelbytes; j++) {
765 *dp++ = *sp++;
766 }
767
768 /* Move to the next bit. */
769 b = b << 1;
770 }
771
772 /* Move to the beginning of the next scanline of the cell. */
773 dp += d_add;
774 }
775}
776
777/** Draw glyph at specified position in viewport.
778 *
779 * @param vport Viewport identification
780 * @param cursor Draw glyph with cursor
781 * @param col Screen position relative to viewport
782 * @param row Screen position relative to viewport
783 *
784 */
785static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
786 unsigned int row)
787{
788 unsigned int x = vport->x + COL2X(col);
789 unsigned int y = vport->y + ROW2Y(row);
790
791 uint32_t glyph;
792 uint32_t fg_color;
793 uint32_t bg_color;
794
795 glyph = vport->backbuf[BB_POS(vport, col, row)].glyph;
796 fg_color = vport->backbuf[BB_POS(vport, col, row)].fg_color;
797 bg_color = vport->backbuf[BB_POS(vport, col, row)].bg_color;
798
799 (*vport->dglyph)(x, y, cursor, vport->glyphs, glyph,
800 fg_color, bg_color);
801}
802
803/** Hide cursor if it is shown
804 *
805 */
806static void cursor_hide(viewport_t *vport)
807{
808 if ((vport->cursor_active) && (vport->cursor_shown)) {
809 draw_vp_glyph(vport, false, vport->cur_col, vport->cur_row);
810 vport->cursor_shown = false;
811 }
812}
813
814
815/** Show cursor if cursor showing is enabled
816 *
817 */
818static void cursor_show(viewport_t *vport)
819{
820 /* Do not check for cursor_shown */
821 if (vport->cursor_active) {
822 draw_vp_glyph(vport, true, vport->cur_col, vport->cur_row);
823 vport->cursor_shown = true;
824 }
825}
826
827
828/** Invert cursor, if it is enabled
829 *
830 */
831static void cursor_blink(viewport_t *vport)
832{
833 if (vport->cursor_shown)
834 cursor_hide(vport);
835 else
836 cursor_show(vport);
837}
838
839
840/** Draw character at given position relative to viewport
841 *
842 * @param vport Viewport identification
843 * @param c Character to draw
844 * @param col Screen position relative to viewport
845 * @param row Screen position relative to viewport
846 *
847 */
848static void draw_char(viewport_t *vport, wchar_t c, unsigned int col, unsigned int row)
849{
850 bb_cell_t *bbp;
851
852 /* Do not hide cursor if we are going to overwrite it */
853 if ((vport->cursor_active) && (vport->cursor_shown) &&
854 ((vport->cur_col != col) || (vport->cur_row != row)))
855 cursor_hide(vport);
856
857 bbp = &vport->backbuf[BB_POS(vport, col, row)];
858 bbp->glyph = (uint32_t) c;
859 bbp->fg_color = vport->attr.fg_color;
860 bbp->bg_color = vport->attr.bg_color;
861
862 draw_vp_glyph(vport, false, col, row);
863
864 vport->cur_col = col;
865 vport->cur_row = row;
866
867 vport->cur_col++;
868 if (vport->cur_col >= vport->cols) {
869 vport->cur_col = 0;
870 vport->cur_row++;
871 if (vport->cur_row >= vport->rows)
872 vport->cur_row--;
873 }
874
875 cursor_show(vport);
876}
877
878/** Draw text data to viewport.
879 *
880 * @param vport Viewport id
881 * @param data Text data.
882 * @param x Leftmost column of the area.
883 * @param y Topmost row of the area.
884 * @param w Number of rows.
885 * @param h Number of columns.
886 */
887static void draw_text_data(viewport_t *vport, keyfield_t *data, unsigned int x,
888 unsigned int y, unsigned int w, unsigned int h)
889{
890 unsigned int i, j;
891 bb_cell_t *bbp;
892 attrs_t *a;
893 attr_rgb_t rgb;
894
895 for (j = 0; j < h; j++) {
896 for (i = 0; i < w; i++) {
897 unsigned int col = x + i;
898 unsigned int row = y + j;
899
900 bbp = &vport->backbuf[BB_POS(vport, col, row)];
901 uint32_t glyph = bbp->glyph;
902
903 a = &data[j * w + i].attrs;
904 rgb_from_attr(&rgb, a);
905
906 bbp->glyph = data[j * w + i].character;
907 bbp->fg_color = rgb.fg_color;
908 bbp->bg_color = rgb.bg_color;
909
910 draw_vp_glyph(vport, false, col, row);
911 }
912 }
913 cursor_show(vport);
914}
915
916
917static void putpixel_pixmap(void *data, unsigned int x, unsigned int y, uint32_t color)
918{
919 int pm = *((int *) data);
920 pixmap_t *pmap = &pixmaps[pm];
921 unsigned int pos = (y * pmap->width + x) * screen.pixelbytes;
922
923 screen.rgb_conv(&pmap->data[pos], color);
924}
925
926
927static void putpixel(void *data, unsigned int x, unsigned int y, uint32_t color)
928{
929 viewport_t *vport = (viewport_t *) data;
930 unsigned int dx = vport->x + x;
931 unsigned int dy = vport->y + y;
932
933 screen.rgb_conv(&screen.fb_addr[FB_POS(dx, dy)], color);
934}
935
936
937/** Return first free pixmap
938 *
939 */
940static int find_free_pixmap(void)
941{
942 unsigned int i;
943
944 for (i = 0; i < MAX_PIXMAPS; i++)
945 if (!pixmaps[i].data)
946 return i;
947
948 return -1;
949}
950
951
952/** Create a new pixmap and return appropriate ID
953 *
954 */
955static int shm2pixmap(unsigned char *shm, size_t size)
956{
957 int pm;
958 pixmap_t *pmap;
959
960 pm = find_free_pixmap();
961 if (pm == -1)
962 return ELIMIT;
963
964 pmap = &pixmaps[pm];
965
966 if (ppm_get_data(shm, size, &pmap->width, &pmap->height))
967 return EINVAL;
968
969 pmap->data = malloc(pmap->width * pmap->height * screen.pixelbytes);
970 if (!pmap->data)
971 return ENOMEM;
972
973 ppm_draw(shm, size, 0, 0, pmap->width, pmap->height, putpixel_pixmap, (void *) &pm);
974
975 return pm;
976}
977
978
979/** Handle shared memory communication calls
980 *
981 * Protocol for drawing pixmaps:
982 * - FB_PREPARE_SHM(client shm identification)
983 * - IPC_M_AS_AREA_SEND
984 * - FB_DRAW_PPM(startx, starty)
985 * - FB_DROP_SHM
986 *
987 * Protocol for text drawing
988 * - IPC_M_AS_AREA_SEND
989 * - FB_DRAW_TEXT_DATA
990 *
991 * @param callid Callid of the current call
992 * @param call Current call data
993 * @param vp Active viewport
994 *
995 * @return false if the call was not handled byt this function, true otherwise
996 *
997 * Note: this function is not threads safe, you would have
998 * to redefine static variables with __thread
999 *
1000 */
1001static bool shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
1002{
1003 static keyfield_t *interbuffer = NULL;
1004 static size_t intersize = 0;
1005
1006 static unsigned char *shm = NULL;
1007 static ipcarg_t shm_id = 0;
1008 static size_t shm_size;
1009
1010 bool handled = true;
1011 int retval = EOK;
1012 viewport_t *vport = &viewports[vp];
1013 unsigned int x;
1014 unsigned int y;
1015 unsigned int w;
1016 unsigned int h;
1017
1018 switch (IPC_GET_METHOD(*call)) {
1019 case IPC_M_SHARE_OUT:
1020 /* We accept one area for data interchange */
1021 if (IPC_GET_ARG1(*call) == shm_id) {
1022 void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
1023 shm_size = IPC_GET_ARG2(*call);
1024 if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
1025 shm = dest;
1026 else
1027 shm_id = 0;
1028
1029 if (shm[0] != 'P')
1030 return false;
1031
1032 return true;
1033 } else {
1034 intersize = IPC_GET_ARG2(*call);
1035 receive_comm_area(callid, call, (void *) &interbuffer);
1036 }
1037 return true;
1038 case FB_PREPARE_SHM:
1039 if (shm_id)
1040 retval = EBUSY;
1041 else
1042 shm_id = IPC_GET_ARG1(*call);
1043 break;
1044
1045 case FB_DROP_SHM:
1046 if (shm) {
1047 as_area_destroy(shm);
1048 shm = NULL;
1049 }
1050 shm_id = 0;
1051 break;
1052
1053 case FB_SHM2PIXMAP:
1054 if (!shm) {
1055 retval = EINVAL;
1056 break;
1057 }
1058 retval = shm2pixmap(shm, shm_size);
1059 break;
1060 case FB_DRAW_PPM:
1061 if (!shm) {
1062 retval = EINVAL;
1063 break;
1064 }
1065 x = IPC_GET_ARG1(*call);
1066 y = IPC_GET_ARG2(*call);
1067
1068 if ((x > vport->width) || (y > vport->height)) {
1069 retval = EINVAL;
1070 break;
1071 }
1072
1073 ppm_draw(shm, shm_size, IPC_GET_ARG1(*call),
1074 IPC_GET_ARG2(*call), vport->width - x, vport->height - y, putpixel, (void *) vport);
1075 break;
1076 case FB_DRAW_TEXT_DATA:
1077 x = IPC_GET_ARG1(*call);
1078 y = IPC_GET_ARG2(*call);
1079 w = IPC_GET_ARG3(*call);
1080 h = IPC_GET_ARG4(*call);
1081 if (!interbuffer) {
1082 retval = EINVAL;
1083 break;
1084 }
1085 if (x + w > vport->cols || y + h > vport->rows) {
1086 retval = EINVAL;
1087 break;
1088 }
1089 if (intersize < w * h * sizeof(*interbuffer)) {
1090 retval = EINVAL;
1091 break;
1092 }
1093 draw_text_data(vport, interbuffer, x, y, w, h);
1094 break;
1095 default:
1096 handled = false;
1097 }
1098
1099 if (handled)
1100 ipc_answer_0(callid, retval);
1101 return handled;
1102}
1103
1104
1105static void copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
1106{
1107 unsigned int width = vport->width;
1108 unsigned int height = vport->height;
1109
1110 if (width + vport->x > screen.xres)
1111 width = screen.xres - vport->x;
1112 if (height + vport->y > screen.yres)
1113 height = screen.yres - vport->y;
1114
1115 unsigned int realwidth = pmap->width <= width ? pmap->width : width;
1116 unsigned int realheight = pmap->height <= height ? pmap->height : height;
1117
1118 unsigned int srcrowsize = vport->width * screen.pixelbytes;
1119 unsigned int realrowsize = realwidth * screen.pixelbytes;
1120
1121 unsigned int y;
1122 for (y = 0; y < realheight; y++) {
1123 unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
1124 memcpy(pmap->data + srcrowsize * y, screen.fb_addr + tmp, realrowsize);
1125 }
1126}
1127
1128
1129/** Save viewport to pixmap
1130 *
1131 */
1132static int save_vp_to_pixmap(viewport_t *vport)
1133{
1134 int pm;
1135 pixmap_t *pmap;
1136
1137 pm = find_free_pixmap();
1138 if (pm == -1)
1139 return ELIMIT;
1140
1141 pmap = &pixmaps[pm];
1142 pmap->data = malloc(screen.pixelbytes * vport->width * vport->height);
1143 if (!pmap->data)
1144 return ENOMEM;
1145
1146 pmap->width = vport->width;
1147 pmap->height = vport->height;
1148
1149 copy_vp_to_pixmap(vport, pmap);
1150
1151 return pm;
1152}
1153
1154
1155/** Draw pixmap on screen
1156 *
1157 * @param vp Viewport to draw on
1158 * @param pm Pixmap identifier
1159 *
1160 */
1161static int draw_pixmap(int vp, int pm)
1162{
1163 pixmap_t *pmap = &pixmaps[pm];
1164 viewport_t *vport = &viewports[vp];
1165
1166 unsigned int width = vport->width;
1167 unsigned int height = vport->height;
1168
1169 if (width + vport->x > screen.xres)
1170 width = screen.xres - vport->x;
1171 if (height + vport->y > screen.yres)
1172 height = screen.yres - vport->y;
1173
1174 if (!pmap->data)
1175 return EINVAL;
1176
1177 unsigned int realwidth = pmap->width <= width ? pmap->width : width;
1178 unsigned int realheight = pmap->height <= height ? pmap->height : height;
1179
1180 unsigned int srcrowsize = vport->width * screen.pixelbytes;
1181 unsigned int realrowsize = realwidth * screen.pixelbytes;
1182
1183 unsigned int y;
1184 for (y = 0; y < realheight; y++) {
1185 unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
1186 memcpy(screen.fb_addr + tmp, pmap->data + y * srcrowsize, realrowsize);
1187 }
1188
1189 return EOK;
1190}
1191
1192
1193/** Tick animation one step forward
1194 *
1195 */
1196static void anims_tick(void)
1197{
1198 unsigned int i;
1199 static int counts = 0;
1200
1201 /* Limit redrawing */
1202 counts = (counts + 1) % 8;
1203 if (counts)
1204 return;
1205
1206 for (i = 0; i < MAX_ANIMATIONS; i++) {
1207 if ((!animations[i].animlen) || (!animations[i].initialized) ||
1208 (!animations[i].enabled))
1209 continue;
1210
1211 draw_pixmap(animations[i].vp, animations[i].pixmaps[animations[i].pos]);
1212 animations[i].pos = (animations[i].pos + 1) % animations[i].animlen;
1213 }
1214}
1215
1216
1217static unsigned int pointer_x;
1218static unsigned int pointer_y;
1219static bool pointer_shown, pointer_enabled;
1220static int pointer_vport = -1;
1221static int pointer_pixmap = -1;
1222
1223
1224static void mouse_show(void)
1225{
1226 int i, j;
1227 int visibility;
1228 int color;
1229 int bytepos;
1230
1231 if ((pointer_shown) || (!pointer_enabled))
1232 return;
1233
1234 /* Save image under the pointer. */
1235 if (pointer_vport == -1) {
1236 pointer_vport = vport_create(pointer_x, pointer_y, pointer_width, pointer_height);
1237 if (pointer_vport < 0)
1238 return;
1239 } else {
1240 viewports[pointer_vport].x = pointer_x;
1241 viewports[pointer_vport].y = pointer_y;
1242 }
1243
1244 if (pointer_pixmap == -1)
1245 pointer_pixmap = save_vp_to_pixmap(&viewports[pointer_vport]);
1246 else
1247 copy_vp_to_pixmap(&viewports[pointer_vport], &pixmaps[pointer_pixmap]);
1248
1249 /* Draw mouse pointer. */
1250 for (i = 0; i < pointer_height; i++)
1251 for (j = 0; j < pointer_width; j++) {
1252 bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8;
1253 visibility = pointer_mask_bits[bytepos] &
1254 (1 << (j % 8));
1255 if (visibility) {
1256 color = pointer_bits[bytepos] &
1257 (1 << (j % 8)) ? 0 : 0xffffff;
1258 if (pointer_x + j < screen.xres && pointer_y +
1259 i < screen.yres)
1260 putpixel(&viewports[0], pointer_x + j,
1261 pointer_y + i, color);
1262 }
1263 }
1264 pointer_shown = 1;
1265}
1266
1267
1268static void mouse_hide(void)
1269{
1270 /* Restore image under the pointer. */
1271 if (pointer_shown) {
1272 draw_pixmap(pointer_vport, pointer_pixmap);
1273 pointer_shown = 0;
1274 }
1275}
1276
1277
1278static void mouse_move(unsigned int x, unsigned int y)
1279{
1280 mouse_hide();
1281 pointer_x = x;
1282 pointer_y = y;
1283 mouse_show();
1284}
1285
1286
1287static int anim_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
1288{
1289 bool handled = true;
1290 int retval = EOK;
1291 int i, nvp;
1292 int newval;
1293
1294 switch (IPC_GET_METHOD(*call)) {
1295 case FB_ANIM_CREATE:
1296 nvp = IPC_GET_ARG1(*call);
1297 if (nvp == -1)
1298 nvp = vp;
1299 if (nvp >= MAX_VIEWPORTS || nvp < 0 ||
1300 !viewports[nvp].initialized) {
1301 retval = EINVAL;
1302 break;
1303 }
1304 for (i = 0; i < MAX_ANIMATIONS; i++) {
1305 if (!animations[i].initialized)
1306 break;
1307 }
1308 if (i == MAX_ANIMATIONS) {
1309 retval = ELIMIT;
1310 break;
1311 }
1312 animations[i].initialized = 1;
1313 animations[i].animlen = 0;
1314 animations[i].pos = 0;
1315 animations[i].enabled = 0;
1316 animations[i].vp = nvp;
1317 retval = i;
1318 break;
1319 case FB_ANIM_DROP:
1320 i = IPC_GET_ARG1(*call);
1321 if (i >= MAX_ANIMATIONS || i < 0) {
1322 retval = EINVAL;
1323 break;
1324 }
1325 animations[i].initialized = 0;
1326 break;
1327 case FB_ANIM_ADDPIXMAP:
1328 i = IPC_GET_ARG1(*call);
1329 if (i >= MAX_ANIMATIONS || i < 0 ||
1330 !animations[i].initialized) {
1331 retval = EINVAL;
1332 break;
1333 }
1334 if (animations[i].animlen == MAX_ANIM_LEN) {
1335 retval = ELIMIT;
1336 break;
1337 }
1338 newval = IPC_GET_ARG2(*call);
1339 if (newval < 0 || newval > MAX_PIXMAPS ||
1340 !pixmaps[newval].data) {
1341 retval = EINVAL;
1342 break;
1343 }
1344 animations[i].pixmaps[animations[i].animlen++] = newval;
1345 break;
1346 case FB_ANIM_CHGVP:
1347 i = IPC_GET_ARG1(*call);
1348 if (i >= MAX_ANIMATIONS || i < 0) {
1349 retval = EINVAL;
1350 break;
1351 }
1352 nvp = IPC_GET_ARG2(*call);
1353 if (nvp == -1)
1354 nvp = vp;
1355 if (nvp >= MAX_VIEWPORTS || nvp < 0 ||
1356 !viewports[nvp].initialized) {
1357 retval = EINVAL;
1358 break;
1359 }
1360 animations[i].vp = nvp;
1361 break;
1362 case FB_ANIM_START:
1363 case FB_ANIM_STOP:
1364 i = IPC_GET_ARG1(*call);
1365 if (i >= MAX_ANIMATIONS || i < 0) {
1366 retval = EINVAL;
1367 break;
1368 }
1369 newval = (IPC_GET_METHOD(*call) == FB_ANIM_START);
1370 if (newval ^ animations[i].enabled) {
1371 animations[i].enabled = newval;
1372 anims_enabled += newval ? 1 : -1;
1373 }
1374 break;
1375 default:
1376 handled = 0;
1377 }
1378 if (handled)
1379 ipc_answer_0(callid, retval);
1380 return handled;
1381}
1382
1383
1384/** Handler for messages concerning pixmap handling
1385 *
1386 */
1387static int pixmap_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
1388{
1389 bool handled = true;
1390 int retval = EOK;
1391 int i, nvp;
1392
1393 switch (IPC_GET_METHOD(*call)) {
1394 case FB_VP_DRAW_PIXMAP:
1395 nvp = IPC_GET_ARG1(*call);
1396 if (nvp == -1)
1397 nvp = vp;
1398 if (nvp < 0 || nvp >= MAX_VIEWPORTS ||
1399 !viewports[nvp].initialized) {
1400 retval = EINVAL;
1401 break;
1402 }
1403 i = IPC_GET_ARG2(*call);
1404 retval = draw_pixmap(nvp, i);
1405 break;
1406 case FB_VP2PIXMAP:
1407 nvp = IPC_GET_ARG1(*call);
1408 if (nvp == -1)
1409 nvp = vp;
1410 if (nvp < 0 || nvp >= MAX_VIEWPORTS ||
1411 !viewports[nvp].initialized)
1412 retval = EINVAL;
1413 else
1414 retval = save_vp_to_pixmap(&viewports[nvp]);
1415 break;
1416 case FB_DROP_PIXMAP:
1417 i = IPC_GET_ARG1(*call);
1418 if (i >= MAX_PIXMAPS) {
1419 retval = EINVAL;
1420 break;
1421 }
1422 if (pixmaps[i].data) {
1423 free(pixmaps[i].data);
1424 pixmaps[i].data = NULL;
1425 }
1426 break;
1427 default:
1428 handled = 0;
1429 }
1430
1431 if (handled)
1432 ipc_answer_0(callid, retval);
1433 return handled;
1434
1435}
1436
1437static int rgb_from_style(attr_rgb_t *rgb, int style)
1438{
1439 switch (style) {
1440 case STYLE_NORMAL:
1441 rgb->fg_color = color_table[COLOR_BLACK];
1442 rgb->bg_color = color_table[COLOR_WHITE];
1443 break;
1444 case STYLE_EMPHASIS:
1445 rgb->fg_color = color_table[COLOR_RED];
1446 rgb->bg_color = color_table[COLOR_WHITE];
1447 break;
1448 default:
1449 return EINVAL;
1450 }
1451
1452 return EOK;
1453}
1454
1455static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
1456 ipcarg_t bg_color, ipcarg_t flags)
1457{
1458 fg_color = (fg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
1459 bg_color = (bg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
1460
1461 rgb->fg_color = color_table[fg_color];
1462 rgb->bg_color = color_table[bg_color];
1463
1464 return EOK;
1465}
1466
1467static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a)
1468{
1469 int rc;
1470
1471 switch (a->t) {
1472 case at_style:
1473 rc = rgb_from_style(rgb, a->a.s.style);
1474 break;
1475 case at_idx:
1476 rc = rgb_from_idx(rgb, a->a.i.fg_color,
1477 a->a.i.bg_color, a->a.i.flags);
1478 break;
1479 case at_rgb:
1480 *rgb = a->a.r;
1481 rc = EOK;
1482 break;
1483 }
1484
1485 return rc;
1486}
1487
1488static int fb_set_style(viewport_t *vport, ipcarg_t style)
1489{
1490 return rgb_from_style(&vport->attr, (int) style);
1491}
1492
1493static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
1494 ipcarg_t bg_color, ipcarg_t flags)
1495{
1496 return rgb_from_idx(&vport->attr, fg_color, bg_color, flags);
1497}
1498
1499/** Function for handling connections to FB
1500 *
1501 */
1502static void fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
1503{
1504 unsigned int vp = 0;
1505 viewport_t *vport = &viewports[vp];
1506
1507 if (client_connected) {
1508 ipc_answer_0(iid, ELIMIT);
1509 return;
1510 }
1511
1512 /* Accept connection */
1513 client_connected = true;
1514 ipc_answer_0(iid, EOK);
1515
1516 while (true) {
1517 ipc_callid_t callid;
1518 ipc_call_t call;
1519 int retval;
1520 unsigned int i;
1521 int scroll;
1522 uint32_t glyph;
1523 unsigned int row, col;
1524
1525 if ((vport->cursor_active) || (anims_enabled))
1526 callid = async_get_call_timeout(&call, 250000);
1527 else
1528 callid = async_get_call(&call);
1529
1530 mouse_hide();
1531 if (!callid) {
1532 cursor_blink(vport);
1533 anims_tick();
1534 mouse_show();
1535 continue;
1536 }
1537
1538 if (shm_handle(callid, &call, vp))
1539 continue;
1540
1541 if (pixmap_handle(callid, &call, vp))
1542 continue;
1543
1544 if (anim_handle(callid, &call, vp))
1545 continue;
1546
1547 switch (IPC_GET_METHOD(call)) {
1548 case IPC_M_PHONE_HUNGUP:
1549 client_connected = false;
1550
1551 /* Cleanup other viewports */
1552 for (i = 1; i < MAX_VIEWPORTS; i++)
1553 vport->initialized = false;
1554
1555 /* Exit thread */
1556 return;
1557
1558 case FB_PUTCHAR:
1559 glyph = IPC_GET_ARG1(call);
1560 row = IPC_GET_ARG2(call);
1561 col = IPC_GET_ARG3(call);
1562
1563 if ((col >= vport->cols) || (row >= vport->rows)) {
1564 retval = EINVAL;
1565 break;
1566 }
1567 ipc_answer_0(callid, EOK);
1568
1569 draw_char(vport, glyph, col, row);
1570
1571 /* Message already answered */
1572 continue;
1573 case FB_CLEAR:
1574 vport_clear(vport);
1575 cursor_show(vport);
1576 retval = EOK;
1577 break;
1578 case FB_CURSOR_GOTO:
1579 row = IPC_GET_ARG1(call);
1580 col = IPC_GET_ARG2(call);
1581
1582 if ((col >= vport->cols) || (row >= vport->rows)) {
1583 retval = EINVAL;
1584 break;
1585 }
1586 retval = EOK;
1587
1588 cursor_hide(vport);
1589 vport->cur_col = col;
1590 vport->cur_row = row;
1591 cursor_show(vport);
1592 break;
1593 case FB_CURSOR_VISIBILITY:
1594 cursor_hide(vport);
1595 vport->cursor_active = IPC_GET_ARG1(call);
1596 cursor_show(vport);
1597 retval = EOK;
1598 break;
1599 case FB_GET_CSIZE:
1600 ipc_answer_2(callid, EOK, vport->rows, vport->cols);
1601 continue;
1602 case FB_SCROLL:
1603 scroll = IPC_GET_ARG1(call);
1604 if ((scroll > (int) vport->rows) || (scroll < (-(int) vport->rows))) {
1605 retval = EINVAL;
1606 break;
1607 }
1608 cursor_hide(vport);
1609 vport_scroll(vport, scroll);
1610 cursor_show(vport);
1611 retval = EOK;
1612 break;
1613 case FB_VIEWPORT_SWITCH:
1614 i = IPC_GET_ARG1(call);
1615 if (i >= MAX_VIEWPORTS) {
1616 retval = EINVAL;
1617 break;
1618 }
1619 if (!viewports[i].initialized) {
1620 retval = EADDRNOTAVAIL;
1621 break;
1622 }
1623 cursor_hide(vport);
1624 vp = i;
1625 vport = &viewports[vp];
1626 cursor_show(vport);
1627 retval = EOK;
1628 break;
1629 case FB_VIEWPORT_CREATE:
1630 retval = vport_create(IPC_GET_ARG1(call) >> 16,
1631 IPC_GET_ARG1(call) & 0xffff,
1632 IPC_GET_ARG2(call) >> 16,
1633 IPC_GET_ARG2(call) & 0xffff);
1634 break;
1635 case FB_VIEWPORT_DELETE:
1636 i = IPC_GET_ARG1(call);
1637 if (i >= MAX_VIEWPORTS) {
1638 retval = EINVAL;
1639 break;
1640 }
1641 if (!viewports[i].initialized) {
1642 retval = EADDRNOTAVAIL;
1643 break;
1644 }
1645 viewports[i].initialized = false;
1646 if (viewports[i].glyphs)
1647 free(viewports[i].glyphs);
1648 if (viewports[i].bgpixel)
1649 free(viewports[i].bgpixel);
1650 if (viewports[i].backbuf)
1651 free(viewports[i].backbuf);
1652 retval = EOK;
1653 break;
1654 case FB_SET_STYLE:
1655 retval = fb_set_style(vport, IPC_GET_ARG1(call));
1656 break;
1657 case FB_SET_COLOR:
1658 retval = fb_set_color(vport, IPC_GET_ARG1(call),
1659 IPC_GET_ARG2(call), IPC_GET_ARG3(call));
1660 break;
1661 case FB_SET_RGB_COLOR:
1662 vport->attr.fg_color = IPC_GET_ARG1(call);
1663 vport->attr.bg_color = IPC_GET_ARG2(call);
1664 retval = EOK;
1665 break;
1666 case FB_GET_RESOLUTION:
1667 ipc_answer_2(callid, EOK, screen.xres, screen.yres);
1668 continue;
1669 case FB_POINTER_MOVE:
1670 pointer_enabled = true;
1671 mouse_move(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
1672 retval = EOK;
1673 break;
1674 default:
1675 retval = ENOENT;
1676 }
1677 ipc_answer_0(callid, retval);
1678 }
1679}
1680
1681/** Initialization of framebuffer
1682 *
1683 */
1684int fb_init(void)
1685{
1686 async_set_client_connection(fb_client_connection);
1687
1688 void *fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
1689 unsigned int fb_offset = sysinfo_value("fb.offset");
1690 unsigned int fb_width = sysinfo_value("fb.width");
1691 unsigned int fb_height = sysinfo_value("fb.height");
1692 unsigned int fb_scanline = sysinfo_value("fb.scanline");
1693 unsigned int fb_visual = sysinfo_value("fb.visual");
1694
1695 unsigned int fbsize = fb_scanline * fb_height;
1696 void *fb_addr = as_get_mappable_page(fbsize);
1697
1698 if (physmem_map(fb_ph_addr + fb_offset, fb_addr,
1699 ALIGN_UP(fbsize, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
1700 return -1;
1701
1702 if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual))
1703 return 0;
1704
1705 return -1;
1706}
1707
1708/**
1709 * @}
1710 */
Note: See TracBrowser for help on using the repository browser.