panel.c

mstar 776 开发的车载dvd

    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_wPanelHTotal;
#endif
}

U16 devPanel_VTOTAL(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_VTOTAL;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    DBG_PANEL(printf("m_wPanelVTotal!%u\n" , pPanelData->m_wPanelVTotal));
    return pPanelData->m_wPanelVTotal;
#endif
}
#if (KEEP_UNUSED_FUNC == 1)
U16 pnlGetMaxHTotal(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_MAX_HTOTAL;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_wPanelMaxHTotal;
#endif
}
U16 pnlGetMinHTotal(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_MIN_HTOTAL;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_wPanelMinHTotal;
#endif
}

U16 pnlGetMaxVTotal(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_MAX_VTOTAL;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_wPanelMaxVTotal;
#endif
}

U16 pnlGetMinVTotal(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_MIN_VTOTAL;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_wPanelMinVTotal;
#endif
}
#endif

U8 pnlGetDCLK(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_DCLK;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_dwPanelDCLK;
#endif
}
#if (KEEP_UNUSED_FUNC == 1)
U8 pnlGetMaxDCLK(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_MAX_DCLK;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_dwPanelMaxDCLK;
#endif
}
U8 pnlGetMinDCLK(void)
{
#if (USE_PANEL_DEFINE == 1)
    return PANEL_MIN_DCLK;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_dwPanelMinDCLK;
#endif
}
#endif

U16 pnlGetSpreadSpectrumStep(void)
{
#if (USE_PANEL_DEFINE == 1)
    return SET_SSC_STEP;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_wSpreadSpectrumStep;
#endif
}

U16 pnlGetSpreadSpectrumSpan(void)
{
#if (USE_PANEL_DEFINE == 1)
    return SET_SSC_SPAN;
#else
    PanelType * pPanelData;
    pPanelData = tPanelIndexTbl[stGenSetting.g_SysSetting.enPanelResType];
    pPanelData += stGenSetting.g_SysSetting.u8PanelModel;
    return pPanelData->m_wSpreadSpectrumSpan;
#endif
}

/******************************************************************************/
///Get the panel ratio type
/******************************************************************************/
U8 devPanel_PANEL_TYPE(void)
{
#if (PANEL_TYPE_SEL == PNL_DAC_CRT)
     return  OTHER_PANEL;
#else
    if( devPanel_WIDTH() * 9 >= devPanel_HEIGHT() * 16 )
        return  _16_9_PANEL;
    else if ( devPanel_WIDTH() * 3 > devPanel_HEIGHT() * 4 )
        return  WIDE_PANEL;
    else if( devPanel_WIDTH() * 4 == devPanel_HEIGHT() * 5 )
        return  _5_4_PANEL;
    else if( devPanel_WIDTH() * 3 == devPanel_HEIGHT() * 4 )
        return  _4_3_PANEL;
    else
        return  OTHER_PANEL;

#endif
}

BOOLEAN devPanel_IsWidePanel(void)
{
    if( devPanel_PANEL_TYPE() == _16_9_PANEL ||
        devPanel_PANEL_TYPE() == WIDE_PANEL )
    {
        //puts("\r\nWide panel");// kevin XX
        return TRUE;
    }
    else
    {
        //puts("\r\nNot Wide panel");// kevin XX
        return FALSE;
}
}

