s3c6410_display_con.c

来自「6410BSP3」· C语言 代码 · 共 1,790 行 · 第 1/5 页

                            g_Win1Config.ByteSwapping | g_Win1Config.HalfWordSwapping | g_Win1Config.LocaPathSourceFormat |
                            g_Win1Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win1Config.BPP_Mode) |
                            ALPHASEL_ALPHA0;

    g_pDispConReg->VIDOSD1A = OSD_LEFTTOPX_F(g_Win1Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win1Config.uiOffsetY);

    g_pDispConReg->VIDOSD1B = OSD_RIGHTBOTX_F(g_Win1Config.uiWidth+g_Win1Config.uiOffsetX-1) |
                                OSD_RIGHTBOTY_F(g_Win1Config.uiHeight+g_Win1Config.uiOffsetY-1);

    g_pDispConReg->VIDOSD1C = 0x0;

    g_pDispConReg->VIDOSD1D = OSD_SIZE(g_Win1Config.uiWidth*g_Win1Config.uiHeight);

    DISP_MSG((_T("[DISP]--Disp_window1_initialize() : %d\n\r"), error));

    return error;
}

static DISP_ERROR Disp_window2_initialize(DISP_WINDOW_MODE Mode, DISP_BPP_MODE BPPMode, unsigned int uiWidth, unsigned int uiHeight, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_window2_initialize(%d, %d, %d, %d, %d, %d)\n\r"), Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY));

    switch(Mode)
    {
    case DISP_WIN2_DMA:
        g_Win2Config.LocalPathEnable = LOCAL_PATH_DISABLE;
        //g_Win2Config.LocalPathSelect;            // Don't care when Local Path is disabled
        //g_Win2Config.LocaPathSourceFormat;    // Don't care when Local Path is disabled
        break;
    case DISP_WIN2_TVSCALER_RGB:
        g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
        g_Win2Config.LocalPathSelect = LOCALSEL_TVSCALER;
        g_Win2Config.LocaPathSourceFormat = LOCAL_IN_RGB888;
        break;
    case DISP_WIN2_TVSCALER_YUV:
        g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
        g_Win2Config.LocalPathSelect = LOCALSEL_TVSCALER;
        g_Win2Config.LocaPathSourceFormat = LOCAL_IN_YUV444;
        break;
    case DISP_WIN2_CICODEC_RGB:
        g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
        g_Win2Config.LocalPathSelect = LOCALSEL_CIPREVIEW;
        g_Win2Config.LocaPathSourceFormat = LOCAL_IN_RGB888;
        break;
    case DISP_WIN2_CICODEC_YUV:
        g_Win2Config.LocalPathEnable = LOCAL_PATH_ENABLE;
        g_Win2Config.LocalPathSelect = LOCALSEL_CIPREVIEW;
        g_Win2Config.LocaPathSourceFormat = LOCAL_IN_YUV444;
        break;
    default:
        DISP_ERR((_T("[DISP:ERR] Disp_window2_initialize() : Unsupported Window Mode [%d]\n\r"), Mode));
        return DISP_ERROR_ILLEGAL_PARAMETER;
        break;
    }

    g_Win2Config.BitSwapping = BITSWP_DISABLE;
    g_Win2Config.ByteSwapping = BYTSWP_DISABLE;
    g_Win2Config.HalfWordSwapping = HAWSWP_DISABLE;

    switch(BPPMode)
    {
    //case DISP_1BPP:
    //case DISP_2BPP:
    //case DISP_4BPP:
    //case DISP_8BPP_NOPAL:
    //case DISP_16BPP_A555:
    //case DISP_16BPP_I555:
    //case DISP_18BPP_A665:
    //case DISP_19BPP_A666:
    //case DISP_24BPP_A887:
    //case DISP_25BPP_A888:
    case DISP_16BPP_565:
        g_Win2Config.uiPageWidth = uiWidth*2;    // 2 byte per pixel
        g_Win2Config.HalfWordSwapping = HAWSWP_ENABLE;    // 16BPP need Halfword Swapping
        break;
    case DISP_18BPP_666:
    case DISP_24BPP_888:
        g_Win2Config.uiPageWidth = uiWidth*4;    // 4 byte per pixel
        break;
    default:
        DISP_ERR((_T("[DISP:ERR] Disp_window2_initialize() : Unsupported BPP Mode [%d]\n\r"), BPPMode));
        return DISP_ERROR_ILLEGAL_PARAMETER;
        break;
    }

    g_Win2Config.BPP_Mode = BPPMode;
    g_Win2Config.BufferSelect = BUFSEL_BUF0;
    g_Win2Config.BufferAutoControl = BUFAUTO_DISABLE;
    g_Win2Config.uiWidth = uiWidth;
    g_Win2Config.uiHeight = uiHeight;
    g_Win2Config.uiOffsetX = uiOffsetX;
    g_Win2Config.uiOffsetY = uiOffsetY;

    if (g_Win2Config.LocalPathEnable == LOCAL_PATH_ENABLE)
    {
        g_Win2Config.BurstLength = BURSTLEN_4WORD;    // 4 Words Burst
    }
    else if ((g_Win2Config.uiPageWidth%64) == 0)        // 16 words burst case
    {
        g_Win2Config.BurstLength = BURSTLEN_16WORD;
    }
    else if ((g_Win2Config.uiPageWidth%32) == 0)    // 8 words burst case
    {
        g_Win2Config.BurstLength = BURSTLEN_8WORD;
    }
    else if ((g_Win2Config.uiPageWidth%16) == 0)    // 4 words burst case
    {
        g_Win2Config.BurstLength = BURSTLEN_4WORD;
    }
    else
    {
        DISP_ERR((_T("[DISP:ERR] Disp_window2_initialize() : uiPageWidth is not Word Aligned [%d]\n\r"), g_Win0Config.uiPageWidth));
        return DISP_ERROR_ILLEGAL_PARAMETER;
    }

    g_pDispConReg->WINCON2 = CSC_WIDE_RANGE | g_Win2Config.LocalPathSelect | //g_Win2Config.LocalPathEnable |
                            g_Win2Config.BufferSelect | g_Win2Config.BufferAutoControl | g_Win2Config.BitSwapping |
                            g_Win2Config.ByteSwapping | g_Win2Config.HalfWordSwapping | g_Win2Config.LocaPathSourceFormat |
                            g_Win2Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win2Config.BPP_Mode) |
                            ALPHASEL_ALPHA0;

    g_pDispConReg->VIDOSD2A = OSD_LEFTTOPX_F(g_Win2Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win2Config.uiOffsetY);

    g_pDispConReg->VIDOSD2B = OSD_RIGHTBOTX_F(g_Win2Config.uiWidth+g_Win2Config.uiOffsetX-1) |
                                OSD_RIGHTBOTY_F(g_Win2Config.uiHeight+g_Win2Config.uiOffsetY-1);

    g_pDispConReg->VIDOSD2C = 0x0;

    g_pDispConReg->VIDOSD2D = OSD_SIZE(g_Win2Config.uiWidth*g_Win2Config.uiHeight);

    DISP_MSG((_T("[DISP]--Disp_window2_initialize() : %d\n\r"), error));

    return error;
}

