📄 drvgop.c
字号:
{
U16 regval;
if(u8win==0)
{
GOP_Read16Reg(GOP_GWIN_ALPHA01, ®val);
regval &= ~0x003F;
regval |= (u8coef&0x3F);
if(bEnable)
regval |= 0x0040;
else
regval &= ~0x0040;
GOP_Write16Reg(GOP_GWIN_ALPHA01, regval, GOP_REG_WORD_MASK);
}
else if(u8win==1)
{
GOP_Read16Reg(GOP_GWIN_ALPHA01, ®val);
regval &= ~0x3F00;
regval |= ((u8coef &0x3F)<<8);
if(bEnable)
regval |= 0x4000;
else
regval &= ~0x4000;
GOP_Write16Reg(GOP_GWIN_ALPHA01, regval, GOP_REG_WORD_MASK);
}
else if(u8win==2)
{
//regval = XBYTE[GOP_GWIN_ALPHA23];
GOP_Read16Reg(GOP_GWIN_ALPHA23, ®val);
regval &= ~0x003F;
regval |= (u8coef&0x3F);
if(bEnable)
regval |= 0x0040;
else
regval &= ~0x0040;
GOP_Write16Reg(GOP_GWIN_ALPHA23, regval, GOP_REG_WORD_MASK);
}
else if(u8win==3)
{
GOP_Read16Reg(GOP_GWIN_ALPHA23, ®val);
regval &= ~0x3F00;
regval |= ((u8coef &0x3F)<<8);
if(bEnable)
regval |= 0x4000;
else
regval &= ~0x4000;
GOP_Write16Reg(GOP_GWIN_ALPHA23, regval, GOP_REG_WORD_MASK);
}
GOP_GWIN_UpdateReg();
}
/********************************************************************************/
/// Set GWIN information to GOP registers
/// @param u8win \b IN \copydoc GWINID
/// @param pinfo \b IN \copydoc GOP_GWIN_INFO
/********************************************************************************/
void MDrv_GOP_GWIN_SetWinInfo(U8 u8win, GOP_GWIN_INFO* pinfo)
{
LONG32_BYTE u32tmp;
LONG16_BYTE u16tmp;
U16 regval;
U8 bpp;
// Addy 20071031
u16GOP_PDOffset = 60;
bpp = MDrv_GOP_GetBPP(pinfo->clrType);
u32tmp.u32Num = ((U32)pinfo->u16WinY * (U32)pinfo->u16RBlkHPixSize + (U32)pinfo->u16WinX)*(bpp/8); // Convert pixel into bytes
u32tmp.u32Num = u32tmp.u32Num / 8; // Convert to word.
GOP_Read16Reg(GOP_GWIN_DRAM_STR_L(u8win), (U16*)®val);
GOP_Read16Reg(GOP_GWIN_DRAM_STR_H(u8win), (U16*)&u16tmp);
if ((u32tmp.u8Num[3] != (regval&0x00ff) ) ||
(u32tmp.u8Num[2] != (regval >> 8)) ||
(u32tmp.u8Num[1] != (u16tmp.u8Num[0]) )) {
GOP_Write16Reg(GOP_GWIN_DRAM_STR_L(u8win), u32tmp.u8Num[3]| (u32tmp.u8Num[2]<<8), GOP_REG_WORD_MASK ); // word
GOP_Write16Reg(GOP_GWIN_DRAM_STR_H(u8win), u32tmp.u8Num[1], GOP_REG_WORD_MASK); // word
// force write
GOP_Write16Reg(GOP_BAK_SEL, GOP_VAL_FWR, GOP_REG_HW_MASK);
GOP_Write16Reg(GOP_BAK_SEL, 0x0000, GOP_REG_HW_MASK);
}
u32tmp.u32Num = pinfo->u32DRAMRBlkStart >> 3;
GOP_Write16Reg(GOP_GWIN_DRAM_RBLK_L(u8win), u32tmp.u8Num[3]| (u32tmp.u8Num[2]<<8), GOP_REG_WORD_MASK ); // word
GOP_Write16Reg(GOP_GWIN_DRAM_RBLK_H(u8win), u32tmp.u8Num[1], GOP_REG_WORD_MASK); // word
// u32tmp.u32Num = ((U32)pinfo->u16RBlkHPixSize * (U32)pinfo->u16RBlkVPixSize) >> 2; // pix --> word
u32tmp.u32Num = ((U32)pinfo->u16RBlkHRblkSize * (U32)pinfo->u16RBlkVPixSize) >> 3; // byte * pix --> word for 1555 fmt
GOP_Write16Reg(GOP_GWIN_DRAM_RBLK_SIZE_L(u8win), u32tmp.u8Num[3]| (u32tmp.u8Num[2]<<8), GOP_REG_WORD_MASK ); // word
GOP_Write16Reg(GOP_GWIN_DRAM_RBLK_SIZE_H(u8win), u32tmp.u8Num[1], GOP_REG_WORD_MASK); // word
// u16tmp.u16Num = pinfo->u16RBlkHPixSize >> 2; // pix -> word
u16tmp.u16Num = pinfo->u16RBlkHRblkSize >> 3; // byte -> word
GOP_Write16Reg(GOP_GWIN_DRAM_RBLK_HSIZE(u8win), u16tmp.u8Num[1]|(u16tmp.u8Num[0]<<8), GOP_REG_WORD_MASK); // word
u16tmp.u16Num = pinfo->u16DispVPixelStart;
GOP_Write16Reg(GOP_GWIN_VSTR_L(u8win), u16tmp.u8Num[1]|(u16tmp.u8Num[0]<<8), GOP_REG_WORD_MASK); // 1 pixel
if (Gwin_V_Dup)
u16tmp.u16Num = (pinfo->u16DispVPixelEnd << 1) - pinfo->u16DispVPixelStart;
else
u16tmp.u16Num = pinfo->u16DispVPixelEnd;
GOP_Read16Reg(GOP_SVM, (U16*)®val);
if( (regval&0x02) == 0x00 ) // Check for interlace mode if GOP destination is IP
{
if(g_DisplayWindowSetting.u8DisplayStatus & DISPLAYWINDOW_INTERLACE) {
u16tmp.u16Num = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
GOP_Write16Reg(GOP_PDATA_WR, 0x0008, 0x0008); // Enable YUV output
GOP_Write16Reg(GOP_GWIN_EN, 0x0000, 0x0100); // Disable Progressive mode
}
u16GOP_PDOffset = 16;
}
else // Assume OP always progressive and use RGB color space.
{
GOP_Write16Reg(GOP_PDATA_WR, 0x0000, 0x0008); // Enable RGB output
GOP_Write16Reg(GOP_GWIN_EN, 0x0100, 0x0100); // Enable Progressive mode
}
GOP_Write16Reg(GOP_GWIN_VEND_L(u8win), u16tmp.u8Num[1]|(u16tmp.u8Num[0]<<8), GOP_REG_WORD_MASK); // 1 pixel
u16tmp.u16Num = ((pinfo->u16DispHPixelStart+GOP_PD_OFFSET)/(64/bpp));
GOP_Write16Reg(GOP_GWIN_HSTR_L(u8win), u16tmp.u8Num[1]|(u16tmp.u8Num[0]<<8), GOP_REG_WORD_MASK); // 4 pixels
if (Gwin_H_Dup)
u16tmp.u16Num = (((pinfo->u16DispHPixelEnd +GOP_PD_OFFSET)<< 1) - (pinfo->u16DispHPixelStart +GOP_PD_OFFSET))/(64/bpp);
else
u16tmp.u16Num = (pinfo->u16DispHPixelEnd+GOP_PD_OFFSET) /(64/bpp);
GOP_Write16Reg(GOP_GWIN_HEND_L(u8win), u16tmp.u8Num[1]|(u16tmp.u8Num[0]<<8), GOP_REG_WORD_MASK); // 4 pixels
u16tmp.u16Num = (pinfo->u16RBlkHPixSize /(64/bpp));
GOP_Write16Reg(GOP_GWIN_HSIZE(u8win), u16tmp.u8Num[1]|(u16tmp.u8Num[0]<<8), GOP_REG_WORD_MASK); // 4 pixels
MDrv_GOP_GWIN_SetWinFmt(u8win, pinfo->clrType);
//GOP_Write16Reg(__GOP_REG(0x04), 0x0000, GOP_REG_WORD_MASK);
//GOP_Write16Reg(__GOP_REG(0x05), 0x0000, GOP_REG_WORD_MASK);
GOP_DEBUGINFO(printf("GWIN_SetWin(%bx): [adr(B), RBsz, offset] = [%lx, %lx, %lx]\r\n", u8win,\
pinfo->u32DRAMRBlkStart,\
((U32)pinfo->u16RBlkHPixSize * (U32)pinfo->u16RBlkVPixSize)/(64/bpp),\
((U32)pinfo->u16WinY * (U32)pinfo->u16RBlkHPixSize + (U32)pinfo->u16WinX)/(64/bpp)));
GOP_DEBUGINFO(printf("\t[Vst, Vend, Hst, Hend, GwinHsz] = [%d, %d, %d, %d, %d]\r\n",\
pinfo->u16DispVPixelStart, pinfo->u16DispVPixelEnd, pinfo->u16DispHPixelStart /(64/bpp), pinfo->u16DispHPixelEnd/(64/bpp),\
pinfo->u16RBlkHPixSize/(64/bpp)));
GOP_GWIN_UpdateReg();
}
/********************************************************************************/
/// Read GWIN information from GOP registers
/// @param u8win \b IN \copydoc GWINID
/// @param pinfo \b OUT buffer to store GWIN information
/********************************************************************************/
void MDrv_GOP_GWIN_GetWinInfo(U8 u8win, GOP_GWIN_INFO* pinfo)
{
LONG32_BYTE u32tmp;
LONG16_BYTE u16tmp;
U8 bpp;
GOP_Read16Reg(GOP_GWIN_DTYPE, (U16*)&u16tmp);
pinfo->clrType = (u16tmp.u16Num >> (u8win*4))&0xF;
bpp = MDrv_GOP_GetBPP( pinfo->clrType);
GOP_Read16Reg(GOP_GWIN_VSTR_L(u8win), (U16*)&u16tmp); // pixel
pinfo->u16DispVPixelStart = u16tmp.u16Num; // pix
GOP_Read16Reg(GOP_GWIN_VEND_L(u8win), (U16*)&u16tmp); // pixel
if (Gwin_V_Dup)
pinfo->u16DispVPixelEnd = (u16tmp.u16Num + pinfo->u16DispVPixelStart) >> 1; // pix
else
pinfo->u16DispVPixelEnd = u16tmp.u16Num; // pix
GOP_Read16Reg(GOP_GWIN_HSTR_L(u8win), (U16*)&u16tmp); // 4 pixel
pinfo->u16DispHPixelStart = (u16tmp.u16Num * (64/bpp))-GOP_PD_OFFSET; // pix
GOP_Read16Reg(GOP_GWIN_HEND_L(u8win), (U16*)&u16tmp); // 4 pixel
u16tmp.u16Num = (u16tmp.u16Num * (64/bpp))-GOP_PD_OFFSET; // pix
if (Gwin_H_Dup)
pinfo->u16DispHPixelEnd = ((u16tmp.u16Num) + pinfo->u16DispHPixelStart) >> 1; // pix
else
pinfo->u16DispHPixelEnd = u16tmp.u16Num; // pix
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_L(u8win), (U16*)&u16tmp);
u32tmp.u8Num[3] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[2] = u16tmp.u8Num[0]; //word
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_H(u8win), (U16*)&u16tmp);
u32tmp.u8Num[1] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[0] = 0;
pinfo->u32DRAMRBlkStart = u32tmp.u32Num << 3; // Byte
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_HSIZE(u8win), (U16*)&u16tmp);
pinfo->u16RBlkHRblkSize = (u16tmp.u16Num) << 3; // Byte
// pinfo->u16RBlkHPixSize = (u16tmp.u16Num) << 2; // Pix
GOP_Read16Reg(GOP_GWIN_HSIZE(u8win), (U16*)&u16tmp);
pinfo->u16RBlkHPixSize = (u16tmp.u16Num) * (64/bpp); // Pix
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_SIZE_L(u8win), (U16*)&u16tmp);
u32tmp.u8Num[3] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[2] = u16tmp.u8Num[0]; //word
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_SIZE_H(u8win), (U16*)&u16tmp);
u32tmp.u8Num[1] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[0] = 0;
pinfo->u16RBlkVPixSize = ((u32tmp.u32Num* (64/bpp)) / pinfo->u16RBlkHPixSize); // Pix
GOP_Read16Reg(GOP_GWIN_DRAM_STR_L(u8win), (U16*)&u16tmp);
u32tmp.u8Num[3] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[2] = u16tmp.u8Num[0]; //word
GOP_Read16Reg(GOP_GWIN_DRAM_STR_H(u8win), (U16*)&u16tmp);
u32tmp.u8Num[1] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[0] = 0;
pinfo->u16WinY = (U16)((u32tmp.u32Num * (64/bpp)) / pinfo->u16RBlkHPixSize); // pix
pinfo->u16WinX= (U16)((u32tmp.u32Num * (64/bpp)) % pinfo->u16RBlkHPixSize); // pix
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_VOFF_L(u8win), (U16*)&u16tmp);
u32tmp.u8Num[3] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[2] = u16tmp.u8Num[0]; //word
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_VOFF_H(u8win), (U16*)&u16tmp);
u32tmp.u8Num[1] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[0] = 0;
pinfo->u32scrY = u32tmp.u32Num * (64/bpp); // pix
GOP_Read16Reg(GOP_GWIN_DRAM_RBLK_HOFF_L(u8win), (U16*)&u16tmp);
u32tmp.u8Num[3] = u16tmp.u8Num[1]; //word
u32tmp.u8Num[2] = u16tmp.u8Num[0]; //word
pinfo->u32scrX = u32tmp.u32Num * (64/bpp); // pix
GOP_DEBUGINFO(printf("GWIN_GetWin(%bx): [adr(B), Hsz, Vsz, Hsdrm, winX, winY ] = [%lx, %x, %x, %d, %d, %d]\r\n", u8win,
pinfo->u32DRAMRBlkStart,
pinfo->u16RBlkHPixSize,
pinfo->u16RBlkVPixSize,
pinfo->u16RBlkHRblkSize,
pinfo->u16WinX,
pinfo->u16WinY));
}
/********************************************************************************/
/// Set GWIN horizontal and vertical duplication
/// @param hext \b IN
/// - 0 disable horizontal pixel duplication
/// - 1 enable horizontal pixel duplication
/// @param vext \b IN
/// - 0 disable vertical line duplication
/// - 1 enable vertical line duplication
/********************************************************************************/
void MDrv_GOP_GWIN_SetDuplication(U8 hext, U8 vext)
{
U16 regval;
GOP_Read16Reg(GOP_GWIN_EN, ®val);
if (hext)
{
Gwin_H_Dup = TRUE;
GOP_Write16Reg(GOP_GWIN_EN, 0x0400, 0x0400); // 4 pixels
}
else
{
Gwin_H_Dup = FALSE;
GOP_Write16Reg(GOP_GWIN_EN, 0x0000, 0x0400); // 4 pixels
}
if (vext)
{
Gwin_V_Dup = TRUE;
GOP_Write16Reg(GOP_GWIN_EN, 0x0800, 0x0800); // 4 pixels
}
else
{
Gwin_V_Dup = FALSE;
GOP_Write16Reg(GOP_GWIN_EN, 0x0000, 0x0800); // 4 pixels
}
}
/********************************************************************************/
/// Set GOP MIU read threshold to hibernate value
/// and disable all GWINs
/********************************************************************************/
void MDrv_GOP_GWIN_Hibernate()
{
GOP_Write16Reg(GOP_MIU_RD_TSH, GOP_BUF_MIU_RD_TH_H_HIBER, 0x007F);
GOP_Write16Reg(GOP_GWIN_EN, 0x0000, GOP_REG_WORD_MASK);
GOP_GWIN_UpdateReg();
}
/********************************************************************************/
/// Set GOP MIU read threshold to wakeup value
/// and enable GWINs that are enabled originally
/********************************************************************************/
void MDrv_GOP_GWIN_Wakeup()
{
U8 u8Idx;
U16 regval;
GOP_Read16Reg(GOP_GWIN_EN, ®val);
for (u8Idx=0; u8Idx<MAX_GWIN_SUPPORT; u8Idx++)
{
regval |= ((gwinFB[gwinMap[u8Idx]].enable & 0x01) << u8Idx);
}
GOP_Write16Reg(GOP_MIU_RD_TSH, GOP_BUF_MIU_RD_TH_H_WORKING, 0x007F);
GOP_Write16Reg(GOP_GWIN_EN, regval, 0xFFEF);
GOP_GWIN_UpdateReg();
}
/******************************************************************************/
/// Initialize internal frame buffer structure for GWIN, and DEFAULT OSD frame buffer.
/// this is called in MDrv_GOP_Init()
/******************************************************************************/
void MDrv_GOP_GWIN_Init()
{
U8 index;
U8 bytePerPix = 2;
U16 width, height, pitch, fbFmt;
U32 addr;
GOP_GWIN_INFO gWin;
GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_Init\n"));
current_bank = 0;
for (index = 0; index <MAX_GWIN_FB_SUPPORT; index++)
{
gwinFB[index].enable = FALSE;
gwinFB[index].allocated = FALSE;
gwinFB[index].gWinId = GWIN_ID_INVALID; // orig GWIN_OSD_DEFAULT;
gwinFB[index].x0 = gWin.u16DispHPixelStart = 0;
gwinFB[index].y0 = gWin.u16DispVPixelStart = 0;
gwinFB[index].width = gWin.u16RBlkHPixSize = 0;
gwinFB[index].height= gWin.u16RBlkVPixSize = 0;
gwinFB[index].x1 = gWin.u16DispHPixelEnd = 0;
gwinFB[index].y1 = gWin.u16DispVPixelEnd = 0;
gwinFB[index].pitch = 0;
gwinFB[index].addr = gWin.u32DRAMRBlkStart = 0;
gwinFB[index].size = 0;
gWin.u16WinX = gWin.u16WinY = 0;
// FB format
gwinFB[index].fbFmt = FB_FMT_AS_DEFAULT;
// update ptrs
gwinFB[index].prev = GWIN_SDRAM_NULL;
gwinFB[index].next = GWIN_SDRAM_NULL;
}
for (index = 0; index<MAX_GWIN_SUPPORT; index++)
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -