WebSVN – HelenOS – Diff – /branches/dd/kernel/genarch/src/fb/fb.c

 /*
+ * Copyright (c) 2008 Martin Decky
  * 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
  * 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.
  */
 /** @addtogroup genarch
  * @{
  */
 /** @file
  */
 #include <genarch/fb/font-8x16.h>
+#include <genarch/fb/logo-196x66.h>
 #include <genarch/fb/visuals.h>
 #include <genarch/fb/fb.h>
 #include <console/chardev.h>
 #include <console/console.h>
 #include <sysinfo/sysinfo.h>
 #include <mm/slab.h>
+#include <align.h>
 #include <panic.h>
 #include <memstr.h>
 #include <config.h>
 #include <bitops.h>
 #include <print.h>
 #include <ddi/ddi.h>
 #include <arch/types.h>
-#include "helenos.xbm"
+SPINLOCK_INITIALIZE(fb_lock);
+static uint8_t *fb_addr;
+static uint8_t *backbuf;
+static uint8_t *glyphs;
+static uint8_t *bgscan;
+static unsigned int xres;
+static unsigned int yres;
+static unsigned int ylogo;
+static unsigned int ytrim;
+static unsigned int rowtrim;
+static unsigned int scanline;
+static unsigned int glyphscanline;
+static unsigned int pixelbytes;
+static unsigned int glyphbytes;
-static parea_t fb_parea;        /**< Physical memory area for fb. */
+static unsigned int bgscanbytes;
+static unsigned int cols;
-SPINLOCK_INITIALIZE(fb_lock);
+static unsigned int rows;
+static unsigned int position = 0;
+#define BG_COLOR     0x000080
-static uint8_t *fbaddress = NULL;
+#define FG_COLOR     0xffff00
-static uint8_t *blankline = NULL;
-static uint8_t *dbbuffer = NULL;    /* Buffer for fast scrolling console */
-static index_t dboffset;
-static unsigned int xres = 0;
-static unsigned int yres = 0;
-static unsigned int scanline = 0;
-static unsigned int pixelbytes = 0;
-#ifdef FB_INVERT_COLORS
+#define CURSOR       219
-static bool invert_colors = true;
-#else
-static bool invert_colors = false;
-#endif
-static unsigned int position = 0;
+#define RED(x, bits)         ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
-static unsigned int columns = 0;
+#define GREEN(x, bits)       ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
-static unsigned int rows = 0;
+#define BLUE(x, bits)        ((x >> (8 - bits)) & ((1 << bits) - 1))
-#define COL_WIDTH   8
+#define COL2X(col)           ((col) * FONT_WIDTH)
-#define ROW_BYTES   (scanline * FONT_SCANLINES)
+#define ROW2Y(row)           ((row) * FONT_SCANLINES)
-#define BGCOLOR     0x000080
-#define FGCOLOR     0xffff00
+#define X2COL(x)             ((x) / FONT_WIDTH)
-#define LOGOCOLOR   0x2020b0
+#define Y2ROW(y)             ((y) / FONT_SCANLINES)
-#define RED(x, bits)    ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
+#define FB_POS(x, y)         ((y) * scanline + (x) * pixelbytes)
-#define GREEN(x, bits)  ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
+#define BB_POS(col, row)     ((row) * cols + (col))
-#define BLUE(x, bits)   ((x >> (8 - bits)) & ((1 << bits) - 1))
+#define GLYPH_POS(glyph, y)  ((glyph) * glyphbytes + (y) * glyphscanline)
-#define POINTPOS(x, y)  ((y) * scanline + (x) * pixelbytes)
-/***************************************************************/
-/* Pixel specific fuctions */
+static void (*rgb_conv)(void *, uint32_t);
-static void (*rgb2scr)(void *, int);
-static int (*scr2rgb)(void *);
+/** ARGB 8:8:8:8 conversion
+ *
+ */
-static inline int COLOR(int color)
+static void rgb_0888(void *dst, uint32_t rgb)
+{
-    return invert_colors ? ~color : color;
+    *((uint32_t *) dst) = rgb & 0xffffff;
+}
-/* Conversion routines between different color representations */
-static void rgb_byte0888(void *dst, int rgb)
-{
-    *((int *) dst) = rgb;
-}
+/** ABGR 8:8:8:8 conversion
+ *
+ */
-static int byte0888_rgb(void *src)
+static void bgr_0888(void *dst, uint32_t rgb)
+{
-    return (*((int *) src)) & 0xffffff;
+    *((uint32_t *) dst)
+        = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
+}
-static void bgr_byte0888(void *dst, int rgb)
-{
-    *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
-        RED(rgb, 8);
-}
+/** RGB 8:8:8 conversion
+ *
+ */
-static int byte0888_bgr(void *src)
+static void rgb_888(void *dst, uint32_t rgb)
+{
-    int color = *(uint32_t *)(src);
+    ((uint8_t *) dst)[0] = BLUE(rgb, 8);
-    return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
+    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
-        ((color >> 16) & 0xff);
+    ((uint8_t *) dst)[2] = RED(rgb, 8);
+}
-static void rgb_byte888(void *dst, int rgb)
-{
-    uint8_t *scr = (uint8_t *) dst;
-#if defined(FB_INVERT_ENDIAN)
-    scr[0] = RED(rgb, 8);
-    scr[1] = GREEN(rgb, 8);
-    scr[2] = BLUE(rgb, 8);
-#else
-    scr[2] = RED(rgb, 8);
-    scr[1] = GREEN(rgb, 8);
-    scr[0] = BLUE(rgb, 8);
-#endif
-}
+/** BGR 8:8:8 conversion
+ *
+ */
-static int byte888_rgb(void *src)
+static void bgr_888(void *dst, uint32_t rgb)
+{
-    uint8_t *scr = (uint8_t *) src;
+    ((uint8_t *) dst)[0] = RED(rgb, 8);
-#if defined(FB_INVERT_ENDIAN)
-    return scr[0] << 16 | scr[1] << 8 | scr[2];
+    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
-#else
-    return scr[2] << 16 | scr[1] << 8 | scr[0];
+    ((uint8_t *) dst)[2] = BLUE(rgb, 8);
-#endif
+}
-/**  16-bit depth (5:5:5) */
-static void rgb_byte555(void *dst, int rgb)
-{
-    /* 5-bit, 5-bits, 5-bits */
-    *((uint16_t *) dst) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
-        BLUE(rgb, 5);
-}
-/** 16-bit depth (5:5:5) */
+/** RGB 5:5:5 conversion
+ *
+ */
-static int byte555_rgb(void *src)
+static void rgb_555(void *dst, uint32_t rgb)
+{
-    int color = *(uint16_t *)(src);
+    *((uint16_t *) dst)
-    return (((color >> 10) & 0x1f) << (16 + 3)) |
-        (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
+        = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
+}
-/**  16-bit depth (5:6:5) */
-static void rgb_byte565(void *dst, int rgb)
-{
-    /* 5-bit, 6-bits, 5-bits */
-    *((uint16_t *) dst) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
-        BLUE(rgb, 5);
-}
-/** 16-bit depth (5:6:5) */
+/** RGB 5:6:5 conversion
+ *
+ */
-static int byte565_rgb(void *src)
+static void rgb_565(void *dst, uint32_t rgb)
+{
-    int color = *(uint16_t *)(src);
+    *((uint16_t *) dst)
-    return (((color >> 11) & 0x1f) << (16 + 3)) |
-        (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
+        = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
+}
-/** Put pixel - 8-bit depth (color palette/3:2:3)
+/** RGB 3:2:3
+ *
  * Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
  * will most likely use a color palette. The color appearance
  * will be pretty random and depend on the default installed
  * palette. This could be fixed by supporting custom palette
  * and setting it to simulate the 8-bit truecolor.
+ *
+ * Currently we set the palette on the ia32, amd64 and sparc64 port.
+ *
+ * Note that the byte is being inverted by this function. The reason is
+ * that we would like to use a color palette where the white color code
+ * is 0 and the black color code is 255, as some machines (Sun Blade 1500)
+ * use these codes for black and white and prevent to set codes
+ * 0 and 255 to other colors.
+ *
  */
-static void rgb_byte8(void *dst, int rgb)
+static void rgb_323(void *dst, uint32_t rgb)
+{
-    *((uint8_t *) dst) = RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 |
+    *((uint8_t *) dst)
-        BLUE(rgb, 3);
+        = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
+}
-/** Return pixel color - 8-bit depth (color palette/3:2:3)
+/** Hide logo and refresh screen
+ *
- * See the comment for rgb_byte().
  */
-static int byte8_rgb(void *src)
+static void logo_hide(bool silent)
+{
+    ylogo = 0;
-    int color = *(uint8_t *)src;
+    ytrim = yres;
-    return (((color >> 5) & 0x7) << (16 + 5)) |
+    rowtrim = rows;
+    if (!silent)
-        (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
+        fb_redraw();
+}
-static void putpixel(unsigned int x, unsigned int y, int color)
-{
-    (*rgb2scr)(&fbaddress[POINTPOS(x, y)], COLOR(color));
-    if (dbbuffer) {
-        int dline = (y + dboffset) % yres;
+/** Draw character at given position
-        (*rgb2scr)(&dbbuffer[POINTPOS(x, dline)], COLOR(color));
-    }
+ *
-}
+ */
-/** Get pixel from viewport */
-static int getpixel(unsigned int x, unsigned int y)
+static void glyph_draw(uint8_t glyph, unsigned int col, unsigned int row, bool silent)
+{
+    unsigned int x = COL2X(col);
+    unsigned int y = ROW2Y(row);
+    unsigned int yd;
+    if (y >= ytrim)
+        logo_hide(silent);
+    backbuf[BB_POS(col, row)] = glyph;
-    if (dbbuffer) {
+    if (!silent) {
-        int dline = (y + dboffset) % yres;
+        for (yd = 0; yd < FONT_SCANLINES; yd++)
+            memcpy(&fb_addr[FB_POS(x, y + yd + ylogo)],
-        return COLOR((*scr2rgb)(&dbbuffer[POINTPOS(x, dline)]));
+                &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
+    }
-    return COLOR((*scr2rgb)(&fbaddress[POINTPOS(x, y)]));
+}
-/** Fill screen with background color */
+/** Scroll screen down by one row
+ *
+ *
+ */
-static void clear_screen(void)
+static void screen_scroll(bool silent)
+{
-    unsigned int y;
-    for (y = 0; y < yres; y++) {
+    if (ylogo > 0) {
-        memcpy(&fbaddress[scanline * y], blankline, xres * pixelbytes);
-        if (dbbuffer)
+        logo_hide(silent);
-            memcpy(&dbbuffer[scanline * y], blankline,
-                xres * pixelbytes);
+        return;
+    }
-}
-/** Scroll screen one row up */
-static void scroll_screen(void)
-{
-    if (dbbuffer) {
+    if (!silent) {
-        count_t first;
-        /* Clear the last row */
-        memcpy(&dbbuffer[dboffset * scanline], blankline, ROW_BYTES);
-        dboffset = (dboffset + FONT_SCANLINES) % yres;
-        first = yres - dboffset;
-        /* Move all rows one row up */
-        if (xres * pixelbytes == scanline) {
-            memcpy(fbaddress, &dbbuffer[dboffset * scanline],
-                first * scanline);
-            memcpy(&fbaddress[first * scanline], dbbuffer,
-                dboffset * scanline);
-        } else {
-            /*
-             * When the scanline is bigger than number of bytes
-             * in the X-resolution, chances are that the
-             * frame buffer memory past the X-resolution is special
-             * in some way. For example, the SUNW,ffb framebuffer
-             * wraps this area around the beginning of the same
-             * line. To avoid troubles, copy only memory as
-             * specified by the resolution.
-             */
-            unsigned int i;
+        unsigned int row;
-            for (i = 0; i < first; i++)
-                memcpy(&fbaddress[i * scanline],
-                    &dbbuffer[(dboffset + i) * scanline],
-                    xres * pixelbytes);
-            for (i = 0; i < dboffset; i++)
-                memcpy(&fbaddress[(first + i) * scanline],
-                    &dbbuffer[i * scanline], xres * pixelbytes);
-        }
-    } else {
-        uint8_t *lastline = &fbaddress[(rows - 1) * ROW_BYTES];
-        if (xres * pixelbytes == scanline) {
+        for (row = 0; row < rows; row++) {
-            /* Move all rows one row up */
+            unsigned int y = ROW2Y(row);
-            memcpy((void *) fbaddress,
+            unsigned int yd;
-                (void *) &fbaddress[ROW_BYTES],
+            for (yd = 0; yd < FONT_SCANLINES; yd++) {
-                scanline * yres - ROW_BYTES);
+                unsigned int x;
-            /* Clear the last row */
+                unsigned int col;
-            memcpy((void *) lastline, (void *) blankline,
+                for (col = 0, x = 0; col < cols; col++,
-                ROW_BYTES);
+                    x += FONT_WIDTH) {
-        } else {
+                    uint8_t glyph;
-            /*
-             * See the comment in the dbbuffer case.
-             */
-            unsigned int i;
+                    if (row < rows - 1) {
-            /* Move all rows one row up */
+                        if (backbuf[BB_POS(col, row)] ==
-            for (i = 0; i < yres - FONT_SCANLINES; i++)
+                            backbuf[BB_POS(col, row + 1)])
-                memcpy(&fbaddress[i * scanline],
+                            continue;
-                    &fbaddress[(i + FONT_SCANLINES) * scanline],
+                        glyph = backbuf[BB_POS(col, row + 1)];
-                    xres * pixelbytes);
+                    } else
-            /* Clear the last row */
+                        glyph = 0;
-            for (i = 0; i < FONT_SCANLINES; i++)
-                memcpy(&lastline[i * scanline],
+                    memcpy(&fb_addr[FB_POS(x, y + yd)],
-                    &blankline[i * scanline],
+                        &glyphs[GLYPH_POS(glyph, yd)],
-                    xres * pixelbytes);
+                        glyphscanline);
+                }
+            }
+        }
+    }
+    memmove(backbuf, backbuf + cols, cols * (rows - 1));
+    memsetb(&backbuf[BB_POS(0, rows - 1)], cols, 0);
+}
-static void invert_pixel(unsigned int x, unsigned int y)
-{
-    putpixel(x, y, ~getpixel(x, y));
-}
-/** Draw one line of glyph at a given position */
-static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)
-{
-    unsigned int i;
-    for (i = 0; i < 8; i++)
-        if (glline & (1 << (7 - i))) {
-            putpixel(x + i, y, FGCOLOR);
-        } else
-            putpixel(x + i, y, BGCOLOR);
-}
-/***************************************************************/
-/* Character-console functions */
-/** Draw character at given position */
-static void draw_glyph(uint8_t glyph, unsigned int col, unsigned int row)
-{
-    unsigned int y;
-    for (y = 0; y < FONT_SCANLINES; y++)
-        draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y],
-            col * COL_WIDTH, row * FONT_SCANLINES + y);
-}
-/** Invert character at given position */
-static void invert_char(unsigned int col, unsigned int row)
+static void cursor_put(bool silent)
+{
-    unsigned int x;
-    unsigned int y;
-    for (x = 0; x < COL_WIDTH; x++)
-        for (y = 0; y < FONT_SCANLINES; y++)
+    glyph_draw(CURSOR, position % cols, position / cols, silent);
-            invert_pixel(col * COL_WIDTH + x,
-                row * FONT_SCANLINES + y);
+}
-/** Draw character at default position */
-static void draw_char(char chr)
-{
-    draw_glyph(chr, position % columns, position / columns);
-}
-static void draw_logo(unsigned int startx, unsigned int starty)
+static void cursor_remove(bool silent)
+{
-    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];
+    glyph_draw(0, position % cols, position / cols, silent);
-            byte >>= x % 8;
-            if (byte & 1)
-                putpixel(startx + x, starty + y,
-                    COLOR(LOGOCOLOR));
-        }
+}
-/***************************************************************/
-/* Stdout specific functions */
-static void invert_cursor(void)
-{
-    invert_char(position % columns, position / columns);
-}
 /** Print character to screen
+ *
- *  Emulate basic terminal commands
+ * Emulate basic terminal commands.
+ *
  */
-static void fb_putchar(chardev_t *dev, char ch)
+static void fb_putchar(chardev_t *dev, char ch, bool silent)
+{
     spinlock_lock(&fb_lock);
     switch (ch) {
     case '\n':
-        invert_cursor();
+        cursor_remove(silent);
-        position += columns;
+        position += cols;
-        position -= position % columns;
+        position -= position % cols;
         break;
     case '\r':
-        invert_cursor();
+        cursor_remove(silent);
-        position -= position % columns;
+        position -= position % cols;
         break;
     case '\b':
-        invert_cursor();
+        cursor_remove(silent);
-        if (position % columns)
+        if (position % cols)
             position--;
         break;
     case '\t':
-        invert_cursor();
+        cursor_remove(silent);
         do {
+            glyph_draw((uint8_t) ' ', position % cols,
-            draw_char(' ');
+                position / cols, silent);
             position++;
-        } while ((position % 8) && position < columns * rows);
+        } while ((position % 8) && (position < cols * rows));
         break;
     default:
+        glyph_draw((uint8_t) ch, position % cols,
-        draw_char(ch);
+            position / cols, silent);
         position++;
+    }
-    if (position >= columns * rows) {
+    if (position >= cols * rows) {
-        position -= columns;
+        position -= cols;
-        scroll_screen();
+        screen_scroll(silent);
+    }
-    invert_cursor();
+    cursor_put(silent);
     spinlock_unlock(&fb_lock);
+}
 static chardev_t framebuffer;
 static chardev_operations_t fb_ops = {
     .write = fb_putchar,
 };
+/** Render glyphs
+ *
+ * Convert glyphs from device independent font
+ * description to current visual representation.
+ *
+ */
+static void glyphs_render(void)
+{
+    /* Prerender glyphs */
+    unsigned int glyph;
+    for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
+        unsigned int y;
+        for (y = 0; y < FONT_SCANLINES; y++) {
+            unsigned int x;
+            for (x = 0; x < FONT_WIDTH; x++) {
+                void *dst = &glyphs[GLYPH_POS(glyph, y) +
+                    x * pixelbytes];
+                uint32_t rgb = (fb_font[ROW2Y(glyph) + y] &
+                    (1 << (7 - x))) ? FG_COLOR : BG_COLOR;
+                rgb_conv(dst, rgb);
+            }
+        }
+    }
+    /* Prerender background scanline */
+    unsigned int x;
+    for (x = 0; x < xres; x++)
+        rgb_conv(&bgscan[x * pixelbytes], BG_COLOR);
+}
+/** Refresh the screen
+ *
+ */
+void fb_redraw(void)
+{
+    if (ylogo > 0) {
+        unsigned int y;
+        for (y = 0; y < LOGO_HEIGHT; y++) {
+            unsigned int x;
+            for (x = 0; x < xres; x++)
+                rgb_conv(&fb_addr[FB_POS(x, y)],
+                    (x < LOGO_WIDTH) ?
+                    fb_logo[y * LOGO_WIDTH + x] :
+                    LOGO_COLOR);
+        }
+    }
+    unsigned int row;
+    for (row = 0; row < rowtrim; row++) {
+        unsigned int y = ylogo + ROW2Y(row);
+        unsigned int yd;
+        for (yd = 0; yd < FONT_SCANLINES; yd++) {
+            unsigned int x;
+            unsigned int col;
+            for (col = 0, x = 0; col < cols;
+                col++, x += FONT_WIDTH) {
+                void *d = &fb_addr[FB_POS(x, y + yd)];
+                void *s = &glyphs[GLYPH_POS(backbuf[BB_POS(col,
+                    row)], yd)];
+                memcpy(d, s, glyphscanline);
+            }
+        }
+    }
+    if (COL2X(cols) < xres) {
+        unsigned int y;
+        unsigned int size = (xres - COL2X(cols)) * pixelbytes;
+        for (y = ylogo; y < yres; y++)
+            memcpy(&fb_addr[FB_POS(COL2X(cols), y)], bgscan, size);
+    }
+    if (ROW2Y(rowtrim) + ylogo < yres) {
+        unsigned int y;
+        for (y = ROW2Y(rowtrim) + ylogo; y < yres; y++)
+            memcpy(&fb_addr[FB_POS(0, y)], bgscan, bgscanbytes);
+    }
+}
 /** Initialize framebuffer as a chardev output device
+ *
  * @param addr   Physical address of the framebuffer
  * @param x      Screen width in pixels
  * @param y      Screen height in pixels
  * @param scan   Bytes per one scanline
  * @param visual Color model
+ *
  */
-void fb_init(uintptr_t addr, unsigned int x, unsigned int y, unsigned int scan,
-    unsigned int visual)
+void fb_init(fb_properties_t *props)
+{
-    switch (visual) {
+    switch (props->visual) {
     case VISUAL_INDIRECT_8:
-        rgb2scr = rgb_byte8;
+        rgb_conv = rgb_323;
-        scr2rgb = byte8_rgb;
         pixelbytes = 1;
         break;
     case VISUAL_RGB_5_5_5:
-        rgb2scr = rgb_byte555;
+        rgb_conv = rgb_555;
-        scr2rgb = byte555_rgb;
         pixelbytes = 2;
         break;
     case VISUAL_RGB_5_6_5:
-        rgb2scr = rgb_byte565;
+        rgb_conv = rgb_565;
-        scr2rgb = byte565_rgb;
         pixelbytes = 2;
         break;
     case VISUAL_RGB_8_8_8:
-        rgb2scr = rgb_byte888;
+        rgb_conv = rgb_888;
+        pixelbytes = 3;
+        break;
+    case VISUAL_BGR_8_8_8:
-        scr2rgb = byte888_rgb;
+        rgb_conv = bgr_888;
         pixelbytes = 3;
         break;
     case VISUAL_RGB_8_8_8_0:
-        rgb2scr = rgb_byte888;
+        rgb_conv = rgb_888;
-        scr2rgb = byte888_rgb;
         pixelbytes = 4;
         break;
     case VISUAL_RGB_0_8_8_8:
-        rgb2scr = rgb_byte0888;
+        rgb_conv = rgb_0888;
-        scr2rgb = byte0888_rgb;
         pixelbytes = 4;
         break;
     case VISUAL_BGR_0_8_8_8:
-        rgb2scr = bgr_byte0888;
+        rgb_conv = bgr_0888;
-        scr2rgb = byte0888_bgr;
         pixelbytes = 4;
         break;
     default:
-        panic("Unsupported visual.\n");
+        panic("Unsupported visual.");
+    }
+    xres = props->x;
+    yres = props->y;
-    unsigned int fbsize = scan * y;
+    scanline = props->scan;
-    /* Map the framebuffer */
+    cols = X2COL(xres);
-    fbaddress = (uint8_t *) hw_map((uintptr_t) addr, fbsize);
+    rows = Y2ROW(yres);
+    if (yres > ylogo) {
+        ylogo = LOGO_HEIGHT;
+        rowtrim = rows - Y2ROW(ylogo);
+        if (ylogo % FONT_SCANLINES > 0)
+            rowtrim--;
+        ytrim = ROW2Y(rowtrim);
+    } else {
-    xres = x;
+        ylogo = 0;
-    yres = y;
+        ytrim = yres;
-    scanline = scan;
+        rowtrim = rows;
+    }
+    glyphscanline = FONT_WIDTH * pixelbytes;
+    glyphbytes = ROW2Y(glyphscanline);
+    bgscanbytes = xres * pixelbytes;
+    unsigned int fbsize = scanline * yres;
+    unsigned int bbsize = cols * rows;
+    unsigned int glyphsize = FONT_GLYPHS * glyphbytes;
+    backbuf = (uint8_t *) malloc(bbsize, 0);
+    if (!backbuf)
+        panic("Unable to allocate backbuffer.");
+    glyphs = (uint8_t *) malloc(glyphsize, 0);
+    if (!glyphs)
+        panic("Unable to allocate glyphs.");
+    bgscan = malloc(bgscanbytes, 0);
+    if (!bgscan)
+        panic("Unable to allocate background pixel.");
+    memsetb(backbuf, bbsize, 0);
+    glyphs_render();
+    fb_addr = (uint8_t *) hw_map((uintptr_t) props->addr, fbsize);
-    rows = y / FONT_SCANLINES;
-    columns = x / COL_WIDTH;
-    fb_parea.pbase = (uintptr_t) addr;
-    fb_parea.vbase = (uintptr_t) fbaddress;
-    fb_parea.frames = SIZE2FRAMES(fbsize);
-    fb_parea.cacheable = false;
-    ddi_parea_register(&fb_parea);
     sysinfo_set_item_val("fb", NULL, true);
     sysinfo_set_item_val("fb.kind", NULL, 1);
     sysinfo_set_item_val("fb.width", NULL, xres);
     sysinfo_set_item_val("fb.height", NULL, yres);
-    sysinfo_set_item_val("fb.scanline", NULL, scan);
+    sysinfo_set_item_val("fb.scanline", NULL, scanline);
-    sysinfo_set_item_val("fb.visual", NULL, visual);
+    sysinfo_set_item_val("fb.visual", NULL, props->visual);
-    sysinfo_set_item_val("fb.address.physical", NULL, addr);
+    sysinfo_set_item_val("fb.address.physical", NULL, props->addr);
-    sysinfo_set_item_val("fb.invert-colors", NULL, invert_colors);
-    /* Allocate double buffer */
-    unsigned int order = fnzb(SIZE2FRAMES(fbsize) - 1) + 1;
-    dbbuffer = (uint8_t *) frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
-    if (!dbbuffer)
-        printf("Failed to allocate scroll buffer.\n");
-    dboffset = 0;
+    fb_redraw();
-    /* Initialized blank line */
-    blankline = (uint8_t *) malloc(ROW_BYTES, FRAME_ATOMIC);
-    if (!blankline)
-        panic("Failed to allocate blank line for framebuffer.");
-    for (y = 0; y < FONT_SCANLINES; y++)
-        for (x = 0; x < xres; x++)
-            (*rgb2scr)(&blankline[POINTPOS(x, y)], COLOR(BGCOLOR));
-    clear_screen();
-    /* Update size of screen to match text area */
-    yres = rows * FONT_SCANLINES;
-    draw_logo(xres - helenos_width, 0);
-    invert_cursor();
     chardev_initialize("fb", &framebuffer, &fb_ops);
     stdout = &framebuffer;
+}
 /** @}

Subversion Repositories HelenOS

(root)/branches/dd/kernel/genarch/src/fb/fb.c – Rev 3022 → 4055