video.c

PPC860常见外围驱动

/*
 * (C) Copyright 2000
 * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), [e-mail]
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program 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 of
 * the License, or (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

// ***********************************************************************
// ** HEADER FILES
// ***********************************************************************

#include <stdarg.h>
#include <ppcboot.h>
#include <config.h>
#include <version.h>
#include <i2c.h>
#include <linux/types.h>
#include <devices.h>

#ifdef CONFIG_VIDEO

// ***********************************************************************
// ** DEBUG SETTINGS
// ***********************************************************************

#define VIDEO_DEBUG_STEP	0
#define PRINTD(x)		if (VIDEO_DEBUG_STEP)	printf(x);

//#define VIDEO_DEBUG_COLORBARS	// Force colorbars output

// ***********************************************************************
// ** VIDEO MODE SETTINGS
// ***********************************************************************

//#define VIDEO_MODE_EXTENDED	// Allow screen size bigger than visible area
//#define VIDEO_MODE_NTSC
#define VIDEO_MODE_PAL
//#define VIDEO_BLINK		// This enables cursor blinking (under construction)
#define VIDEO_INFO		// Show PPCBOOT informations
#define VIDEO_INFO_X		VIDEO_LOGO_WIDTH+8
#define VIDEO_INFO_Y		16

// ***********************************************************************
// ** VIDEO ENCODER CONSTANTS
// ***********************************************************************

#ifdef CONFIG_VIDEO_ENCODER_AD7176

#include <video_ad7176.h>	// Sets encoder data, mode, and visible and active area

#define VIDEO_I2C		1
#define VIDEO_I2C_RATE		(VIDEO_ENCODER_I2C_RATE >> 1) 
#define VIDEO_I2C_ADDR		CONFIG_VIDEO_ENCODER_AD7176_ADDR
#define VIDEO_I2C_DATA_ADDR	video_encoder_data
#define VIDEO_I2C_DATA_SIZE	sizeof(video_encoder_data)
#endif

#ifdef CONFIG_VIDEO_ENCODER_AD7177

#include <video_ad7177.h>	// Sets encoder data, mode, and visible and active area

#define VIDEO_I2C		1
#define VIDEO_I2C_RATE		(VIDEO_ENCODER_I2C_RATE >> 1) 
#define VIDEO_I2C_ADDR		CONFIG_VIDEO_ENCODER_AD7177_ADDR
#define VIDEO_I2C_DATA_ADDR	video_encoder_data
#define VIDEO_I2C_DATA_SIZE	sizeof(video_encoder_data)
#endif

// ***********************************************************************
// ** VIDEO MODE CONSTANTS
// ***********************************************************************

#ifdef VIDEO_MODE_EXTENDED
#define VIDEO_COLS	VIDEO_ACTIVE_COLS
#define VIDEO_ROWS	VIDEO_ACTIVE_ROWS
#else
#define VIDEO_COLS	VIDEO_VISIBLE_COLS
#define VIDEO_ROWS	VIDEO_VISIBLE_ROWS
#endif

#define VIDEO_PIXEL_SIZE	(VIDEO_MODE_BPP/8)	
#define VIDEO_SIZE		(VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)// Total size of buffer			
#define VIDEO_PIX_BLOCKS	(VIDEO_SIZE >> 2)			// Number of ints
#define VIDEO_LINE_LEN		(VIDEO_COLS*VIDEO_PIXEL_SIZE)		// Number of bytes per line
#define VIDEO_BURST_LEN		(VIDEO_COLS/8)

#ifdef VIDEO_MODE_YUYV
#define VIDEO_BG_COL 	0x80108010	// Background color in YUYV format
#else
#define VIDEO_BG_COL 	0x00000000	// Background color in RGB format
#endif

// ***********************************************************************
// ** FONT AND LOGO DATA
// ***********************************************************************

#include <video_font.h>		// Get font data, width and height

#ifdef CONFIG_VIDEO_LOGO
#include <video_logo.h>		// Get logo data, width and height

#define VIDEO_LOGO_WIDTH	DEF_PPCBOOT_LOGO_WIDTH
#define VIDEO_LOGO_HEIGHT	DEF_PPCBOOT_LOGO_HEIGHT
#define VIDEO_LOGO_ADDR		&ppcboot_logo
#endif

// ***********************************************************************
// ** VIDEO CONTROLLER CONSTANTS
// ***********************************************************************

// VCCR - VIDEO CONTROLLER CONFIGURATION REGISTER

#define VIDEO_VCCR_VON	0	// Video controller ON
#define VIDEO_VCCR_CSRC	1	// Clock source
#define VIDEO_VCCR_PDF	13	// Pixel display format
#define VIDEO_VCCR_IEN	11	// Interrupt enable

// VSR - VIDEO STATUS REGISTER

#define VIDEO_VSR_CAS	6	// Active set
#define VIDEO_VSR_EOF	0	// End of frame

// VCMR - VIDEO COMMAND REGISTER

#define VIDEO_VCMR_BD	0	// Blank display
#define VIDEO_VCMR_ASEL	1	// Active set selection

// VBCB - VIDEO BACKGROUND COLOR BUFFER REGISTER

#define VIDEO_BCSR4_RESET_BIT	21 	// BCSR4 - Extern video encoder reset
#define VIDEO_BCSR4_EXTCLK_BIT	22	// BCSR4 - Extern clock enable
#define VIDEO_BCSR4_VIDLED_BIT	23	// BCSR4 - Video led disable

// ***********************************************************************
// ** CONSOLE CONSTANTS
// ***********************************************************************

#ifdef 	CONFIG_VIDEO_LOGO
#define CONSOLE_ROWS		((VIDEO_ROWS - VIDEO_LOGO_HEIGHT) / VIDEO_FONT_HEIGHT)
#define VIDEO_LOGO_SKIP		(VIDEO_COLS - VIDEO_LOGO_WIDTH)
#else
#define CONSOLE_ROWS		(VIDEO_ROWS / VIDEO_FONT_HEIGHT)
#endif

#define CONSOLE_COLS		(VIDEO_COLS / VIDEO_FONT_WIDTH)
#define CONSOLE_ROW_SIZE 	(VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
#define CONSOLE_ROW_FIRST	(video_console_address)
#define CONSOLE_ROW_SECOND 	(video_console_address + CONSOLE_ROW_SIZE)
#define CONSOLE_ROW_LAST	(video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
#define CONSOLE_SIZE 		(CONSOLE_ROW_SIZE * CONSOLE_ROWS)
#define CONSOLE_SCROLL_SIZE	(CONSOLE_SIZE - CONSOLE_ROW_SIZE)

// Simple color definitions

#define CONSOLE_COLOR_BLACK 0
#define CONSOLE_COLOR_WHITE 15
#define CONSOLE_COLOR_GRAY  14

// ***********************************************************************
// ** BITOPS MACROS
// ***********************************************************************

#define HISHORT(i)	((i >> 16)&0xffff)
#define LOSHORT(i)	(i & 0xffff)
#define HICHAR(s)	((i >> 8)&0xff)
#define LOCHAR(s)	(i & 0xff)
#define HI(c)		((c >> 4)&0xf)
#define LO(c)		(c & 0xf)
#define SWAPINT(i)	(HISHORT(i) | (LOSHORT(i) << 16))
#define SWAPSHORT(s)	(HICHAR(s) | (LOCHAR(s) << 8))
#define SWAPCHAR(c)	(HI(c) | (LO(c) << 4))
#define BITMASK(b)	(1 << (b))
#define GETBIT(v,b)	(((v) & BITMASK(b)) > 0)
#define SETBIT(v,b,d)	(v = (((d)>0) ? (v) | BITMASK(b): (v) & ~BITMASK(b)))

// ***********************************************************************
// ** STRUCTURES
// ***********************************************************************

typedef struct {
    unsigned char   V,
		    Y1,
		    U,
		    Y2;
} tYUYV ; 

/* This structure is based on the Video Ram in the MPC823. */
typedef struct VRAM
{
   unsigned hx:2,      /* Horizontal sync */
            vx:2,      /* Vertical sync */
            fx:2,      /* Frame */
            bx:2,      /* Blank */
            res1:6,    /* Reserved */
            vds:2,     /* Video Data Select */
            inter:1,   /* Interrupt */
            res2:2,    /* Reserved */
            lcyc:11,   /* Loop/video cycles */
            lp:1,      /* Loop start/end */
            lst:1;     /* Last entry */
} VRAM;