/******************************************************************************/
///initialize registers for Gamma
/******************************************************************************/
/////////////////////////////////////////////////////////////////////////////
// Gamma format
// 0, 1, 2, 3, ..., 255, 255 (must re-fill 255 (2bytes))
// tNormalGammaR/G/B[]
// _____________________________________________
//  Byte | 1            2            3 ..
//     [inc|cnt]    [inc|cnt]    [inc|cnt]
//
// tNormalGammaR/G/B_2[]
// _____________________________________________
//  Byte | 1              2
//   [p3|p2|p1|p0]  [p7|p6|p5|p4]
BYTE msWriteGammaTbl( BYTE channel, BYTE* ucTab1, BYTE* ucTab2 )
{
    BYTE ucCurVal = 0;
    BYTE ucInc, ucLen;
    WORD wOutCnt = 0;
    BYTE i;
    BYTE ucSecondData = 0;
    BYTE ucMinor;
    U16 u16GammaValue;
    U8 u8Bank;

    u8Bank = MDrv_ReadByte(BK_SELECT_00);
    MDrv_WriteByte(BK_SELECT_00, REG_BANK_VOP);

    for( i = 0; wOutCnt < 256; ++ i )
    {
        ucInc = ucTab1[i]>>5;
        ucLen = ( ucTab1[i] & 0x1f ) + 1;
        while( ucLen > 0 )
        {
            // calculate gamma value
            ucCurVal = ucCurVal + ucInc;
            ucMinor = (ucTab2[wOutCnt/4] >> ((wOutCnt%4)*2)) & 0x3;
            u16GammaValue = (ucCurVal << 2) | ucMinor;
            //printf("ch=%bu,tab1[%bu]=0x%bx,tab2[%u]=0x%bx\n", channel, i, ucTab1[i], wOutCnt/4, ucTab2[wOutCnt/4]);
            //printf("                                      Gamma[%u]=0x%bx,0x%bx,0x%x\n", wOutCnt, ucCurVal, ucMinor, u16GammaValue);

            if (SC_GAMMA_LUT_TYPE == SC_GAMMA_LUT_12BIT)
                u16GammaValue *= 4;

            // write gamma value
            while ((MDrv_ReadByte(BK_SC_VOP_71_L)) & 0xE0);                     //Check whether the Write chanel is ready
            MDrv_WriteByte(BK_SC_VOP_70_L, (U8) wOutCnt);                       // set address port
            MDrv_Write2Byte(BK_SC_VOP_72_L+(channel*2), u16GammaValue);
            MDrv_WriteByte(BK_SC_VOP_71_L, 0x1 << (5+channel));                 // kick off
            /*{
                // wait write finished
                while ((MDrv_ReadByte(BK_SC_VOP_71_L)) & 0xE0);                 //Check whether the Write chanel is ready

                //read back
                MDrv_WriteByte(BK_SC_VOP_70_L, (U8) wOutCnt);                   // set address port
                MDrv_WriteByte(BK_SC_VOP_71_H, 0x1 << (5+channel));             // kick off
                while ((MDrv_ReadByte(BK_SC_VOP_71_H)) & 0xE0);                 //Check whether the Write chanel is ready
                //u16GammaValue = MDrv_Read2Byte(L_BK_VOP(0x75+channel));
                u16GammaValue = MDrv_Read2Byte(BK_SC_VOP_75_L+(channel*2));
                printf("                                      regGamma=0x%x\n", u16GammaValue);
            }*/

            if( 0 == wOutCnt )
            {
                ucSecondData = ucCurVal;
            }
            ++ wOutCnt;

            -- ucLen;
        } // while
    } // for

    MDrv_WriteByte(BK_SELECT_00, u8Bank);

    return ucSecondData;
}

void devPanel_InitGammaTbl(void)
{
    BYTE ucBank;
    BYTE ucTgtChannel = 0;
    BYTE* pcTab1;
    BYTE* pcTab2;
    BYTE ucFirstData;

    BYTE ucBackupMainSubEnableFlag = 0;

    ucBank = MDrv_ReadByte(BK_SELECT_00);
    MDrv_WriteByte(BK_SELECT_00, REG_BANK_VOP);

    // If gamma is on, turn if off
    if(MDrv_ReadByte(BK_SC_VOP_50_L) & _BIT0)
    {
        MDrv_WriteByteMask(BK_SC_VOP_50_L, 0, _BIT0);
        ucBackupMainSubEnableFlag |= _BIT0;
    }

    while( ucTgtChannel < 3 )   // 0 for R, 1 for G, 2 for B
    {
        pcTab1 = tAllGammaTab[0][0+2*ucTgtChannel];
        pcTab2 = tAllGammaTab[0][1+2*ucTgtChannel];

        // Write data to gamma channel
        ucFirstData = msWriteGammaTbl( ucTgtChannel, pcTab1, pcTab2 );

        ucTgtChannel += 1;
    }

    // Recovery gamma table
    if( ucBackupMainSubEnableFlag & _BIT0 )
        MDrv_WriteByteMask(BK_SC_VOP_50_L, 1, _BIT0);

    MDrv_WriteByte(BK_SELECT_00, ucBank);
}

