bspslcdcclass.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

//------------------------------------------------------------------------------
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//------------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Copyright (C) 2005-2006, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT 
//---------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// File:        BSPSlcdcClass.cpp
// Purpose:     BSPSlcdcClass module
//
//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
// INCLUDE FILES  
//------------------------------------------------------------------------------
#include <windows.h>
#include <winddi.h>
#include <ceddk.h>
#include <gpe.h>
#include <emul.h>
#include <Winreg.h>
#include <Pwingdi.h>
#include <pm.h>

#include "bsp.h"
#include "BSPSlcdcClass.h"

//------------------------------------------------------------------------------
// GLOBAL DEFINITIONS  
//------------------------------------------------------------------------------
INSTANTIATE_GPE_ZONES((GPE_ZONE_ERROR|GPE_ZONE_INIT),"DDI Driver","unused1","unused2")


//------------------------------------------------------------------------------
// The mode according to supported panel types
//------------------------------------------------------------------------------
static GPEMode ModeArray[numPanels] =
{
    // Epson_QVGA_L2F50282T00
    {DISPLAY_MODE_DEVICE, SLCD_WIDTH, SLCD_HEIGHT, SLCD_BYTESPER_PIXEL*8, 30, gpe16Bpp}, // 240*320*16bpp

    // Put other panel info here in future expasion
    // ... ...
};

//------------------------------------------------------------------------------
// Supported Color Masks
//------------------------------------------------------------------------------
static ULONG masks[] = {RGB565_RED, RGB565_GREEN, RGB565_BLUE};

// 0. misc
//--------------------------------------------------------------------------
//
// Function: ConfigGPIO_to_SLCD16bit
//
// This function config gpio for controller to be 16-bit parallel mode.
//                  According to controller spec (SLCDC)(open PA6-PA27 (AIN))
//                      slcdc_lcd_data[0:15]    => PA6-PA21, AIN
//                      slcdc_lcd_rs            => PA25, AIN
//                      slcdc_lcd_cs            => PA26, AIN (but here PA23 connect to panel XCS)
//                      SLCDC1_CLK              => PA27, AIN
//
// Parameters:
//      bEnable
//          [in] This argument decide whether supply or stop the clock to controller.
//               True means supply, FALSE means stop. 
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void ConfigGPIO_to_SLCD16bit(BOOL bEnable)
{
    DDK_GPIO_CFG cfg;
    BOOL initState;
    
    // Enable SLCDC pins
    DDK_GPIO_SET_CONFIG(cfg, SLCDC);
    if(bEnable)
        initState = DDKGpioEnable(&cfg);
    else
        initState = DDKGpioDisable(&cfg);    
}

//--------------------------------------------------------------------------
//
// Function: ConfigClock_to_SLCDC
//
// This function supply or stop the clock to controller.
//
// Parameters:
//      bEnable
//          [in] This argument decide whether supply or stop the clock to controller.
//               True means supply, FALSE means stop. 
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void ConfigClock_to_SLCDC(BOOL bEnable)
{
    BOOL initState;

    if(bEnable)
    {
        initState = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SLCDC, DDK_CLOCK_GATE_MODE_ENABLE);
        initState = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_HCLK_SLCDC, DDK_CLOCK_GATE_MODE_ENABLE);
    }
    else
    {
        initState = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_SLCDC, DDK_CLOCK_GATE_MODE_DISABLE);
        initState = DDKClockSetGatingMode(DDK_CLOCK_GATE_INDEX_HCLK_SLCDC, DDK_CLOCK_GATE_MODE_DISABLE);
    }    
}

//--------------------------------------------------------------------------
//
// Function: ResetSLCD
//
// This function set gpio(PA31 connect to pannel XRES) low to reset panel.
//
// Parameters:
//      bReset
//          [in] This argument decide whether reset or canel reset the Smart LCD panel.
//               Need wait more than 100us accdording to panel spec.
//               True means reset, FALSE means canel reset. 
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void ResetSLCD(BOOL bReset)
{
    DDK_GPIO_CFG cfg;
    BOOL initState;
    
    DDK_GPIO_SET_CONFIG(cfg, SLCDCRESET);
    initState = DDKGpioEnable(&cfg);

    if(bReset)
        DDKGpioWriteData(GPIO_PORT_A, 0x80000000, 0);
    else       
        DDKGpioWriteData(GPIO_PORT_A, 0x80000000, 0x80000000);

	// system reset（XRES="L" during more than 100us)
    // cancel the system reset and wait more than 100us
    Sleep(1);
}

//--------------------------------------------------------------------------
//
// Function: TurnOnBKL
//
// This function set gpio(PA23 connect to pannel XCS) low to select Panel.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void SelectPanel(void)
{
    DDK_GPIO_CFG cfg;
    BOOL initState;
    
    DDK_GPIO_SET_CONFIG(cfg, SLCDCCS);
    initState = DDKGpioEnable(&cfg);

    DDKGpioWriteData(GPIO_PORT_A, 0x00800000, 0);
}

//--------------------------------------------------------------------------
//
// Function: TurnOnBKL
//
// This function set gpio(PA30) high to power on backlight.
//
// Parameters:
//      bOnBKL
//          [in] This argument decide whether turn on or turn off the backlight of Smart LCD panel.
//               True means turn on, FALSE means turn off.
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void TurnOnBKL(BOOL bOnBKL)
{
    DDK_GPIO_CFG cfg;
    BOOL initState;
    
    DDK_GPIO_SET_CONFIG(cfg, SLCDCBKL);
    initState = DDKGpioEnable(&cfg);

    if(bOnBKL)
        DDKGpioWriteData(GPIO_PORT_A, 0x40000000, 0x40000000);
    else       
        DDKGpioWriteData(GPIO_PORT_A, 0x40000000, 0x0);
}


