Subversion Repositories openrisc

//==========================================================================

//

//        vga_support.c

//

//        NMI picasso - VGA support

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####                                            

// -------------------------------------------                              

// This file is part of eCos, the Embedded Configurable Operating System.   

// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under    

// the terms of the GNU General Public License as published by the Free     

// Software Foundation; either version 2 or (at your option) any later      

// version.                                                                 

//

// eCos is distributed in the hope that it will be useful, but WITHOUT      

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or    

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    

// for more details.                                                        

//

// You should have received a copy of the GNU General Public License        

// along with eCos; if not, write to the Free Software Foundation, Inc.,    

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            

//

// As a special exception, if other files instantiate templates or use      

// macros or inline functions from this file, or you compile this file      

// and link it with other works to produce a work based on this file,       

// this file does not by itself cause the resulting work to be covered by   

// the GNU General Public License. However the source code for this file    

// must still be made available in accordance with section (3) of the GNU   

// General Public License v2.                                               

//

// This exception does not invalidate any other reasons why a work based    

// on this file might be covered by the GNU General Public License.         

// -------------------------------------------                              

// ####ECOSGPLCOPYRIGHTEND####                                              

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):     gthomas

// Contributors:  gthomas

// Date:          2001-11-03

// Description:   Simple VGA support

//####DESCRIPTIONEND####

#include <pkgconf/hal.h>

#include <cyg/infra/diag.h>

#include <cyg/hal/hal_io.h>       // IO macros

#include <cyg/hal/hal_if.h>       // Virtual vector support

#include <cyg/hal/hal_arch.h>     // Register state info

#include <cyg/hal/hal_intr.h>     // HAL interrupt macros

#include <cyg/hal/vga_support.h>

#include <cyg/hal/hal_cache.h>

#include <cyg/hal/plx.h>          // Localbus I/O

#include <string.h>

#ifdef CYGPKG_ISOINFRA

# include <pkgconf/isoinfra.h>

# ifdef CYGINT_ISO_STDIO_FORMATTED_IO

#  include <stdio.h>  // sscanf

# endif

#endif

#ifndef FALSE

#define FALSE 0

#define TRUE  1

#endif

// Logical layout

#define VGA_WIDTH  640

#define VGA_HEIGHT 480

#define VGA_DEPTH    8

static int bg = 0;

static int fg = 1;

static struct vga_info vga;

struct VGA_ctlr {

    unsigned short rev;

    unsigned char  enable;

    unsigned char  _fill1[13];

    struct ADV471 {

        unsigned short write_addr;

        unsigned short data;

        unsigned short pixel_read_mask;

        unsigned short read_addr;

        unsigned short overlay_data;

        unsigned short _fill2[2];

        unsigned short overlay_read_addr;

    } clut;

    unsigned char _fill3[0x100000-0x20];

    unsigned char fb[1];

};

// Compute the location for a pixel within the framebuffer

static cyg_uint8 *

vga_fb(int row, int col)

{

    cyg_uint8 *res = (cyg_uint8 *)((char *)vga.fb+(row*vga.rlen)+(col*vga.stride));

    return res;

}

void

vga_on(bool enable)

{

    static bool on = false;

    volatile struct VGA_ctlr *ctlr = vga.ctlr;

    if (enable) {

        if (!on) {

            ctlr->enable = 1;

        }

        on = true;

    } else {

        ctlr->enable = 0;

        on = false;

    }

}

// Initialize VGA hardware

static void

vga_set_cmap(volatile struct VGA_ctlr *ctlr, int index,

             int red, int green, int blue)

{

    if (index > 255) {

        // Invalid index

        return;

    }

    ctlr->clut.write_addr = index;  // Select

    ctlr->clut.data = red>>2;

    ctlr->clut.data = green>>2;

    ctlr->clut.data = blue>>2;

}

void

vga_init(cyg_uint32 *addr)