static DISP_ERROR Disp_window3_initialize(DISP_WINDOW_MODE Mode, DISP_BPP_MODE BPPMode, unsigned int uiWidth, unsigned int uiHeight, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_window3_initialize(%d, %d, %d, %d, %d, %d)\n\r"), Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY));

    g_Win3Config.BitSwapping = BITSWP_DISABLE;
    g_Win3Config.ByteSwapping = BYTSWP_DISABLE;
    g_Win3Config.HalfWordSwapping = HAWSWP_DISABLE;

    switch(BPPMode)
    {
    //case DISP_1BPP:
    //case DISP_2BPP:
    //case DISP_4BPP:
    //case DISP_16BPP_A555:
    //case DISP_16BPP_I555:
    //case DISP_18BPP_A665:
    //case DISP_19BPP_A666:
    //case DISP_24BPP_A887:
    //case DISP_25BPP_A888:
    case DISP_16BPP_565:
        g_Win3Config.uiPageWidth = uiWidth*2;    // 2 byte per pixel
        g_Win3Config.HalfWordSwapping = HAWSWP_ENABLE;    // 16BPP need Halfword Swapping
        break;
    case DISP_18BPP_666:
    case DISP_24BPP_888:
        g_Win3Config.uiPageWidth = uiWidth*4;    // 4 byte per pixel
        break;
    default:
        DISP_ERR((_T("[DISP:ERR] Disp_window3_initialize() : Unsupported BPP Mode [%d]\n\r"), BPPMode));
        return DISP_ERROR_ILLEGAL_PARAMETER;
        break;
    }

    g_Win3Config.BPP_Mode = BPPMode;
    g_Win3Config.uiWidth = uiWidth;
    g_Win3Config.uiHeight = uiHeight;
    g_Win3Config.uiOffsetX = uiOffsetX;
    g_Win3Config.uiOffsetY = uiOffsetY;

    if (g_Win3Config.uiPageWidth%4)
    {
        DISP_ERR((_T("[DISP:ERR] Disp_window3_initialize() : uiPageWidth is not Word Aligned [%d]\n\r"), g_Win0Config.uiPageWidth));
        return DISP_ERROR_ILLEGAL_PARAMETER;
    }
    else if (g_Win3Config.uiPageWidth >= 16*4)
    {
        g_Win3Config.BurstLength = BURSTLEN_16WORD;
    }
    else if (g_Win3Config.uiPageWidth >= 8*4)
    {
        g_Win3Config.BurstLength = BURSTLEN_8WORD;
    }
    else
    {
        g_Win3Config.BurstLength = BURSTLEN_4WORD;
    }

    g_pDispConReg->WINCON3 = g_Win3Config.BitSwapping | g_Win3Config.ByteSwapping | g_Win3Config.HalfWordSwapping |
                            g_Win3Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win3Config.BPP_Mode) |
                            ALPHASEL_ALPHA0;

    g_pDispConReg->VIDOSD3A = OSD_LEFTTOPX_F(g_Win3Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win3Config.uiOffsetY);

    g_pDispConReg->VIDOSD3B = OSD_RIGHTBOTX_F(g_Win3Config.uiWidth+g_Win3Config.uiOffsetX-1) |
                                OSD_RIGHTBOTY_F(g_Win3Config.uiHeight+g_Win3Config.uiOffsetY-1);

    g_pDispConReg->VIDOSD3C = 0x0;

    DISP_MSG((_T("[DISP]--Disp_window3_initialize() : %d\n\r"), error));

    return error;
}

