//
// 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_ldi.c

Abstract:       Libray to control LDI

Functions:


Notes:


--*/

#include <bsp.h>
//#include <windows.h>
//#include <bsp_cfg.h>
//#include <s3c6410.h>
#include "s3c6410_ldi.h"
#include "s3c6410_display_con.h"
#include "s3c6410_display_con_macro.h"
#include "LTS222QV_RGB_dataset.h"
#include "LTV350QV_RGB_dataset.h"
#include "LTM030DK_RGB_dataset.h"

#define LDI_MSG(x)  
#define LDI_INF(x)  
#define LDI_ERR(x)  

#define LCDP_CLK            (1<<1)  // GPC[1]
#define LCDP_MOSI           (1<<2)  // GPC[2]
#define LCDP_nSS            (1<<3)  // GPC[3]

#define LCD_CLK         (1<<5)  // GPC[5]
#define LCD_MOSI        (1<<6)  // GPC[6]
#define LCD_nSS         (1<<7)  // GPC[7]
#define LCDP_CLK_Lo        (g_pGPIOReg->GPCDAT &= ~LCDP_CLK)
#define LCDP_CLK_Hi        (g_pGPIOReg->GPCDAT |= LCDP_CLK)
#define LCDP_MOSI_Lo        (g_pGPIOReg->GPCDAT &= ~LCDP_MOSI)
#define LCDP_MOSI_Hi        (g_pGPIOReg->GPCDAT |= LCDP_MOSI)
#define LCDP_nSS_Lo        (g_pGPIOReg->GPCDAT &= ~LCDP_nSS)
#define LCDP_nSS_Hi        (g_pGPIOReg->GPCDAT |= LCDP_nSS)

#define LCD_CLK_Lo      (g_pGPIOReg->GPCDAT &= ~LCD_CLK)
#define LCD_CLK_Hi      (g_pGPIOReg->GPCDAT |= LCD_CLK)
#define LCD_MOSI_Lo     (g_pGPIOReg->GPCDAT &= ~LCD_MOSI)
#define LCD_MOSI_Hi     (g_pGPIOReg->GPCDAT |= LCD_MOSI)
#define LCD_nSS_Lo      (g_pGPIOReg->GPCDAT &= ~LCD_nSS)
#define LCD_nSS_Hi      (g_pGPIOReg->GPCDAT |= LCD_nSS)

// SYS I/F CSn Main
#define LCD_nCSMain_Lo  (g_pGPIOReg->GPJDAT &= ~(1<<8))
#define LCD_nCSMain_Hi  (g_pGPIOReg->GPJDAT |= (1<<8))
#define LCD_RD_Lo       (g_pGPIOReg->GPJDAT &= ~(1<<7))
#define LCD_RD_Hi       (g_pGPIOReg->GPJDAT |= (1<<7))
#define LCD_RS_Lo       (g_pGPIOReg->GPJDAT &= ~(1<<10))
#define LCD_RS_Hi       (g_pGPIOReg->GPJDAT |= (1<<10))
#define LCD_nWR_Lo      (g_pGPIOReg->GPJDAT &= ~(1<<11))
#define LCD_nWR_Hi      (g_pGPIOReg->GPJDAT |= (1<<11))

#define LCD_DELAY_1MS    30000          // Sufficient under 1Ghz
#define SPI_DELAY        100            // Sufficient under 1Ghz


static volatile S3C6410_SPI_REG *g_pSPIReg = NULL;
static volatile S3C6410_GPIO_REG *g_pGPIOReg = NULL;
static volatile S3C6410_DISPLAY_REG *g_pDispConReg = NULL;
static LDI_LCD_MODULE_TYPE g_ModuleType;

