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 > 9) {
        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 1445	Rev 1447
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 > 9) {
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	printf("Framebuffer initialization failed.\n");	-
165	return -1;	164	return -1;
166	}	-
167		165
168	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)
169	return -1;	167	return -1;
170		168
171	if (init_fb() != 0) {	169	if (init_fb() != 0)
172	printf("Framebuffer initialization failed.\n");	-
173	return -1;	170	return -1;
174	}	-
175		171
176	async_manager();	172	async_manager();
177	/* Never reached */	173	/* Never reached */
178	return 0;	174	return 0;
179	}	175	}
180		176
181		177
182	#define GRAPHICS_ITEMS 1024	178	#define GRAPHICS_ITEMS 1024
183		179
184		180
185	/***************************************************************/	181	/***************************************************************/
186	/* Pixel specific fuctions */	182	/* Pixel specific fuctions */
187		183
188	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);
189	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);
190		186
191	typedef struct framebuffer_descriptor	187	typedef struct framebuffer_descriptor
192	{	188	{
193	__u8 *fbaddress ;	189	__u8 *fbaddress ;
194		190
195	unsigned int xres ;	191	unsigned int xres ;
196	unsigned int yres ;	192	unsigned int yres ;
197	unsigned int scanline ;	193	unsigned int scanline ;
198	unsigned int pixelbytes ;	194	unsigned int pixelbytes ;
199		195
200	unsigned int position ;	196	unsigned int position ;
201	unsigned int columns ;	197	unsigned int columns ;
202	unsigned int rows ;	198	unsigned int rows ;
203		199
204	unsigned int BGCOLOR;	200	unsigned int BGCOLOR;
205	unsigned int FGCOLOR;	201	unsigned int FGCOLOR;
206	unsigned int LOGOCOLOR;	202	unsigned int LOGOCOLOR;
207		203
208	putpixel_fn_t putpixel;	204	putpixel_fn_t putpixel;
209	getpixel_fn_t getpixel;	205	getpixel_fn_t getpixel;
210		206
211	}framebuffer_descriptor_t;	207	}framebuffer_descriptor_t;
212		208
213	void * graphics_items[GRAPHICS_ITEMS+1]={NULL};	209	void * graphics_items[GRAPHICS_ITEMS+1]={NULL};
214		210
215	#define FB(__a__,__b__) (((framebuffer_descriptor_t*)(graphics_items[__a__]))->__b__)	211	#define FB(__a__,__b__) (((framebuffer_descriptor_t*)(graphics_items[__a__]))->__b__)
216		212
217	#define COL_WIDTH 8	213	#define COL_WIDTH 8
218	#define ROW_BYTES (FB(item,scanline) * FONT_SCANLINES)	214	#define ROW_BYTES (FB(item,scanline) * FONT_SCANLINES)
219	#define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))	215	#define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))
220	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))	216	#define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
221	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))	217	#define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1))
222		218
223	#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))
224		220
225		221
226		222
227		223
228	/** Put pixel - 24-bit depth, 1 free byte */	224	/** Put pixel - 24-bit depth, 1 free byte */
229	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)
230	{	226	{
231	((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) = color;	227	((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) = color;
232	}	228	}
233		229
234	/** Return pixel color - 24-bit depth, 1 free byte */	230	/** Return pixel color - 24-bit depth, 1 free byte */
235	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)
236	{	232	{
237	return ((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) & 0xffffff;	233	return ((__u32 )(FB(item,fbaddress) + POINTPOS(x, y))) & 0xffffff;
238	}	234	}
239		235
240	/** Put pixel - 24-bit depth */	236	/** Put pixel - 24-bit depth */
241	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)
242	{	238	{
243	unsigned int startbyte = POINTPOS(x, y);	239	unsigned int startbyte = POINTPOS(x, y);
244		240
245	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))	241	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))
246	FB(item,fbaddress)[startbyte] = RED(color, 8);	242	FB(item,fbaddress)[startbyte] = RED(color, 8);
247	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);	243	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);
248	FB(item,fbaddress)[startbyte + 2] = BLUE(color, 8);	244	FB(item,fbaddress)[startbyte + 2] = BLUE(color, 8);
249	#else	245	#else
250	FB(item,fbaddress)[startbyte + 2] = RED(color, 8);	246	FB(item,fbaddress)[startbyte + 2] = RED(color, 8);
251	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);	247	FB(item,fbaddress)[startbyte + 1] = GREEN(color, 8);
252	FB(item,fbaddress)[startbyte + 0] = BLUE(color, 8);	248	FB(item,fbaddress)[startbyte + 0] = BLUE(color, 8);
253	#endif	249	#endif
254		250
255	}	251	}
256		252
257	/** Return pixel color - 24-bit depth */	253	/** Return pixel color - 24-bit depth */
258	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)
259	{	255	{
260	unsigned int startbyte = POINTPOS(x, y);	256	unsigned int startbyte = POINTPOS(x, y);
261		257
262		258
263		259
264	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))	260	#if (defined(BIG_ENDIAN) \|\| defined(FB_BIG_ENDIAN))
265	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];
266	#else	262	#else
267	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];
268	#endif	264	#endif
269		265
270		266
271	}	267	}
272		268
273	/** Put pixel - 16-bit depth (5:6:5) */	269	/** Put pixel - 16-bit depth (5:6:5) */
274	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)
275	{	271	{
276	/* 5-bit, 6-bits, 5-bits */	272	/* 5-bit, 6-bits, 5-bits */
277	((__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);
278	}	274	}
279		275
280	/** Return pixel color - 16-bit depth (5:6:5) */	276	/** Return pixel color - 16-bit depth (5:6:5) */
281	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)
282	{	278	{
283	int color = ((__u16 )(FB(item,fbaddress) + POINTPOS(x, y)));	279	int color = ((__u16 )(FB(item,fbaddress) + POINTPOS(x, y)));
284	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);
285	}	281	}
286		282
287	/** Put pixel - 8-bit depth (3:2:3) */	283	/** Put pixel - 8-bit depth (3:2:3) */
288	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)
289	{	285	{
290	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);
291	}	287	}
292		288
293	/** Return pixel color - 8-bit depth (3:2:3) */	289	/** Return pixel color - 8-bit depth (3:2:3) */
294	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)
295	{	291	{
296	int color = FB(item,fbaddress)[POINTPOS(x, y)];	292	int color = FB(item,fbaddress)[POINTPOS(x, y)];
297	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);
298	}	294	}
299		295
300	/** Fill line with color BGCOLOR */	296	/** Fill line with color BGCOLOR */
301	static void clear_line(int item,unsigned int y)	297	static void clear_line(int item,unsigned int y)
302	{	298	{
303	unsigned int x;	299	unsigned int x;
304	for (x = 0; x < FB(item,xres); x++)	300	for (x = 0; x < FB(item,xres); x++)
305	FB(item,putpixel)(item,x, y, FB(item,BGCOLOR));	301	FB(item,putpixel)(item,x, y, FB(item,BGCOLOR));
306	}	302	}
307		303
308		304
309	/** Fill screen with background color */	305	/** Fill screen with background color */
310	static void clear_screen(int item)	306	static void clear_screen(int item)
311	{	307	{
312	unsigned int y;	308	unsigned int y;
313	for (y = 0; y < FB(item,yres); y++)	309	for (y = 0; y < FB(item,yres); y++)
314	{	310	{
315	clear_line(item,y);	311	clear_line(item,y);
316	}	312	}
317	}	313	}
318		314
319		315
320	/** Scroll screen one row up */	316	/** Scroll screen one row up */
321	static void scroll_screen(int item)	317	static void scroll_screen(int item)
322	{	318	{
323	unsigned int i;	319	unsigned int i;
324	unsigned int j;	320	unsigned int j;
325		321
326	for(j=0;j<FB(item,yres)-FONT_SCANLINES;j++)	322	for(j=0;j<FB(item,yres)-FONT_SCANLINES;j++)
327	memcpy((void ) FB(item,fbaddress)+jFB(item,scanline),	323	memcpy((void ) FB(item,fbaddress)+jFB(item,scanline),
328	(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));
329		325
330	//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);
331		327
332	/* Clear last row */	328	/* Clear last row */
333	for (i = 0; i < FONT_SCANLINES; i++)	329	for (i = 0; i < FONT_SCANLINES; i++)
334	clear_line(item,(FB(item,rows) - 1) * FONT_SCANLINES + i);	330	clear_line(item,(FB(item,rows) - 1) * FONT_SCANLINES + i);
335	}	331	}
336		332
337		333
338	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)
339	{	335	{
340	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));
341	}	337	}
342		338
343		339
344	/** Draw one line of glyph at a given position */	340	/** Draw one line of glyph at a given position */
345	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)
346	{	342	{
347	unsigned int i;	343	unsigned int i;
348		344
349	for (i = 0; i < 8; i++)	345	for (i = 0; i < 8; i++)
350	if (glline & (1 << (7 - i))) {	346	if (glline & (1 << (7 - i))) {
351	FB(item,putpixel)(item,x + i, y, FB(item,FGCOLOR));	347	FB(item,putpixel)(item,x + i, y, FB(item,FGCOLOR));
352	} else	348	} else
353	FB(item,putpixel)(item,x + i, y, FB(item,BGCOLOR));	349	FB(item,putpixel)(item,x + i, y, FB(item,BGCOLOR));
354	}	350	}
355		351
356	/***************************************************************/	352	/***************************************************************/
357	/* Character-console functions */	353	/* Character-console functions */
358		354
359	/** Draw character at given position */	355	/** Draw character at given position */
360	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)
361	{	357	{
362	unsigned int y;	358	unsigned int y;
363		359
364	for (y = 0; y < FONT_SCANLINES; y++)	360	for (y = 0; y < FONT_SCANLINES; y++)
365	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);
366	}	362	}
367		363
368	/** Invert character at given position */	364	/** Invert character at given position */
369	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)
370	{	366	{
371	unsigned int x;	367	unsigned int x;
372	unsigned int y;	368	unsigned int y;
373		369
374	for (x = 0; x < COL_WIDTH; x++)	370	for (x = 0; x < COL_WIDTH; x++)
375	for (y = 0; y < FONT_SCANLINES; y++)	371	for (y = 0; y < FONT_SCANLINES; y++)
376	invert_pixel(item,col * COL_WIDTH + x, row * FONT_SCANLINES + y);	372	invert_pixel(item,col * COL_WIDTH + x, row * FONT_SCANLINES + y);
377	}	373	}
378		374
379	/** Draw character at default position */	375	/** Draw character at default position */
380	static void draw_char(int item,char chr)	376	static void draw_char(int item,char chr)
381	{	377	{
382	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));
383	}	379	}
384		380
385	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)
386	{	382	{
387	unsigned int x;	383	unsigned int x;
388	unsigned int y;	384	unsigned int y;
389	unsigned int byte;	385	unsigned int byte;
390	unsigned int rowbytes;	386	unsigned int rowbytes;
391		387
392	rowbytes = (helenos_width - 1) / 8 + 1;	388	rowbytes = (helenos_width - 1) / 8 + 1;
393		389
394	for (y = 0; y < helenos_height; y++)	390	for (y = 0; y < helenos_height; y++)
395	for (x = 0; x < helenos_width; x++) {	391	for (x = 0; x < helenos_width; x++) {
396	byte = helenos_bits[rowbytes * y + x / 8];	392	byte = helenos_bits[rowbytes * y + x / 8];
397	byte >>= x % 8;	393	byte >>= x % 8;
398	if (byte & 1)	394	if (byte & 1)
399	FB(item,putpixel)(item,startx + x, starty + y, FB(item,LOGOCOLOR));	395	FB(item,putpixel)(item,startx + x, starty + y, FB(item,LOGOCOLOR));
400	}	396	}
401	}	397	}
402		398
403	/***************************************************************/	399	/***************************************************************/
404	/* Stdout specific functions */	400	/* Stdout specific functions */
405		401
406	static void invert_cursor(int item)	402	static void invert_cursor(int item)
407	{	403	{
408	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));
409	}	405	}
410		406
411	/** Print character to screen	407	/** Print character to screen
412	*	408	*
413	* Emulate basic terminal commands	409	* Emulate basic terminal commands
414	*/	410	*/
415	static void fb_putchar(int item,char ch)	411	static void fb_putchar(int item,char ch)
416	{	412	{
417		413
418	switch (ch) {	414	switch (ch) {
419	case '\n':	415	case '\n':
420	invert_cursor(item);	416	invert_cursor(item);
421	FB(item,position) += FB(item,columns);	417	FB(item,position) += FB(item,columns);
422	FB(item,position) -= FB(item,position) % FB(item,columns);	418	FB(item,position) -= FB(item,position) % FB(item,columns);
423	break;	419	break;
424	case '\r':	420	case '\r':
425	invert_cursor(item);	421	invert_cursor(item);
426	FB(item,position) -= FB(item,position) % FB(item,columns);	422	FB(item,position) -= FB(item,position) % FB(item,columns);
427	break;	423	break;
428	case '\b':	424	case '\b':
429	invert_cursor(item);	425	invert_cursor(item);
430	if (FB(item,position) % FB(item,columns))	426	if (FB(item,position) % FB(item,columns))
431	FB(item,position)--;	427	FB(item,position)--;
432	break;	428	break;
433	case '\t':	429	case '\t':
434	invert_cursor(item);	430	invert_cursor(item);
435	do {	431	do {
436	draw_char(item,' ');	432	draw_char(item,' ');
437	FB(item,position)++;	433	FB(item,position)++;
438	} while (FB(item,position) % 8);	434	} while (FB(item,position) % 8);
439	break;	435	break;
440	default:	436	default:
441	draw_char(item,ch);	437	draw_char(item,ch);
442	FB(item,position)++;	438	FB(item,position)++;
443	}	439	}
444		440
445	if (FB(item,position) >= FB(item,columns) * FB(item,rows)) {	441	if (FB(item,position) >= FB(item,columns) * FB(item,rows)) {
446	FB(item,position) -= FB(item,columns);	442	FB(item,position) -= FB(item,columns);
447	scroll_screen(item);	443	scroll_screen(item);
448	}	444	}
449		445
450	invert_cursor(item);	446	invert_cursor(item);
451		447
452	}	448	}
453		449
454		450
455	/** Initialize framebuffer as a chardev output device	451	/** Initialize framebuffer as a chardev output device
456	*	452	*
457	* @param addr Address of theframebuffer	453	* @param addr Address of theframebuffer
458	* @param x Screen width in pixels	454	* @param x Screen width in pixels
459	* @param y Screen height in pixels	455	* @param y Screen height in pixels
460	* @param bpp Bits per pixel (8, 16, 24, 32)	456	* @param bpp Bits per pixel (8, 16, 24, 32)
461	* @param scan Bytes per one scanline	457	* @param scan Bytes per one scanline
462	*	458	*
463	*/	459	*/
464	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,
465	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR)	461	unsigned int BGCOLOR,unsigned int FGCOLOR,unsigned int LOGOCOLOR)
466	{	462	{
467		463
468	if( (graphics_items[item]=malloc(sizeof(framebuffer_descriptor_t))) ==NULL)	464	if( (graphics_items[item]=malloc(sizeof(framebuffer_descriptor_t))) ==NULL)
469	{	465	{
470	return;	466	return;
471	}	467	}
472		468
473	switch (bpp) {	469	switch (bpp) {
474	case 8:	470	case 8:
475	FB(item,putpixel) = putpixel_1byte;	471	FB(item,putpixel) = putpixel_1byte;
476	FB(item,getpixel) = getpixel_1byte;	472	FB(item,getpixel) = getpixel_1byte;
477	FB(item,pixelbytes) = 1;	473	FB(item,pixelbytes) = 1;
478	break;	474	break;
479	case 16:	475	case 16:
480	FB(item,putpixel) = putpixel_2byte;	476	FB(item,putpixel) = putpixel_2byte;
481	FB(item,getpixel) = getpixel_2byte;	477	FB(item,getpixel) = getpixel_2byte;
482	FB(item,pixelbytes) = 2;	478	FB(item,pixelbytes) = 2;
483	break;	479	break;
484	case 24:	480	case 24:
485	FB(item,putpixel) = putpixel_3byte;	481	FB(item,putpixel) = putpixel_3byte;
486	FB(item,getpixel) = getpixel_3byte;	482	FB(item,getpixel) = getpixel_3byte;
487	FB(item,pixelbytes) = 3;	483	FB(item,pixelbytes) = 3;
488	break;	484	break;
489	case 32:	485	case 32:
490	FB(item,putpixel) = putpixel_4byte;	486	FB(item,putpixel) = putpixel_4byte;
491	FB(item,getpixel) = getpixel_4byte;	487	FB(item,getpixel) = getpixel_4byte;
492	FB(item,pixelbytes) = 4;	488	FB(item,pixelbytes) = 4;
493	break;	489	break;
494	}	490	}
495		491
496		492
497	FB(item,fbaddress) = (unsigned char *) addr;	493	FB(item,fbaddress) = (unsigned char *) addr;
498	FB(item,xres) = x;	494	FB(item,xres) = x;
499	FB(item,yres) = y;	495	FB(item,yres) = y;
500	FB(item,scanline) = scan;	496	FB(item,scanline) = scan;

Subversion Repositories HelenOS-historic

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