drvgop_bloader.c

mstar 776 开发的车载dvd

}

/********************************************************************************/
/// Enable or Disable transparent color
/// @param fmt \b IN @copydoc GOPTRANSCLRFMT
/// @param bEnable \b IN
///   - # TRUE enable transparent color
///   - # FALSE disable transparent color
/********************************************************************************/
void MDrv_GOP_GWIN_EnableTransClr(GOPTRANSCLRFMT fmt, BOOLEAN bEnable)
{
    U16 regval;

    // Dummy code for avoid compile warning
    regval = (U16) fmt;

    GOP_Read16Reg(GOP_GWIN_EN, &regval);

    if(bEnable)
        regval |= 0x8000;
    else
        regval &= ~0x8000;

    GOP_Write16Reg(GOP_GWIN_EN, regval, GOP_REG_WORD_MASK);

    GOP_GWIN_UpdateReg();
}

/********************************************************************************/
/// Set GWIN alpha blending
/// @param u8win \b IN \copydoc GWINID
/// @param bEnable \b IN
///   - # TRUE enable alpha blending
///   - # FALSE disable alpha blending
/// @param u8coef \b IN alpha blending coefficient (0-7)
/********************************************************************************/
void MDrv_GOP_GWIN_SetBlending(U8 u8win, BOOLEAN bEnable, U8 u8coef)
{
    U16 regval;

    if(u8win==0)
    {
        GOP_Read16Reg(GOP_GWIN_ALPHA01, &regval);

        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, &regval);

        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, &regval);

        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, &regval);

        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;

    bpp = MDrv_GOP_GetBPP(pinfo->clrType);

    u32tmp.u32Num = ((U32)pinfo->u16WinY * (U32)pinfo->u16RBlkHPixSize  + (U32)pinfo->u16WinX) >> 2;

    GOP_Read16Reg(GOP_GWIN_DRAM_STR_L(u8win), (U16*)&regval);
    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_WORD_MASK);
        GOP_Write16Reg(GOP_BAK_SEL, 0x0000, GOP_REG_WORD_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;

    #if(PANEL_TYPE_SEL==PNL_DAC_CRT)
    #if (CRT_INTERLACE_OUT)
    u16tmp.u16Num = pinfo->u16DispVPixelStart + (pinfo->u16DispVPixelEnd - pinfo->u16DispVPixelStart) / 2;
    #endif
    #endif
    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_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));

}

/******************************************************************************/
/// 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++)
    {
        gwinMap[index] = GWIN_ID_INVALID;
    }

    MDrv_GE_GetFrameBufferInfo(&width, &height, &pitch, &fbFmt, &addr);
    gwinFB[MAX_GWIN_FB_SUPPORT].enable = TRUE;
    gwinFB[MAX_GWIN_FB_SUPPORT].allocated = TRUE;
    gwinFB[MAX_GWIN_FB_SUPPORT].gWinId = MAX_GWIN_SUPPORT;
    gwinFB[MAX_GWIN_FB_SUPPORT].x0 = 0;
    gwinFB[MAX_GWIN_FB_SUPPORT].y0 = 0;
    gwinFB[MAX_GWIN_FB_SUPPORT].width = width;
    gwinFB[MAX_GWIN_FB_SUPPORT].height = height;
    gwinFB[MAX_GWIN_FB_SUPPORT].x1  = gwinFB[MAX_GWIN_FB_SUPPORT].x0 + gwinFB[MAX_GWIN_FB_SUPPORT].width;
    gwinFB[MAX_GWIN_FB_SUPPORT].y1  = gwinFB[MAX_GWIN_FB_SUPPORT].y0 + gwinFB[MAX_GWIN_FB_SUPPORT].height;
    gwinFB[MAX_GWIN_FB_SUPPORT].pitch = (pitch & 0xFFF8);  // pitch must be 4-pix alignment;
    gwinFB[MAX_GWIN_FB_SUPPORT].addr   = addr;
    gwinFB[MAX_GWIN_FB_SUPPORT].size  =  ((U32)width) * ((U32)height) * ((U32)bytePerPix);
    // FB format
    gwinFB[MAX_GWIN_FB_SUPPORT].fbFmt  = fbFmt;
    // update ptrs
    gwinFB[MAX_GWIN_FB_SUPPORT].prev = GWIN_SDRAM_NULL;
    gwinFB[MAX_GWIN_FB_SUPPORT].next = GWIN_SDRAM_NULL;

    gwinMap[MAX_GWIN_SUPPORT] = MAX_GWIN_FB_SUPPORT;

}