U32 devPanel_DClkFactor(void)
{
    return (((U32)MST_XTAL_CLOCK_MHZ * PANEL_LPLL_MM)*(524288 * PANEL_LPLL_LM * PANEL_LPLL_K)/PANEL_LPLL_A);
}

/******************************************************************************/
///Get the panel DCLK
/******************************************************************************/
U8 devPanel_DCLK(void)
{
    return PANEL_DCLK;
}

/******************************************************************************/
///Get the panel has dual port or not
/******************************************************************************/
BOOLEAN devPanel_Is_DUAL_PORT(void)
{
    return PANEL_DUAL_PORT;
}

BOOLEAN devPanel_Is_ChannelSwap(void)
{
    return PANEL_DUAL_PORT ? ((PANEL_CONNECTOR_SWAP_PORT != FALSE) != (PANEL_SWAP_PORT != FALSE)) : FALSE;
}

U16 devPanel_MaxVTOTAL(void)
{
    return PANEL_MAX_VTOTAL;
}

U16 devPanel_MinHTOTAL(void)
{
    return PANEL_MIN_HTOTAL;
}

U8 devPanel_LockYLine(void)
{
    return PANEL_LOCK_Y_LINE;
}

/******************************************************************************/
///Get the panel type is LVDS or not
/******************************************************************************/
BOOLEAN devPanel_IsLVDS(void)
{
    return PANEL_LVDS;
}

/******************************************************************************/
///Get the panel type is TTL or not
/******************************************************************************/
BOOLEAN devPanel_IsTTL(void)
{
    return PANEL_TTL;
}

/******************************************************************************/
///Get the panel has TCON or not
/******************************************************************************/
BOOLEAN devPanel_IsTCON(void)
{
    return PANEL_DTCON;
}

/******************************************************************************/
///Get the panel has analog TCON or not
/******************************************************************************/
BOOLEAN devPanel_Is_ANALOG_TCON(void)
{
    return PANEL_ATCON;
}

U16 devPanel_DE_VSTART(void)
{
    return PANEL_DE_VSTART;
}

U16 devPanel_OCTRL(void)
{
    return ((((PANEL_DUAL_PORT & _BIT0) | (PANEL_CONNECTOR_SWAP_PORT & _BIT1))<<8) |
            ((PANEL_SWAP_EVEN_RB & _BIT0) | (PANEL_SWAP_ODD_RB & _BIT1) |
            (PANEL_SWAP_EVEN_ML & _BIT2) | (PANEL_SWAP_ODD_ML &_BIT3)));
}

U16 devPanel_OSTRL(void)
{
    return ((U16)(0xF7<<8) | (PANEL_DCLK_DELAY << 4 ) | (_BIT3 & PANEL_INV_DCLK) |
            (_BIT2 & PANEL_INV_DE) | (_BIT1 & PANEL_INV_VSYNC) |
            (_BIT0 & PANEL_INV_HSYNC));
}

U8 devPanel_ODRV (void)
{
    return ((PANEL_DCLK_CURRENT << 6) | (PANEL_DE_CURRENT << 4) |
            (PANEL_ODD_DATA_CURRENT << 2) | (PANEL_EVEN_DATA_CURRENT));
}

U16 devPanel_DITHCTRL(void)
{
#if (PANEL_DITHER)
    return 0x2D05;
#else
    return 0x2D00;
#endif
}