WebSVN – HelenOS-historic – Diff – /uspace/trunk/fb/fb.c


/*
 * Copyright (C) 2006 Jakub Vana
 * Copyright (C) 2006 Ondrej Palkovsky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ddi.h>
#include <task.h>
#include <sysinfo.h>
#include <align.h>
#include <as.h>
#include <ipc/fb.h>
#include <ipc/ipc.h>
#include <ipc/ns.h>
#include <ipc/services.h>
#include <kernel/errno.h>
#include <async.h>
#include "font-8x16.h"
#include "helenos.xbm"
#include "fb.h"
 
#define EFB (-1)
 
#define DEFAULT_BGCOLOR     0x000080
#define DEFAULT_FGCOLOR     0xffff00
#define DEFAULT_LOGOCOLOR   0x0000ff
 
#define MAIN_BGCOLOR        0x404000
#define MAIN_FGCOLOR        0x000000
#define MAIN_LOGOCOLOR  0x404000
 
#define SPACING (2)
 
#define H_NO_VFBS 3
#define V_NO_VFBS 3
 
static void fb_putchar(int item,char ch);
int create_window(int item,unsigned int x, unsigned int y,unsigned int x_size, unsigned int y_size,
    unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR);
void fb_init(int item,__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan,
    unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR);
 
unsigned int mod_col(unsigned int col,int mod);
 
static int init_fb(void)
{
    __address fb_ph_addr;
    unsigned int fb_width;
    unsigned int fb_height;
    unsigned int fb_bpp;
    unsigned int fb_scanline;
    __address fb_addr;
    int a=0;
    int i,j,k;
    int w;
    char text[]="HelenOS Framebuffer driver\non Virtual Framebuffer\nVFB ";
 
    fb_ph_addr=sysinfo_value("fb.address.physical");
    fb_width=sysinfo_value("fb.width");
    fb_height=sysinfo_value("fb.height");
    fb_bpp=sysinfo_value("fb.bpp");
    fb_scanline=sysinfo_value("fb.scanline");
 
    fb_addr=ALIGN_UP(((__address)set_maxheapsize(USER_ADDRESS_SPACE_SIZE_ARCH>>1)),PAGE_SIZE);
   
    map_physmem(task_get_id(),(void *)((__address)fb_ph_addr),(void *)fb_addr,
            (fb_scanline*fb_height+PAGE_SIZE-1)>>PAGE_WIDTH,
            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
   
    fb_init(0,fb_addr, fb_width, fb_height, fb_bpp, fb_scanline,
        MAIN_BGCOLOR,MAIN_FGCOLOR,MAIN_LOGOCOLOR);
 
    fb_putchar(0,'\n');
    fb_putchar(0,' ');
 
    for(i=0;i<H_NO_VFBS;i++)
        for(j=0;j<V_NO_VFBS;j++) {
            w = create_window(0,(fb_width/H_NO_VFBS)*i+SPACING,
                      (fb_height/V_NO_VFBS)*j+SPACING,(fb_width/H_NO_VFBS)-2*SPACING ,
                      (fb_height/V_NO_VFBS)-2*SPACING,mod_col(DEFAULT_BGCOLOR,/*i+j*H_NO_VFBS*/0),
                      mod_col(DEFAULT_FGCOLOR,/*i+j*H_NO_VFBS*/0),
                      mod_col(DEFAULT_LOGOCOLOR,/*i+j*H_NO_VFBS)*/0));
           
            if( w== EFB)
                return -1;
           
            for(k=0;text[k];k++)
                fb_putchar(w,text[k]);
            fb_putchar(w,w+'0');
            fb_putchar(w,'\n');
        }
    return 0;
}
 
int vfb_no = 1;
void client_connection(ipc_callid_t iid, ipc_call_t *icall)
{
    ipc_callid_t callid;
    ipc_call_t call;
    int vfb = vfb_no++;
 
    if (vfb > VFB_CONNECTIONS) {
        ipc_answer_fast(iid, ELIMIT, 0,0);
        return;
    }
    ipc_answer_fast(iid, 0, 0, 0);
 
    while (1) {
        callid = async_get_call(&call);
        switch (IPC_GET_METHOD(call)) {
        case IPC_M_PHONE_HUNGUP:
            ipc_answer_fast(callid,0,0,0);
            return; /* Exit thread */
 
        case FB_PUTCHAR:
            ipc_answer_fast(callid,0,0,0);
            fb_putchar(vfb,IPC_GET_ARG2(call));
            break;
        default:
            ipc_answer_fast(callid,ENOENT,0,0);
        }
    }
}
 
int main(int argc, char *argv[])
{
    ipc_call_t call;
    ipc_callid_t callid;
    char connected = 0;
    int res;
    int c;
    ipcarg_t phonead;
   
    ipcarg_t retval, arg1, arg2;
 
    if(!sysinfo_value("fb"))
        return -1;
 
    if ((res = ipc_connect_to_me(PHONE_NS, SERVICE_VIDEO, 0, &phonead)) != 0)
        return -1;
   
    if (init_fb() != 0)
        return -1;
 
    async_manager();
    /* Never reached */
    return 0;
}
 
 
#define GRAPHICS_ITEMS 1024
 
 
/***************************************************************/
/* Pixel specific fuctions */
 
typedef void (*putpixel_fn_t)(int item,unsigned int x, unsigned int y, int color);
typedef int (*getpixel_fn_t)(int item,unsigned int x, unsigned int y);
 
typedef struct framebuffer_descriptor
{
    __u8 *fbaddress ;
 
    unsigned int xres ;
    unsigned int yres ;
    unsigned int scanline ;
    unsigned int pixelbytes ;
 
    unsigned int position ;
    unsigned int columns ;
    unsigned int rows ;
   
    unsigned int BGCOLOR;
    unsigned int FGCOLOR;
    unsigned int LOGOCOLOR;
   
    putpixel_fn_t putpixel;
    getpixel_fn_t getpixel;
   
}framebuffer_descriptor_t;
 
void * graphics_items[GRAPHICS_ITEMS+1]={NULL};
 
#define FB(__a__,__b__) (((framebuffer_descriptor_t*)(graphics_items[__a__]))->__b__)
 
#define COL_WIDTH   8
#define ROW_BYTES   (FB(item,scanline) * FONT_SCANLINES)
#define RED(x, bits)    ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))
#define GREEN(x, bits)  ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
#define BLUE(x, bits)   ((x >> (8 - bits)) & ((1 << bits) - 1))
 