/******************************************************************************/
/// Create GWIN
/// @param dispX \b IN x
/// @param dispY \b IN y
/// @param width \b IN width
/// @param height \b IN height
/// @param fbFmt \b IN frame buffer pixel format
///   - #0xFFFF default FB format
/// @see MDrv_GOP_GWIN_DestroyWin
/******************************************************************************/
U8 MDrv_GOP_GWIN_CreateWin(U16 dispX, U16 dispY, U16 width, U16 height,  U16 fbFmt)
{
    U8 bytePerPix = 2;
    U8 gId, fbId;
    GOP_GWIN_INFO gWin;

    // look for an availavle gwin index
    for (gId = 0; gId < MAX_GWIN_SUPPORT; gId++ )
    {
        if (gwinMap[gId] == GWIN_ID_INVALID)
        {
            break;
        }
    }
    if (gId >= MAX_GWIN_SUPPORT)
    {
     GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateWin: gwin max already reached, cannot open new win\n"));
        return GWIN_NO_AVAILABLE;
    }

    GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateWin: new gwinId = %bd \r\n", gId));

    // look for available Sdram slot
    for (fbId = 0; fbId < MAX_GWIN_FB_SUPPORT; fbId++)
    {
        if (gwinFB[fbId].allocated == FALSE)
        {
            break;
        }
    }

    if (MDrv_GOP_GWIN_CreateFB(fbId, dispX, dispY, width, height,  fbFmt) != GWIN_OK)
    {
        GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateWin: failed to create FB\n"));
        return GWIN_NO_AVAILABLE;
    }

    // update gwin_map
    gwinMap[gId] = fbId;

    MDrv_GOP_GWIN_Enable(gId, FALSE);
    gwinFB[fbId].enable = TRUE;
    gwinFB[fbId].gWinId = gId;

    gWin.u16DispHPixelStart = gwinFB[fbId].x0;
    gWin.u16DispVPixelStart = gwinFB[fbId].y0;
    gWin.u16RBlkHPixSize = gwinFB[fbId].width;
    gWin.u16RBlkVPixSize = gwinFB[fbId].height;
    gWin.u16RBlkHRblkSize = gwinFB[fbId].pitch;
    gWin.u16DispHPixelEnd = gwinFB[fbId].x1;
    gWin.u16DispVPixelEnd = gwinFB[fbId].y1;
    gWin.u32DRAMRBlkStart = gwinFB[fbId].addr;
    gWin.u16WinX = gWin.u16WinY = 0;
    gWin.clrType = MDrv_GOP_GWIN_BufFmtMap(0, gwinFB[fbId].fbFmt);

    // update gwin regs
    MDrv_GOP_GWIN_SetWinInfo(gId, &gWin);
    // MDrv_GOP_GWIN_Enable(gId, TRUE); // Enable it may cause flicker

    return (gId);
}

/******************************************************************************/
/// Switch GE to render on a GWIN's frame buffer
/// @param gId \b IN \copydoc GWINID
/******************************************************************************/
void MDrv_GOP_GWIN_Switch2Win(U8 gId)
{
    U8 fbId;

    if (gId > MAX_GWIN_SUPPORT)  // may go to GWIN_OSD_DEFAULT (==MAX_GWIN_SUPPORT) for OSD
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_Switch2Win(Id....), out of bound\n" ) );
        return;
    }

    fbId = gwinMap[gId];

    if ((fbId == GWIN_ID_INVALID) || (gwinFB[fbId].allocated== FALSE))
    {
        GOP_DEBUGINFO( printf("MDrv_GOP_GWIN_GetWinAttr: gId=%d not allocated\n",gId));
        return;
    }

    //printf("\r\n MDrv_GOP_GWIN_Switch2Win>W:%u, H:%u, P:%u, Addr:0x%08LX ", gwinFB[fbId].width, gwinFB[fbId].height, gwinFB[fbId].pitch, gwinFB[fbId].addr);