//**********************************************************************
//                                                                      
// Filename: gpeflat.cpp
//                                                                      
// Description: Flat driver for the EP9312.
//
// 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.
//
// Use of this source code is subject to the terms of the Cirrus 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 
// EULA.RTF on your install media.
//
// Copyright(c) Cirrus Logic Corporation 2002, All Rights Reserved                       
//                                                                      
//**********************************************************************
                   
#include    "precomp.h"
#include    "..\common\palette.h" // for 8Bpp we use the natural palette

INSTANTIATE_PALETTE

//
// Set up the debug zones.
//
INSTANTIATE_GPE_ZONES(0x0003,"Flat DDI Driver","Palette","unused2")    // Start with errors and warnings
#define     GPE_ZONE_PALETTE    DEBUGZONE(14)


static  GPE *gGPE = (GPE*)NULL;

// This prototype avoids problems exporting from .lib
BOOL APIENTRY GPEEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
                              PENGCALLBACKS  engineCallbacks);


//****************************************************************************
// DrvEnableDriver
//****************************************************************************
//
BOOL APIENTRY DrvEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
                              PENGCALLBACKS  engineCallbacks)
{
    return GPEEnableDriver(engineVersion, cj, data, engineCallbacks);
}

//****************************************************************************
// GetGPE
//****************************************************************************
// Main entry point for a GPE-compliant driver
// 
//

GPE *GetGPE(void)
{
    if (!gGPE)
    {
        gGPE = new GPEFlat();
    }

    return gGPE;
}


//****************************************************************************
// GPEFlat::GPEFlat
//****************************************************************************
// GPEFlat Constructor
//
GPEFlat::GPEFlat (void)
{
    DWORD       oldMode;
    ULONG       fbSize;
    StartStop   StartStopTemp;


    DEBUGMSG(GPE_ZONE_INIT,(TEXT("GPEFlat::GPEFlat\r\n")));
    RETAILMSG(1,(TEXT("Init Raster engine\r\n")));

    oldMode = SetKMode(TRUE);

    //
    // Read in the settings from the registry.
    //
    GetDisplayRegistrySettings(&m_Registry);

    //
    // Initialize the values that are being used.
    //
    m_VirtualFrameBuffer    = FRAMEBUF_VIRTUAL_MEMORY;
    m_pvFlatFrameBuffer     = FRAMEBUF_PHYSICAL_MEMORY;
    m_ulColorDepth          = m_Registry.ulColorDepth;
    m_nScreenWidth          = m_Registry.ulScreenWidth;
    m_nScreenHeight         = m_Registry.ulScreenHeight;


    //
    // If the flag Set Directly is used then take the Raster values directly
    // from the registry.
    //
    if(m_Registry.ulSetDirectly)
    {
        //
        // Use the values from the registry to setup the display.
        //       
        GenericDisplaySetup(&m_Registry, FRAMEBUF_PHYSICAL_MEMORY, &StartStopTemp);
    }
    else
    {
        //
        // Use the generic CRT setup.
        //
        CRTVideoSetup
        (
            m_nScreenWidth,
            m_nScreenHeight,
            m_ulColorDepth,
            m_Registry.ulFrequency, 
            m_pvFlatFrameBuffer,
            &StartStopTemp
        );
    }
    
    //
    // Program the proper color depth settings.
    //
    switch(m_ulColorDepth)
    {
        case  8:
        
            //
            // Set up the Color Look up table.   There are two LUT's in hardware.
            // the lookup table that is visible is not the one that is accessable.
            //
            SetPalette(_rgbIdentity, 0 , PALETTE_SIZE);
            
            //
            // Set up the Pixel mode.
            //
            *RASTER_PIXELMODE       = PIXELMODE_C_LUT | PIXELMODE_M_BLINKDISABLED |
                                      PIXELMODE_S_MODE1 | PIXELMODE_P_8BITS;
            m_ModeInfo.format       = gpe8Bpp;
            break;                                       
            
        case 16:
            *RASTER_PIXELMODE        = PIXELMODE_C_565 | PIXELMODE_M_BLINKDISABLED | PIXELMODE_S_MODE1 | 
                                       PIXELMODE_P_16BITS;
                                       
            //
            // Since we are not using a palette, setup red, green and blue masks.
            //                                       
            m_RedMaskSize           = 5;
            m_RedMaskPosition       = 11;
            m_GreenMaskSize         = 6;
            m_GreenMaskPosition     = 5;
            m_BlueMaskSize          = 5;
            m_BlueMaskPosition      = 0;
            m_ModeInfo.format       = gpe16Bpp;
            break;            
            
        case 24:
            *RASTER_PIXELMODE        = PIXELMODE_C_TRIPLE8 | PIXELMODE_M_BLINKDISABLED | PIXELMODE_S_MODE1 | 
                                       PIXELMODE_P_24BITS;
            //
            // Since we are not using a palette, setup red, green and blue masks.
            //                                       
            m_RedMaskSize           = 8;
            m_RedMaskPosition       = 16;
            m_GreenMaskSize         = 8;
            m_GreenMaskPosition     = 8;
            m_BlueMaskSize          = 8;
            m_BlueMaskPosition      = 0;
            m_ModeInfo.format       = gpe24Bpp;
            break;                                       

        case    32:
            //m_ModeInfo.format = gpe32Bpp;
            //break;

        default:
            DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Invalid BPP value passed to driver - %d\r\n"), m_ModeInfo.Bpp));
            m_ModeInfo.format = gpeUndefined;
            break;
    }            
    m_pMode = &m_ModeInfo;    



    //
    //  Copy a few more variables.
    //
    m_cxPhysicalScreen  = m_nScreenWidth;
    m_cyPhysicalScreen  = m_nScreenHeight;
    m_cbScanLineLength  = m_cxPhysicalScreen * (m_ulColorDepth /8);


    //
    // set rest of ModeInfo values
    //
    m_ModeInfo.modeId       = 0;
    m_ModeInfo.width        = m_nScreenWidth;
    m_ModeInfo.height       = m_nScreenHeight;
    m_ModeInfo.Bpp          = m_ulColorDepth;
    m_ModeInfo.frequency    = m_Registry.ulFrequency;
    

    m_pPrimarySurface = new GPESurf
        (
            m_nScreenWidth, 
            m_nScreenHeight, 
            (void*)m_VirtualFrameBuffer, 
            m_cbScanLineLength, 
            m_ModeInfo.format
        );
    
    //
    // Clear the screen.
    //
    RETAILMSG(1,(TEXT("Clearing screen\r\n")));
    fbSize = m_cyPhysicalScreen * m_cbScanLineLength ;     
    memset ((void*)m_VirtualFrameBuffer, 0x0, fbSize);
    RETAILMSG(1,(TEXT("memset of video\r\n")));


    //
    // Setup the cursor stuff.
    //
    m_CursorVisible = FALSE;
    m_CursorDisabled = TRUE;
    m_CursorForcedOff = FALSE;
    memset (&m_CursorRect, 0x0, sizeof(m_CursorRect));
    m_CursorBackingStore = NULL;
    m_CursorXorShape = NULL;
    m_CursorAndShape = NULL;
    RETAILMSG(1,(TEXT("Returning from DDI init\r\n")));
}