{

    volatile struct VGA_ctlr *ctlr;

    ctlr = (volatile struct VGA_ctlr *)addr;

    vga.ctlr = (void*)ctlr;

    vga.fb = ctlr->fb;

    vga.bpp = VGA_DEPTH;

    vga.height = VGA_HEIGHT;

    vga.width = VGA_WIDTH;

    vga.rlen = VGA_WIDTH;

    vga.stride = 1;

    vga.access_size = 1;

    vga_set_cmap(ctlr, 0, 0x00, 0x00, 0x00);  // 0 -> black

    vga_set_cmap(ctlr, 1, 0xFF, 0xFF, 0xFF);  // 1 -> white

//    diag_printf("VGA init at %p/%p\n", vga.ctlr, vga.fb);

    ctlr->enable = 1;

}

// Get information about the frame buffer

int

vga_getinfo(struct vga_info *info)

{

    if (vga.bpp == 0) {

        return 0;  // VGA not initialized

    }

    *info = vga;

    return 1; // Information valid

}

// Clear screen

void

vga_clear(void)

{

#if 0

    cyg_uint32 *fb_row0, *fb_rown;

    cyg_uint32 _bg = (bg<<16)|bg;

    fb_row0 = vga_fb(0, 0);

    fb_rown = vga_fb(vga_height, 0);

    while (fb_row0 != fb_rown) {

        *fb_row0++ = _bg;

    }

#endif

}

#ifdef CYGSEM_UE250_VGA_COMM

//

// Additional support for VGA/Keyboard as 'console' device

//

#ifdef CYGOPT_UE250_VGA_COMM_LOGO

#include "banner.xpm"

#endif

#include "font.h"

// Virtual screen info

static int curX = 0;  // Last used position

static int curY = 0;

//static int width = VGA_WIDTH / (FONT_WIDTH*NIBBLES_PER_PIXEL);

//static int height = VGA_HEIGHT / (FONT_HEIGHT*SCREEN_SCALE);

#define SCREEN_PAN            20

#define SCREEN_WIDTH          80

#define SCREEN_HEIGHT         (VGA_HEIGHT/FONT_HEIGHT)

#define VISIBLE_SCREEN_WIDTH  (VGA_WIDTH/FONT_WIDTH)

#define VISIBLE_SCREEN_HEIGHT (VGA_HEIGHT/FONT_HEIGHT)

static char screen[SCREEN_HEIGHT][SCREEN_WIDTH];

static int screen_height = SCREEN_HEIGHT;

static int screen_width = SCREEN_WIDTH;

static int screen_pan = 0;

// Usable area on screen [logical pixel rows]

static int screen_start = 0;

static int screen_end = VGA_HEIGHT/FONT_HEIGHT;

static bool cursor_enable = true;

// Functions

static void vga_drawc(cyg_uint8 c, int x, int y);

static __inline__ void

set_pixel(int row, int col, unsigned char val)

{

    unsigned char *pix = (unsigned char *)vga_fb(row, col);

    *pix = val;

}

#ifdef CYGOPT_UE250_VGA_COMM_LOGO

static int

_hexdigit(char c)

{

    if ((c >= '0') && (c <= '9')) {

        return c - '0';

    } else {

        if ((c >= 'A') && (c <= 'F')) {

            return (c - 'A') + 0x0A;

        } else {

            if ((c >= 'a') && (c <= 'f')) {

                return (c - 'a') + 0x0a;

            }

        }

    }

    return 0;

}

static int

_hex(char *cp)

{

    return (_hexdigit(*cp)<<4) | _hexdigit(*(cp+1));

}

static void

parse_color(char *cp, int *red, int *green, int *blue)

{

    *red = *green = *blue = 0xFF;

    while (*cp && (*cp != 'c')) cp++;

    if (cp) {

        cp += 2;

        if (*cp == '#') {

            *red = _hex(cp+1);

            *green = _hex(cp+3);

            *blue = _hex(cp+5);

        }

    }

}

#ifndef CYGINT_ISO_STDIO_FORMATTED_IO

