s3c6410_display_con.c

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

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES OR INDEMNITIES.
//
//
// Copyright (c) Samsung Electronics. Co. LTD.  All rights reserved.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:    s3c6410_display_con.c

Abstract:       Implementation of Display Controller Control Library
                This module implements Low Level HW control 

Functions:


Notes:


--*/

#include <windows.h>
#include <bsp_cfg.h>    // for reference S3C6410_HCLK, S3C6410_ECLK
#include <s3c6410.h>
#include "s3c6410_display_con.h"
#include "s3c6410_display_con_macro.h"

#define DISP_MSG(x)
#define DISP_INF(x)
#define DISP_ERR(x)    RETAILMSG(TRUE, x)

static volatile S3C6410_DISPLAY_REG *g_pDispConReg = NULL;
static volatile S3C6410_MSMIF_REG *g_pMSMIFReg = NULL;
static volatile S3C6410_GPIO_REG *g_pGPIOReg = NULL;

static tDevInfo g_DevInfoRGB;
static tDevInfo g_DevInfoTV;
static tDispWindow0Config g_Win0Config;
static tDispWindow12Config g_Win1Config;
static tDispWindow12Config g_Win2Config;
static tDispWindow34Config g_Win3Config;
static tDispWindow34Config g_Win4Config;

DISP_ERROR Disp_initialize_register_address(void *pDispConReg, void *pMSMIFReg, void *pGPIOReg)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_initialize_register_address(0x%08x, 0x%08x, 0x%08x)\n\r"), pDispConReg, pMSMIFReg, pGPIOReg));

    if (pDispConReg == NULL || pMSMIFReg == NULL || pGPIOReg == NULL)
    {
        DISP_ERR((_T("[DISP:ERR] Disp_initialize_register_address() : NULL pointer parameter\n\r")));
        error = DISP_ERROR_NULL_PARAMETER;
    }
    else
    {
        g_pDispConReg = (S3C6410_DISPLAY_REG *)pDispConReg;
        g_pMSMIFReg = (S3C6410_MSMIF_REG *)pMSMIFReg;
        g_pGPIOReg = (S3C6410_GPIO_REG *)pGPIOReg;
        DISP_INF((_T("[DISP:INF] g_pDispConReg = 0x%08x\n\r"), g_pDispConReg));
        DISP_INF((_T("[DISP:INF] g_pMSMIFReg = 0x%08x\n\r"), g_pMSMIFReg));
        DISP_INF((_T("[DISP:INF] g_pGPIOReg    = 0x%08x\n\r"), g_pGPIOReg));
    }

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

    return error;
}

DISP_ERROR Disp_set_output_device_information(void *pInfo)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_set_output_device_information(%0x08x)\n\r"), pInfo));

    if (pInfo == NULL)
    {
        DISP_ERR((_T("[DISP:ERR] Disp_set_output_device_information() : NULL pointer parameter\n\r")));
        error = DISP_ERROR_NULL_PARAMETER;
    }
    else
    {
        memcpy(&g_DevInfoRGB, pInfo, sizeof(tDevInfo));
    }

    DISP_MSG((_T("[DISP]--Disp_set_output_device_information()\n\r")));

    return error;
}

#if    0    // Depricated
void* Disp_get_output_device_information_buffer(void)
{
    DISP_MSG((_T("[DISP]++Disp_get_output_device_information_buffer()\n\r")));

    // Device Information is Filled by LDI_fill_output_device_information()
    return (void *)&g_DevInfoRGB;
}
#endif

DISP_ERROR Disp_set_output_TV_information(unsigned int uiWidth, unsigned int uiHeight)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_set_output_TV_information(%d, %d)\n\r"), uiWidth, uiHeight));

    if (uiWidth > 800)
    {
        DISP_ERR((_T("[DISP:ERR] Disp_set_output_TV_information() : Horizontal Resolution[%d] should lower than 800 pixel\n\r"), uiWidth));
        error = DISP_ERROR_ILLEGAL_PARAMETER;
    }
    else
    {
        g_DevInfoTV.RGBOutMode = DISP_18BIT_RGB666_S;
        g_DevInfoTV.uiWidth = uiWidth;
        g_DevInfoTV.uiHeight = uiHeight;
        g_DevInfoTV.VBPD_Value = 3;
        g_DevInfoTV.VFPD_Value = 5;
        g_DevInfoTV.VSPW_Value = 5;
        g_DevInfoTV.HBPD_Value = 13;
        g_DevInfoTV.HFPD_Value = 8;
        g_DevInfoTV.HSPW_Value = 3;
        g_DevInfoTV.VCLK_Polarity = IVCLK_FALL_EDGE;
        g_DevInfoTV.HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
        g_DevInfoTV.VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
        g_DevInfoTV.VDEN_Polarity = IVDEN_HIGH_ACTIVE;
        g_DevInfoTV.PNR_Mode = PNRMODE_RGB_P;
        g_DevInfoTV.VCLK_Source = CLKSEL_F_EXT27M;
        g_DevInfoTV.VCLK_Direction = CLKDIR_DIRECT;
        g_DevInfoTV.Frame_Rate = 60;
    }

    DISP_MSG((_T("[DISP]--Disp_set_output_TV_information()\n\r")));

    return error;
}