LDI_ERROR LDI_initialize_register_address(void *pSPIReg, void *pDispConReg, void *pGPIOReg)
{
    LDI_ERROR error = LDI_SUCCESS;

    LDI_MSG((_T("[LDI]++LDI_initialize_register_address(0x%08x, 0x%08x, 0x%08x)\n\r"), pSPIReg, pDispConReg, pGPIOReg));

    if (pSPIReg == NULL || pDispConReg == NULL || pGPIOReg == NULL)
    {
        LDI_ERR((_T("[LDI:ERR] LDI_initialize_register_address() : NULL pointer parameter\n\r")));
        error = LDI_ERROR_NULL_PARAMETER;
    }
    else
    {
        g_pSPIReg = (S3C6410_SPI_REG *)pSPIReg;
        g_pDispConReg = (S3C6410_DISPLAY_REG *)pDispConReg;
        g_pGPIOReg = (S3C6410_GPIO_REG *)pGPIOReg;
        LDI_INF((_T("[LDI:INF] g_pSPIReg = 0x%08x\n\r"), g_pSPIReg));
        LDI_INF((_T("[LDI:INF] g_pDispConReg = 0x%08x\n\r"), g_pDispConReg));
        LDI_INF((_T("[LDI:INF] g_pGPIOReg    = 0x%08x\n\r"), g_pGPIOReg));
    }

    LDI_MSG((_T("[LDI]--LDI_initialize_register_address() : %d\n\r"), error));

    return error;
}

LDI_ERROR LDI_set_LCD_module_type(LDI_LCD_MODULE_TYPE ModuleType)
{
    LDI_ERROR error = LDI_SUCCESS;

    LDI_MSG((_T("[LDI]++LDI_set_LCD_module_type(%d)\n\r"), ModuleType));

    g_ModuleType = ModuleType;

    LDI_MSG((_T("[LDI]--LDI_set_LCD_module_type() : %d\n\r"), error));

    return error;
}

LDI_ERROR LDI_initialize_LCD_module(void)
{
    LDI_ERROR error = LDI_SUCCESS;

    LDI_MSG((_T("[LDI]++LDI_initialize_LCD_module()\n\r")));

    switch(g_ModuleType)
    {
    case LDI_LTS222QV_RGB:
        LDI_INF((_T("[LDI:INF] LDI_initialize_LCD_module() : Type [%d] LDI_LTS222QV_RGB\n\r"), g_ModuleType));
        LDI_LTS222QV_port_initialize();
        LDI_LTS222QV_reset();
        LDI_LTS222QV_RGB_initialize();
        break;
    case LDI_LTV350QV_RGB:
        LDI_INF((_T("[LDI:INF] LDI_initialize_LCD_module() : Type [%d] LDI_LTV350QV_RGB\n\r"), g_ModuleType));
        LDI_LTV350QV_port_initialize();
        LDI_LTV350QV_reset();
        LDI_LTV350QV_RGB_initialize();
        break;
    case LDI_LTE480WV_RGB:
        LDI_INF((_T("[LDI:INF] LDI_initialize_LCD_module() : Type [%d] LDI_LTE480WV_RGB\n\r"), g_ModuleType));
        LDI_LTE480WV_RGB_port_initialize();
        LDI_LTE480WV_RGB_power_on();
        LDI_LTE480WV_RGB_initialize();
        break;
    case LDI_LTP700WV_RGB:
        LDI_INF((_T("[LDI:INF] LDI_initialize_LCD_module() : Type [%d] LDI_LTP700WV_RGB\n\r"), g_ModuleType));
        LDI_LTP700WV_port_initialize();
        LDI_LTP700WV_reset();
        LDI_LTP700WV_RGB_initialize();
        break;
    case LDI_SMRP_TD043MTEA1_RGB:
        LDI_INF((_T("[LDI:INF] LDI_initialize_LCD_module() : Type [%d] LDI_SMRP_TD043MTEA1_RGB\n\r"), g_ModuleType));
        LDI_TD043MTEA1_port_initialize();
        LDI_TD043MTEA1_power_on();
        LDI_TD043MTEA1_RGB_initialize();
        break;
    case LDI_SMRP_LTE480WV_RGB:
        LDI_INF((_T("[LDI:INF] LDI_initialize_LCD_module() : Type [%d] LDI_SMRP_LTE480WV_RGB\n\r"), g_ModuleType));
        LDI_SMRP_LTE480WV_RGB_port_initialize();
        LDI_SMRP_LTE480WV_RGB_power_on();
        LDI_SMRP_LTE480WV_RGB_initialize();
        break;
    case LDI_LTM030DK_RGB:
        LDI_INF((_T("[LDI:INF] LDI_initialize_LCD_module() : Type [%d] LDI_LTM030DK_RGB\n\r"), g_ModuleType));
        LDI_LTM030DK_port_initialize();
//        LDI_LTM030DK_SetALC();
        LDI_LTM030DK_RGB_initialize();
        break;
    default:
        LDI_ERR((_T("[LDI:ERR] LDI_initialize_LCD_module() : Unknown LCD Module Type [%d]\n\r"), g_ModuleType));
        error = LDI_ERROR_ILLEGAL_PARAMETER;
        break;
    }

    LDI_MSG((_T("[LDI]--LDI_initialize_LCD_module() : %d\n\r"), error));

    return error;
}