static DISP_ERROR Disp_window4_initialize(DISP_WINDOW_MODE Mode, DISP_BPP_MODE BPPMode, unsigned int uiWidth, unsigned int uiHeight, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_window4_initialize(%d, %d, %d, %d, %d, %d)\n\r"), Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY));

    g_Win4Config.BitSwapping = BITSWP_DISABLE;
    g_Win4Config.ByteSwapping = BYTSWP_DISABLE;
    g_Win4Config.HalfWordSwapping = HAWSWP_DISABLE;

    switch(BPPMode)
    {
    //case DISP_1BPP:
    //case DISP_2BPP:
    //case DISP_16BPP_A555:
    //case DISP_16BPP_I555:
    //case DISP_18BPP_A665:
    //case DISP_19BPP_A666:
    //case DISP_24BPP_A887:
    //case DISP_25BPP_A888:
    case DISP_16BPP_565:
        g_Win4Config.uiPageWidth = uiWidth*2;    // 2 byte per pixel
        g_Win4Config.HalfWordSwapping = HAWSWP_ENABLE;    // 16BPP need Halfword Swapping
        break;
    case DISP_18BPP_666:
    case DISP_24BPP_888:
        g_Win4Config.uiPageWidth = uiWidth*4;    // 4 byte per pixel
        break;
    default:
        DISP_ERR((_T("[DISP:ERR] Disp_window4_initialize() : Unsupported BPP Mode [%d]\n\r"), BPPMode));
        return DISP_ERROR_ILLEGAL_PARAMETER;
        break;
    }

    g_Win4Config.BPP_Mode = BPPMode;
    g_Win4Config.uiWidth = uiWidth;
    g_Win4Config.uiHeight = uiHeight;
    g_Win4Config.uiOffsetX = uiOffsetX;
    g_Win4Config.uiOffsetY = uiOffsetY;

    if (g_Win4Config.uiPageWidth%4)
    {
        DISP_ERR((_T("[DISP:ERR] Disp_window4_initialize() : uiPageWidth is not Word Aligned [%d]\n\r"), g_Win0Config.uiPageWidth));
        return DISP_ERROR_ILLEGAL_PARAMETER;
    }
    else if (g_Win4Config.uiPageWidth >= 16*4)
    {
        g_Win4Config.BurstLength = BURSTLEN_16WORD;
    }
    else if (g_Win4Config.uiPageWidth >= 8*4)
    {
        g_Win4Config.BurstLength = BURSTLEN_8WORD;
    }
    else
    {
        g_Win4Config.BurstLength = BURSTLEN_4WORD;
    }

    g_pDispConReg->WINCON4 = g_Win4Config.BitSwapping | g_Win4Config.ByteSwapping | g_Win4Config.HalfWordSwapping |
                            g_Win4Config.BurstLength | BLEND_PER_PLANE | BPPMODE_F(g_Win4Config.BPP_Mode) |
                            ALPHASEL_ALPHA0;

    g_pDispConReg->VIDOSD4A = OSD_LEFTTOPX_F(g_Win4Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win4Config.uiOffsetY);

    g_pDispConReg->VIDOSD4B = OSD_RIGHTBOTX_F(g_Win4Config.uiWidth+g_Win4Config.uiOffsetX-1) |
                                OSD_RIGHTBOTY_F(g_Win4Config.uiHeight+g_Win4Config.uiOffsetY-1);

    g_pDispConReg->VIDOSD4C = 0x0;

    DISP_MSG((_T("[DISP]--Disp_window4_initialize() : %d\n\r"), error));

    return error;
}