#define POINTPOS(x, y)  (y * FB(item,scanline) + x * FB(item,pixelbytes))
 
 
 
 
/** Put pixel - 24-bit depth, 1 free byte */
static void putpixel_4byte(int item,unsigned int x, unsigned int y, int color)
{
    *((__u32 *)(FB(item,fbaddress) + POINTPOS(x, y))) = color;
}
 
/** Return pixel color - 24-bit depth, 1 free byte */
static int getpixel_4byte(int item,unsigned int x, unsigned int y)
{
    return *((__u32 *)(FB(item,fbaddress) + POINTPOS(x, y))) & 0xffffff;
}
 
/** Put pixel - 24-bit depth */
static void putpixel_3byte(int item,unsigned int x, unsigned int y, int color)
{
    unsigned int startbyte = POINTPOS(x, y);
 
#if (defined(BIG_ENDIAN) || defined(FB_BIG_ENDIAN))
    FB(item,fbaddress)[startbyte] = RED(color, 8);
    FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);
    FB(item,fbaddress)[startbyte + 2] = BLUE(color, 8);
#else
    FB(item,fbaddress)[startbyte + 2] = RED(color, 8);
    FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);
    FB(item,fbaddress)[startbyte + 0] = BLUE(color, 8);
#endif
 
}
 
/** Return pixel color - 24-bit depth */
static int getpixel_3byte(int item,unsigned int x, unsigned int y)
{
    unsigned int startbyte = POINTPOS(x, y);
 
 
 
#if (defined(BIG_ENDIAN) || defined(FB_BIG_ENDIAN))
    return FB(item,fbaddress)[startbyte] << 16 | FB(item,fbaddress)[startbyte + 1] << 8 | FB(item,fbaddress)[startbyte + 2];
#else
    return FB(item,fbaddress)[startbyte + 2] << 16 | FB(item,fbaddress)[startbyte + 1] << 8 | FB(item,fbaddress)[startbyte + 0];
#endif
                               
 
}
 
/** Put pixel - 16-bit depth (5:6:5) */
static void putpixel_2byte(int item,unsigned int x, unsigned int y, int color)
{
    /* 5-bit, 6-bits, 5-bits */
    *((__u16 *)(FB(item,fbaddress) + POINTPOS(x, y))) = RED(color, 5) << 11 | GREEN(color, 6) << 5 | BLUE(color, 5);
}
 
