vou.c

华为 HI3510 BOOTLOADER HIBOOT 源码包

/******************************************************************************

  Copyright (C), 2001-2011, Hisilicon Tech. Co., Ltd.

 ******************************************************************************
  File Name     : hi_vou.c
  Version       : Initial Draft
  Author        : Hisilicon multimedia software group
  Created       : 2004/06/25
  Last Modified :
  Description   : SD592 VOU driver C source  file
                  The purpose of  VOU is provide  VOU's functionality.
                  
  Function List :
                  
                  
                  VOU_Disable
                  VOU_Enable
                  VOU_Int
                  
  History       :
  1.Date        : 2004/06/25
    Author      : yuanyabin
    Modification: Created file

******************************************************************************/

#include <config.h>

#if defined(CONFIG_HI3510_LOGO)


#include "hi_common/hi.h"


#include "hi_inc.h"
#include "hi_video.h"

#include "hi_i2c.h"

#include "hi_vou.h"
#include "vou.h"
#include "vou_reg.h"


/*
  Act1Height, VSyncWidth, Act1Vbb, Act1Voffset, 
  Act2Height, Act2Vbb, Act2Voffset, ActWidth, 
  HSyncWidth, ActHbb, ActHoffset, 601n656, MasterMode;
*/

static const VOU_TVCfg_Type defaultTvCfg[VIDEO_NORM_SUPPORT] = 
{
  {288,5,2,22, 288,2,23,720, 128,12,132,0,1},
  {244,6,2,16, 243,3,17,720, 128,16,122,0,1}
};


static const VOU_LCDCfg_Type defaultLCDCfg = 
{
  480,2,33,10,640,16,127,18
};


static VOU_Reg_Type *pVouReg = NULL;


/* VOU interrupt routine. */
static void vouInt(void);


/* VOU enable routine. */
HI_RET VOU_Enable(void)
{ 
  VOU_sCtrlReg control;
  
  /* Revise Enable control bit to enable VOU. */ 
  control.ul32= pVouReg->control.ul32;
  control.bits.ulVoEn = VOU_CONTROL_ENABLE;
  pVouReg->control.ul32 = control.ul32;
     
  return HI_OK;
}

/* VOU disable routine. */
HI_RET VOU_Disable(void)
{
  VOU_sCtrlReg control;
  
  /* Revise Enable control bit to enable VOU. */  
  control.ul32 = pVouReg->control.ul32;
  control.bits.ulVoEn = VOU_CONTROL_DISABLE;
  pVouReg->control.ul32 = control.ul32;
    
  return HI_OK;
}




HI_RET VOU_Init(void)
{	
	UINT32 VOU_REG_ADDR_MEMMAP;
	
	/* Vou object base address register definition. */  	  	
#ifndef GDB_DEBUG
	VOU_REG_ADDR_MEMMAP = (U32)memmap(VOU_BASE_ADRS, VOU_REG_SIZE);
	if(VOU_REG_ADDR_MEMMAP == 0)
	{
		printx(("VOU_Init(): memmap failed!"));
		return HI_ERROR;
	}
	pVouReg = (volatile VOU_Reg_Type *)(VOU_REG_ADDR_MEMMAP);
#else
	pVouReg = (VOU_Reg_Type *)malloc(sizeof(VOU_Reg_Type));
#endif

	/* default VOU Initialization */
	VOU_Disable();
	
	VOU_DefaultSetting();

#if 0
	VOU_SetOutputMode(
		VOU_OUTPUT_MODE_LCD,
		VOU_ENCODING_MODE_PAL,
		VOU_CONTROL_MODE_MASTER);
#else
	VOU_SetOutputMode(
		VOU_OUTPUT_MODE_BT656,
		VOU_ENCODING_MODE_PAL,
		VOU_CONTROL_MODE_MASTER);
#endif

	/* Layer setting */
	VOU_LayerDisable(VOU_LAYER_MAIN);
	VOU_LayerDisable(VOU_LAYER_OVER1);
	VOU_LayerDisable(VOU_LAYER_OVER2);

	VOU_LayerDefaultSetting(VOU_LAYER_MAIN);
	VOU_LayerDefaultSetting(VOU_LAYER_OVER1);
	VOU_LayerDefaultSetting(VOU_LAYER_OVER2);
	
	/* Hardware cursor default setting */
	VOU_LayerDisable(VOU_LAYER_HC);
	VOU_BGSetColor(0x808080);
	VOU_HCDefaultSetting();

	//VOU_Enable();

	return HI_OK;
}