//--------------------------------------------------------------------------
//
// Function: BSPSlcdcClassInit
//
// This function allocate resource and init controller.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void BSPSlcdcClassInit(void)
{
    PHYSICAL_ADDRESS phyAddr;
    BOOL result = TRUE;
    
    DEBUGMSG(GPE_ZONE_ENTER, (TEXT("++BSPSlcdcClass\r\n")));

    // Map the SLCDC registers space for user access    
    phyAddr.QuadPart = CSP_BASE_REG_PA_SLCDC;   
    slcdc = (CSP_SLCDC_REGS *)MmMapIoSpace(phyAddr, sizeof(CSP_SLCDC_REGS), FALSE);
    if(!slcdc) 
    {
        DEBUGMSG(GPE_ZONE_ERROR, (TEXT("CSPSlcdcCalss: MmMapIoSpace failed!\r\n")));
    }

    // Setting the current panel
    m_dwPanelType = GetPanelTypeFromRegistry();

    if (m_dwPanelType != -1)
    {
        if ((m_dwPanelType >= numModes))
        {
            // Use default panel type
            m_dwPanelType = DISPLAY_PANEL_DEFAULT;
        }
    }
    else
    {
        DEBUGMSG(GPE_ZONE_INIT, (TEXT("%s: Could not get panel type!\r\n"), __WFUNCTION__));
        m_dwPanelType = DISPLAY_PANEL_DEFAULT;
    }

    // Build array of supported modes
    m_SupportedModes = (GPEMode *)LocalAlloc(LPTR, MAX_NUM_MODES * sizeof(GPEMode));
    m_SupportedModes[DISPLAY_MODE_DEVICE] = ModeArray[m_dwPanelType];

    // Always start using the LCD mode as default
    memcpy(&mode, &(m_SupportedModes[DISPLAY_MODE_DEVICE]), sizeof(GPEMode));
    
    // Enable GPIO pins for SLCDC interface
    ConfigGPIO_to_SLCD16bit(TRUE);
    
    // Set up the framebuffer
    {
        UINT32 size;
        void *mem;
        
        // Set up parameter size - bytes
        parm_size = SLCDC_PARMBUFFER_SIZE;
        
        // Setup video size - bytes
        video_size = mode.width * mode.height * (mode.Bpp/8);
        
        // parm header + video size - bytes
        size = parm_size + video_size;
        if(size<IMAGE_SHARE_FRAMEBUFFER_RAM_SIZE)
            size = IMAGE_SHARE_FRAMEBUFFER_RAM_SIZE;
        
        //Map for user access
        phyAddr.QuadPart = SLCDC_PARMBUFFER_PADDR;
        if(!(mem = MmMapIoSpace(phyAddr, size, FALSE)))
        {
            DEBUGMSG(GPE_ZONE_ERROR, (TEXT("BSPSlcdcClass: Map video frame buffer failed!\r\n")));
            goto cleanup;
        }

        // Set parm header
        parm_mem = (UINT16 *) mem;
        
        // Set video mem
        video_mem = (UINT16 *) (((UINT8 *) mem) + parm_size);
        
        // Zero parms
        memset((void*)parm_mem,  0, parm_size);
    }
    
    // Init the Smart LCD Controller
    SlcdcInit();
    
    // Clear to White
    memset((void *) video_mem, 0xFF, video_size);
    
    // Blank the screen
    if(!DisplayFrame((UINT16 *) SLCDC_FRAMEBUFFER_PADDR, SLCD_START_COL, SLCD_END_COL, 
        SLCD_START_ROW, SLCD_END_ROW))
    {
        DEBUGMSG(GPE_ZONE_ERROR, (TEXT("BSPSlcdcClass: lank the screen failed!\r\n")));
        result = FALSE;
    }
    
cleanup:
    if (result == FALSE)
        Destroy();
    DEBUGMSG(GPE_ZONE_ENTER, (TEXT("--BSPSlcdcClass\r\n")));
}

//--------------------------------------------------------------------------
//
// Function: BSPSlcdcClassDeInit
//
// This function free resource.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void BSPSlcdcClassDeInit(void)
{
    // Destroy the Class
    Destroy();
}

//--------------------------------------------------------------------------
//
// Function: Destroy
//
// This function free used buffer and disable controller.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------
void Destroy(void)
{
    DEBUGMSG(GPE_ZONE_ENTER, (TEXT("++Destroy\r\n")));
    // Free frame buffer
    if (video_mem != NULL)
    {
        // Blank the display memory
        memset ((void *) video_mem, 0xFF, video_size);

        // Blank the screen
        DisplayFrame((UINT16 *) SLCDC_FRAMEBUFFER_PADDR, SLCD_START_COL, SLCD_END_COL, 
            SLCD_START_ROW, SLCD_END_ROW);
        MmUnmapIoSpace((PVOID) video_mem,  video_size);
        video_mem = NULL;
    }

    // Free parm buffer
    if (parm_mem != NULL)
    {
        MmUnmapIoSpace((PVOID) parm_mem,  parm_size);
        parm_mem = NULL;
    }

    // Disable GPIO pins for SLCDC interface
    ConfigGPIO_to_SLCD16bit(FALSE);

    // Free mapped SLCDC module space
    if (slcdc != NULL)
    {
        MmUnmapIoSpace ((PVOID) slcdc, sizeof(CSP_SLCDC_REGS));
        slcdc = NULL;
    }
    
    DEBUGMSG(GPE_ZONE_ENTER, (TEXT("--Destroy\r\n")));
}

//--------------------------------------------------------------------------
//
// Function: SlcdcInit
//
// This function init the Smart LCD panel and controller.
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//--------------------------------------------------------------------------