dispdrvr.c

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

//
// 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 2000-2003 Intel Corporation All Rights Reserved.
**
** Portions of the source code contained or described herein and all documents
** related to such source code (Material) are owned by Intel Corporation
** or its suppliers or licensors and is licensed by Microsoft Corporation for distribution.  
** Title to the Material remains with Intel Corporation or its suppliers and licensors. 
** Use of the Materials is subject to the terms of the Microsoft license agreement which accompanied the Materials.  
** No other license under any patent, copyright, trade secret or other intellectual
** property right is granted to or conferred upon you by disclosure or
** delivery of the Materials, either expressly, by implication, inducement,
** estoppel or otherwise 
** Some portion of the Materials may be copyrighted by Microsoft Corporation.
*/

#include <windows.h>
#include <types.h>
#include <string.h>
#include <stdio.h>
#include <tchar.h>
#include <nkintr.h>

#include <xllp_gpio.h>
#include "bulverde_base_regs.h"
//#include <bulverde.h>
#include <ceddk.h>
#include "memdefs.h"

#include "DispDrvr.h"
#define  DEFINE_CURSOR_GLOBALS
#include "cursor.h"

#include "xllp_defs.h"
#include "xllp_serialization.h"
#include "xllp_lcd.h"
#include "dispCtrlrData.h"
#include "ssplink.h"

#include "xllp_ost.h"
#include "xllp_dmac.h"
#include "xllp_i2c.h"
extern XLLP_STATUS_T    XllpDmacInit(void);


extern XLLP_UINT32_T XllpLock(XLLP_PROTECTED_REGISTER Xllp_RegisterID);

extern XLLP_STATUS_T XllpLCDInit(P_XLLP_LCD_T pXllpLCD);
extern void XllpLCDLoadPalette(P_XLLP_LCD_T pXllpLCD);
extern void XllpLCDSuspend(P_XLLP_LCD_T pXllpLCD, int SuspendType);
extern void XllpLCDResume(P_XLLP_LCD_T pXllpLCD);

void SetFrameBuffer(DWORD color);

#define NUM_FRAME_BUFFERS 1

XLLP_LCD_T XllpLCD;
XLLP_STATUS_T status;

#define FRAME_BUFFER_BASE_PHYSICAL FRAME_BUFFER_0_BASE_PHYSICAL

BOOL gDrawCursorFlag = FALSE;
BOOL gInPowerHandler = FALSE;
BOOL bDoRotation     = FALSE;
BOOL g_fDisableRotation = FALSE;     // Enable/disable screen rotation

CRITICAL_SECTION displayMutex;
CRITICAL_SECTION frameDescriptorMutex;

int DispDrvr_cxScreen;
int DispDrvr_cyScreen;
int DispDrvr_cdwStride;  
int activeFrameBuffer=0;
unsigned int frameBufferSize = 0;

PBYTE gDibBuffer        = NULL;     // pointer to first byte of composition buffer
PBYTE gFrameBuffer      = NULL;     // pointer to first byte of screen memory
PBYTE gBlankFrameBuffer = NULL;     // pointer to first byte of screen memory
RECT  gCursorRect;
UINT  nDisplayType;

DWORD g_DisplayBasePhysical;
DWORD g_DisplayBaseVirtual;

volatile LCDRegs              * v_pLcdRegs                  = NULL;
volatile XLLP_CLKMGR_T        * v_pClkRegs                  = NULL;
volatile XLLP_GPIO_T          * v_pGPIORegs                 = NULL;
volatile XLLP_SSPREGS_T       * v_pSSPRegs                  = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorCh0fd1       = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorCh0fd2       = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorCh1          = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorPalette      = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorTemp         = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorCh2_YCbCr_Y  = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorCh3_YCbCr_Cb = NULL;
volatile LCD_FRAME_DESCRIPTOR * frameDescriptorCh4_YCbCr_Cr = NULL;
volatile LCD_PALETTE          * v_pPaletteBuffer            = NULL;
volatile unsigned int         * pOSCR                       = NULL;

///
volatile unsigned int * v_pOSTRegs = NULL;
volatile unsigned int * v_pCIRegs  = NULL;
volatile XLLP_DMAC_T  * v_pDMAC    = NULL;

HANDLE hIntEventKnown;
HANDLE hIntEvent;
///

void LCDClearStatusReg();
void LcdSetupGPIOs();
void Cleanup();
void InitLCDController();
void LCDDisableController(P_XLLP_LCD_T pXllpLCD);
void LCDEnableController(P_XLLP_LCD_T pXllpLCD);
void InitCursor();
BOOL MapVirtualAddress();
BOOL ReadRegistryData(VOID);
void CopyFrameBuffer(BOOL gDirection);
void ClearFrameBuffer(BOOL color);
void ScrollBuffer(int direction);
void ClearDMACInterrupt(int channel);
BOOL WriteLcdControllerData(LCD_CTRLR_DATA *plcdData);