LDI_ERROR LDI_deinitialize_LCD_module(void)
{
    LDI_ERROR error = LDI_SUCCESS;

    LDI_MSG((_T("[LDI]++LDI_deinitialize_LCD_module()\n\r")));

    switch(g_ModuleType)
    {
    case LDI_LTS222QV_RGB:
    case LDI_LTV350QV_RGB:
    case LDI_LTP700WV_RGB:
    case LDI_LTM030DK_RGB:        
        // TODO: Nothing to do with Current Hardware
        break;
    case LDI_LTE480WV_RGB:
        LDI_INF((_T("[LDI:INF] LDI_deinitialize_LCD_module() : Type [%d] LDI_LTE480WV_RGB\n\r"), g_ModuleType));
        LDI_LTE480WV_RGB_power_off();
        break;
    case LDI_SMRP_TD043MTEA1_RGB:
        LDI_INF((_T("[LDI:INF] LDI_deinitialize_LCD_module() : Type [%d] LDI_SMRP_TD043MTEA1_RGB\n\r"), g_ModuleType));
        LDI_TD043MTEA1_power_off();
        break;
    case LDI_SMRP_LTE480WV_RGB:
        LDI_INF((_T("[LDI:INF] LDI_deinitialize_LCD_module() : Type [%d] LDI_SMRP_LTE480WV_RGB\n\r"), g_ModuleType));
        LDI_SMRP_LTE480WV_RGB_power_off();
        break;
    default:
        LDI_ERR((_T("[LDI:ERR] LDI_initialize_LCD_module() : Unknown LCD Module Type [%d]\n\r"), g_ModuleType));
        error = LDI_ERROR_ILLEGAL_PARAMETER;
        break;
    }

    LDI_MSG((_T("[LDI]--LDI_deinitialize_LCD_module() : %d\n\r"), error));

    return error;
}

