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.
//
/*
** 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 <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 "xllp_bcr.h"
#include "xllp_ost.h"
#include "xllp_dmac.h"
#include "xllp_i2c.h"
extern XLLP_STATUS_T    XllpDmacInit(void);


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);

#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;

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 gBlackFrameBuffer = NULL;     // pointer to first byte of screen memory
RECT  gCursorRect;
UINT  nDisplayType;

//Frame buffer. DMA will copy from here to the LCD
DWORD g_DisplayBasePhysical;
DWORD g_DisplayBaseVirtual;

//Black Buffer. DMA will copy from here during idle/suspend IF EnableScreenBlanking RegKey is enabled
DWORD g_DisplayBlackBasePhysical;
DWORD g_DisplayBlackBaseVirtual;

BOOL g_fDisableRotation = FALSE;       //Enable/disable screen rotation
BOOL g_fEnableDMASourceSwap = FALSE;   //Enable/disable screen blacking with DMA pointer swap

volatile LCDRegs              * v_pLcdRegs                  = NULL;
volatile XLLP_CLKMGR_T        * v_pClkRegs                  = NULL;
volatile XLLP_GPIO_T          * v_pGPIORegs                 = 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 unsigned int * v_pI2C     = NULL;
volatile XLLP_DMAC_T  * v_pDMAC    = NULL;

HANDLE hIntEventKnown;
HANDLE hIntEvent;
///

void LCDClearStatusReg();
void LcdSetupGPIOs();
void Cleanup();
void InitLCDController();
void EnableLCDController();
void DisableLCDController();
void InitCursor();
BOOL MapVirtualAddress();
BOOL ReadRegistryData(VOID);
void ClearFrameBuffer(unsigned * fbp, BOOL color);
void ScrollBuffer(int direction);
void ClearDMACInterrupt(int channel);

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);

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
    XllpOstDelayMilliSeconds((XLLP_OST_T *)v_pOSTRegs, 1);

    XllpLCD.GPIO = (XLLP_VUINT32_T *) v_pGPIORegs;
    XllpLCD.CLKMan = (XLLP_VUINT32_T *) v_pClkRegs;
    XllpLCD.LCDC = (XLLP_VUINT32_T *) v_pLcdRegs;
    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();

    ClearFrameBuffer((unsigned *)gFrameBuffer + (activeFrameBuffer * frameBufferSize), TRUE);

    if( g_fEnableDMASourceSwap )
    {
        ClearFrameBuffer((unsigned *)gBlackFrameBuffer, FALSE);
    }

    // Initialize the LCD Controller and Board Control Register
    XllpLCDInit(&XllpLCD);


    //InitRegs((XLLP_OST_T *)v_pOSTRegs, (P_XLLP_I2C_T)v_pI2C);

    XllpI2cInit((P_XLLP_I2C_T)v_pI2C, (P_XLLP_GPIO_T) v_pGPIORegs, (P_XLLP_CLKMGR_T) v_pClkRegs, (XLLP_UINT32_T) 0);

    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;
    PHYSICAL_ADDRESS   PhysAddr;

    DMA_ADAPTER_OBJECT AdapterBlackScreen;
    PHYSICAL_ADDRESS   PhysAddrBlackScreen;

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

    g_DisplayBaseVirtual  = (DWORD)HalAllocateCommonBuffer(&Adapter, DISPLAY_BUFFER_SIZE, &PhysAddr, FALSE);
    g_DisplayBasePhysical = PhysAddr.LowPart;

    if (!g_DisplayBaseVirtual)
    {
        Cleanup();
        return FALSE;
    }

    // map shared virtual memory, and set the virtual ptr to that address rather than local process
    // address; from this point on, all processes (including DDraw apps) will be able to access the
    // display region using g_DisplayBaseVirtual
    g_DisplayBaseVirtual = (DWORD)VirtualAlloc(NULL, DISPLAY_BUFFER_SIZE, MEM_RESERVE, PAGE_NOACCESS);

    if(!VirtualCopy((LPVOID)g_DisplayBaseVirtual, (LPVOID)((unsigned long)g_DisplayBasePhysical >> 8), DISPLAY_BUFFER_SIZE, (PAGE_READWRITE | PAGE_NOCACHE | PAGE_PHYSICAL)))
    {
        RETAILMSG(1,(TEXT("CRITICAL ERROR: display SDRAM region allocation failed")));
    }

    if(g_fEnableDMASourceSwap)
    {
        AdapterBlackScreen.ObjectSize    = sizeof (DMA_ADAPTER_OBJECT);
        AdapterBlackScreen.InterfaceType = Internal;
        AdapterBlackScreen.BusNumber     = 0;

        g_DisplayBlackBaseVirtual = (DWORD)HalAllocateCommonBuffer(&AdapterBlackScreen, FRAME_BUFFER_SIZE, &PhysAddrBlackScreen, FALSE);
        g_DisplayBlackBasePhysical = PhysAddrBlackScreen.LowPart;

        if (!g_DisplayBlackBaseVirtual)
        {
            Cleanup();
            return FALSE;
        }

        g_DisplayBlackBaseVirtual = (DWORD)VirtualAlloc(NULL, FRAME_BUFFER_SIZE, MEM_RESERVE, PAGE_NOACCESS);

        if(!VirtualCopy((LPVOID)g_DisplayBlackBaseVirtual, (LPVOID)((unsigned long)g_DisplayBlackBasePhysical >> 8), FRAME_BUFFER_SIZE, (PAGE_READWRITE | PAGE_NOCACHE | PAGE_PHYSICAL)))
        {
            RETAILMSG(1,(TEXT("CRITICAL ERROR: blank display SDRAM region allocation failed")));
        }
    }


    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_pI2C = (volatile unsigned int *)VirtualAllocCopyPhysical(sizeof(BULVERDE_IICBUS_REG),"DispDrvrInitialize : v_pI2CRegs",(PVOID)(BULVERDE_BASE_REG_PA_I2C));
    if (!v_pI2C)
    {
        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)
    {