DISP_ERROR Disp_initialize_output_interface(DISP_VIDOUT_MODE VidoutMode)
{
    DISP_ERROR error = DISP_SUCCESS;

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

    if (g_pDispConReg == NULL || g_pGPIOReg == NULL)
    {
        DISP_ERR((_T("[DISP:ERR] Disp_initialize_output_interface() : Register Address Not Initialized\n\r")));
        error = DISP_ERROR_NOT_INITIALIZED;
    }

    g_DevInfoRGB.VideoOutMode = VidoutMode;

    switch(VidoutMode)
    {
    case DISP_VIDOUT_RGBIF:
        Disp_initialize_port_RGBIF(g_DevInfoRGB.RGBOutMode);
        Disp_initialize_RGBIF();
        break;
    case DISP_VIDOUT_TVENCODER:
        // TODO: Port Close ???? Disp_initialize_port_RGBIF(g_DevInfoRGB.RGBOutMode);
        Disp_initialize_TVEnc();
        break;
    case DISP_VIDOUT_RGBIF_TVENCODER:
        Disp_initialize_port_RGBIF(g_DevInfoRGB.RGBOutMode);
        Disp_initialize_RGBIF_withTVEnc();
        break;
    case DISP_VIDOUT_I80IF_LDI0:
    case DISP_VIDOUT_I80IF_LDI1:
    case DISP_VIDOUT_I80IF_LDI0_TVENCODER:
    case DISP_VIDOUT_I80IF_LDI1_TVENCODER:
    default:
        DISP_ERR((_T("[DISP:ERR] Disp_initialize_output_interface() : Not Implemented Video Output Mode [%d]\n\r"), VidoutMode));
        error = DISP_ERROR_NOT_IMPLEMENTED;
        break;
    }

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

    return error;
}

DISP_ERROR Disp_set_window_mode(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_set_window_mode(%d)\n\r"), Mode));

    switch(Mode)
    {
    case DISP_WIN0_DMA:
    case DISP_WIN0_POST_RGB:
    case DISP_WIN0_POST_YUV:
        Disp_window0_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
        break;
    case DISP_WIN1_DMA:
    case DISP_WIN1_TVSCALER_RGB:
    case DISP_WIN1_TVSCALER_YUV:
    case DISP_WIN1_CIPREVIEW_RGB:
    case DISP_WIN1_CIPREVIEW_YUV:
        Disp_window1_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
        break;
    case DISP_WIN2_DMA:
    case DISP_WIN2_TVSCALER_RGB:
    case DISP_WIN2_TVSCALER_YUV:
    case DISP_WIN2_CICODEC_RGB:
    case DISP_WIN2_CICODEC_YUV:
        Disp_window2_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
        break;
    case DISP_WIN3_DMA:
        Disp_window3_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
        break;
    case DISP_WIN4_DMA:
        Disp_window4_initialize(Mode, BPPMode, uiWidth, uiHeight, uiOffsetX, uiOffsetY);
        break;
    default:
        DISP_ERR((_T("[DISP:ERR] Disp_set_window_mode() : Unsupported Window Mode [%d]\n\r"), Mode));
        error = DISP_ERROR_ILLEGAL_PARAMETER;
        break;
    }

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

    return error;
}

