WebSVN – HelenOS – Blame – /branches/sparc/uspace/srv/fb/fb.c

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

Subversion Repositories HelenOS

(root)/branches/sparc/uspace/srv/fb/fb.c – Rev 3742