/* commom control Functions--------------------------------------------*/
HI_RET VOU_DefaultSetting(void)
{	
	VOU_sCtrlReg control;
	
	control.bits.ulVoEn = 1;
	control.bits.ulMainEn = 0;
	control.bits.ulOvl1En = 0;
	control.bits.ulOvl2En = 0;
	control.bits.ulHcEn = 0;

	/* little endian */
	control.bits.ulLittleEndian = 1;

	/* mastrt mode */
	control.bits.ulMasterMode = 1;
	

	/* TV_CLIP disabled */
	control.bits.ulClipEn = 0;

	/* 输出到LCD */
	control.bits.ulOutFormat = VOU_OUTPUT_MODE_LCD;
	control.bits.ulRGBOut = 1;

	/* invert output enable: available when high */
	control.bits.ulIoe = 0;	
	/* invert horizontal signal: available when high */
	control.bits.ulIhs = 1;
	/* invert vertical  signal: available when high */
	control.bits.ulIvs = 1;
	/* vo_cb信号选择:field2信号 */
	control.bits.ulCb = 1;
	/* field2信号输出时反相: 奇数场 */
	control.bits.ulIfs = 0;
	/* 从模式时，由field2作为垂直同步信号 */
	control.bits.ulFieldSync = 0;

	pVouReg->control.ul32 = control.ul32;
	
	return HI_OK;
}







HI_RET VOU_SetOutputMode(
	VOU_OUTPUT_MODE_t OutputMode,
	VOU_ENCODING_MODE_t EncodeingMode,
	VOU_CONTROL_MODE_t  ControlMode)
{

	VOU_sVoVsync1Reg vSync1;
	VOU_sVoVsync2Reg vSync2;
	VOU_sVoHsyncReg hSync;
	
	VOU_sCtrlReg control;

	if(OutputMode >= VOU_OUTPUT_MODE_SUPPORT)
	{
		printf("VOU_SetOutputMode(): OutputMode >= VOU_OUTPUT_MODE_SUPPORT.\n");
		return HI_ERROR;
	}

	if(EncodeingMode >= VOU_ENCODING_MODE_SUPPORT)
	{
		printf("VOU_SetOutputMode(): EncodeingMode >= VOU_ENCODING_MODE_SUPPORT.\n");
		return HI_ERROR;
	}

	control.ul32 = pVouReg->control.ul32;
	
	control.bits.ulOutFormat = OutputMode;
	control.bits.ulMasterMode = ControlMode;

	if(OutputMode == VOU_OUTPUT_MODE_LCD)
	{
		/* LCD Output Mode */
		vSync1.ulVouLCDBits.ulLpp = defaultLCDCfg.ulLpp - 1;
		vSync1.ulVouLCDBits.ulVsw = defaultLCDCfg.ulVsw - 1;
		vSync1.ulVouLCDBits.ulVbp = defaultLCDCfg.ulVbp - 1;
		vSync1.ulVouLCDBits.ulVfp = defaultLCDCfg.ulVfp - 1;
		pVouReg->vSync1.ul32 = vSync1.ul32;

		
		hSync.ulVouLCDBits.ulPpl = defaultLCDCfg.ulPpl - 1;
		hSync.ulVouLCDBits.ulHsw = defaultLCDCfg.ulHsw - 1;
		hSync.ulVouLCDBits.ulHbp = defaultLCDCfg.ulHbp - 1;
		hSync.ulVouLCDBits.ulHfp = defaultLCDCfg.ulHfp - 1;
		pVouReg->hSync.ul32 = hSync.ul32;

		/* LCD use VOU_CONTROL_MODE_MASTER */
		control.bits.ulMasterMode = VOU_CONTROL_MODE_MASTER;
	}
	else if( (OutputMode == VOU_OUTPUT_MODE_BT656) || \
		(OutputMode == VOU_OUTPUT_MODE_BT601) )
	{
	
		/* TV Mode */
		vSync1.ulVouTVBits.ulAct1Height = defaultTvCfg[EncodeingMode].ulAct1Height - 1;
		vSync1.ulVouTVBits.ulVSyncWidth = defaultTvCfg[EncodeingMode].ulVSyncWidth;
		vSync1.ulVouTVBits.ulAct1Vbb = defaultTvCfg[EncodeingMode].ulAct1Vbb - 1;
		vSync1.ulVouTVBits.ulAct1Voffset = defaultTvCfg[EncodeingMode].ulAct1Voffset - 1;
		pVouReg->vSync1.ul32 = vSync1.ul32;

		vSync2.bits.ulAct2Height = defaultTvCfg[EncodeingMode].ulAct1Height - 1;
		vSync2.bits.ulAct2Vbb = defaultTvCfg[EncodeingMode].ulAct2Vbb - 1;
		vSync2.bits.ulAct2Voffset = defaultTvCfg[EncodeingMode].ulAct2Voffset - 1;
		vSync2.bits.ulHsyncWidthMsb = (defaultTvCfg[EncodeingMode].ulHSyncWidth)>>4;	/* default */
		hSync.ulVouTVBits.ulHSyncWidthLsb = (defaultTvCfg[EncodeingMode].ulHSyncWidth)&0xf;	/* default */
		pVouReg->vSync2.ul32 = vSync2.ul32;

		hSync.ulVouTVBits.ulActWidth = defaultTvCfg[EncodeingMode].ulActWidth*2 - 1;
		hSync.ulVouTVBits.ulActHbb = defaultTvCfg[EncodeingMode].ulActHbb*2 - 1;
		hSync.ulVouTVBits.ulActHoffset = defaultTvCfg[EncodeingMode].ulActHoffset*2 - 1;
		pVouReg->hSync.ul32 = hSync.ul32;
		
		
		if(OutputMode == VOU_OUTPUT_MODE_BT601)
		{
			control.bits.ulOutFormat = VOU_OUTPUT_MODE_BT601;
		}

		if(OutputMode == VOU_OUTPUT_MODE_BT656)
		{
			/* TV_CLIP must be enabled */
			control.bits.ulOutFormat = VOU_OUTPUT_MODE_BT656;
			control.bits.ulClipEn = VOU_CONTROL_CLIP_ENABLE;
		}
	}
	else if(OutputMode == VOU_OUTPUT_MODE_RAW_DATA)
	{
		printf("VOU_SetOutputMode(): OutputMode == VOU_OUTPUT_MODE_RAW_DATA.\n");
		return HI_ERROR;
	}

	pVouReg->control.ul32 = control.ul32;

	return HI_OK;
}




