sa2video.cpp

Intel PXA27X Display Driver Windows CE

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/* 
** INTEL CONFIDENTIAL
** Copyright 2000-2003 Intel Corporation All Rights Reserved.
**
** The source code contained or described herein and all documents
** related to the source code (Material) are owned by Intel Corporation
** or its suppliers or licensors.  Title to the Material remains with
** Intel Corporation or its suppliers and licensors. The Material contains
** trade secrets and proprietary and confidential information of Intel
** or its suppliers and licensors. The Material is protected by worldwide
** copyright and trade secret laws and treaty provisions. No part of the
** Material may be used, copied, reproduced, modified, published, uploaded,
** posted, transmitted, distributed, or disclosed in any way without Intel抯
** prior express written permission.

** No 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. Any license under such intellectual property rights
** must be express and approved by Intel in writing.
*/

#include <windows.h>
#include <types.h>
#include <nkintr.h>
#include <syspal.h>
#include <ceddk.h>
#include "memdefs.h"

#include "precomp.h"
#include "cursor.h"
#include "xllp_lcd.h"
#include "xllp_gpio.h"

extern "C" PVOID VirtualAllocCopy(unsigned size,char *str,PVOID pVirtualAddress);
extern "C" void DispDrvrSetPalette(const PALETTEENTRY *,USHORT,USHORT);
extern "C" void *gFrameBuffer;
extern "C" volatile LCD_PALETTE *v_pPaletteBuffer;
extern "C" BOOL bDoRotation;
extern "C" void ScrollBuffer(int direction);
extern "C" void DispDrvrDirtyRectDump2(LPCRECT prc,DWORD color);
extern "C" void DispDrvrDirtyRectDump_rectfill(LPCRECT prc,DWORD color);
extern "C" BOOL gDrawCursorFlag;
extern "C" XLLP_LCD_T XllpLCD;
extern "C" void Overlay2_Enable(P_XLLP_OVERLAY_T pXllpOverlay);
extern "C" void Overlay2_Disable(P_XLLP_OVERLAY_T pXllpOverlay);
extern "C" void Overlay2_DMA_Length(P_XLLP_OVERLAY_T pXllpOverlay);
extern "C" volatile LCD_FRAME_DESCRIPTOR    *frameDescriptorCh2_YCbCr_Y;
extern "C" volatile LCD_FRAME_DESCRIPTOR    *frameDescriptorCh3_YCbCr_Cb;
extern "C" volatile LCD_FRAME_DESCRIPTOR    *frameDescriptorCh4_YCbCr_Cr;
extern "C" volatile unsigned int            *pOSCR;
extern "C" void ApplicationImageProcessingHandler(void);
extern "C" void msWait(unsigned int);

extern "C" HANDLE hIntEventKnown;
extern "C" HANDLE hIntEvent;


volatile LCDRegs     * v_pLcdRegs = NULL;
volatile XLLP_GPIO_T * v_pGPIORegs = NULL;

BOOL bCapturingVideo = TRUE;

#define NUM_FRAME_BUFFERS 2

DDGPE * pGPE = NULL;

// These masks are used to extract the color component for a 16 bit pixel value.  5 bits red, 6 bits green, 5 bits blue.
ulong BitMasks[] = {0xF800, 0x07E0, 0x001F};

INSTANTIATE_GPE_ZONES(0x3,"GDI Driver","unused1","unused2")     /* Start with Errors, warnings, and temporary messages */

BOOL APIENTRY
GPEEnableDriver(
    ULONG          iEngineVersion,
    ULONG          cj,
    DRVENABLEDATA *pded,
    PENGCALLBACKS  pEngCallbacks
    );

BOOL APIENTRY
DrvEnableDriver(
    ULONG          iEngineVersion,
    ULONG          cj,
    DRVENABLEDATA *data,
    PENGCALLBACKS  pEngineCallbacks
    )
{
    return GPEEnableDriver(iEngineVersion,cj,data,pEngineCallbacks);
}

#define DMA_CHANNEL_0  _T("DMA_CHANNEL_0")

////////////////////////////////////////////////////////////////////////////////////////////

// Main entry point for a GPE-compliant driver

