drvgop_bloader.c

mstar 776 开发的车载dvd

    MDrv_GE_SetFrameBufferInfo(gwinFB[fbId].width, gwinFB[fbId].height, gwinFB[fbId].pitch, gwinFB[fbId].fbFmt, gwinFB[fbId].addr);
}

/******************************************************************************/
/// Check if GWIN is created
/// @param gId \b IN \copydoc GWINID
/******************************************************************************/
U8   MDrv_GOP_GWIN_IsGwinExist(U8 gId)
{

    if ((gId > MAX_GWIN_SUPPORT) || (gwinMap[gId]>MAX_GWIN_FB_SUPPORT) || \
        (gwinFB[gwinMap[gId]].allocated == FALSE) || (gwinMap[gId] == GWIN_ID_INVALID))
    {
        return FALSE;
    }

    return TRUE;
}

/******************************************************************************/
/// Move a GWIN's display left top position
/// @param gId  \b IN \copydoc GWINID
/// @param dispX \b IN left top x
/// @param dispY \b IN left top y
/******************************************************************************/
void MDrv_GOP_GWIN_SetWinDispPosition(U8 gId, U16 dispX, U16 dispY)
{
    GOP_GWIN_INFO gWin;
    U8 fbId;

    if (gId >= MAX_GWIN_SUPPORT )
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinDispPosition(Id....), gId out of bound\n" ) );
        return;
    }

    fbId = gwinMap[gId];

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

    if (fbId > MAX_GWIN_FB_SUPPORT)
    {
        GOP_DEBUGINFO( printf( "MDrv_GOP_GWIN_SetWinDispPosition(Id....), gId --> fb out of bound\n" ) );
        return;
    }

    MDrv_GOP_GWIN_GetWinInfo(gId, &gWin);

    gwinFB[fbId].x0 = gWin.u16DispHPixelStart = dispX;
    gwinFB[fbId].y0 = gWin.u16DispVPixelStart = dispY;
    gwinFB[fbId].x1 = gWin.u16DispHPixelEnd = dispX + gwinFB[fbId].width;
    gwinFB[fbId].y1 = gWin.u16DispVPixelEnd = dispY + gwinFB[fbId].height;

    //printf("\r\n MDrv_GOP_GWIN_SetWinDispPosition>");
    //printf("(%u, %u)-(%u, %u)", gwinFB[fbId].x0, gwinFB[fbId].y0, gwinFB[fbId].x1, gwinFB[fbId].y1);
    MDrv_GOP_GWIN_SetWinInfo(gId, &gWin);
}