//****************************************************************************
// GPEFlat::SetMode
//****************************************************************************
// Sets the Graphics mode and the palette.
//
SCODE   GPEFlat::SetMode (INT modeId, HPALETTE *palette)
{
    DEBUGMSG(GPE_ZONE_INIT,(TEXT("GPEFlat::SetMode\r\n")));

    if (modeId != 0)
    {
        DEBUGMSG(GPE_ZONE_ERROR,(TEXT("GPEFlat::SetMode Want mode %d, only have mode 0\r\n"),modeId));
        return  E_INVALIDARG;
    }

    if (palette)
    {
        switch (m_ulColorDepth)
        {
            case    8:
                *palette = EngCreatePalette (PAL_INDEXED,
                             PALETTE_SIZE,
                             (ULONG*)_rgbIdentity,
                             0,
                             0,
                             0);
                break;

            case    16:
            case    24:
            case    32:
                *palette = EngCreatePalette (PAL_BITFIELDS,
                                             0,
                                             NULL,
                                             ((1 << m_RedMaskSize) - 1) << m_RedMaskPosition,
                                             ((1 << m_GreenMaskSize) - 1) << m_GreenMaskPosition,
                                             ((1 << m_BlueMaskSize) - 1) << m_BlueMaskPosition);
                break;
        }
    }

    return S_OK;
}

//****************************************************************************
// GPEFlat::GetModeInfo
//****************************************************************************
//
//
SCODE GPEFlat::GetModeInfo(GPEMode *mode, INT modeNumber)
{
    DEBUGMSG (GPE_ZONE_INIT, (TEXT("GPEFlat::GetModeInfo\r\n")));

    if (modeNumber != 0)
    {
        return E_INVALIDARG;
    }

    *mode = m_ModeInfo;

    return S_OK;
}

//****************************************************************************
// GPEFlat::NumModes
//****************************************************************************
// Only one graphics mode currently supported.
// 
//
int  GPEFlat::NumModes()
{
    DEBUGMSG (GPE_ZONE_INIT, (TEXT("GPEFlat::NumModes\r\n")));
    return  1;
}

//****************************************************************************
// GPEFlat::CursorOn
//****************************************************************************
// 
// 
void  GPEFlat::CursorOn (void)
{
    UCHAR   *ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();
    UCHAR   *ptrLine;
    UCHAR   *cbsLine;
    UCHAR   *xorLine;
    UCHAR   *andLine;
    int     x, y;

    if (!m_CursorForcedOff && !m_CursorDisabled && !m_CursorVisible)
    {
        if (!m_CursorBackingStore)
        {
            DEBUGMSG (GPE_ZONE_ERROR, (TEXT("GPEFlat::CursorOn - No backing store available\r\n")));
            return;
        }

        for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
        {
            if (y < 0)
            {
                continue;
            }
            if (y >= m_nScreenHeight)
            {
                break;
            }

            ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];
            cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_ulColorDepth >> 3))];
            xorLine = &m_CursorXorShape[(y - m_CursorRect.top) * m_CursorSize.x];
            andLine = &m_CursorAndShape[(y - m_CursorRect.top) * m_CursorSize.x];

            for (x = m_CursorRect.left; x < m_CursorRect.right; x++)
            {
                if (x < 0)
                {
                    continue;
                }
                if (x >= m_nScreenWidth)
                {
                    break;
                }

                cbsLine[(x - m_CursorRect.left) * (m_ulColorDepth >> 3)] = ptrLine[x * (m_ulColorDepth >> 3)];