DISP_ERROR Disp_set_window_position(DISP_WINDOW Win, unsigned int uiOffsetX, unsigned int uiOffsetY)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_set_window_position(%d, %d, %d)\n\r"), Win, uiOffsetX, uiOffsetY));

    switch(Win)
    {
    case DISP_WIN0:
        g_Win0Config.uiOffsetX = uiOffsetX;
        g_Win0Config.uiOffsetY = uiOffsetY;

        g_pDispConReg->VIDOSD0A = OSD_LEFTTOPX_F(g_Win0Config.uiOffsetX) | OSD_LEFTTOPY_F(g_Win0Config.uiOffsetY);

        g_pDispConReg->VIDOSD0B = OSD_RIGHTBOTX_F(g_Win0Config.uiWidth+g_Win0Config.uiOffsetX-1) |
                                    OSD_RIGHTBOTY_F(g_Win0Config.uiHeight+g_Win0Config.uiOffsetY-1);
        break;
    case DISP_WIN1:
        g_Win1Config.uiOffsetX = uiOffsetX;
        g_Win1Config.uiOffsetY = uiOffsetY;

        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);
        break;
    case DISP_WIN2:
        g_Win2Config.uiOffsetX = uiOffsetX;
        g_Win2Config.uiOffsetY = uiOffsetY;

        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);
        break;
    case DISP_WIN3:
        g_Win3Config.uiOffsetX = uiOffsetX;
        g_Win3Config.uiOffsetY = uiOffsetY;

        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);
        break;
    case DISP_WIN4:
        g_Win4Config.uiOffsetX = uiOffsetX;
        g_Win4Config.uiOffsetY = uiOffsetY;

        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);
        break;
    default:
        DISP_ERR((_T("[DISP:ERR] Disp_set_window_position() : Unknown Window Number [%d]\n\r"), Win));
        error = DISP_ERROR_ILLEGAL_PARAMETER;
        break;
    }

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

    return error;
}

DISP_ERROR Disp_set_framebuffer(DISP_WINDOW Win, unsigned int uiFrameBufferAddress)
{
    DISP_ERROR error = DISP_SUCCESS;

    DISP_MSG((_T("[DISP]++Disp_set_framebuffer(%d, 0x%08x)\n\r"), Win, uiFrameBufferAddress));

    switch(Win)
    {
    case DISP_WIN0:
        if (g_Win0Config.LocalPathEnable == LOCAL_PATH_ENABLE)
        {
#if    0
            DISP_ERR((_T("[DISP:ERR] Disp_set_framebuffer() : Window0 Local Path is Enabled\n\r")));
            error = DISP_ERROR_ILLEGAL_PARAMETER;
#else
            // Safe Frame buffer Address for Local Path
            g_pDispConReg->VIDW00ADD0B0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
            g_pDispConReg->VIDW00ADD1B0 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+0x10);    // 4 Words
            g_pDispConReg->VIDW00ADD2 = PAGEWIDTH_F(0x10);                                    // 4 Words
            g_pDispConReg->WINCON0 &= ~(BUFSEL_BUF1);    // Buffer set to Buf0
#endif
        }
        else
        {
            g_pDispConReg->VIDW00ADD0B0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
            g_pDispConReg->VIDW00ADD1B0 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+g_Win0Config.uiPageWidth*g_Win0Config.uiHeight);
            g_pDispConReg->VIDW00ADD2 = PAGEWIDTH_F(g_Win0Config.uiPageWidth);
            g_pDispConReg->WINCON0 &= ~(BUFSEL_BUF1);    // Buffer set to Buf0
        }
        break;
    case DISP_WIN1:
        if (g_Win1Config.LocalPathEnable == LOCAL_PATH_ENABLE)
        {
#if    0
            DISP_ERR((_T("[DISP:ERR] Disp_set_framebuffer() : Window1 Local Path is Enabled\n\r")));
            error = DISP_ERROR_ILLEGAL_PARAMETER;
#else
            // Safe Frame buffer Address for Local Path
            g_pDispConReg->VIDW01ADD0B0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
            g_pDispConReg->VIDW01ADD1B0 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+0x10);    // 4 Words
            g_pDispConReg->VIDW01ADD2 = PAGEWIDTH_F(0x10);                                    // 4 Words
            g_pDispConReg->WINCON1 &= ~(BUFSEL_BUF1);    // Buffer set to Buf0
#endif
        }
        else
        {
            g_pDispConReg->VIDW01ADD0B0 = VBANK_F(uiFrameBufferAddress>>24) | VBASEU_F(uiFrameBufferAddress);
            g_pDispConReg->VIDW01ADD1B0 = VBASEL_F(VBASEU_F(uiFrameBufferAddress)+g_Win1Config.uiPageWidth*g_Win1Config.uiHeight);
            g_pDispConReg->VIDW01ADD2 = PAGEWIDTH_F(g_Win1Config.uiPageWidth);
            g_pDispConReg->WINCON1 &= ~(BUFSEL_BUF1);    // Buffer set to Buf0
        }
        break;
    case DISP_WIN2:
        if (g_Win2Config.LocalPathEnable == LOCAL_PATH_ENABLE)
        {
#if    0
            DISP_ERR((_T("[DISP:ERR] Disp_set_framebuffer() : Window2 Local Path is Enabled\n\r")));