LDI_ERROR LDI_fill_output_device_information(void *pDevInfo)
{
    LDI_ERROR error = LDI_SUCCESS;
    tDevInfo *pDeviceInfo;

    LDI_MSG((_T("[LDI]++LDI_fill_output_device_information()\n\r")));

    if (pDevInfo == NULL)
    {
        LDI_ERR((_T("[LDI:ERR] LDI_fill_output_device_information() : Null Parameter\n\r")));
        error = DISP_ERROR_NULL_PARAMETER;
        goto CleanUp;
    }

    pDeviceInfo = (tDevInfo *)pDevInfo;

    switch(g_ModuleType)
    {
    case LDI_LTS222QV_RGB:
        LDI_INF((_T("[LDI:INF] Output Devce Type [%d] = LDI_LTS222QV_RGB\n\r"), g_ModuleType));
        pDeviceInfo->RGBOutMode = DISP_18BIT_RGB666_S;
        pDeviceInfo->uiWidth = 240;
        pDeviceInfo->uiHeight = 320;
        pDeviceInfo->VBPD_Value = 7;
        pDeviceInfo->VFPD_Value = 10;
        pDeviceInfo->VSPW_Value = 3;
        pDeviceInfo->HBPD_Value = 2;
        pDeviceInfo->HFPD_Value = 2;
        pDeviceInfo->HSPW_Value = 1;
        pDeviceInfo->VCLK_Polarity = IVCLK_FALL_EDGE;
        pDeviceInfo->HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
        pDeviceInfo->VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
        pDeviceInfo->VDEN_Polarity = IVDEN_HIGH_ACTIVE;
        pDeviceInfo->PNR_Mode = PNRMODE_RGB_S;
        pDeviceInfo->VCLK_Source = CLKSEL_F_LCDCLK;
        pDeviceInfo->VCLK_Direction = CLKDIR_DIVIDED;
        pDeviceInfo->Frame_Rate = 60;
        break;

    case LDI_LTV350QV_RGB:
        LDI_INF((_T("[LDI:INF] Output Devce Type [%d] = LDI_LTV350QV_RGB\n\r"), g_ModuleType));
        pDeviceInfo->RGBOutMode = DISP_16BIT_RGB565_P;
        pDeviceInfo->uiWidth = 320;
        pDeviceInfo->uiHeight = 240;
        pDeviceInfo->VBPD_Value = 5;
        pDeviceInfo->VFPD_Value = 3;
        pDeviceInfo->VSPW_Value = 4;
        pDeviceInfo->HBPD_Value = 5;
        pDeviceInfo->HFPD_Value = 3;
        pDeviceInfo->HSPW_Value = 10;
        pDeviceInfo->VCLK_Polarity = IVCLK_RISE_EDGE;
        pDeviceInfo->HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
        pDeviceInfo->VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
        pDeviceInfo->VDEN_Polarity = IVDEN_LOW_ACTIVE;
        pDeviceInfo->PNR_Mode = PNRMODE_RGB_P;
        pDeviceInfo->VCLK_Source = CLKSEL_F_LCDCLK;
        pDeviceInfo->VCLK_Direction = CLKDIR_DIVIDED;
        pDeviceInfo->Frame_Rate = 60;    // VCLK (Max 10 MHz)
        break;

    case LDI_LTE480WV_RGB:
    case LDI_SMRP_LTE480WV_RGB:
        LDI_INF((_T("[LDI:INF] Output Devce Type [%d] = LDI_(SMRP)LTE480WV_RGB\n\r"), g_ModuleType));
        pDeviceInfo->RGBOutMode = DISP_16BIT_RGB565_P;
        pDeviceInfo->uiWidth = 800;
        pDeviceInfo->uiHeight = 480;
        pDeviceInfo->VBPD_Value = 3;
        pDeviceInfo->VFPD_Value = 5;
        pDeviceInfo->VSPW_Value = 5;
        pDeviceInfo->HBPD_Value = 13;
        pDeviceInfo->HFPD_Value = 8;
        pDeviceInfo->HSPW_Value = 3;
        pDeviceInfo->VCLK_Polarity = IVCLK_FALL_EDGE;
        pDeviceInfo->HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
        pDeviceInfo->VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
        pDeviceInfo->VDEN_Polarity = IVDEN_HIGH_ACTIVE;
        pDeviceInfo->PNR_Mode = PNRMODE_RGB_P;
        pDeviceInfo->VCLK_Source = CLKSEL_F_LCDCLK;
        pDeviceInfo->VCLK_Direction = CLKDIR_DIVIDED;
        pDeviceInfo->Frame_Rate = 60;    // VCLK > 24.5 MHz (Max 35.7 MHz)
        break;

    case LDI_LTP700WV_RGB:
        LDI_INF((_T("[LDI:INF] Output Devce Type [%d] = LDI_LTP700WV_RGB\n\r"), g_ModuleType));
        pDeviceInfo->RGBOutMode = DISP_24BIT_RGB888_P;
        pDeviceInfo->uiWidth = 800;
        pDeviceInfo->uiHeight = 480;
        pDeviceInfo->VBPD_Value = 7;
        pDeviceInfo->VFPD_Value = 5;
        pDeviceInfo->VSPW_Value = 1;
        pDeviceInfo->HBPD_Value = 13;
        pDeviceInfo->HFPD_Value = 8;
        pDeviceInfo->HSPW_Value = 3;
        pDeviceInfo->VCLK_Polarity = IVCLK_FALL_EDGE;
        pDeviceInfo->HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
        pDeviceInfo->VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
        pDeviceInfo->VDEN_Polarity = IVDEN_HIGH_ACTIVE;
        pDeviceInfo->PNR_Mode = PNRMODE_RGB_P;
        pDeviceInfo->VCLK_Source = CLKSEL_F_LCDCLK;
        pDeviceInfo->VCLK_Direction = CLKDIR_DIVIDED;
        pDeviceInfo->Frame_Rate = 60;
        break;

    case LDI_SMRP_TD043MTEA1_RGB:
        LDI_INF((_T("[LDI:INF] Output Devce Type [%d] = LDI_SMRP_TD043MTEA1_RGB\n\r"), g_ModuleType));
        pDeviceInfo->RGBOutMode = DISP_16BIT_RGB565_P;
        pDeviceInfo->uiWidth = 800;
        pDeviceInfo->uiHeight = 480;
        pDeviceInfo->VBPD_Value = 30;
        pDeviceInfo->VFPD_Value = 10;
        pDeviceInfo->VSPW_Value = 5;
        pDeviceInfo->HBPD_Value = 200;
        pDeviceInfo->HFPD_Value = 40;
        pDeviceInfo->HSPW_Value = 16;
        pDeviceInfo->VCLK_Polarity = IVCLK_FALL_EDGE;
        pDeviceInfo->HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
        pDeviceInfo->VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
        pDeviceInfo->VDEN_Polarity = IVDEN_HIGH_ACTIVE;
        pDeviceInfo->PNR_Mode = PNRMODE_RGB_P;
        pDeviceInfo->VCLK_Source = CLKSEL_F_LCDCLK;
        pDeviceInfo->VCLK_Direction = CLKDIR_DIVIDED;
        pDeviceInfo->Frame_Rate = 60;
        break;
        
    case LDI_LTM030DK_RGB:
        LDI_INF((_T("[LDI:INF] Output Devce Type [%d] = LDI_LTM030DK_RGB\n\r"), g_ModuleType));
        pDeviceInfo->RGBOutMode = DISP_16BIT_RGB565_P;
        pDeviceInfo->uiWidth = 480;
        pDeviceInfo->uiHeight = 800;
        pDeviceInfo->VBPD_Value = 3;
        pDeviceInfo->VFPD_Value = 6;
        pDeviceInfo->VSPW_Value = 2;
        pDeviceInfo->HBPD_Value = 4;
        pDeviceInfo->HFPD_Value = 6;
        pDeviceInfo->HSPW_Value = 6;
        pDeviceInfo->VCLK_Polarity = IVCLK_RISE_EDGE;
        pDeviceInfo->HSYNC_Polarity = IHSYNC_LOW_ACTIVE;
        pDeviceInfo->VSYNC_Polarity = IVSYNC_LOW_ACTIVE;
        pDeviceInfo->VDEN_Polarity = IVDEN_HIGH_ACTIVE;
        pDeviceInfo->PNR_Mode = PNRMODE_RGB_P;
        pDeviceInfo->VCLK_Source = CLKSEL_F_LCDCLK;
        pDeviceInfo->VCLK_Direction = CLKDIR_DIVIDED;
        pDeviceInfo->Frame_Rate = 60;
        break;

    default:
        LDI_INF((_T("[LDI:ERR] LDI_fill_output_device_information() : Unknown device type [%d]\n\r"), g_ModuleType));
        error = DISP_ERROR_ILLEGAL_PARAMETER;
        break;
    }

CleanUp:

    LDI_MSG((_T("[LDI]--LDI_fill_output_device_information()\n\r")));

    return error;
}