HI_RET VOU_LayerDefaultSetting(VOU_LAYER_t WhichLayer)
{
	VOU_sCtrlReg control;
	VOU_sVoOvlStartReg ovlStart;
	VOU_sVoOvlReg overLayer;
	VOU_sVoOvlAlphaReg ovlAlpha;	

	VOU_sVoImageReg image;
	VOU_sVoImageOffsetReg offset;

	control.ul32 = pVouReg->control.ul32;

	switch(WhichLayer)
	{
		case VOU_LAYER_OVER1:
			control.bits.ulOvl1En = VOU_CONTROL_LAYER_DISABLE;
			control.bits.ulOvl1KeyEn = VOU_CONTROL_OVLKEY_DISABLE;
			control.bits.ulOvl1MaskEn = VOU_CONTROL_OVLMASK_DISABLE;
			control.bits.ulOvl1Type = PIXEL_FORMAT_YUV_A422;

			ovlStart.bits.ulOvlStartLine = 0;
			ovlStart.bits.ulOvlStartPixel= 0;

			overLayer.bits.ulOvlWidth = 0;
			overLayer.bits.ulOvlHeight= 0;

			ovlAlpha.bits.ulOvlAlpha0 = 0x80;
			ovlAlpha.bits.ulOvlAlpha1 = 0x80;

			pVouReg->ovl1.ul32 = overLayer.ul32;
			pVouReg->ovl1Start.ul32 = ovlStart.ul32;
			pVouReg->ovl1Alpha.ul32 = ovlAlpha.ul32;
			pVouReg->ovl1Key.ul32 = 0x0;

			
		break;
		
		case VOU_LAYER_OVER2:
			control.bits.ulOvl2En = VOU_CONTROL_LAYER_DISABLE;
			control.bits.ulOvl2KeyEn = VOU_CONTROL_OVLKEY_DISABLE;
			control.bits.ulOvl2MaskEn = VOU_CONTROL_OVLMASK_DISABLE;
			control.bits.ulOvl2Type = PIXEL_FORMAT_YUV_A422;


			ovlStart.bits.ulOvlStartLine = 0;
			ovlStart.bits.ulOvlStartPixel= 0;

			overLayer.bits.ulOvlWidth = 0;
			overLayer.bits.ulOvlHeight= 0;

			ovlAlpha.bits.ulOvlAlpha0 = 0x80;
			ovlAlpha.bits.ulOvlAlpha1 = 0x80;

			pVouReg->ovl2.ul32 = overLayer.ul32;
			pVouReg->ovl2Start.ul32 = ovlStart.ul32;
			pVouReg->ovl2Alpha.ul32 = ovlAlpha.ul32;
			pVouReg->ovl2Key.ul32 = 0x0;

			
		break;


		case VOU_LAYER_MAIN:
			control.bits.ulMainEn = VOU_CONTROL_LAYER_DISABLE;
			control.bits.ulMainMode = PIXEL_FORMAT_YUV_0;

			image.bits.ulImageWidth = 0;
			image.bits.ulImageHeight = 0;

			offset.bits.ulImageHOffset = 0;
			offset.bits.ulImageVOffset = 0;

			pVouReg->image.ul32 = image.ul32;
			pVouReg->imageOff.ul32 = offset.ul32;
			
		break;

		default:
			return HI_ERROR;
		break;

	}

	pVouReg->control.ul32 = control.ul32;
	
	return HI_OK;

}