/** Return pixel color - 16-bit depth (5:6:5) */
static int getpixel_2byte(int item,unsigned int x, unsigned int y)
{
    int color = *((__u16 *)(FB(item,fbaddress) + POINTPOS(x, y)));
    return (((color >> 11) & 0x1f) << (16 + 3)) | (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
}
 
/** Put pixel - 8-bit depth (3:2:3) */
static void putpixel_1byte(int item,unsigned int x, unsigned int y, int color)
{
    FB(item,fbaddress)[POINTPOS(x, y)] = RED(color, 3) << 5 | GREEN(color, 2) << 3 | BLUE(color, 3);
}
 
/** Return pixel color - 8-bit depth (3:2:3) */
static int getpixel_1byte(int item,unsigned int x, unsigned int y)
{
    int color = FB(item,fbaddress)[POINTPOS(x, y)];
    return (((color >> 5) & 0x7) << (16 + 5)) | (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
}
 
/** Fill line with color BGCOLOR */
static void clear_line(int item,unsigned int y)
{
    unsigned int x;
    for (x = 0; x < FB(item,xres); x++)
        FB(item,putpixel)(item,x, y, FB(item,BGCOLOR));
}
 
 
/** Fill screen with background color */
static void clear_screen(int item)
{
    unsigned int y;
    for (y = 0; y < FB(item,yres); y++)
    {
        clear_line(item,y);
    }  
}
 
 
/** Scroll screen one row up */
static void scroll_screen(int item)
{
    unsigned int i;
    unsigned int j;
 
    for(j=0;j<FB(item,yres)-FONT_SCANLINES;j++)
        memcpy((void *) FB(item,fbaddress)+j*FB(item,scanline),
            (void *) &FB(item,fbaddress)[ROW_BYTES+j*FB(item,scanline)], FB(item,pixelbytes)*FB(item,xres));
 
    //memcpy((void *) FB(item,fbaddress), (void *) &FB(item,fbaddress)[ROW_BYTES], FB(item,scanline) * FB(item,yres) - ROW_BYTES);
 
    /* Clear last row */
    for (i = 0; i < FONT_SCANLINES; i++)
        clear_line(item,(FB(item,rows) - 1) * FONT_SCANLINES + i);
}
 
 
static void invert_pixel(int item,unsigned int x, unsigned int y)
{
    FB(item,putpixel)(item, x, y, ~FB(item,getpixel)(item, x, y));
}
 
 
/** Draw one line of glyph at a given position */
static void draw_glyph_line(int item,unsigned int glline, unsigned int x, unsigned int y)
{
    unsigned int i;
 
    for (i = 0; i < 8; i++)
        if (glline & (1 << (7 - i))) {
            FB(item,putpixel)(item,x + i, y, FB(item,FGCOLOR));
        } else
            FB(item,putpixel)(item,x + i, y, FB(item,BGCOLOR));
}
 
/***************************************************************/
/* Character-console functions */
 
/** Draw character at given position */
static void draw_glyph(int item,__u8 glyph, unsigned int col, unsigned int row)
{
    unsigned int y;
 
    for (y = 0; y < FONT_SCANLINES; y++)
        draw_glyph_line(item ,fb_font[glyph * FONT_SCANLINES + y], col * COL_WIDTH, row * FONT_SCANLINES + y);
}
 
/** Invert character at given position */
static void invert_char(int item,unsigned int col, unsigned int row)
{
    unsigned int x;
    unsigned int y;
 
    for (x = 0; x < COL_WIDTH; x++)
        for (y = 0; y < FONT_SCANLINES; y++)
            invert_pixel(item,col * COL_WIDTH + x, row * FONT_SCANLINES + y);
}
 
/** Draw character at default position */
static void draw_char(int item,char chr)
{
    draw_glyph(item ,chr, FB(item,position) % FB(item,columns), FB(item,position) / FB(item,columns));
}
 
static void draw_logo(int item,unsigned int startx, unsigned int starty)
{
    unsigned int x;
    unsigned int y;
    unsigned int byte;
    unsigned int rowbytes;
 
    rowbytes = (helenos_width - 1) / 8 + 1;
 
    for (y = 0; y < helenos_height; y++)
        for (x = 0; x < helenos_width; x++) {
            byte = helenos_bits[rowbytes * y + x / 8];
            byte >>= x % 8;
            if (byte & 1)
                FB(item,putpixel)(item,startx + x, starty + y, FB(item,LOGOCOLOR));
        }
}
 
/***************************************************************/
/* Stdout specific functions */
 
static void invert_cursor(int item)
{
    invert_char(item,FB(item,position) % FB(item,columns), FB(item,position) / FB(item,columns));
}
 
/** Print character to screen
 *
 *  Emulate basic terminal commands
 */
static void fb_putchar(int item,char ch)
{
   
    switch (ch) {
        case '\n':
            invert_cursor(item);
            FB(item,position) += FB(item,columns);
            FB(item,position) -= FB(item,position) % FB(item,columns);
            break;
        case '\r':
            invert_cursor(item);
            FB(item,position) -= FB(item,position) % FB(item,columns);
            break;
        case '\b':
            invert_cursor(item);
            if (FB(item,position) % FB(item,columns))
                FB(item,position)--;
            break;
        case '\t':
            invert_cursor(item);
            do {
                draw_char(item,' ');
                FB(item,position)++;
            } while (FB(item,position) % 8);
            break;
        default:
            draw_char(item,ch);
            FB(item,position)++;
    }
   
    if (FB(item,position) >= FB(item,columns) * FB(item,rows)) {
        FB(item,position) -= FB(item,columns);
        scroll_screen(item);
    }
   
    invert_cursor(item);
   
}
 
 
/** Initialize framebuffer as a chardev output device
 *
 * @param addr Address of theframebuffer
 * @param x    Screen width in pixels
 * @param y    Screen height in pixels
 * @param bpp  Bits per pixel (8, 16, 24, 32)
 * @param scan Bytes per one scanline
 *
 */
void fb_init(int item,__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan,
    unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR)
{
   
    if( (graphics_items[item]=malloc(sizeof(framebuffer_descriptor_t))) ==NULL)
    {
        return;
    }
 
    switch (bpp) {
        case 8:
            FB(item,putpixel) = putpixel_1byte;
            FB(item,getpixel) = getpixel_1byte;
            FB(item,pixelbytes) = 1;
            break;
        case 16:
            FB(item,putpixel) = putpixel_2byte;
            FB(item,getpixel) = getpixel_2byte;
            FB(item,pixelbytes) = 2;
            break;
        case 24:
            FB(item,putpixel) = putpixel_3byte;
            FB(item,getpixel) = getpixel_3byte;
            FB(item,pixelbytes) = 3;
            break;
        case 32:
            FB(item,putpixel) = putpixel_4byte;
            FB(item,getpixel) = getpixel_4byte;
            FB(item,pixelbytes) = 4;
            break;
    }
 
       
    FB(item,fbaddress) = (unsigned char *) addr;
    FB(item,xres) = x;
    FB(item,yres) = y;
    FB(item,scanline) = scan;
   
   
    FB(item,rows) = y / FONT_SCANLINES;
    FB(item,columns) = x / COL_WIDTH;
 
    FB(item,BGCOLOR)=BGCOLOR;
    FB(item,FGCOLOR)=FGCOLOR;
    FB(item,LOGOCOLOR)=LOGOCOLOR;
 
 
    clear_screen(item);
    draw_logo(item,FB(item,xres) - helenos_width, 0);
    invert_cursor(item);
 
}
 
 
static int get_free_item()
{
    int item;
    for(item=0;graphics_items[item]!=NULL;item++);
    return (item==GRAPHICS_ITEMS)?EFB:item;
}
 
unsigned int mod_col(unsigned int col,int mod)
{
    if(mod & 1) col^=0xff;
    if(mod & 2) col^=0xff00;
    if(mod & 4) col^=0xff0000;
    return col;
}
 
 
int create_window(int item,unsigned int x, unsigned int y,unsigned int x_size, unsigned int y_size,
    unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR)
{
    int item_new;
   
    if(EFB==(item_new=get_free_item()))return EFB;
   
   
    if( (graphics_items[item_new]=malloc(sizeof(framebuffer_descriptor_t))) == NULL)
    {
        return EFB;
    }
   
   
   
    FB(item_new,putpixel) = FB(item,putpixel);
    FB(item_new,getpixel) = FB(item,getpixel);
    FB(item_new,pixelbytes) = FB(item,pixelbytes);
 
    FB(item_new,fbaddress) = FB(item,fbaddress) + POINTPOS(x, y) ;
    FB(item_new,xres) = x_size;
    FB(item_new,yres) = y_size;
    FB(item_new,scanline) =  FB(item,scanline);
   
 
    FB(item_new,rows) = y_size / FONT_SCANLINES;
    FB(item_new,columns) = x_size / COL_WIDTH;
 
    FB(item_new,BGCOLOR)=BGCOLOR;
    FB(item_new,FGCOLOR)=FGCOLOR;
    FB(item_new,LOGOCOLOR)=LOGOCOLOR;
 
 
    clear_screen(item_new);
    draw_logo(item_new,FB(item_new,xres) - helenos_width, 0);
    invert_cursor(item_new);
 
    return item_new;
}
 
 
 
 

Rev 1447	Rev 1451
1	/*	1	/*
2	* Copyright (C) 2006 Jakub Vana	2	* Copyright (C) 2006 Jakub Vana
3	* Copyright (C) 2006 Ondrej Palkovsky	3	* Copyright (C) 2006 Ondrej Palkovsky
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	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	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.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	#include <stdio.h>	30	#include <stdio.h>
31	#include <stdlib.h>	31	#include <stdlib.h>
32	#include <unistd.h>	32	#include <unistd.h>
33	#include <string.h>	33	#include <string.h>
34	#include <ddi.h>	34	#include <ddi.h>
35	#include <task.h>	35	#include <task.h>
36	#include <sysinfo.h>	36	#include <sysinfo.h>
37	#include <align.h>	37	#include <align.h>
38	#include <as.h>	38	#include <as.h>
39	#include <ipc/fb.h>	39	#include <ipc/fb.h>
40	#include <ipc/ipc.h>	40	#include <ipc/ipc.h>
41	#include <ipc/ns.h>	41	#include <ipc/ns.h>
42	#include <ipc/services.h>	42	#include <ipc/services.h>
43	#include <kernel/errno.h>	43	#include <kernel/errno.h>
44	#include <async.h>	44	#include <async.h>
45	#include "font-8x16.h"	45	#include "font-8x16.h"
46	#include "helenos.xbm"	46	#include "helenos.xbm"
47	#include "fb.h"	47	#include "fb.h"
48		48
49	#define EFB (-1)	49	#define EFB (-1)
50		50
51	#define DEFAULT_BGCOLOR 0x000080	51	#define DEFAULT_BGCOLOR 0x000080
52	#define DEFAULT_FGCOLOR 0xffff00	52	#define DEFAULT_FGCOLOR 0xffff00
53	#define DEFAULT_LOGOCOLOR 0x0000ff	53	#define DEFAULT_LOGOCOLOR 0x0000ff
54		54
55	#define MAIN_BGCOLOR 0x404000	55	#define MAIN_BGCOLOR 0x404000
56	#define MAIN_FGCOLOR 0x000000	56	#define MAIN_FGCOLOR 0x000000
57	#define MAIN_LOGOCOLOR 0x404000	57	#define MAIN_LOGOCOLOR 0x404000
58		58
59	#define SPACING (2)	59	#define SPACING (2)
60		60
61	#define H_NO_VFBS 3	61	#define H_NO_VFBS 3
62	#define V_NO_VFBS 3	62	#define V_NO_VFBS 3
63		63
64	static void fb_putchar(int item,char ch);	64	static void fb_putchar(int item,char ch);
65	int create_window(int item,unsigned int x, unsigned int y,unsigned int x_size, unsigned int y_size,	65	int create_window(int item,unsigned int x, unsigned int y,unsigned int x_size, unsigned int y_size,
66	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR);	66	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR);
67	void fb_init(int item,__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan,	67	void fb_init(int item,__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan,
68	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR);	68	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR);
69		69
70	unsigned int mod_col(unsigned int col,int mod);	70	unsigned int mod_col(unsigned int col,int mod);
71		71
72	static int init_fb(void)	72	static int init_fb(void)
73	{	73	{
74	__address fb_ph_addr;	74	__address fb_ph_addr;
75	unsigned int fb_width;	75	unsigned int fb_width;
76	unsigned int fb_height;	76	unsigned int fb_height;
77	unsigned int fb_bpp;	77	unsigned int fb_bpp;
78	unsigned int fb_scanline;	78	unsigned int fb_scanline;
79	__address fb_addr;	79	__address fb_addr;
80	int a=0;	80	int a=0;
81	int i,j,k;	81	int i,j,k;
82	int w;	82	int w;
83	char text[]="HelenOS Framebuffer driver\non Virtual Framebuffer\nVFB ";	83	char text[]="HelenOS Framebuffer driver\non Virtual Framebuffer\nVFB ";
84		84
85	fb_ph_addr=sysinfo_value("fb.address.physical");	85	fb_ph_addr=sysinfo_value("fb.address.physical");
86	fb_width=sysinfo_value("fb.width");	86	fb_width=sysinfo_value("fb.width");
87	fb_height=sysinfo_value("fb.height");	87	fb_height=sysinfo_value("fb.height");
88	fb_bpp=sysinfo_value("fb.bpp");	88	fb_bpp=sysinfo_value("fb.bpp");
89	fb_scanline=sysinfo_value("fb.scanline");	89	fb_scanline=sysinfo_value("fb.scanline");
90		90
91	fb_addr=ALIGN_UP(((__address)set_maxheapsize(USER_ADDRESS_SPACE_SIZE_ARCH>>1)),PAGE_SIZE);	91	fb_addr=ALIGN_UP(((__address)set_maxheapsize(USER_ADDRESS_SPACE_SIZE_ARCH>>1)),PAGE_SIZE);
92		92
93	map_physmem(task_get_id(),(void )((__address)fb_ph_addr),(void )fb_addr,	93	map_physmem(task_get_id(),(void )((__address)fb_ph_addr),(void )fb_addr,
94	(fb_scanline*fb_height+PAGE_SIZE-1)>>PAGE_WIDTH,	94	(fb_scanline*fb_height+PAGE_SIZE-1)>>PAGE_WIDTH,
95	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);	95	AS_AREA_READ \| AS_AREA_WRITE \| AS_AREA_CACHEABLE);
96		96
97	fb_init(0,fb_addr, fb_width, fb_height, fb_bpp, fb_scanline,	97	fb_init(0,fb_addr, fb_width, fb_height, fb_bpp, fb_scanline,
98	MAIN_BGCOLOR,MAIN_FGCOLOR,MAIN_LOGOCOLOR);	98	MAIN_BGCOLOR,MAIN_FGCOLOR,MAIN_LOGOCOLOR);
99		99
100	fb_putchar(0,'\n');	100	fb_putchar(0,'\n');
101	fb_putchar(0,' ');	101	fb_putchar(0,' ');
102		102
103	for(i=0;i<H_NO_VFBS;i++)	103	for(i=0;i<H_NO_VFBS;i++)
104	for(j=0;j<V_NO_VFBS;j++) {	104	for(j=0;j<V_NO_VFBS;j++) {
105	w = create_window(0,(fb_width/H_NO_VFBS)*i+SPACING,	105	w = create_window(0,(fb_width/H_NO_VFBS)*i+SPACING,
106	(fb_height/V_NO_VFBS)j+SPACING,(fb_width/H_NO_VFBS)-2SPACING ,	106	(fb_height/V_NO_VFBS)j+SPACING,(fb_width/H_NO_VFBS)-2SPACING ,
107	(fb_height/V_NO_VFBS)-2SPACING,mod_col(DEFAULT_BGCOLOR,/i+jH_NO_VFBS/0),	107	(fb_height/V_NO_VFBS)-2SPACING,mod_col(DEFAULT_BGCOLOR,/i+jH_NO_VFBS/0),
108	mod_col(DEFAULT_FGCOLOR,/i+jH_NO_VFBS*/0),	108	mod_col(DEFAULT_FGCOLOR,/i+jH_NO_VFBS*/0),
109	mod_col(DEFAULT_LOGOCOLOR,/i+jH_NO_VFBS)*/0));	109	mod_col(DEFAULT_LOGOCOLOR,/i+jH_NO_VFBS)*/0));
110		110
111	if( w== EFB)	111	if( w== EFB)
112	return -1;	112	return -1;
113		113
114	for(k=0;text[k];k++)	114	for(k=0;text[k];k++)
115	fb_putchar(w,text[k]);	115	fb_putchar(w,text[k]);
116	fb_putchar(w,w+'0');	116	fb_putchar(w,w+'0');
117	fb_putchar(w,'\n');	117	fb_putchar(w,'\n');
118	}	118	}
119	return 0;	119	return 0;
120	}	120	}
121		121
122	int vfb_no = 1;	122	int vfb_no = 1;
123	void client_connection(ipc_callid_t iid, ipc_call_t *icall)	123	void client_connection(ipc_callid_t iid, ipc_call_t *icall)
124	{	124	{
125	ipc_callid_t callid;	125	ipc_callid_t callid;
126	ipc_call_t call;	126	ipc_call_t call;
127	int vfb = vfb_no++;	127	int vfb = vfb_no++;
128		128
129	if (vfb > 9) {	129	if (vfb > VFB_CONNECTIONS) {
130	ipc_answer_fast(iid, ELIMIT, 0,0);	130	ipc_answer_fast(iid, ELIMIT, 0,0);
131	return;	131	return;
132	}	132	}
133	ipc_answer_fast(iid, 0, 0, 0);	133	ipc_answer_fast(iid, 0, 0, 0);
134		134
135	while (1) {	135	while (1) {
136	callid = async_get_call(&call);	136	callid = async_get_call(&call);
137	switch (IPC_GET_METHOD(call)) {	137	switch (IPC_GET_METHOD(call)) {
138	case IPC_M_PHONE_HUNGUP:	138	case IPC_M_PHONE_HUNGUP:
139	ipc_answer_fast(callid,0,0,0);	139	ipc_answer_fast(callid,0,0,0);
140	return; /* Exit thread */	140	return; /* Exit thread */
141		141
142	case FB_PUTCHAR:	142	case FB_PUTCHAR:
143	ipc_answer_fast(callid,0,0,0);	143	ipc_answer_fast(callid,0,0,0);
144	fb_putchar(vfb,IPC_GET_ARG2(call));	144	fb_putchar(vfb,IPC_GET_ARG2(call));
145	break;	145	break;
146	default:	146	default:
147	ipc_answer_fast(callid,ENOENT,0,0);	147	ipc_answer_fast(callid,ENOENT,0,0);
148	}	148	}
149	}	149	}
150	}	150	}
151		151
152	int main(int argc, char *argv[])	152	int main(int argc, char *argv[])
153	{	153	{
154	ipc_call_t call;	154	ipc_call_t call;
155	ipc_callid_t callid;	155	ipc_callid_t callid;
156	char connected = 0;	156	char connected = 0;
157	int res;	157	int res;
158	int c;	158	int c;
159	ipcarg_t phonead;	159	ipcarg_t phonead;
160		160
161	ipcarg_t retval, arg1, arg2;	161	ipcarg_t retval, arg1, arg2;
162		162
163	if(!sysinfo_value("fb"))	163	if(!sysinfo_value("fb"))
164	return -1;	164	return -1;
165		165
166	if ((res = ipc_connect_to_me(PHONE_NS, SERVICE_VIDEO, 0, &phonead)) != 0)	166	if ((res = ipc_connect_to_me(PHONE_NS, SERVICE_VIDEO, 0, &phonead)) != 0)
167	return -1;	167	return -1;
168		168
169	if (init_fb() != 0)	169	if (init_fb() != 0)
170	return -1;	170	return -1;
171		171
172	async_manager();	172	async_manager();
173	/* Never reached */	173	/* Never reached */
174	return 0;	174	return 0;
175	}	175	}
176		176
177		177
178	#define GRAPHICS_ITEMS 1024	178	#define GRAPHICS_ITEMS 1024
179		179
180		180
181	/***************************************************************/	181	/***************************************************************/
182	/* Pixel specific fuctions */	182	/* Pixel specific fuctions */
183		183
184	typedef void (*putpixel_fn_t)(int item,unsigned int x, unsigned int y, int color);	184	typedef void (*putpixel_fn_t)(int item,unsigned int x, unsigned int y, int color);
185	typedef int (*getpixel_fn_t)(int item,unsigned int x, unsigned int y);	185	typedef int (*getpixel_fn_t)(int item,unsigned int x, unsigned int y);
186		186
187	typedef struct framebuffer_descriptor	187	typedef struct framebuffer_descriptor
188	{	188	{
189	__u8 *fbaddress ;	189	__u8 *fbaddress ;
190		190
191	unsigned int xres ;	191	unsigned int xres ;
192	unsigned int yres ;	192	unsigned int yres ;
193	unsigned int scanline ;	193	unsigned int scanline ;
194	unsigned int pixelbytes ;	194	unsigned int pixelbytes ;
195		195
196	unsigned int position ;	196	unsigned int position ;
197	unsigned int columns ;	197	unsigned int columns ;
198	unsigned int rows ;	198	unsigned int rows ;
199		199
200	unsigned int BGCOLOR;	200	unsigned int BGCOLOR;
201	unsigned int FGCOLOR;	201	unsigned int FGCOLOR;
202	unsigned int LOGOCOLOR;	202	unsigned int LOGOCOLOR;
203		203
204	putpixel_fn_t putpixel;	204	putpixel_fn_t putpixel;
205	getpixel_fn_t getpixel;	205	getpixel_fn_t getpixel;
206		206
207	}framebuffer_descriptor_t;	207	}framebuffer_descriptor_t;
208		208
209	void * graphics_items[GRAPHICS_ITEMS+1]={NULL};	209	void * graphics_items[GRAPHICS_ITEMS+1]={NULL};
210		210
211	#define FB(__a__,__b__) (((framebuffer_descriptor_t*)(graphics_items[__a__]))->__b__)	211	#define FB(__a__,__b__) (((framebuffer_descriptor_t*)(graphics_items[__a__]))->__b__)
212		212
213	#define COL_WIDTH 8	213	#define COL_WIDTH 8
214	#define ROW_BYTES (FB(item,scanline) * FONT_SCANLINES)	214	#define ROW_BYTES (FB(item,scanline) * FONT_SCANLINES)
215	#define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))	215	#define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))
216	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))	216	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
217	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))	217	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))
218		218
219	#define POINTPOS(x, y) (y * FB(item,scanline) + x * FB(item,pixelbytes))	219	#define POINTPOS(x, y) (y * FB(item,scanline) + x * FB(item,pixelbytes))
220		220
221		221
222		222
223		223
224	/** Put pixel - 24-bit depth, 1 free byte */	224	/** Put pixel - 24-bit depth, 1 free byte */
225	static void putpixel_4byte(int item,unsigned int x, unsigned int y, int color)	225	static void putpixel_4byte(int item,unsigned int x, unsigned int y, int color)
226	{	226	{
227	((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) = color;	227	((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) = color;
228	}	228	}
229		229
230	/** Return pixel color - 24-bit depth, 1 free byte */	230	/** Return pixel color - 24-bit depth, 1 free byte */
231	static int getpixel_4byte(int item,unsigned int x, unsigned int y)	231	static int getpixel_4byte(int item,unsigned int x, unsigned int y)
232	{	232	{
233	return ((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) & 0xffffff;	233	return ((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) & 0xffffff;
234	}	234	}
235		235
236	/** Put pixel - 24-bit depth */	236	/** Put pixel - 24-bit depth */
237	static void putpixel_3byte(int item,unsigned int x, unsigned int y, int color)	237	static void putpixel_3byte(int item,unsigned int x, unsigned int y, int color)
238	{	238	{
239	unsigned int startbyte = POINTPOS(x, y);	239	unsigned int startbyte = POINTPOS(x, y);
240		240
241	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))	241	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))
242	FB(item,fbaddress)[startbyte] = RED(color, 8);	242	FB(item,fbaddress)[startbyte] = RED(color, 8);
243	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);	243	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);
244	FB(item,fbaddress)[startbyte + 2] = BLUE(color, 8);	244	FB(item,fbaddress)[startbyte + 2] = BLUE(color, 8);
245	#else	245	#else
246	FB(item,fbaddress)[startbyte + 2] = RED(color, 8);	246	FB(item,fbaddress)[startbyte + 2] = RED(color, 8);
247	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);	247	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);
248	FB(item,fbaddress)[startbyte + 0] = BLUE(color, 8);	248	FB(item,fbaddress)[startbyte + 0] = BLUE(color, 8);
249	#endif	249	#endif
250		250
251	}	251	}
252		252
253	/** Return pixel color - 24-bit depth */	253	/** Return pixel color - 24-bit depth */
254	static int getpixel_3byte(int item,unsigned int x, unsigned int y)	254	static int getpixel_3byte(int item,unsigned int x, unsigned int y)
255	{	255	{
256	unsigned int startbyte = POINTPOS(x, y);	256	unsigned int startbyte = POINTPOS(x, y);
257		257
258		258
259		259
260	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))	260	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))
261	return FB(item,fbaddress)[startbyte] << 16 \| FB(item,fbaddress)[startbyte + 1] << 8 \| FB(item,fbaddress)[startbyte + 2];	261	return FB(item,fbaddress)[startbyte] << 16 \| FB(item,fbaddress)[startbyte + 1] << 8 \| FB(item,fbaddress)[startbyte + 2];
262	#else	262	#else
263	return FB(item,fbaddress)[startbyte + 2] << 16 \| FB(item,fbaddress)[startbyte + 1] << 8 \| FB(item,fbaddress)[startbyte + 0];	263	return FB(item,fbaddress)[startbyte + 2] << 16 \| FB(item,fbaddress)[startbyte + 1] << 8 \| FB(item,fbaddress)[startbyte + 0];
264	#endif	264	#endif
265		265
266		266
267	}	267	}
268		268
269	/** Put pixel - 16-bit depth (5:6:5) */	269	/** Put pixel - 16-bit depth (5:6:5) */
270	static void putpixel_2byte(int item,unsigned int x, unsigned int y, int color)	270	static void putpixel_2byte(int item,unsigned int x, unsigned int y, int color)
271	{	271	{
272	/* 5-bit, 6-bits, 5-bits */	272	/* 5-bit, 6-bits, 5-bits */
273	((__u16 )(FB(item,fbaddress) + POINTPOS(x, y))) = RED(color, 5) << 11 \| GREEN(color, 6) << 5 \| BLUE(color, 5);	273	((__u16 )(FB(item,fbaddress) + POINTPOS(x, y))) = RED(color, 5) << 11 \| GREEN(color, 6) << 5 \| BLUE(color, 5);
274	}	274	}
275		275
276	/** Return pixel color - 16-bit depth (5:6:5) */	276	/** Return pixel color - 16-bit depth (5:6:5) */
277	static int getpixel_2byte(int item,unsigned int x, unsigned int y)	277	static int getpixel_2byte(int item,unsigned int x, unsigned int y)
278	{	278	{
279	int color = ((__u16 )(FB(item,fbaddress) + POINTPOS(x, y)));	279	int color = ((__u16 )(FB(item,fbaddress) + POINTPOS(x, y)));
280	return (((color >> 11) & 0x1f) << (16 + 3)) \| (((color >> 5) & 0x3f) << (8 + 2)) \| ((color & 0x1f) << 3);	280	return (((color >> 11) & 0x1f) << (16 + 3)) \| (((color >> 5) & 0x3f) << (8 + 2)) \| ((color & 0x1f) << 3);
281	}	281	}
282		282
283	/** Put pixel - 8-bit depth (3:2:3) */	283	/** Put pixel - 8-bit depth (3:2:3) */
284	static void putpixel_1byte(int item,unsigned int x, unsigned int y, int color)	284	static void putpixel_1byte(int item,unsigned int x, unsigned int y, int color)
285	{	285	{
286	FB(item,fbaddress)[POINTPOS(x, y)] = RED(color, 3) << 5 \| GREEN(color, 2) << 3 \| BLUE(color, 3);	286	FB(item,fbaddress)[POINTPOS(x, y)] = RED(color, 3) << 5 \| GREEN(color, 2) << 3 \| BLUE(color, 3);
287	}	287	}
288		288
289	/** Return pixel color - 8-bit depth (3:2:3) */	289	/** Return pixel color - 8-bit depth (3:2:3) */
290	static int getpixel_1byte(int item,unsigned int x, unsigned int y)	290	static int getpixel_1byte(int item,unsigned int x, unsigned int y)
291	{	291	{
292	int color = FB(item,fbaddress)[POINTPOS(x, y)];	292	int color = FB(item,fbaddress)[POINTPOS(x, y)];
293	return (((color >> 5) & 0x7) << (16 + 5)) \| (((color >> 3) & 0x3) << (8 + 6)) \| ((color & 0x7) << 5);	293	return (((color >> 5) & 0x7) << (16 + 5)) \| (((color >> 3) & 0x3) << (8 + 6)) \| ((color & 0x7) << 5);
294	}	294	}
295		295
296	/** Fill line with color BGCOLOR */	296	/** Fill line with color BGCOLOR */
297	static void clear_line(int item,unsigned int y)	297	static void clear_line(int item,unsigned int y)
298	{	298	{
299	unsigned int x;	299	unsigned int x;
300	for (x = 0; x < FB(item,xres); x++)	300	for (x = 0; x < FB(item,xres); x++)
301	FB(item,putpixel)(item,x, y, FB(item,BGCOLOR));	301	FB(item,putpixel)(item,x, y, FB(item,BGCOLOR));
302	}	302	}
303		303
304		304
305	/** Fill screen with background color */	305	/** Fill screen with background color */
306	static void clear_screen(int item)	306	static void clear_screen(int item)
307	{	307	{
308	unsigned int y;	308	unsigned int y;
309	for (y = 0; y < FB(item,yres); y++)	309	for (y = 0; y < FB(item,yres); y++)
310	{	310	{
311	clear_line(item,y);	311	clear_line(item,y);
312	}	312	}
313	}	313	}
314		314
315		315
316	/** Scroll screen one row up */	316	/** Scroll screen one row up */
317	static void scroll_screen(int item)	317	static void scroll_screen(int item)
318	{	318	{
319	unsigned int i;	319	unsigned int i;
320	unsigned int j;	320	unsigned int j;
321		321
322	for(j=0;j<FB(item,yres)-FONT_SCANLINES;j++)	322	for(j=0;j<FB(item,yres)-FONT_SCANLINES;j++)
323	memcpy((void ) FB(item,fbaddress)+jFB(item,scanline),	323	memcpy((void ) FB(item,fbaddress)+jFB(item,scanline),
324	(void ) &FB(item,fbaddress)[ROW_BYTES+jFB(item,scanline)], FB(item,pixelbytes)*FB(item,xres));	324	(void ) &FB(item,fbaddress)[ROW_BYTES+jFB(item,scanline)], FB(item,pixelbytes)*FB(item,xres));
325		325
326	//memcpy((void ) FB(item,fbaddress), (void ) &FB(item,fbaddress)[ROW_BYTES], FB(item,scanline) * FB(item,yres) - ROW_BYTES);	326	//memcpy((void ) FB(item,fbaddress), (void ) &FB(item,fbaddress)[ROW_BYTES], FB(item,scanline) * FB(item,yres) - ROW_BYTES);
327		327
328	/* Clear last row */	328	/* Clear last row */
329	for (i = 0; i < FONT_SCANLINES; i++)	329	for (i = 0; i < FONT_SCANLINES; i++)
330	clear_line(item,(FB(item,rows) - 1) * FONT_SCANLINES + i);	330	clear_line(item,(FB(item,rows) - 1) * FONT_SCANLINES + i);
331	}	331	}
332		332
333		333
334	static void invert_pixel(int item,unsigned int x, unsigned int y)	334	static void invert_pixel(int item,unsigned int x, unsigned int y)
335	{	335	{
336	FB(item,putpixel)(item, x, y, ~FB(item,getpixel)(item, x, y));	336	FB(item,putpixel)(item, x, y, ~FB(item,getpixel)(item, x, y));
337	}	337	}
338		338
339		339
340	/** Draw one line of glyph at a given position */	340	/** Draw one line of glyph at a given position */
341	static void draw_glyph_line(int item,unsigned int glline, unsigned int x, unsigned int y)	341	static void draw_glyph_line(int item,unsigned int glline, unsigned int x, unsigned int y)
342	{	342	{
343	unsigned int i;	343	unsigned int i;
344		344
345	for (i = 0; i < 8; i++)	345	for (i = 0; i < 8; i++)
346	if (glline & (1 << (7 - i))) {	346	if (glline & (1 << (7 - i))) {
347	FB(item,putpixel)(item,x + i, y, FB(item,FGCOLOR));	347	FB(item,putpixel)(item,x + i, y, FB(item,FGCOLOR));
348	} else	348	} else
349	FB(item,putpixel)(item,x + i, y, FB(item,BGCOLOR));	349	FB(item,putpixel)(item,x + i, y, FB(item,BGCOLOR));
350	}	350	}
351		351
352	/***************************************************************/	352	/***************************************************************/
353	/* Character-console functions */	353	/* Character-console functions */
354		354
355	/** Draw character at given position */	355	/** Draw character at given position */
356	static void draw_glyph(int item,__u8 glyph, unsigned int col, unsigned int row)	356	static void draw_glyph(int item,__u8 glyph, unsigned int col, unsigned int row)
357	{	357	{
358	unsigned int y;	358	unsigned int y;
359		359
360	for (y = 0; y < FONT_SCANLINES; y++)	360	for (y = 0; y < FONT_SCANLINES; y++)
361	draw_glyph_line(item ,fb_font[glyph * FONT_SCANLINES + y], col * COL_WIDTH, row * FONT_SCANLINES + y);	361	draw_glyph_line(item ,fb_font[glyph * FONT_SCANLINES + y], col * COL_WIDTH, row * FONT_SCANLINES + y);
362	}	362	}
363		363
364	/** Invert character at given position */	364	/** Invert character at given position */
365	static void invert_char(int item,unsigned int col, unsigned int row)	365	static void invert_char(int item,unsigned int col, unsigned int row)
366	{	366	{
367	unsigned int x;	367	unsigned int x;
368	unsigned int y;	368	unsigned int y;
369		369
370	for (x = 0; x < COL_WIDTH; x++)	370	for (x = 0; x < COL_WIDTH; x++)
371	for (y = 0; y < FONT_SCANLINES; y++)	371	for (y = 0; y < FONT_SCANLINES; y++)
372	invert_pixel(item,col * COL_WIDTH + x, row * FONT_SCANLINES + y);	372	invert_pixel(item,col * COL_WIDTH + x, row * FONT_SCANLINES + y);
373	}	373	}
374		374
375	/** Draw character at default position */	375	/** Draw character at default position */
376	static void draw_char(int item,char chr)	376	static void draw_char(int item,char chr)
377	{	377	{
378	draw_glyph(item ,chr, FB(item,position) % FB(item,columns), FB(item,position) / FB(item,columns));	378	draw_glyph(item ,chr, FB(item,position) % FB(item,columns), FB(item,position) / FB(item,columns));
379	}	379	}
380		380
381	static void draw_logo(int item,unsigned int startx, unsigned int starty)	381	static void draw_logo(int item,unsigned int startx, unsigned int starty)
382	{	382	{
383	unsigned int x;	383	unsigned int x;
384	unsigned int y;	384	unsigned int y;
385	unsigned int byte;	385	unsigned int byte;
386	unsigned int rowbytes;	386	unsigned int rowbytes;
387		387
388	rowbytes = (helenos_width - 1) / 8 + 1;	388	rowbytes = (helenos_width - 1) / 8 + 1;
389		389
390	for (y = 0; y < helenos_height; y++)	390	for (y = 0; y < helenos_height; y++)
391	for (x = 0; x < helenos_width; x++) {	391	for (x = 0; x < helenos_width; x++) {
392	byte = helenos_bits[rowbytes * y + x / 8];	392	byte = helenos_bits[rowbytes * y + x / 8];
393	byte >>= x % 8;	393	byte >>= x % 8;
394	if (byte & 1)	394	if (byte & 1)
395	FB(item,putpixel)(item,startx + x, starty + y, FB(item,LOGOCOLOR));	395	FB(item,putpixel)(item,startx + x, starty + y, FB(item,LOGOCOLOR));
396	}	396	}
397	}	397	}
398		398
399	/***************************************************************/	399	/***************************************************************/
400	/* Stdout specific functions */	400	/* Stdout specific functions */
401		401
402	static void invert_cursor(int item)	402	static void invert_cursor(int item)
403	{	403	{
404	invert_char(item,FB(item,position) % FB(item,columns), FB(item,position) / FB(item,columns));	404	invert_char(item,FB(item,position) % FB(item,columns), FB(item,position) / FB(item,columns));
405	}	405	}
406		406
407	/** Print character to screen	407	/** Print character to screen
408	*	408	*
409	* Emulate basic terminal commands	409	* Emulate basic terminal commands
410	*/	410	*/
411	static void fb_putchar(int item,char ch)	411	static void fb_putchar(int item,char ch)
412	{	412	{
413		413
414	switch (ch) {	414	switch (ch) {
415	case '\n':	415	case '\n':
416	invert_cursor(item);	416	invert_cursor(item);
417	FB(item,position) += FB(item,columns);	417	FB(item,position) += FB(item,columns);
418	FB(item,position) -= FB(item,position) % FB(item,columns);	418	FB(item,position) -= FB(item,position) % FB(item,columns);
419	break;	419	break;
420	case '\r':	420	case '\r':
421	invert_cursor(item);	421	invert_cursor(item);
422	FB(item,position) -= FB(item,position) % FB(item,columns);	422	FB(item,position) -= FB(item,position) % FB(item,columns);
423	break;	423	break;
424	case '\b':	424	case '\b':
425	invert_cursor(item);	425	invert_cursor(item);
426	if (FB(item,position) % FB(item,columns))	426	if (FB(item,position) % FB(item,columns))
427	FB(item,position)--;	427	FB(item,position)--;
428	break;	428	break;
429	case '\t':	429	case '\t':
430	invert_cursor(item);	430	invert_cursor(item);
431	do {	431	do {
432	draw_char(item,' ');	432	draw_char(item,' ');
433	FB(item,position)++;	433	FB(item,position)++;
434	} while (FB(item,position) % 8);	434	} while (FB(item,position) % 8);
435	break;	435	break;
436	default:	436	default:
437	draw_char(item,ch);	437	draw_char(item,ch);
438	FB(item,position)++;	438	FB(item,position)++;
439	}	439	}
440		440
441	if (FB(item,position) >= FB(item,columns) * FB(item,rows)) {	441	if (FB(item,position) >= FB(item,columns) * FB(item,rows)) {
442	FB(item,position) -= FB(item,columns);	442	FB(item,position) -= FB(item,columns);
443	scroll_screen(item);	443	scroll_screen(item);
444	}	444	}
445		445
446	invert_cursor(item);	446	invert_cursor(item);
447		447
448	}	448	}
449		449
450		450
451	/** Initialize framebuffer as a chardev output device	451	/** Initialize framebuffer as a chardev output device
452	*	452	*
453	* @param addr Address of theframebuffer	453	* @param addr Address of theframebuffer
454	* @param x Screen width in pixels	454	* @param x Screen width in pixels
455	* @param y Screen height in pixels	455	* @param y Screen height in pixels
456	* @param bpp Bits per pixel (8, 16, 24, 32)	456	* @param bpp Bits per pixel (8, 16, 24, 32)
457	* @param scan Bytes per one scanline	457	* @param scan Bytes per one scanline
458	*	458	*
459	*/	459	*/
460	void fb_init(int item,__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan,	460	void fb_init(int item,__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan,
461	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR)	461	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR)
462	{	462	{
463		463
464	if( (graphics_items[item]=malloc(sizeof(framebuffer_descriptor_t))) ==NULL)	464	if( (graphics_items[item]=malloc(sizeof(framebuffer_descriptor_t))) ==NULL)
465	{	465	{
466	return;	466	return;
467	}	467	}
468		468
469	switch (bpp) {	469	switch (bpp) {
470	case 8:	470	case 8:
471	FB(item,putpixel) = putpixel_1byte;	471	FB(item,putpixel) = putpixel_1byte;
472	FB(item,getpixel) = getpixel_1byte;	472	FB(item,getpixel) = getpixel_1byte;
473	FB(item,pixelbytes) = 1;	473	FB(item,pixelbytes) = 1;
474	break;	474	break;
475	case 16:	475	case 16:
476	FB(item,putpixel) = putpixel_2byte;	476	FB(item,putpixel) = putpixel_2byte;
477	FB(item,getpixel) = getpixel_2byte;	477	FB(item,getpixel) = getpixel_2byte;
478	FB(item,pixelbytes) = 2;	478	FB(item,pixelbytes) = 2;
479	break;	479	break;
480	case 24:	480	case 24:
481	FB(item,putpixel) = putpixel_3byte;	481	FB(item,putpixel) = putpixel_3byte;
482	FB(item,getpixel) = getpixel_3byte;	482	FB(item,getpixel) = getpixel_3byte;
483	FB(item,pixelbytes) = 3;	483	FB(item,pixelbytes) = 3;
484	break;	484	break;
485	case 32:	485	case 32:
486	FB(item,putpixel) = putpixel_4byte;	486	FB(item,putpixel) = putpixel_4byte;
487	FB(item,getpixel) = getpixel_4byte;	487	FB(item,getpixel) = getpixel_4byte;
488	FB(item,pixelbytes) = 4;	488	FB(item,pixelbytes) = 4;
489	break;	489	break;
490	}	490	}
491		491
492		492
493	FB(item,fbaddress) = (unsigned char *) addr;	493	FB(item,fbaddress) = (unsigned char *) addr;
494	FB(item,xres) = x;	494	FB(item,xres) = x;
495	FB(item,yres) = y;	495	FB(item,yres) = y;
496	FB(item,scanline) = scan;	496	FB(item,scanline) = scan;
497		497
498		498
499	FB(item,rows) = y / FONT_SCANLINES;	499	FB(item,rows) = y / FONT_SCANLINES;
500	FB(item,columns) = x / COL_WIDTH;	500	FB(item,columns) = x / COL_WIDTH;

Subversion Repositories HelenOS-historic

(root)/uspace/trunk/fb/fb.c @ 1447 – Rev 1447 → 1451