// ***********************************************************************
// ** VARIABLES
// ***********************************************************************

static int	
    video_panning_range_x 	= 0,	// Video mode invisible pixels x range
    video_panning_range_y 	= 0,	// Video mode invisible pixels y range
    video_panning_value_x 	= 0,	// Video mode x panning value (absolute)
    video_panning_value_y 	= 0,	// Video mode y panning value (absolute)
    video_panning_factor_x 	= 0,	// Video mode x panning value (-127 +127)
    video_panning_factor_y 	= 0,	// Video mode y panning value (-127 +127)
    
    console_col  		= 0,	// Cursor col
    console_row  		= 0,	// Cursor row
    
    video_palette[16];			// Our palette
    
static const int
    video_font_draw_table[] = {0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff} ;

static char 

    video_color_fg 		= 0,	// Current fg color index (0-15)
    video_color_bg 		= 0,	// Current bg color index (0-15)
	
    video_enable 		= 0 ;	// Video has been initialized?

static void 
    *video_fb_address,			// Frame buffer address
    *video_console_address ;		// Console frame buffer start address

// ***********************************************************************
// ** MEMORY FUNCTIONS (32bit)
// ***********************************************************************

static void memsetl (int *p, int c, int v)
{
    while (c--)
	*(p++) = v ;
}