extern PVOID VirtualAllocCopy(unsigned size,char *str,PVOID pVirtualAddress);
extern PVOID VirtualAllocCopyPhysical(unsigned size,char *str,PVOID pPhysicalAddress);
extern BOOL VirtualSetAttributes(LPVOID lpvAddress, DWORD cbSize, DWORD dwNewFlags, DWORD dwMask, LPDWORD lpdwOldFlags);
extern void msWait(unsigned int);

unsigned int    halted       = 0;
unsigned char * fbpY;
unsigned char * fbpCr;
unsigned char * fbpCb;

//

#define _OPT_ASM

#ifdef _OPT_ASM
    void dirtyRectDump_core_ASM(WORD *pwSrc, WORD *pwDst,int rowLen, DWORD srcWidthB,
            DWORD bytesPerRow, DWORD srcMarginWidth, DWORD dstMarginWidth);

    void DirtyRectDumpPortraitLoop_C(BYTE    *pDstBuf, BYTE  *pSrcBuf, DWORD    yTop, DWORD yBottom,
            DWORD srcWidthB, DWORD bytesPerRow, DWORD bytesPerPixel, DWORD srcMarginWidth, DWORD dstMarginWidth);

    void ellipse_core_ASM(WORD srcColor,DWORD margin,DWORD width,WORD* pDstBuf);
    void DispDrvrDirtyRectDump2(LPCRECT prc,DWORD color);
    void DirtyRectDumpPortraitLoop_C_rectfill(BYTE    *pDstBuf, WORD srcColor,DWORD yTop,DWORD yBottom,
            DWORD srcWidthB, DWORD bytesPerRow, DWORD bytesPerPixel, DWORD srcMarginWidth, DWORD dstMarginWidth);
    void DispDrvrDirtyRectDump_rectfill(LPCRECT prc, DWORD color);

#endif

void DispDrvrSetDibBuffer(void *data)
{
    gDibBuffer = data;        
}

void DispDrvrSetPalette (const PALETTEENTRY source[],unsigned short firstEntry,unsigned short numEntries)
{
    int i;
    int end = firstEntry + numEntries;

    // Don't walk off the end of the palette buffer.
    if (firstEntry > sizeof(source) || end >= sizeof(source))
    {
        return;
    }

    EnterCriticalSection(&frameDescriptorMutex);

    // Store the palette entries into palette ram
    for(i=firstEntry;i<end;i++) 
    {
        // store 5 bits red, 6 bits green, and 5 bits blue
        v_pPaletteBuffer->palette[i] = (
            (source[i].peBlue)            >>  3    |
            ((source[i].peGreen & 0xfc)    <<  3)    |
            ((source[i].peRed    & 0xf8)    <<  8)
            );
    }

    XllpLCDLoadPalette(&XllpLCD);
    
    LeaveCriticalSection(&frameDescriptorMutex);
}

void DispDrvrInitialize (void)
{
    // Read display driver configuration from system registry
    ReadRegistryData();

    frameBufferSize = bpp / 8 * DispDrvr_cxScreen * DispDrvr_cyScreen;

    // Map registers, the frame buffer, and frame descriptors from Kernel mode virtual address 
    // into our user mode virtual address space
    if (!MapVirtualAddress())
    {
        return;
    }

    // Initialize for use with Suspend resume macros
    msWait(1);

    XllpLCD.GPIO = (XLLP_VUINT32_T *) v_pGPIORegs;
    XllpLCD.CLKMan = (XLLP_VUINT32_T *) v_pClkRegs; 
    XllpLCD.LCDC = (XLLP_VUINT32_T *) v_pLcdRegs;
    XllpLCD.SSP = (XLLP_VUINT32_T *) v_pSSPRegs;
    XllpLCD.DisplayType = nDisplayType;
    XllpLCD.FrameBufferWidth = DispDrvr_cxScreen;
    XllpLCD.FrameBufferHeight = DispDrvr_cyScreen;
    XllpLCD.BPP = BPP_16;
    XllpLCD.PixelDataFormat = PDFOR_00; //with overlays enabled use PDFOR_11 for 16bpp
    XllpLCD.CurrentPage = 0;
    XllpLCD._FRAME_BUFFER_BASE_PHYSICAL = FRAME_BUFFER_BASE_PHYSICAL;
    XllpLCD._PALETTE_BUFFER_BASE_PHYSICAL = PALETTE_BUFFER_BASE_PHYSICAL;
    XllpLCD._DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_PHYSICAL = DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_PHYSICAL;    
    XllpLCD._DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_PHYSICAL = DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_PHYSICAL;
    XllpLCD._DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_PHYSICAL = DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_PHYSICAL;
    XllpLCD._PALETTE_FRAME_DESCRIPTOR_BASE_PHYSICAL = PALETTE_FRAME_DESCRIPTOR_BASE_PHYSICAL;
    XllpLCD.frameDescriptorCh0fd1 = frameDescriptorCh0fd1;
    XllpLCD.frameDescriptorCh0fd2 = frameDescriptorCh0fd2;
    XllpLCD.frameDescriptorCh1 = frameDescriptorCh1;
    XllpLCD.frameDescriptorPalette = frameDescriptorPalette;
    XllpLCD.frameDescriptorTemp = frameDescriptorTemp;

    InitializeCriticalSection(&displayMutex);
    InitializeCriticalSection(&frameDescriptorMutex);

    // Initialize Cursor
    InitCursor();
    
	// Initialize SSP Link
	SSPLinkSetup(&XllpLCD);

	// Initialize source driver
	WriteLcdControllerData(InitSequence);

    // Initialize the LCD Controller
    XllpLCDInit(&XllpLCD);
    
    pOSCR = v_pOSTRegs + 4;

    // Use this event to signal the IST that we now know the dynamically assigned DMA channel
    // And with that information, we know which event to wait on for the interrupt.
    hIntEventKnown = CreateEvent(NULL,FALSE,FALSE,NULL);

    RETAILMSG(1,(TEXT("Display Driver Initialization Complete\r\n")));

    return;
}