/******************************************************************************/
/// Create frame buffer, (width * height * 2) bytes will be allocated
/// from SDRAM
/// @param fbId  \b IN frame buffer id 0 ~ (MAX_GWIN_FB_SUPPORT - 1)
/// @param dispX \b IN display x
/// @param dispY \b IN display y
/// @param width \b IN width
/// @param height \b IN height
/// @param fbFmt \b IN frame buffer format
/// @return
///   - #GWIN_NO_AVAILABLE fbId is not valid
///   - #GWIN_OK destroy successfully
/// @see MDrv_GOP_GWIN_DestroyFB
/******************************************************************************/
U8 MDrv_GOP_GWIN_CreateFB(U8 fbId, U16 dispX, U16 dispY, U16 width, U16 height,  U16 fbFmt)
{
    U8 bytePerPix = 2;
    U8 gIdLast; // gIdLast is the prev valid winId
    U32 addr;
    U32 size;

    if (fbId >= MAX_GWIN_FB_SUPPORT)
    {
        msWarning(ERR_FB_ID_OUT_OF_RANGE);
        GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateFB: gwin max already reached, cannot open new win\n"));
        return GWIN_NO_AVAILABLE;
    }

    if (gwinFB[fbId].allocated == TRUE)
    {
        msWarning(ERR_FB_ID_ALREADY_ALLOCATED);
        GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateFB: gwin  already allocated\n"));
        return GWIN_NO_AVAILABLE;

    }

    GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateFB: new gwinFBId = %bd \r\n", fbId));

    // look for available Sdram slot
    gIdLast = gwinMap[GWIN_OSD_DEFAULT];  // gIdLast is the prev valid winId

    while   (gwinFB[gIdLast].next != GWIN_SDRAM_NULL)
    {
        gIdLast = gwinFB[gIdLast].next;
    }

    if (gIdLast == gwinMap[GWIN_OSD_DEFAULT])
   {
        addr = (GWIN_KEEP_INIT_OSDWIN == 0) ? GOP_GWIN_RB_BASE_ADR : \
                    gwinFB[gIdLast].addr + gwinFB[gIdLast].size; //consider if need to keep OSD data
        addr = (addr + GWIN_SDRAM_PG_UNIT-1) & (~(GWIN_SDRAM_PG_UNIT-1));
    }
    else
   {
        addr = (gwinFB[gIdLast].addr + gwinFB[gIdLast].size + GWIN_SDRAM_PG_UNIT-1) & (~(GWIN_SDRAM_PG_UNIT-1));
    }

    if (width & 0x0003)  /* width must be multi-of-4 */
    {
        width &= 0xFFFC;
     GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateFB: width must be multiple of 4, rounding to %d\n", width));
    }

    size =  ((U32)width) * ((U32)height) * ((U32)bytePerPix);

    // check available fb buffer size
    if (addr + size >= GOP_GWIN_RB_BASE_ADR + GOP_GWIN_RB_BASE_LEN)
    {
        if (gopSdramFree >= size) // too many fragments
        {
            //GOP_GWIN_REARRANGE_SDRAM(fbId, &addr);
        }
        else
        {
            msWarning(ERR_FB_OUT_OF_MEMORY);
            return GWIN_NO_AVAILABLE;
        }
    }
    #if 0
    if ((addr & GOP_SDRAM_BOUNDARY_MASK) != ((addr + size) & GOP_SDRAM_BOUNDARY_MASK))
    {
        residue = ((addr + size) & GOP_SDRAM_BOUNDARY_MASK) - addr;
        gopSdramFree -= residue;
        addr = ((addr + size) & GOP_SDRAM_BOUNDARY_MASK);
    }
    if ((addr & GOP_SDRAM_BOUNDARY_MASK) != ((addr + size) & GOP_SDRAM_BOUNDARY_MASK))
    {
        GOP_DEBUGINFO(printf("cannot allocate fb!\r\n"));
        gopSdramFree += residue;
        return GWIN_NO_AVAILABLE;
    }
    #endif
    gopSdramFree -= size;
    GOP_DEBUGINFO(printf("MDrv_GOP_GWIN_CreateFB(fbId=%bd): addr=%lx, size =%lx, available=%lx\n", fbId, addr, size, gopSdramFree));

    gwinFB[fbId].enable = FALSE;
    gwinFB[fbId].allocated = TRUE;
    //gwinFB[fbId].gWinId = gId;  // set by calling functions
    dispX += GOP_PD_OFFSET;
    gwinFB[fbId].x0 = dispX;
    gwinFB[fbId].y0 = dispY;
    gwinFB[fbId].width = width;
    gwinFB[fbId].height= height;
    gwinFB[fbId].x1 = gwinFB[fbId].x0 + gwinFB[fbId].width;
    gwinFB[fbId].y1 = gwinFB[fbId].y0 + gwinFB[fbId].height;
//    gwinFB[fbId].pitch = width & 0xFFFC;//width; //(width & 0xFFF8);  // pitch must be 4-pix alignment
    gwinFB[fbId].addr  = addr;
    gwinFB[fbId].size  = size;

    // FB format
    gwinFB[fbId].fbFmt  = (fbFmt != FB_FMT_AS_DEFAULT) ? fbFmt : gwinFB[gwinMap[GWIN_OSD_DEFAULT]].fbFmt;
    gwinFB[fbId].fbFmt |= gwinFB[fbId].fbFmt << 8;

    switch ( (gwinFB[fbId].fbFmt & 0xff ) )
    {
    case GE_FMT_I1 :
        gwinFB[fbId].pitch = (width) >> 3;
        break;
    case GE_FMT_I2 :
        gwinFB[fbId].pitch = (width<<1) >> 3;
        break;
    case GE_FMT_I4 :
        gwinFB[fbId].pitch = (width<<2) >> 3;
        break;
    case GE_FMT_I8 :
        gwinFB[fbId].pitch = width;
        break;
    case GE_FMT_RGB565 :
    case GE_FMT_ARGB1555 :
    case GE_FMT_ARGB4444 :
    case GE_FMT_1ABFgBg12355:
    case GE_FMT_1BAAFGBG123433 :
        gwinFB[fbId].pitch = width << 1;
        break;
    case GE_FMT_ARGB8888 :
        gwinFB[fbId].pitch = width << 2;
        break;
    default :
        //print err
        break;
    }

    // update ptrs
    gwinFB[fbId].prev = gIdLast;
    gwinFB[gIdLast].next = fbId;

    return (GWIN_OK);
}

