Changeset 76fca31 in mainline for kernel/genarch/src/fb/fb.c


Ignore:
Timestamp:
2008-12-16T19:02:07Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5ae4443
Parents:
8fe5980
Message:

kconsole is optional
kernel & uspace framebuffer rewrite with speedups (some things are slightly broken yet)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/genarch/src/fb/fb.c

    r8fe5980 r76fca31  
    11/*
     2 * Copyright (c) 2008 Martin Decky
    23 * Copyright (c) 2006 Ondrej Palkovsky
    34 * All rights reserved.
    … …  
    2728 */
    2829
    29 /** @addtogroup genarch 
     30/** @addtogroup genarch
    3031 * @{
    3132 */
    … …  
    4041#include <sysinfo/sysinfo.h>
    4142#include <mm/slab.h>
     43#include <align.h>
    4244#include <panic.h>
    4345#include <memstr.h>
    … …  
    4850#include <arch/types.h>
    4951
    50 #include "helenos.xbm"
    51 
    52 static parea_t fb_parea;                /**< Physical memory area for fb. */
    53 
    5452SPINLOCK_INITIALIZE(fb_lock);
    5553
    56 static uint8_t *fbaddress = NULL;
    57 
    58 static uint8_t *blankline = NULL;
    59 static uint8_t *dbbuffer = NULL;        /* Buffer for fast scrolling console */
    60 static index_t dboffset;
    61 
    62 static unsigned int xres = 0;
    63 static unsigned int yres = 0;
    64 static unsigned int scanline = 0;
    65 static unsigned int pixelbytes = 0;
    66 #ifdef FB_INVERT_COLORS
    67 static bool invert_colors = true;
     54/**< Physical memory area for fb. */
     55static parea_t fb_parea;
     56
     57static uint8_t *fb_addr;
     58static uint8_t *backbuf;
     59static uint8_t *glyphs;
     60
     61static void *bgpixel;
     62
     63static unsigned int xres;
     64static unsigned int yres;
     65
     66static unsigned int scanline;
     67static unsigned int glyphscanline;
     68
     69static unsigned int pixelbytes;
     70static unsigned int glyphbytes;
     71
     72static unsigned int cols;
     73static unsigned int rows;
     74static unsigned int position = 0;
     75
     76#define BG_COLOR     0x000080
     77#define FG_COLOR     0xffff00
     78
     79#define CURSOR       219
     80
     81#define RED(x, bits)         ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
     82#define GREEN(x, bits)       ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
     83#define BLUE(x, bits)        ((x >> (8 - bits)) & ((1 << bits) - 1))
     84
     85#define COL2X(col)           ((col) * FONT_WIDTH)
     86#define ROW2Y(row)           ((row) * FONT_SCANLINES)
     87
     88#define X2COL(x)             ((x) / FONT_WIDTH)
     89#define Y2ROW(y)             ((y) / FONT_SCANLINES)
     90
     91#define FB_POS(x, y)         ((y) * scanline + (x) * pixelbytes)
     92#define BB_POS(col, row)     ((row) * cols + (col))
     93#define GLYPH_POS(glyph, y)  ((glyph) * glyphbytes + (y) * glyphscanline)
     94
     95
     96static void (*rgb_conv)(void *, uint32_t);
     97
     98
     99/** ARGB 8:8:8:8 conversion
     100 *
     101 */
     102static void rgb_0888(void *dst, uint32_t rgb)
     103{
     104        *((uint32_t *) dst) = rgb & 0xffffff;
     105}
     106
     107
     108/** ABGR 8:8:8:8 conversion
     109 *
     110 */
     111static void bgr_0888(void *dst, uint32_t rgb)
     112{
     113        *((uint32_t *) dst)
     114            = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
     115}
     116
     117
     118/** BGR 8:8:8 conversion
     119 *
     120 */
     121static void rgb_888(void *dst, uint32_t rgb)
     122{
     123#if defined(FB_INVERT_ENDIAN)
     124        *((uint32_t *) dst)
     125            = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8)
     126            | (*((uint32_t *) dst) & 0xff0000);
    68127#else
    69 static bool invert_colors = false;
     128        *((uint32_t *) dst)
     129            = (rgb & 0xffffff) | (*((uint32_t *) dst) & 0xff0000);
    70130#endif
    71 
    72 static unsigned int position = 0;
    73 static unsigned int columns = 0;
    74 static unsigned int rows = 0;
    75 
    76 #define COL_WIDTH       8
    77 #define ROW_BYTES       (scanline * FONT_SCANLINES)
    78 
    79 #define BGCOLOR         0x000080
    80 #define FGCOLOR         0xffff00
    81 #define LOGOCOLOR       0x2020b0
    82 
    83 #define RED(x, bits)    ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
    84 #define GREEN(x, bits)  ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
    85 #define BLUE(x, bits)   ((x >> (8 - bits)) & ((1 << bits) - 1))
    86 
    87 #define POINTPOS(x, y)  ((y) * scanline + (x) * pixelbytes)
    88 
    89 /***************************************************************/
    90 /* Pixel specific fuctions */
    91 
    92 static void (*rgb2scr)(void *, int);
    93 static int (*scr2rgb)(void *);
    94 
    95 static inline int COLOR(int color)
    96 {
    97         return invert_colors ? ~color : color;
    98 }
    99 
    100 /* Conversion routines between different color representations */
    101 static void rgb_byte0888(void *dst, int rgb)
    102 {
    103         *((int *) dst) = rgb;
    104 }
    105 
    106 static int byte0888_rgb(void *src)
    107 {
    108         return (*((int *) src)) & 0xffffff;
    109 }
    110 
    111 static void bgr_byte0888(void *dst, int rgb)
    112 {
    113         *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
    114             RED(rgb, 8);
    115 }
    116 
    117 static int byte0888_bgr(void *src)
    118 {
    119         int color = *(uint32_t *)(src);
    120         return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
    121             ((color >> 16) & 0xff);
    122 }
    123 
    124 static void rgb_byte888(void *dst, int rgb)
    125 {
    126         uint8_t *scr = (uint8_t *) dst;
    127 #if defined(FB_INVERT_ENDIAN)
    128         scr[0] = RED(rgb, 8);
    129         scr[1] = GREEN(rgb, 8);
    130         scr[2] = BLUE(rgb, 8);
    131 #else
    132         scr[2] = RED(rgb, 8);
    133         scr[1] = GREEN(rgb, 8);
    134         scr[0] = BLUE(rgb, 8);
    135 #endif
    136 }
    137 
    138 static int byte888_rgb(void *src)
    139 {
    140         uint8_t *scr = (uint8_t *) src;
    141 #if defined(FB_INVERT_ENDIAN)
    142         return scr[0] << 16 | scr[1] << 8 | scr[2];
    143 #else
    144         return scr[2] << 16 | scr[1] << 8 | scr[0];
    145 #endif 
    146 }
    147 
    148 /**  16-bit depth (5:5:5) */
    149 static void rgb_byte555(void *dst, int rgb)
    150 {
    151         /* 5-bit, 5-bits, 5-bits */
    152         *((uint16_t *) dst) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
    153             BLUE(rgb, 5);
    154 }
    155 
    156 /** 16-bit depth (5:5:5) */
    157 static int byte555_rgb(void *src)
    158 {
    159         int color = *(uint16_t *)(src);
    160         return (((color >> 10) & 0x1f) << (16 + 3)) |
    161             (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
    162 }
    163 
    164 /**  16-bit depth (5:6:5) */
    165 static void rgb_byte565(void *dst, int rgb)
    166 {
    167         /* 5-bit, 6-bits, 5-bits */
    168         *((uint16_t *) dst) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
    169             BLUE(rgb, 5);
    170 }
    171 
    172 /** 16-bit depth (5:6:5) */
    173 static int byte565_rgb(void *src)
    174 {
    175         int color = *(uint16_t *)(src);
    176         return (((color >> 11) & 0x1f) << (16 + 3)) |
    177             (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
    178 }
    179 
    180 /** Put pixel - 8-bit depth (color palette/3:2:3, inverted)
     131}
     132
     133
     134/** RGB 5:5:5 conversion
     135 *
     136 */
     137static void rgb_555(void *dst, uint32_t rgb)
     138{
     139        *((uint16_t *) dst)
     140            = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
     141}
     142
     143
     144/** RGB 5:6:5 conversion
     145 *
     146 */
     147static void rgb_565(void *dst, uint32_t rgb)
     148{
     149        *((uint16_t *) dst)
     150            = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
     151}
     152
     153
     154/** RGB 3:2:3
    181155 *
    182156 * Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
    … …  
    186160 * and setting it to simulate the 8-bit truecolor.
    187161 *
    188  * Currently we set the palette on the sparc64 port.
     162 * Currently we set the palette on the ia32 and sparc64 port.
    189163 *
    190164 * Note that the byte is being inverted by this function. The reason is
    … …  
    194168 * 0 and 255 to other colors.
    195169 */
    196 static void rgb_byte8(void *dst, int rgb)
    197 {
    198         *((uint8_t *) dst) = 255 - (RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 |
    199             BLUE(rgb, 3));
    200 }
    201 
    202 /** Return pixel color - 8-bit depth (color palette/3:2:3)
    203  *
    204  * See the comment for rgb_byte().
    205  */
    206 static int byte8_rgb(void *src)
    207 {
    208         int color = 255 - (*(uint8_t *)src);
    209         return (((color >> 5) & 0x7) << (16 + 5)) |
    210             (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
    211 }
    212 
    213 static void putpixel(unsigned int x, unsigned int y, int color)
    214 {
    215         (*rgb2scr)(&fbaddress[POINTPOS(x, y)], COLOR(color));
    216 
    217         if (dbbuffer) {
    218                 int dline = (y + dboffset) % yres;
    219                 (*rgb2scr)(&dbbuffer[POINTPOS(x, dline)], COLOR(color));
    220         }
    221 }
    222 
    223 /** Get pixel from viewport */
    224 static int getpixel(unsigned int x, unsigned int y)
    225 {
    226         if (dbbuffer) {
    227                 int dline = (y + dboffset) % yres;
    228                 return COLOR((*scr2rgb)(&dbbuffer[POINTPOS(x, dline)]));
    229         }
    230         return COLOR((*scr2rgb)(&fbaddress[POINTPOS(x, y)]));
    231 }
    232 
    233 
    234 /** Fill screen with background color */
    235 static void clear_screen(void)
    236 {
    237         unsigned int y;
    238 
    239         for (y = 0; y < yres; y++) {
    240                 memcpy(&fbaddress[scanline * y], blankline, xres * pixelbytes);
    241                 if (dbbuffer)
    242                         memcpy(&dbbuffer[scanline * y], blankline,
    243                             xres * pixelbytes);
    244         }
    245 }
    246 
    247 
    248 /** Scroll screen one row up */
     170static void rgb_323(void *dst, uint32_t rgb)
     171{
     172        *((uint8_t *) dst)
     173            = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
     174}
     175
     176
     177/** Draw character at given position
     178 *
     179 */
     180static void draw_glyph(uint8_t glyph, unsigned int col, unsigned int row)
     181{
     182        unsigned int x = COL2X(col);
     183        unsigned int y = ROW2Y(row);
     184        unsigned int yd;
     185       
     186        backbuf[BB_POS(col, row)] = glyph;
     187       
     188        for (yd = 0; yd < FONT_SCANLINES; yd++)
     189                memcpy(&fb_addr[FB_POS(x, y + yd)],
     190                    &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
     191}
     192
     193
     194/** Scroll screen down by one row
     195 *
     196 *
     197 */
    249198static void scroll_screen(void)
    250199{
    251         if (dbbuffer) {
    252                 count_t first;
     200        unsigned int row;
     201       
     202        for (row = 0; row < rows; row++) {
     203                unsigned int y = ROW2Y(row);
     204                unsigned int yd;
    253205               
    254                 /* Clear the last row */
    255                 memcpy(&dbbuffer[dboffset * scanline], blankline, ROW_BYTES);
    256                
    257                 dboffset = (dboffset + FONT_SCANLINES) % yres;
    258                 first = yres - dboffset;
    259                
    260                 /* Move all rows one row up */
    261                 if (xres * pixelbytes == scanline) {
    262                         memcpy(fbaddress, &dbbuffer[dboffset * scanline],
    263                             first * scanline);
    264                         memcpy(&fbaddress[first * scanline], dbbuffer,
    265                             dboffset * scanline);
    266                 } else {
    267                         /*
    268                          * When the scanline is bigger than number of bytes
    269                          * in the X-resolution, chances are that the
    270                          * frame buffer memory past the X-resolution is special
    271                          * in some way. For example, the SUNW,ffb framebuffer
    272                          * wraps this area around the beginning of the same
    273                          * line. To avoid troubles, copy only memory as
    274                          * specified by the resolution.
    275                          */
    276                         unsigned int i;
    277 
    278                         for (i = 0; i < first; i++)
    279                                 memcpy(&fbaddress[i * scanline],
    280                                     &dbbuffer[(dboffset + i) * scanline],
    281                                     xres * pixelbytes);
    282                         for (i = 0; i < dboffset; i++)
    283                                 memcpy(&fbaddress[(first + i) * scanline],
    284                                     &dbbuffer[i * scanline], xres * pixelbytes);
     206                for (yd = 0; yd < FONT_SCANLINES; yd++) {
     207                        unsigned int x;
     208                        unsigned int col;
     209                       
     210                        for (col = 0, x = 0; col < cols; col++, x += FONT_WIDTH) {
     211                                uint8_t glyph;
     212                               
     213                                if (row < rows - 1) {
     214                                        if (backbuf[BB_POS(col, row)] == backbuf[BB_POS(col, row + 1)])
     215                                                continue;
     216                                       
     217                                        glyph = backbuf[BB_POS(col, row + 1)];
     218                                } else
     219                                        glyph = 0;
     220                               
     221                                memcpy(&fb_addr[FB_POS(x, y + yd)],
     222                                    &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
     223                        }
    285224                }
    286         } else {
    287                 uint8_t *lastline = &fbaddress[(rows - 1) * ROW_BYTES];
    288                
    289                 if (xres * pixelbytes == scanline) {
    290                         /* Move all rows one row up */
    291                         memcpy((void *) fbaddress,
    292                             (void *) &fbaddress[ROW_BYTES],
    293                             scanline * yres - ROW_BYTES);
    294                         /* Clear the last row */
    295                         memcpy((void *) lastline, (void *) blankline,
    296                             ROW_BYTES);
    297                 } else {
    298                         /*
    299                          * See the comment in the dbbuffer case.
    300                          */
    301                         unsigned int i;
    302 
    303                         /* Move all rows one row up */
    304                         for (i = 0; i < yres - FONT_SCANLINES; i++)
    305                                 memcpy(&fbaddress[i * scanline],
    306                                     &fbaddress[(i + FONT_SCANLINES) * scanline],
    307                                     xres * pixelbytes);
    308                         /* Clear the last row */
    309                         for (i = 0; i < FONT_SCANLINES; i++)
    310                                 memcpy(&lastline[i * scanline],
    311                                     &blankline[i * scanline],
    312                                     xres * pixelbytes);
    313                 }
    314         }
    315 }
    316 
    317 
    318 static void invert_pixel(unsigned int x, unsigned int y)
    319 {
    320         putpixel(x, y, ~getpixel(x, y));
    321 }
    322 
    323 
    324 /** Draw one line of glyph at a given position */
    325 static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)
    326 {
    327         unsigned int i;
    328 
    329         for (i = 0; i < 8; i++)
    330                 if (glline & (1 << (7 - i))) {
    331                         putpixel(x + i, y, FGCOLOR);
    332                 } else
    333                         putpixel(x + i, y, BGCOLOR);
    334 }
    335 
    336 /***************************************************************/
    337 /* Character-console functions */
    338 
    339 /** Draw character at given position */
    340 static void draw_glyph(uint8_t glyph, unsigned int col, unsigned int row)
    341 {
    342         unsigned int y;
    343 
    344         for (y = 0; y < FONT_SCANLINES; y++)
    345                 draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y],
    346                     col * COL_WIDTH, row * FONT_SCANLINES + y);
    347 }
    348 
    349 /** Invert character at given position */
    350 static void invert_char(unsigned int col, unsigned int row)
    351 {
    352         unsigned int x;
    353         unsigned int y;
    354 
    355         for (x = 0; x < COL_WIDTH; x++)
    356                 for (y = 0; y < FONT_SCANLINES; y++)
    357                         invert_pixel(col * COL_WIDTH + x,
    358                             row * FONT_SCANLINES + y);
    359 }
    360 
    361 /** Draw character at default position */
    362 static void draw_char(char chr)
    363 {
    364         draw_glyph(chr, position % columns, position / columns);
    365 }
    366 
    367 static void draw_logo(unsigned int startx, unsigned int starty)
    368 {
    369         unsigned int x;
    370         unsigned int y;
    371         unsigned int byte;
    372         unsigned int rowbytes;
    373 
    374         rowbytes = (helenos_width - 1) / 8 + 1;
    375 
    376         for (y = 0; y < helenos_height; y++)
    377                 for (x = 0; x < helenos_width; x++) {
    378                         byte = helenos_bits[rowbytes * y + x / 8];
    379                         byte >>= x % 8;
    380                         if (byte & 1)
    381                                 putpixel(startx + x, starty + y,
    382                                     COLOR(LOGOCOLOR));
    383                 }
    384 }
    385 
    386 /***************************************************************/
    387 /* Stdout specific functions */
    388 
    389 static void invert_cursor(void)
    390 {
    391         invert_char(position % columns, position / columns);
    392 }
     225        }
     226       
     227        memcpy(backbuf, backbuf + cols, cols * (rows - 1));
     228        memsetb(&backbuf[BB_POS(0, rows - 1)], cols, 0);
     229}
     230
     231
     232static void cursor_put(void)
     233{
     234        draw_glyph(CURSOR, position % cols, position / cols);
     235}
     236
     237
     238static void cursor_remove(void)
     239{
     240        draw_glyph(0, position % cols, position / cols);
     241}
     242
    393243
    394244/** Print character to screen
    395245 *
    396  *  Emulate basic terminal commands
     246 * Emulate basic terminal commands.
     247 *
    397248 */
    398249static void fb_putchar(chardev_t *dev, char ch)
    … …  
    402253        switch (ch) {
    403254        case '\n':
    404                 invert_cursor();
    405                 position += columns;
    406                 position -= position % columns;
     255                cursor_remove();
     256                position += cols;
     257                position -= position % cols;
    407258                break;
    408259        case '\r':
    409                 invert_cursor();
    410                 position -= position % columns;
     260                cursor_remove();
     261                position -= position % cols;
    411262                break;
    412263        case '\b':
    413                 invert_cursor();
    414                 if (position % columns)
     264                cursor_remove();
     265                if (position % cols)
    415266                        position--;
    416267                break;
    417268        case '\t':
    418                 invert_cursor();
     269                cursor_remove();
    419270                do {
    420                         draw_char(' ');
     271                        draw_glyph((uint8_t) ' ', position % cols, position / cols);
    421272                        position++;
    422                 } while ((position % 8) && position < columns * rows);
     273                } while ((position % 8) && (position < cols * rows));
    423274                break;
    424275        default:
    425                 draw_char(ch);
     276                draw_glyph((uint8_t) ch, position % cols, position / cols);
    426277                position++;
    427278        }
    428279       
    429         if (position >= columns * rows) {
    430                 position -= columns;
     280        if (position >= cols * rows) {
     281                position -= cols;
    431282                scroll_screen();
    432283        }
    433284       
    434         invert_cursor();
     285        cursor_put();
    435286       
    436287        spinlock_unlock(&fb_lock);
    … …  
    443294
    444295
     296/** Render glyphs
     297 *
     298 * Convert glyphs from device independent font
     299 * description to current visual representation.
     300 *
     301 */
     302static void render_glyphs(void)
     303{
     304        unsigned int glyph;
     305       
     306        for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
     307                unsigned int y;
     308               
     309                for (y = 0; y < FONT_SCANLINES; y++) {
     310                        unsigned int x;
     311                       
     312                        for (x = 0; x < FONT_WIDTH; x++)
     313                                rgb_conv(&glyphs[GLYPH_POS(glyph, y) + x * pixelbytes],
     314                                    (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x))) ? FG_COLOR : BG_COLOR);
     315                }
     316        }
     317       
     318        rgb_conv(bgpixel, BG_COLOR);
     319}
     320
     321
     322/** Refresh the screen
     323 *
     324 */
     325void fb_redraw(void)
     326{
     327        unsigned int row;
     328       
     329        for (row = 0; row < rows; row++) {
     330                unsigned int y = ROW2Y(row);
     331                unsigned int yd;
     332               
     333                for (yd = 0; yd < FONT_SCANLINES; yd++) {
     334                        unsigned int x;
     335                        unsigned int col;
     336                       
     337                        for (col = 0, x = 0; col < cols; col++, x += FONT_WIDTH)
     338                                memcpy(&fb_addr[FB_POS(x, y + yd)],
     339                            &glyphs[GLYPH_POS(backbuf[BB_POS(col, row)], yd)],
     340                            glyphscanline);
     341                }
     342        }
     343       
     344        if (COL2X(cols) < xres) {
     345                unsigned int y;
     346               
     347                for (y = 0; y < yres; y++) {
     348                        unsigned int x;
     349                       
     350                        for (x = COL2X(cols); x < xres; x++)
     351                                memcpy(&fb_addr[FB_POS(x, y)], bgpixel, pixelbytes);
     352                }
     353        }
     354       
     355        if (ROW2Y(rows) < yres) {
     356                unsigned int y;
     357               
     358                for (y = ROW2Y(rows); y < yres; y++) {
     359                        unsigned int x;
     360                       
     361                        for (x = 0; x < xres; x++)
     362                                memcpy(&fb_addr[FB_POS(x, y)], bgpixel, pixelbytes);
     363                }
     364        }
     365}
     366
     367
    445368/** Initialize framebuffer as a chardev output device
    446369 *
    447  * @param props         Properties of the framebuffer device.
     370 * @param addr   Physical address of the framebuffer
     371 * @param x      Screen width in pixels
     372 * @param y      Screen height in pixels
     373 * @param scan   Bytes per one scanline
     374 * @param visual Color model
     375 *
    448376 */
    449377void fb_init(fb_properties_t *props)
    … …  
    451379        switch (props->visual) {
    452380        case VISUAL_INDIRECT_8:
    453                 rgb2scr = rgb_byte8;
    454                 scr2rgb = byte8_rgb;
     381                rgb_conv = rgb_323;
    455382                pixelbytes = 1;
    456383                break;
    457384        case VISUAL_RGB_5_5_5:
    458                 rgb2scr = rgb_byte555;
    459                 scr2rgb = byte555_rgb;
     385                rgb_conv = rgb_555;
    460386                pixelbytes = 2;
    461387                break;
    462388        case VISUAL_RGB_5_6_5:
    463                 rgb2scr = rgb_byte565;
    464                 scr2rgb = byte565_rgb;
     389                rgb_conv = rgb_565;
    465390                pixelbytes = 2;
    466391                break;
    467392        case VISUAL_RGB_8_8_8:
    468                 rgb2scr = rgb_byte888;
    469                 scr2rgb = byte888_rgb;
     393                rgb_conv = rgb_888;
    470394                pixelbytes = 3;
    471395                break;
    472396        case VISUAL_RGB_8_8_8_0:
    473                 rgb2scr = rgb_byte888;
    474                 scr2rgb = byte888_rgb;
     397                rgb_conv = rgb_888;
    475398                pixelbytes = 4;
    476399                break;
    477400        case VISUAL_RGB_0_8_8_8:
    478                 rgb2scr = rgb_byte0888;
    479                 scr2rgb = byte0888_rgb;
     401                rgb_conv = rgb_0888;
    480402                pixelbytes = 4;
    481403                break;
    482404        case VISUAL_BGR_0_8_8_8:
    483                 rgb2scr = bgr_byte0888;
    484                 scr2rgb = byte0888_bgr;
     405                rgb_conv = bgr_0888;
    485406                pixelbytes = 4;
    486407                break;
    … …  
    488409                panic("Unsupported visual.\n");
    489410        }
    490        
    491         unsigned int fbsize = props->scan * props->y;
    492        
    493         /* Map the framebuffer */
    494         fbaddress = (uint8_t *) hw_map((uintptr_t) props->addr,
    495                 fbsize + props->offset);
    496         fbaddress += props->offset;
    497411       
    498412        xres = props->x;
    … …  
    500414        scanline = props->scan;
    501415       
    502         rows = props->y / FONT_SCANLINES;
    503         columns = props->x / COL_WIDTH;
    504 
     416        cols = xres / FONT_WIDTH;
     417        rows = yres / FONT_SCANLINES;
     418       
     419        glyphscanline = FONT_WIDTH * pixelbytes;
     420        glyphbytes = glyphscanline * FONT_SCANLINES;
     421       
     422        unsigned int fbsize = scanline * yres;
     423        unsigned int bbsize = cols * rows;
     424        unsigned int glyphsize = FONT_GLYPHS * glyphbytes;
     425       
     426        backbuf = (uint8_t *) malloc(bbsize, 0);
     427        if (!backbuf)
     428                panic("Unable to allocate backbuffer.\n");
     429       
     430        glyphs = (uint8_t *) malloc(glyphsize, 0);
     431        if (!glyphs)
     432                panic("Unable to allocate glyphs.\n");
     433       
     434        bgpixel = malloc(pixelbytes, 0);
     435        if (!bgpixel)
     436                panic("Unable to allocate background pixel.\n");
     437       
     438        memsetb(backbuf, bbsize, 0);
     439        memsetb(glyphs, glyphsize, 0);
     440        memsetb(bgpixel, pixelbytes, 0);
     441       
     442        render_glyphs();
     443       
     444        fb_addr = (uint8_t *) hw_map((uintptr_t) props->addr, fbsize);
     445       
    505446        fb_parea.pbase = (uintptr_t) props->addr + props->offset;
    506         fb_parea.vbase = (uintptr_t) fbaddress;
     447        fb_parea.vbase = (uintptr_t) fb_addr;
    507448        fb_parea.frames = SIZE2FRAMES(fbsize);
    508449        fb_parea.cacheable = false;
    509450        ddi_parea_register(&fb_parea);
    510 
     451       
    511452        sysinfo_set_item_val("fb", NULL, true);
    512453        sysinfo_set_item_val("fb.kind", NULL, 1);
    513454        sysinfo_set_item_val("fb.width", NULL, xres);
    514455        sysinfo_set_item_val("fb.height", NULL, yres);
    515         sysinfo_set_item_val("fb.scanline", NULL, props->scan);
     456        sysinfo_set_item_val("fb.scanline", NULL, scanline);
    516457        sysinfo_set_item_val("fb.visual", NULL, props->visual);
    517458        sysinfo_set_item_val("fb.address.physical", NULL, props->addr);
    518         sysinfo_set_item_val("fb.offset", NULL, props->offset);
    519         sysinfo_set_item_val("fb.invert-colors", NULL, invert_colors);
    520 
    521         /* Allocate double buffer */
    522         unsigned int order = fnzb(SIZE2FRAMES(fbsize) - 1) + 1;
    523         dbbuffer = (uint8_t *) frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
    524         if (!dbbuffer)
    525                 printf("Failed to allocate scroll buffer.\n");
    526         dboffset = 0;
    527 
    528         /* Initialized blank line */
    529         blankline = (uint8_t *) malloc(ROW_BYTES, FRAME_ATOMIC);
    530         if (!blankline)
    531                 panic("Failed to allocate blank line for framebuffer.");
    532         unsigned int x, y;
    533         for (y = 0; y < FONT_SCANLINES; y++)
    534                 for (x = 0; x < xres; x++)
    535                         (*rgb2scr)(&blankline[POINTPOS(x, y)], COLOR(BGCOLOR));
    536        
    537         clear_screen();
    538 
    539         /* Update size of screen to match text area */
    540         yres = rows * FONT_SCANLINES;
    541 
    542         draw_logo(xres - helenos_width, 0);
    543         invert_cursor();
    544 
     459       
     460        fb_redraw();
     461       
    545462        chardev_initialize("fb", &framebuffer, &fb_ops);
    546463        stdout = &framebuffer;
Note: See TracChangeset for help on using the changeset viewer.