void InitCursor()
{
    gDrawCursorFlag = FALSE;
    gCursorRect.left = (DispDrvr_cxScreen - CURSOR_XSIZE) >> 1;
    gCursorRect.right = gCursorRect.left + CURSOR_XSIZE;
    gCursorRect.top = (DispDrvr_cyScreen - CURSOR_YSIZE) >> 1;
    gCursorRect.bottom = gCursorRect.top + CURSOR_YSIZE;
    gxHot = gyHot = 0;
    memset ((BYTE *)gCursorMask, 0xFF, sizeof(gCursorMask));
}

BOOL MapVirtualAddress()
{
    DMA_ADAPTER_OBJECT Adapter;
    unsigned int displayBufferSize= (3 * DMA_DESC_SIZE) + PALETTE_BUFFER_SIZE + (NUM_FRAME_BUFFERS) * frameBufferSize;

    Adapter.ObjectSize    = sizeof (DMA_ADAPTER_OBJECT);
    Adapter.InterfaceType = Internal;
    Adapter.BusNumber     = 0;

    g_DisplayBasePhysical = INTERNAL_MEMORY_START;
    g_DisplayBaseVirtual = (DWORD)VirtualAllocCopyPhysical(displayBufferSize,"DispDrvrInitialize : g_DisplayBaseVirtual)", (PVOID)(g_DisplayBasePhysical));
    if (!g_DisplayBaseVirtual)
    {
        Cleanup();
        return FALSE;
    }

    v_pDMAC = (P_XLLP_DMAC_T)VirtualAllocCopyPhysical(sizeof(XLLP_DMAC_T),"DispDrvrInitialize : v_pDMAC",(PVOID)(BULVERDE_BASE_REG_PA_DMAC));
    if (!v_pDMAC)
    {
        Cleanup();
        return FALSE;
    }

    v_pOSTRegs = (volatile unsigned int *)VirtualAllocCopyPhysical(sizeof(XLLP_OST_T),"DispDrvrInitialize : v_pOSTRegs",(PVOID)(BULVERDE_BASE_REG_PA_OST));
    if (!v_pOSTRegs)
    {
        Cleanup();
        return FALSE;
    }

    v_pLcdRegs = (volatile LCDRegs *)VirtualAllocCopyPhysical(sizeof(LCDRegs),"DispDrvrInitialize : v_pLcdRegs",(PVOID)(BULVERDE_BASE_REG_PA_LCD));
    if (!v_pLcdRegs)
    {
        Cleanup();
        return FALSE;
    }

    v_pClkRegs = (volatile XLLP_CLKMGR_T *)VirtualAllocCopyPhysical(sizeof(XLLP_CLKMGR_T),"DispDrvrInitialize : v_pClkRegs",(PVOID)(BULVERDE_BASE_REG_PA_CLKMGR));
    if (!v_pClkRegs)
    {
        Cleanup();
        return FALSE;
    }
    
    v_pGPIORegs = (volatile XLLP_GPIO_T *)VirtualAllocCopyPhysical(sizeof(XLLP_GPIO_T),"DispDrvrInitialize : v_pGPIORegs",(PVOID)(BULVERDE_BASE_REG_PA_GPIO));
    if (!v_pGPIORegs)
    {
        Cleanup();
        return FALSE;
    }

	v_pSSPRegs = (volatile XLLP_SSPREGS_T *)VirtualAllocCopyPhysical(sizeof(XLLP_SSPREGS_T),"DispDrvrInitialize : v_pSSPRegs",(PVOID)(BULVERDE_BASE_REG_PA_SSP3));
    if (!v_pSSPRegs)
    {
        Cleanup();
        return FALSE;
    }


    frameDescriptorCh0fd1  = (volatile LCD_FRAME_DESCRIPTOR *)(DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_VIRTUAL);
    frameDescriptorCh0fd2  = (volatile LCD_FRAME_DESCRIPTOR *)(DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_VIRTUAL);
    frameDescriptorCh1     = (volatile LCD_FRAME_DESCRIPTOR *)(DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_VIRTUAL);
    frameDescriptorPalette = (volatile LCD_FRAME_DESCRIPTOR *)(PALETTE_FRAME_DESCRIPTOR_BASE_VIRTUAL);
    v_pPaletteBuffer       = (volatile LCD_PALETTE *)(PALETTE_BUFFER_BASE_VIRTUAL);

    // Enter into Kernel mode to enable us to modify the section descriptor