HI_RET VOU_LayerSetDataType(VOU_LAYER_t WhichLayer, PIXEL_FORMAT_t LayerDataFormat)
{
	VOU_sCtrlReg control;
	
	control.ul32 = pVouReg ->control.ul32;
	
	switch(WhichLayer)
	{
		case VOU_LAYER_OVER1:
			control.bits.ulOvl1Type  = LayerDataFormat;
			break;

		case VOU_LAYER_OVER2:
			control.bits.ulOvl2Type  = LayerDataFormat;
			break;

		case VOU_LAYER_MAIN:
			control.bits.ulMainMode = LayerDataFormat - PIXEL_FORMAT_YUV_0;
		break;
		
		case VOU_LAYER_HC:
			control.bits.ulHcMode = LayerDataFormat - PIXEL_FORMAT_2COLOR;
		break;

		default:
			return HI_ERROR;
		break;			
	}
	pVouReg ->control.ul32 = control.ul32;
	return HI_OK;
	
}






HI_RET VOU_LayerSetMask(
	VOU_LAYER_t WhichLayer,  BOOL  maskEnable,
	UINT8 Mask_Y,
	UINT8 Mask_C)
{
	VOU_sVoMaskReg mask;
	VOU_sCtrlReg control;
	
	control.ul32 = pVouReg ->control.ul32;
	
	mask.ul32 = pVouReg->mask.ul32;
	
	switch(WhichLayer)
	{
		case VOU_LAYER_OVER1:
			mask.bits.ulOvl1MaskY = Mask_Y;
			mask.bits.ulOvl1MaskC = Mask_C;
			
			if(maskEnable == HI_OK)
				control.bits.ulOvl1MaskEn = VOU_CONTROL_OVLMASK_ENABLE;
			else
				control.bits.ulOvl1MaskEn = VOU_CONTROL_OVLMASK_DISABLE;
		break;
		
		case VOU_LAYER_OVER2:
			mask.bits.ulOvl2MaskY= Mask_Y;
			mask.bits.ulOvl2MaskC= Mask_C;

			if(maskEnable == HI_OK)
				control.bits.ulOvl2MaskEn= VOU_CONTROL_OVLMASK_ENABLE;
			else
				control.bits.ulOvl2MaskEn = VOU_CONTROL_OVLMASK_DISABLE;
			
		break;
		
		default:
			return HI_ERROR;
		break;
	}
	
	pVouReg->mask.ul32 = mask.ul32;
	pVouReg ->control.ul32 = control.ul32;
	
	
	return HI_OK;
}