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

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

Subversion Repositories HelenOS

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