static int

get_int(unsigned char **_cp)

{

    char *cp = *_cp;

    char c;

    int val = 0;

    while ((c = *cp++) && (c != ' ')) {

        if ((c >= '0') && (c <= '9')) {

            val = val * 10 + (c - '0');

        } else {

            return -1;

        }

    }

    *_cp = cp;

    return val;

}

#endif

static int

show_xpm(char *xpm[], int screen_pos)

{

    int i, row, col, offset;

    unsigned char *cp;

    int nrows, ncols, nclrs, cwid;

    short color_index;

    int red, green, blue;

//#define HORRIBLY_SLOW_COLOR_MAPPING

#ifdef HORRIBLY_SLOW_COLOR_MAPPING

    bool color_match;

    short cmap[256][2];

    int j;

#else

    // Caution - this is very GIMP specific

    short cmap[256][3];  // Enough room for 256 colors

    short cmap_col, cmap_row;

    unsigned char std_cmap[] = " .+";

#endif

    cp = xpm[0];

#ifdef CYGINT_ISO_STDIO_FORMATTED_IO

    if (sscanf(cp, "%d %d %d %d", &ncols, &nrows, &nclrs, &cwid) != 4) {

#else

    if (((ncols = get_int(&cp)) < 0) ||

        ((nrows = get_int(&cp)) < 0) ||

        ((nclrs = get_int(&cp)) < 0) ||

        ((cwid = get_int(&cp)) < 0)) {

#endif

        diag_printf("Can't parse XPM data, sorry\n");

        return 0;

    }

//    diag_printf("%d rows, %d cols, %d colors %d chars/pixel\n", nrows, ncols, nclrs, cwid);

    if (cwid > 2) {

        diag_printf("Color map is too wide - %d\n", cwid);

        return 0;

    }

    for (i = 0;  i < 256;  i++) {

#ifdef HORRIBLY_SLOW_COLOR_MAPPING

        cmap[i][0] = 0;  cmap[i][1] = 0;

#else

        cmap[i][0] = 0;  cmap[i][1] = 0;  cmap[i][2] = 0;

#endif

    }

    color_index = 0;

    for (i = 0;  i < nclrs;  i++) {

        cp = xpm[i+1];

#ifdef HORRIBLY_SLOW_COLOR_MAPPING

        for (j = 0;  j < cwid;  j++) {

            cmap[color_index][j] = cp[j];

        }

#else

        if (cwid == 1) {

            cmap_col = 0;

        } else {

            for (cmap_col = 0;  cmap_col < 3;  cmap_col++) {

                if (cp[1] == std_cmap[cmap_col]) {

                    break;

                }

            }

        }

        cmap_row = *cp;

        cmap[cmap_row][cmap_col] = color_index;

#endif

        parse_color(cp+cwid, &red, &green, &blue);

//        diag_printf("Color[%d] = %02x/%02x/%02x\n", color_index, red, green, blue);

        vga_set_cmap(vga.ctlr, color_index+2, red, green, blue);

        color_index++;

    }

#ifdef CYGOPT_UE250_VGA_COMM_LOGO_TOP

    offset = screen_pos;

#else

    offset = screen_pos-nrows;

#endif

    for (row = 0;  row < nrows;  row++) {

        cp = xpm[nclrs+1+row];

        for (col = 0;  col < ncols;  col++) {

#ifdef HORRIBLY_SLOW_COLOR_MAPPING

            // Horrible, but portable, way to map colors

            for (color_index = 0;  color_index < nclrs;  color_index++) {

                color_match = true;

                for (j = 0;  j < cwid;  j++) {

                    if (cmap[color_index][j] != cp[j]) {

                        color_match = false;

                    }

                }

                if (color_match) {

                    break;

                }

            }

#else

            if (cwid == 1) {

                cmap_col = 0;

            } else {

                for (cmap_col = 0;  cmap_col < 3;  cmap_col++) {

                    if (cp[1] == std_cmap[cmap_col]) {

                        break;

                    }

                }

            }

            cmap_row = *cp;

            color_index = cmap[cmap_row][cmap_col];

#endif

            set_pixel(row+offset, col, color_index+2);

            cp += cwid;

        }

    }

#ifdef CYGOPT_UE250_VGA_COMM_LOGO_TOP

    screen_start = (nrows + (FONT_HEIGHT-1))/FONT_HEIGHT;

    screen_end = VGA_HEIGHT/FONT_HEIGHT;

    return offset+nrows;

#else    

    screen_start = 0;

    screen_height = offset / FONT_HEIGHT;

    screen_end = screen_height;

    return offset;

#endif

}

#endif

void

vga_screen_clear(void)

{

    int row, col;

#ifdef CYGOPT_UE250_VGA_COMM_LOGO

    int pos;

#endif

    for (row = 0;  row < screen_height;  row++) {

        for (col = 0;  col < screen_width;  col++) {

            screen[row][col] = ' ';

            vga_drawc(' ', col, row);

        }

    }

#ifdef CYGOPT_UE250_VGA_COMM_LOGO

    // Note: Row 0 seems to wrap incorrectly

#ifdef CYGOPT_UE250_VGA_COMM_LOGO_TOP

    pos = 0;

#else

    pos = (VGA_HEIGHT-1);

#endif

    show_xpm(banner_xpm, pos);

#endif // CYGOPT_UE250_VGA_COMM_LOGO

    curX = 0;  curY = screen_start;

    if (cursor_enable) {

        vga_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

}

// Position cursor

void

vga_moveto(int X, int Y)

{

    if (cursor_enable) {

        vga_drawc(screen[curY][curX], curX-screen_pan, curY);

    }

    if (X < 0) X = 0;

    if (X >= screen_width) X = screen_width-1;

    curX = X;

    if (Y < screen_start) Y = screen_start;

    if (Y >= screen_height) Y = screen_height-1;

    curY = Y;

    if (cursor_enable) {

        vga_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

}

static unsigned long _bitmap[] = {

#ifdef FONT_LEFT_TO_RIGHT

    0x00000000, 0x01000000, 0x00010000, 0x01010000,

    0x00000100, 0x01000100, 0x00010100, 0x01010100,

    0x00000001, 0x01000001, 0x00010001, 0x01010001,

    0x00000101, 0x01000101, 0x00010101, 0x01010101,

#else

    0x00000000, 0x00000001, 0x00000100, 0x00000101,

    0x00010000, 0x00010001, 0x00010100, 0x00010101,

    0x01000000, 0x01000001, 0x01000100, 0x01000101,

    0x01010000, 0x01010001, 0x01010100, 0x01010101

#endif

};

// Render a character at position (X,Y) with current background/foreground

static void

vga_drawc(cyg_uint8 c, int x, int y)

{

    cyg_uint8 bits;

    int l, p;

    int xoff, yoff;

    unsigned long *pix;

    if ((x < 0) || (x >= VISIBLE_SCREEN_WIDTH) ||

        (y < 0) || (y >= screen_height)) return;

    for (l = 0;  l < FONT_HEIGHT;  l++) {

        bits = font_table[c-FIRST_CHAR][l];

        yoff = y*FONT_HEIGHT + l;

        xoff = x*FONT_WIDTH;

#if 0  // Render font characters one bit at a time

        for (p = 0;  p < FONT_WIDTH;  p++) {

#ifdef FONT_LEFT_TO_RIGHT

            set_pixel(yoff, xoff + p, (bits & 0x80) ? fg : bg);

            bits <<= 1;

#else

            set_pixel(yoff, xoff + p, (bits & 0x01) ? fg : bg);

            bits >>= 1;

#endif

        }

#else  // Render characters 4 bits at a time

        pix = (unsigned long *)vga_fb(yoff, xoff);

#ifdef FONT_LEFT_TO_RIGHT

        *pix++ = _bitmap[(bits & 0xF0) >> 4];

        *pix++ = _bitmap[(bits & 0x0F)];

#else

        *pix++ = _bitmap[(bits & 0x0F)];

        *pix++ = _bitmap[(bits & 0xF0) >> 4];

#endif

#endif

    }

}

static void

vga_refresh(void)

{

    int row, col;

    for (row = screen_start;  row < screen_height;  row++) {

        for (col = 0;  col < VISIBLE_SCREEN_WIDTH;  col++) {

            if ((col+screen_pan) < screen_width) {

                vga_drawc(screen[row][col+screen_pan], col, row);

            } else {

                vga_drawc(' ', col, row);

            }

        }

    }

    if (cursor_enable) {

        vga_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

}

static void

vga_scroll(void)

{

    int col;

    cyg_uint8 *c1;

    cyg_uint32 *lc0, *lc1, *lcn;

    cyg_uint32 *fb_row0, *fb_row1, *fb_rown;

    // First scroll up the virtual screen

#if ((SCREEN_WIDTH%4) != 0)

#error Scroll code optimized for screen with multiple of 4 columns

#endif

    lc0 = (cyg_uint32 *)&screen[0][0];

    lc1 = (cyg_uint32 *)&screen[1][0];

    lcn = (cyg_uint32 *)&screen[screen_height][0];

    while (lc1 != lcn) {

        *lc0++ = *lc1++;

    }

    c1 = &screen[screen_height-1][0];

    for (col = 0;  col < screen_width;  col++) {

        *c1++ = 0x20;

    }

#if 0  // Scrolling like this is *relly* slow

    fb_row0 = (cyg_uint32 *)vga_fb(screen_start*FONT_HEIGHT, 0);

    fb_row1 = (cyg_uint32 *)vga_fb((screen_start+1)*FONT_HEIGHT, 0);

    fb_rown = (cyg_uint32 *)vga_fb(screen_end*FONT_HEIGHT, 0);

#if 0

    while (fb_row1 != fb_rown) {

        *fb_row0++ = *fb_row1++;

    }

#else

    // Optimized ARM assembly "move" code

    asm __volatile(

        "mov r0,%0;"

        "mov r1,%1;"

        "mov r2,%2;"

        "10: ldmia r1!,{r3-r6};"

        "stmia r0!,{r3-r6};"

        "ldmia r1!,{r3-r6};"

        "stmia r0!,{r3-r6};"

        "cmp r1,r2;"

        "bne 10b"

        :

        : "r"(fb_row0), "r"(fb_row1), "r"(fb_rown)

        : "r0","r1","r2","r3","r4","r5","r6"

        );

#endif

    // Erase bottom line

    for (col = 0;  col < screen_width;  col++) {

        vga_drawc(' ', col, screen_end-1);

    }

#else  // Clear & redraw is faster!

    vga_refresh();

#endif

}

// Draw one character at the current position

void

vga_putc(cyg_uint8 c)

{

    if (cursor_enable) {

        vga_drawc(screen[curY][curX], curX-screen_pan, curY);

    }

    switch (c) {

    case '\r':

        curX = 0;

        break;

    case '\n':

        curY++;

        break;

    case '\b':

        curX--;

        if (curX < 0) {

            curY--;

            if (curY < 0) curY = 0;

            curX = screen_width-1;

        }

        break;

    default:

        if (((int)c < FIRST_CHAR) || ((int)c > LAST_CHAR)) c = '.';

        screen[curY][curX] = c;

        vga_drawc(c, curX-screen_pan, curY);

        curX++;

        if (curX == screen_width) {

            curY++;

            curX = 0;

        }

    }

    if (curY >= screen_height) {

        vga_scroll();

        curY = (screen_height-1);

    }

    if (cursor_enable) {

        vga_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

}

// Basic VGA 'printf()' support

#include <stdarg.h>

#define is_digit(c) ((c >= '0') && (c <= '9'))

static int

_cvt(unsigned long val, char *buf, long radix, char *digits)