//-------------------------------------------------------------------------------------------------
/// Set GOP Destination DisplayPlane
/// @param u8GOP_num \b IN: GOP number: 0 or 1
/// @param eDstType \b IN: GOP Destination DisplayPlane Type
/// @return TRUE: sucess / FALSE: fail
//-------------------------------------------------------------------------------------------------
BOOLEAN MDrv_GOP_DstPlane_Set(U8 u8GOP_num, GOPDstType eDstType)
{
    U16 u16RegVal;
#if 1
    MS_IPSEL_GOP IPSEL_GOP;


    if ((u8GOP_num>= MAX_GOP_SUPPORT))
    {
        return FALSE;
    }

//    MsOS_DiableAllInterrupts(u32OldIntr);

    // Set GOP Register for set Dst Plane is OP or IP

    if(current_bank != u8GOP_num)
        GOP_Write16Reg(GOP_BAK_SEL, u8GOP_num, 0x0003);


    u16RegVal = eDstType;
    GOP_Write16Reg(GOP_SVM, u16RegVal, 0x0003);      // Write gwin_dest[1:0]

    GOP_Write16Reg(GOP_BAK_SEL, current_bank, 0x0003);


    // Set GOP is IP0 or IP1
    if ((eDstType & BIT_MASK(GOP_DST_TYPE_VALIDBITS)) == 0x01)
    {
        switch (u8GOP_num)
        {
        case 0:
            if (eDstType == E_GOP_DST_IP0)
            {
                IPSEL_GOP = MS_IP0_SEL_GOP0;
            }
            else if (eDstType == E_GOP_DST_IP1)
            {
                IPSEL_GOP = MS_IP1_SEL_GOP0;
            }
            else
            {
//                MsOS_RestoreAllInterrupts(u32OldIntr);
                return FALSE;
            }
            break;

        case 1:
            if (eDstType == E_GOP_DST_IP0)
            {
                IPSEL_GOP = MS_IP0_SEL_GOP1;
            }
            else if (eDstType == E_GOP_DST_IP1)
            {
                IPSEL_GOP = MS_IP1_SEL_GOP1;
            }
            else
            {
                return FALSE;
            }
            break;
        default:
            return FALSE;
        }
//        _MDrv_Scaler_Set_GOPSel(IPSEL_GOP);
    }

#if 0       // Doesn't necessary.
    //Record in Gobal Variables.
    for (u32Wid =0; u32Wid < MAX_GWIN_SUPPORT; u32Wid++)
    {
        _GWinInfo[u8GOP_num][u32Wid].eDstType = eDstType;
    }
#endif

#endif
    return TRUE;
}

/********************************************************************************/
/// Set GWIN data format to GOP registers
/// @param u8win \b IN \copydoc GWINID
/// @param clrtype \b IN \copydoc GOPColorType
/********************************************************************************/
void MDrv_GOP_GWIN_SetWinFmt(U8 u8win, GOPColorType clrtype)
{
    U16 regval;
    U16 mask;

    GOP_Read16Reg(GOP_GWIN_DTYPE, &regval);
    clrtype = clrtype & 0x0f;
    mask = (U16)(0xF)<< (u8win*4);
    regval &= ~mask;
    regval |= ((clrtype << (u8win*4)) & mask);
    GOP_Write16Reg(GOP_GWIN_DTYPE, regval, GOP_REG_WORD_MASK);

}