GPE *
GetGPE()
{
    if (!pGPE)
    {
        pGPE = new SA2Video();
    }

    return pGPE;
}

VOID
SA2Video::PowerHandler(
    BOOL bOff
    )
{
    DispDrvrPowerHandler(bOff);
}

SA2Video::SA2Video()
{
    DEBUGMSG(GPE_ZONE_INIT,(TEXT("SA2Video::SA2Video\r\n")));

    m_InDDraw = FALSE;

    // Determine the display type
    // Setup the LCD controller for that display
    // Power up and enable the display
    DispDrvrInitialize();

    m_ModeInfo.modeId = 0;
    m_ModeInfo.width = m_nScreenWidth = DispDrvr_cxScreen;
    m_ModeInfo.height = m_nScreenHeight = DispDrvr_cyScreen;
    m_ModeInfo.Bpp = bpp;
    m_ModeInfo.frequency = 60;
    m_ModeInfo.format = bpp == 8 ? gpe8Bpp : gpe16Bpp;
    m_pMode = &m_ModeInfo;

    m_pModeEx.modeInfo.modeId = 0;
    m_pModeEx.modeInfo.width = m_nScreenWidth = DispDrvr_cxScreen;
    m_pModeEx.modeInfo.height = m_nScreenHeight = DispDrvr_cyScreen;
    m_pModeEx.modeInfo.Bpp = bpp;
    m_pModeEx.modeInfo.frequency = 60;
    m_pModeEx.modeInfo.format = bpp == 8 ? gpe8Bpp : gpe16Bpp;

    m_iRotate = GetRotateModeFromReg();
    SetRotateParams();

    m_pVirtualFrameBuffer = gFrameBuffer;

    m_pPrimarySurface = new DDGPESurf(m_nScreenWidth,m_nScreenHeight,m_pVirtualFrameBuffer,
         DispDrvr_cdwStride,m_ModeInfo.format);

    m_VirtualFrameBuffer = (ULONG)FRAME_BUFFER_0_BASE_VIRTUAL;

    if (m_pPrimarySurface)
    {
        ((GPESurf *)m_pPrimarySurface)->SetRotation(m_nScreenWidth, m_nScreenHeight, m_iRotate);
    }

    // Set up the software cursor state.
    m_CursorVisible   = FALSE;
    m_CursorDisabled  = TRUE; 
    m_CursorForcedOff = FALSE;
}

SCODE
SA2Video::SetMode(
    int        modeId,
    HPALETTE * pPalette)
{
    SCODE Result = E_INVALIDARG;

    // Here, we use EngCreatePalette to create a palette that that MGDI will use as a
    // stock palette
    if(pPalette && 0 == modeId)
    {
        switch (bpp)
        {
        case 8:
            *pPalette = EngCreatePalette(PAL_INDEXED, PALETTE_SIZE, (ULONG*)_rgbIdentity, 0, 0, 0);
            Result    = S_OK;
            break;

        case 16:
            *pPalette = EngCreatePalette(PAL_BITFIELDS, 0, NULL, BitMasks[0], BitMasks[1], BitMasks[2]);
            Result    = S_OK;
            break;

        default:
            *pPalette = NULL;
            break;
        }
    }

    return Result;
}

SCODE
SA2Video::GetModeInfo(
    GPEMode * pMode, 
    int       modeNumber
    )
{
    if(modeNumber != 0)
    {
        return E_INVALIDARG;
    }

    *pMode = m_ModeInfo;

    return S_OK;
}

int
SA2Video::NumModes()
{
    return 1;
}