// Port_Init -> SPI Init -> LDI REset LDI Init ->
void LDI_LTM030DK_port_initialize(void)
{
    LDI_MSG((_T("[LDI]++%s()\n\r"), _T(__FUNCTION__)));
    
//    (*(volatile unsigned *)0x7410800c)=0;    //Must be '0' for Normal-path instead of By-pass
    // nReset    : GPN[5]


    // set GPIO Initial Value to High
    g_pGPIOReg->GPNDAT |= (1<<5);            // nReset

    // Pull Up/Down Disable
    g_pGPIOReg->GPNPUD &= ~(0x3<<10);                // nReset

    // Set GPIO direction to output
    g_pGPIOReg->GPNCON = (g_pGPIOReg->GPNCON & ~(0x3<<10)) | (1<<10);        // nReset

    // nReset    : GPN[5]
    g_pGPIOReg->GPNDAT |= (1<<5);        // nReset High
    DelayLoop_1ms(50);                    // 10 ms

    g_pGPIOReg->GPNDAT &= ~(1<<5);    // nReset Low
    DelayLoop_1ms(10);                    // 10 ms

    g_pGPIOReg->GPNDAT |= (1<<5);        // nReset High
    DelayLoop_1ms(10);                    // 10 ms

    LDI_MSG((_T("[LDI]--%s()\n\r"), _T(__FUNCTION__)));
}

static void LDI_LTM030DK_spi_port_enable(void)
{
    LDI_MSG((_T("[LDI]++%s()\n\r"), _T(__FUNCTION__)));

    // Clk        : GPC[5]
    // MOSI        : GPC[6]
    g_pGPIOReg->SPCON &= ~(0x3<<0);    // Host I/F
//    g_pGPIOReg->GPICON = 0xaaaaaaaa;        // VD Signal
//    g_pGPIOReg->GPJCON = 0xaaaaaaaa;        // VD Signal