/********************************************************************************/
/// Map GE/GOP buffer format
/// @param u8Type \b IN 0: GE to GOP, 1: GOP to GE
/// @param u8Fmt \b IN  Color type of GE/GOP
/********************************************************************************/
U8 MDrv_GOP_GWIN_BufFmtMap(U8 u8Type , U8 u8Fmt)
{
    U8 ret;
    if(u8Type == 0) {       // GE to GOP
        switch(u8Fmt) {
            case GE_FMT_I2:
                ret = E_GOP_COLOR_I2;
                break;
            case GE_FMT_I4:
                ret = E_GOP_COLOR_I4;
                break;
            case GE_FMT_I8:
                ret = E_GOP_COLOR_I8;
                break;
            case GE_FMT_RGB565:
                ret = E_GOP_COLOR_RGB565;
                break;
            case GE_FMT_ARGB1555:
#if (CC_USE_123433 == 1)
                ret = E_GOP_COLOR_ALPHABLINK;
#else
                ret = E_GOP_COLOR_RGB555_BLINK;
#endif

                break;
            case GE_FMT_ARGB4444:
                ret = E_GOP_COLOR_ARGB4444;
                break;
            case GE_FMT_1BAAFGBG123433:
                ret = E_GOP_COLOR_ALPHABLINK;
                break;
            case GE_FMT_ARGB8888:
                ret = E_GOP_COLOR_ARGB8888;
                break;
            case GE_FMT_I1:
            default:
                ret = E_GOP_COLOR_RGB565;
                break;
        }

    }
    else {                  // GOP to GE
        switch(u8Fmt) {
            case E_GOP_COLOR_RGB555_BLINK:
                ret = GE_FMT_ARGB1555;
                break;
            case E_GOP_COLOR_RGB565:
                ret = GE_FMT_RGB565;
                break;
            case E_GOP_COLOR_ARGB4444:
                ret = GE_FMT_ARGB4444;
                break;
            case E_GOP_COLOR_ALPHABLINK:
                ret = GE_FMT_1BAAFGBG123433;
                break;
            case E_GOP_COLOR_I8:
                ret = E_GOP_COLOR_I8;
                break;
            case E_GOP_COLOR_ARGB8888:
                ret = GE_FMT_ARGB1555;
                break;
            case E_GOP_COLOR_I4:
                ret = GE_FMT_ARGB8888;
                break;
            case E_GOP_COLOR_I2:
                ret = GE_FMT_I2;
                break;
            case E_GOP_COLOR_RGB555YUV422:
            case E_GOP_COLOR_YUV422:
            default:
                ret = 0xFF;
                break;

        }
    }

    return ret;
}

/********************************************************************************/
/// Get bpp information according to buffer format
/// @param fbFmt \b IN Buffer format
/// @return bits per pixel (bpp) of spefific buffer format
/********************************************************************************/
U16 MDrv_GOP_GetBPP(U8 fbFmt)
{
    U16 bpp;

    switch ( fbFmt )
    {
    case E_GOP_COLOR_RGB555_BLINK :
    case E_GOP_COLOR_RGB565 :
    case E_GOP_COLOR_ARGB4444 :
    case E_GOP_COLOR_ALPHABLINK :
    case E_GOP_COLOR_RGB555YUV422:
        bpp = 16;
        break;
    case E_GOP_COLOR_ARGB8888 :
        bpp = 32;
        break;

    case E_GOP_COLOR_YUV422:
    case E_GOP_COLOR_I8 :
        bpp = 8;
        break;
    case E_GOP_COLOR_I4 :
        bpp = 4;
        break;

    case E_GOP_COLOR_I2 :
        bpp = 2;
        break;

    default :
        //print err
        break;
    }
    return bpp;

}