SCODE
SA2Video::SetPointerShape(
    GPESurf * pMask,
    GPESurf * pColorSurf,
    int       xHot,
    int       yHot,
    int       cX,
    int       cY
    )
{
    int        row;
    int        colByte;
    BYTE     * pAND;
    BYTE     * pXOR;
    BYTE       bitMask;
    unsigned   i;

    if (!bDoRotation)
    {
        CursorOff();
    }

    if (!pMask)
    {   // Turn off the cursor.
        memset((BYTE *)gCursorMask,0xFF,sizeof(gCursorMask));
        memset((BYTE *)gCursorData,0x00,sizeof(gCursorData));

        m_CursorDisabled = TRUE;
    }
    else 
    {
        i = 0;

        for (row = 0; row < cY; row++) 
        {
            for (colByte = 0; colByte < (cX / 8); colByte++) 
            {
                pAND = (unsigned char *)pMask->Buffer()+(row*pMask->Stride())+colByte;
                pXOR = pAND+(cY*pMask->Stride());

                for (bitMask = 0x0080; bitMask; bitMask >>= 1) 
                {
                    gCursorMask[i] = (*pAND & bitMask) ? 0xFFFF : 0x0000;
                    gCursorData[i] = (*pXOR & bitMask) ? 0xFFFF : 0x0000;
                    i++;
                }
            }
        }

        m_CursorDisabled = FALSE;
        m_CursorSize.x   = cX;
        m_CursorSize.y   = cY;
        gxHot            = xHot;
        gyHot            = yHot;
    }

    return S_OK;
}

SCODE
SA2Video::MovePointer(
    int xPosition,
    int yPosition
    )
{
    if (!bDoRotation) 
    {
        CursorOff();
    }

    if(xPosition != -1 || yPosition != -1)
    {
        // enable cursor
        DispDrvrMoveCursor(xPosition, yPosition);

        m_CursorRect.left   = xPosition - gxHot;
        m_CursorRect.right  = m_CursorRect.left + m_CursorSize.x;
        m_CursorRect.top    = yPosition - gyHot;
        m_CursorRect.bottom = m_CursorRect.top + m_CursorSize.y;

        if (!bDoRotation)
        {
            CursorOn();
        }
    }
    else 
    {
        // disable cursor
        DispDrvrMoveCursor(DispDrvr_cxScreen, DispDrvr_cyScreen);        
    }

    return S_OK;
}

void
SA2Video::WaitForNotBusy()
{
    return;
}

int
SA2Video::IsBusy()
{
    return 0;    // Never busy as there is no acceleration
}

void
SA2Video::GetPhysicalVideoMemory(
    unsigned long * pPhysicalMemoryBase,
    unsigned long * pVideoMemorySize
    )
{
    *pPhysicalMemoryBase = (ULONG)FRAME_BUFFER_0_BASE_VIRTUAL;
    *pVideoMemorySize    = DispDrvr_cdwStride * DispDrvr_cyScreen;
}

void
SA2Video::GetVirtualVideoMemory(
    unsigned long * pVirtualMemoryBase,
    unsigned long * pVideoMemorySize
    )
{
    *pVirtualMemoryBase = (unsigned)(m_pPrimarySurface->Buffer());
    *pVideoMemorySize   = (unsigned)(m_pPrimarySurface->Stride()*m_pPrimarySurface->Height());
}

SCODE
SA2Video::AllocSurface(
    DDGPESurf         ** ppSurf,
    int                  width,
    int                  height,
    EGPEFormat           format,
    EDDGPEPixelFormat    pixelFormat,
    int                  surfaceFlags
    )
{
    if (surfaceFlags & GPE_REQUIRE_VIDEO_MEMORY)
    {
        *ppSurf = NULL;

        return E_OUTOFMEMORY;
    }

    DWORD SurfBpp       = EGPEFormatToBpp[format];
    DWORD stride        = ((SurfBpp * width + 31) >> 5) << 2;
    DWORD nSurfaceBytes = stride * height;

    *ppSurf = new DDGPESurf(width, height, stride, format, pixelFormat);

    if (NULL != *ppSurf)
    {
        if (((*ppSurf)->Buffer()) == NULL)
        {
            delete *ppSurf;
            *ppSurf = NULL;
        }
        else
        {
            return S_OK;
        }
    }

    return E_OUTOFMEMORY;
}

SCODE
SA2Video::AllocSurface(
    GPESurf    ** surface,
    int           width,
    int           height,
    EGPEFormat    format,
    int           surfaceFlags
    )
{
    if (surfaceFlags & GPE_REQUIRE_VIDEO_MEMORY)
    {
        // Can't allocate video-memory surfaces in the SA2Video environment
        return E_OUTOFMEMORY;
    }

    // Allocate from system memory
    *surface = new GPESurf(width,height,format);