Subversion Repositories openrisc_me

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

//

//        Lcd_support.c

//

//        Cogent CSB281 - LCD/CRT support routines

//

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

//####ECOSGPLCOPYRIGHTBEGIN####

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

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

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

// Copyright (C) 2003 Gary Thomas

//

// 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.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.

//

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

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

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

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

//####ECOSGPLCOPYRIGHTEND####

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

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

//

// Author(s):     gthomas

// Contributors:  gthomas

// Date:          2001-11-03

// Description:   Simple LCD 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/lcd_support.h>

#include <cyg/hal/hal_cache.h>

#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 LCD_WIDTH  640

#define LCD_HEIGHT 480

#define LCD_DEPTH   16

#define RGB_RED(x)   (((x)&0x1F)<<11)

#define RGB_GREEN(x) (((x)&0x3F)<<5)

#define RGB_BLUE(x)  (((x)&0x1F)<<0)

// Black on light blue

static int bg = RGB_RED(0x1F) | RGB_GREEN(0x3F) | RGB_BLUE(0x1F);

static int fg = RGB_RED(0) | RGB_GREEN(0) | RGB_BLUE(0);

static struct lcd_info lcd;

int sed135x_init(int depth, struct lcd_info *info);

// Compute the location for a pixel within the framebuffer

static cyg_uint16 *

lcd_fb(int row, int col)

{

    cyg_uint16 *res = (cyg_uint16 *)((char *)lcd.fb+(row*lcd.rlen)+(col*lcd.stride));

    return res;

}

void

lcd_on(bool enable)

{

    static bool on = false;

    if (enable) {

        if (!on) {

            (*lcd.on)();

        }

        on = true;

    } else {

//        (*lcd.off)();

    }

}

// Initialize LCD hardware

void

lcd_init(int depth)

{

    sed135x_init(depth, &lcd);

}

// Get information about the frame buffer

int

lcd_getinfo(struct lcd_info *info)

{

    if (lcd.bpp == 0) {

        return 0;  // LCD not initialized

    }

    *info = lcd;

    return 1; // Information valid

}

// Clear screen

void

lcd_clear(void)

{

#if 0

    cyg_uint32 *fb_row0, *fb_rown;

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

    fb_row0 = lcd_fb(0, 0);

    fb_rown = lcd_fb(lcd_height, 0);

    while (fb_row0 != fb_rown) {

        *fb_row0++ = _bg;

    }

#endif

}

#ifdef CYGSEM_CSB281_LCD_COMM

//

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

//

#ifdef CYGOPT_CSB281_LCD_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 = LCD_WIDTH / (FONT_WIDTH*NIBBLES_PER_PIXEL);

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

#define SCREEN_PAN            20

#define SCREEN_WIDTH          80

#define SCREEN_HEIGHT         (LCD_HEIGHT/FONT_HEIGHT)

#define VISIBLE_SCREEN_WIDTH  (LCD_WIDTH/FONT_WIDTH)

#define VISIBLE_SCREEN_HEIGHT (LCD_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 = LCD_HEIGHT/FONT_HEIGHT;

static bool cursor_enable = true;

// Functions

static void lcd_drawc(cyg_int8 c, int x, int y);

// Note: val is a 16 bit, RGB555 value which must be mapped

// onto a 12 bit value.

#define RED(v)   ((v>>12) & 0x0F)

#define GREEN(v) ((v>>7) & 0x0F)

#define BLUE(v)  ((v>>1) & 0x0F)

static void

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

{

    unsigned short *pix = (unsigned short *)lcd_fb(row, col);

    *pix = _le16(val);

}

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 unsigned short

parse_color(char *cp)

{

    int red, green, blue;

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

    if (cp) {

        cp += 2;

        if (*cp == '#') {

            red = _hex(cp+1);

            green = _hex(cp+3);

            blue = _hex(cp+5);

#define USE_RGB565

#ifdef USE_RGB565

            return RGB_RED(red>>3) | RGB_GREEN(green>>2) | RGB_BLUE(blue>>3);

#else

            return RGB_RED(red>>3) | RGB_GREEN(green>>3) | RGB_BLUE(blue>>3);

#endif

        } else {

            // Should be "None"

            return 0xFFFF;

        }

    } else {

        return 0xFFFF;

    }

}

#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

#ifdef CYGOPT_CSB281_LCD_COMM_LOGO

static int

show_xpm(char *xpm[], int screen_pos)

{

    int i, row, col, offset;

    unsigned char *cp;

    int nrows, ncols, nclrs, cwid;

    unsigned short colors[256];  // Mapped by character index

    short color_value, color_index;

//#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++) {

        colors[i] = 0x0000;

#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

        color_value = parse_color(cp+cwid);

        colors[color_index++] = color_value;

//        diag_printf("Color[%d] = %04x\n", color_index-1, colors[color_index-1]);

    }