static void memcpyl (int *d, int *s, int c)
{
    while (c--)
	*(d++) = *(s++) ;
}

// ***********************************************************************
// ** VIDEO DRAWING AND COLOR FUNCTIONS 
// ***********************************************************************

static int video_maprgb 	(int r, int g, int b)
{
#ifdef VIDEO_MODE_YUYV
    unsigned int pR, pG, pB ;
    tYUYV		YUYV ;
    unsigned int	*ret = (unsigned int*) &YUYV ;
    
    // Transform (0-255) components to (0-100)

    pR = r * 100 / 255 ;
    pG = g * 100 / 255 ;
    pB = b * 100 / 255 ;
    
    // Calculate YUV values (0-255) from RGB beetween 0-100

    YUYV.Y1 = YUYV.Y2 	=  209 * (pR + pG + pB) / 300 + 16  ; 
    YUYV.U  		=  pR - (pG*3/4) - (pB/4)     + 128 ; 
    YUYV.V  		=  pB - (pR/4)   - (pG*3/4)   + 128 ; 
    return *ret ;
#endif
#ifdef VIDEO_MODE_RGB
    return ((r >> 3) << 11) | ((g > 2) << 6) | (b >> 3) ;
#endif
}    

static void video_setpalette (int color, int r, int g, int b)
{
    color &= 0xf ;
    
    video_palette[color] = video_maprgb(r,g,b);
    
    // Swap values if our panning offset is odd
    if (video_panning_value_x & 1)
	video_palette[color] = SWAPINT (video_palette[color]);
}

static void video_fill(int color)
{
    memsetl (video_fb_address, VIDEO_PIX_BLOCKS, color);
}

static void video_setfgcolor(int i)
{
    video_color_fg = i & 0xf;
}

static void video_setbgcolor(int i)
{
    video_color_bg = i  & 0xf;
}

static int video_pickcolor(int i)
{
    return video_palette[i & 0xf];
}

// Absolute console plotting functions

#ifdef VIDEO_BLINK
static void video_revchar (int xx, int yy)
{
    int rows;
    u8 *dest ;
    dest = video_fb_address + yy * VIDEO_LINE_LEN + xx * 2;
    
    for (rows = VIDEO_FONT_HEIGHT; rows--; dest += VIDEO_LINE_LEN) {
	switch (VIDEO_FONT_WIDTH) {
	case 16:
	    ((u32 *)dest)[6] ^= 0xffffffff; ((u32 *)dest)[7] ^= 0xffffffff;
	    /* FALL THROUGH */
	case 12:
	    ((u32 *)dest)[4] ^= 0xffffffff; ((u32 *)dest)[5] ^= 0xffffffff;
	    /* FALL THROUGH */
	case 8:
	    ((u32 *)dest)[2] ^= 0xffffffff; ((u32 *)dest)[3] ^= 0xffffffff;
	    /* FALL THROUGH */
	case 4:
	    ((u32 *)dest)[0] ^= 0xffffffff; ((u32 *)dest)[1] ^= 0xffffffff;
	}
    }
}
#endif

static void video_drawchars(int xx, int yy, unsigned char *s, int count)
{
    u8  *cdat, *dest, *dest0;
    int rows, offset, c;
    u32 eorx, fgx, bgx;

    offset = yy * VIDEO_LINE_LEN + xx * 2;
    dest0 = video_fb_address + offset ;

    fgx = video_pickcolor (video_color_fg) ;
    bgx = video_pickcolor (video_color_bg) ;
    
    if (xx & 1)	    
    {
	fgx = SWAPINT(fgx);
	bgx = SWAPINT(bgx);
    }
	    
    eorx = fgx ^ bgx;

    switch (VIDEO_FONT_WIDTH) {
    case 4:
    case 8:
	while (count--)
	{
	    c = *s ;
	    cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
	    for (rows = VIDEO_FONT_HEIGHT, dest = dest0; rows--; dest += VIDEO_LINE_LEN) {
		u8 bits = *cdat++;
		((u32 *)dest)[0] = (video_font_draw_table[bits >> 6] & eorx) ^ bgx;
		((u32 *)dest)[1] = (video_font_draw_table[bits >> 4 & 3] & eorx) ^ bgx;