static BOOL Disp_get_vclk_direction_divider(unsigned int CLKSrc, unsigned int *ClkDir, unsigned int *ClkDiv)
{
    DWORD dwVCLKSrc = 0;
    DWORD dwHozTime = 0;
    DWORD dwVerTime = 0;
    DWORD dwVCLK = 0;
    DWORD dwDiv = 0;

    DISP_MSG((_T("[DISP]++Disp_get_vclk_direction_divider(%d)\n\r"), CLKSrc));

    if (CLKSrc == CLKSEL_F_HCLK)
    {
        dwVCLKSrc = S3C6410_HCLK;
        DISP_INF((_T("[DISP:INF] VCLK Source = HCLK (%d Hz)\n\r"), dwVCLKSrc));
    }
    else if (CLKSrc == CLKSEL_F_LCDCLK)
    {
        dwVCLKSrc = S3C6410_DoutMPLL;    // LCD_CLK is set to DoutMPLL by CLK_SRC in SysCon
        DISP_INF((_T("[DISP:INF] VCLK Source = LCDCLK (%d Hz)\n\r"), dwVCLKSrc));
    }
    else if (CLKSrc == CLKSEL_F_EXT27M)
    {
        dwVCLKSrc = 27000000;    // 27MHz
        DISP_INF((_T("[DISP:INF] VCLK Source = EXT27M (%d Hz)\n\r"), dwVCLKSrc));
    }
    else
    {
        DISP_ERR((_T("[DISP:ERR] --Disp_get_vclk_direction_divider() : Unknown CLKSrc = %d\n\r"), CLKSrc));
        return FALSE;
    }

    switch(g_DevInfoRGB.RGBOutMode)
    {
        case DISP_16BIT_RGB565_P:
        case DISP_18BIT_RGB666_P:
        case DISP_24BIT_RGB888_P:
            dwHozTime = g_DevInfoRGB.uiWidth+g_DevInfoRGB.HBPD_Value+g_DevInfoRGB.HFPD_Value+g_DevInfoRGB.HSPW_Value;
            break;
        case DISP_16BIT_RGB565_S:
        case DISP_18BIT_RGB666_S:
        case DISP_24BIT_RGB888_S:
            dwHozTime = g_DevInfoRGB.uiWidth*3+g_DevInfoRGB.HBPD_Value+g_DevInfoRGB.HFPD_Value+g_DevInfoRGB.HSPW_Value;
            break;
    }

    dwVerTime = g_DevInfoRGB.uiHeight+g_DevInfoRGB.VBPD_Value+g_DevInfoRGB.VFPD_Value+g_DevInfoRGB.VSPW_Value;

    dwVCLK = dwHozTime*dwVerTime*g_DevInfoRGB.Frame_Rate;

    dwDiv = dwVCLKSrc/dwVCLK;

    DISP_INF((_T("[DISP:INF] VCLKSrc = %d, VCLK = %d, Div = %d\n\r"), dwVCLKSrc, dwVCLK, dwDiv));

    if (dwDiv < 1)
    {
        DISP_ERR((_T("[DISP:ERR] --Disp_get_vclk_direction_divider() : VCLK Source is Too Slow\n\r")));
        return FALSE;
    }
    else     if (dwDiv == 1)
    {
        // No Divide, Direct Clock
        *ClkDir = CLKDIR_DIRECT;
        *ClkDiv = 1;
        DISP_INF((_T("[DISP:INF] VCLK Direction = Direct, VCLK = %d Hz\n\r"), dwVCLKSrc));
    }
    else
    {
        // Divide by more than 1, Divided Clock
        *ClkDir = CLKDIR_DIVIDED;
        *ClkDiv = dwDiv;
        DISP_INF((_T("[DISP:INF] VCLK Direction = Divided, Divider = %d, VCLK = %d Hz\n\r"), *ClkDiv,  (unsigned int)((double)dwVCLKSrc/(double)(*ClkDiv))));