#ifdef CYGOPT_CSB281_LCD_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, colors[color_index]);

            cp += cwid;

        }

    }

#ifdef CYGOPT_CSB281_LCD_COMM_LOGO_TOP

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

    screen_end = LCD_HEIGHT/FONT_HEIGHT;

    return offset+nrows;

#else    

    screen_start = 0;

    screen_height = offset / FONT_HEIGHT;

    screen_end = screen_height;

    return offset;

#endif

}

#endif

void

lcd_screen_clear(void)

{

    int row, col, pos;

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

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

            screen[row][col] = ' ';

            lcd_drawc(' ', col, row);

        }

    }

#ifdef CYGOPT_CSB281_LCD_COMM_LOGO

    // Note: Row 0 seems to wrap incorrectly

#ifdef CYGOPT_CSB281_LCD_COMM_LOGO_TOP

    pos = 0;

#else

    pos = (LCD_HEIGHT-1);

#endif

    show_xpm(banner_xpm, pos);

#endif // CYGOPT_CSB281_LCD_COMM_LOGO

    curX = 0;  curY = screen_start;

    if (cursor_enable) {

        lcd_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

}

// Position cursor

void

lcd_moveto(int X, int Y)

{

    if (cursor_enable) {

        lcd_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) {

        lcd_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

}

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

static void

lcd_drawc(cyg_int8 c, int x, int y)

{

    cyg_uint8 bits;

    int l, p;

    int xoff, yoff;

    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_HEIGHT;

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

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

            bits >>= 1;

        }

    }

}

static void

lcd_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) {

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

            } else {

                lcd_drawc(' ', col, row);

            }

        }

    }

    if (cursor_enable) {

        lcd_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

}

static void

lcd_scroll(void)

{

    int col;

    cyg_uint8 *c1;

    cyg_uint32 *lc0, *lc1, *lcn;

    cyg_uint16 *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;

    }

    fb_row0 = lcd_fb(screen_start*FONT_HEIGHT, 0);

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

    fb_rown = lcd_fb(screen_end*FONT_HEIGHT, 0);

    while (fb_row1 != fb_rown) {

        *fb_row0 = *fb_row1;

        fb_row0 = (cyg_uint16 *)((char *)fb_row0 + lcd.stride);

        fb_row1 = (cyg_uint16 *)((char *)fb_row1 + lcd.stride);

    }

    // Erase bottom line

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

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

    }

}

// Draw one character at the current position

void

lcd_putc(cyg_int8 c)

{

// TEMP

    int cache_on;

    HAL_DCACHE_IS_ENABLED(cache_on);

    if (cache_on) {

        HAL_DCACHE_SYNC();

        HAL_DCACHE_DISABLE();

    }

// TEMP

    if (cursor_enable) {

        lcd_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 (((cyg_uint8)c < FIRST_CHAR) || ((cyg_uint8)c > LAST_CHAR)) c = '.';

        screen[curY][curX] = c;

        lcd_drawc(c, curX-screen_pan, curY);

        curX++;

        if (curX == screen_width) {

            curY++;

            curX = 0;

        }

    }

    if (curY >= screen_height) {

        lcd_scroll();

        curY = (screen_height-1);

    }

    if (cursor_enable) {

        lcd_drawc(CURSOR_ON, curX-screen_pan, curY);

    }

// TEMP

    if (cache_on) {

        HAL_DCACHE_ENABLE();

    }

// TEMP

}

// Basic LCD '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)

{

    char temp[80];

    char *cp = temp;

    int length = 0;

    if (val == 0) {

        /* Special case */

        *cp++ = '0';

    } else {

        while (val) {

            *cp++ = digits[val % radix];

            val /= radix;

        }

    }

    while (cp != temp) {

        *buf++ = *--cp;

        length++;

    }

    *buf = '\0';

    return (length);

}

static int

lcd_vprintf(void (*putc)(cyg_int8), const char *fmt0, va_list ap)

{

    char c, sign, *cp;

    int left_prec, right_prec, zero_fill, length, pad, pad_on_right;

    char buf[32];

    long val;

    while ((c = *fmt0++)) {

        cp = buf;

        length = 0;

        if (c == '%') {

            c = *fmt0++;

            left_prec = right_prec = pad_on_right = 0;

            if (c == '-') {

                c = *fmt0++;

                pad_on_right++;

            }

            if (c == '0') {

                zero_fill = TRUE;

                c = *fmt0++;

            } else {

                zero_fill = FALSE;

            }

            while (is_digit(c)) {

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

                c = *fmt0++;

            }

            if (c == '.') {

                c = *fmt0++;

                zero_fill++;

                while (is_digit(c)) {

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

                    c = *fmt0++;

                }

            } else {

                right_prec = left_prec;

            }

            sign = '\0';

            switch (c) {

            case 'd':

            case 'x':

            case 'X':

                val = va_arg(ap, long);

                switch (c) {