/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

* naviengine_assp\lcdgce\lcdgce.h

*

*/

/**

 @file Definitions for the ne1_tb GCE PDD

 @internalTechnology

 @prototype

*/

#ifndef __LCDGCE_H__

#define __LCDGCE_H__

#include <display.h>

const TUint   KVSyncEnable 					= 1<<1;

const TUint64 KVSyncDisable 				= ~(TUint64)(KVSyncEnable) ;

const TUint   KVSyncClear 					= 1<<1;

const TUint   KVSyncStatus 					= 1<<1;

const TUint   KVSyncSelectToChannel1		= 1<<8;

const TUint   KHex8 						= 0x8;

/* The available display modes.

	These modes can be changed by software, but the initial mode is specified by

	DSW1 DIP switch settings (7 & 8) as described in the table below:

DSW1 | 7 8 |

-----------------------------------------------------------------------------------------------------

     | 0 0 | 640 x 480 | D-SUB       | landscape |  VGA on analog 15 pin DSUB connector

     | 0 1 | 800 x 480 | NEC LCD     | landscape | WVGA

     | 1 0 | 480 x 640 | Hitachi LCD | portrait  |  VGA (LCD switches: SW4=0111, SW5=0, SW6=0, SW7=0)

     | 1 1 | 320 x 240 | D-SUB       | landscape | QVGA on analog 15 pin DSUB connector

*/

enum TVideoMode

	{

	DISPLAY_MODE_ANALOG_VGA   = 0,

	DISPLAY_MODE_HITACHI_VGA,

	DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE_OLD,

	DISPLAY_MODE_HITACHI_QVGA,

	DISPLAY_MODE_NEC_WVGA,

	DISPLAY_MODE_ANALOG_QVGA_PORTRAIT,

	DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE,

	DISPLAY_NUM_MODES

	};

inline TInt ReadDipSwitchDisplayMode()

	{

	// Check the IDMODE register for DIP switch settings

	// to set the requested display mode

	// Read bits 12 and 13 from IDMODE register to get the LCD mode

	TUint switches = (AsspRegister::Read32(KHwIDMODE) & KHmLcdSwitches) >> KHsLcdSwitches;

	TInt mode = 0;

	switch (switches)

		{

		default:

		case 0:

			mode = DISPLAY_MODE_ANALOG_VGA;

			break;

		case 1:

			mode = DISPLAY_MODE_HITACHI_VGA;

			break;

		case 2:

			mode = DISPLAY_MODE_NEC_WVGA;

			break;

		case 3:

			mode = DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE;

			break;

			// An alternative case 3 line for QVGA Portrait

			//		case 3: iInitialMode = DISPLAY_MODE_ANALOG_QVGA_PORTRAIT;   break;

		}

	return mode;

	}

/********************************************************************/

/* Class Definition                                                 */

/********************************************************************/

/**

 * This class defines a callback mechanism that is used by a resource user to specify its callback. It contains a

 * function pointer and data pointer. The function pointer specifies the user callback function to be invoked by the

 * resource while the data pointer specifies the data to be passed to the callback function.

 */

class TLcdUserCallBack

    {

public:

    // The constructor for the callback mechanism.

    TLcdUserCallBack(TInt (*aFunction)(TUint aResID, TAny* aPtr), TAny* aPtr)

        {

        iCbFn = aFunction;

        iDataPtr = aPtr;

        }

public:

    // The callback function pointer.

    TInt (*iCbFn)(TUint aResID, TAny* aPtr);

    // Pointer to the data structure to be passed to the callback function.

    TAny *iDataPtr;

    };

/**

 PDD Factory class

 */

class DDisplayPddFactory : public DPhysicalDevice

	{

public:

	DDisplayPddFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);

	virtual TInt Validate(TInt aDeviceType, const TDesC8* anInfo, const TVersion& aVer);

	};

class DDisplayPddNaviEng : public DDisplayPdd

	{

	public:

	DDisplayPddNaviEng();

	~DDisplayPddNaviEng();

   	//Inherited from DDisplayPdd

   	TInt  		SetLegacyMode();

    TInt  		SetGceMode();

    TInt  		SetRotation(RDisplayChannel::TDisplayRotation aRotation);

	TInt  		PostUserBuffer(TBufferNode* aNode);

	TInt  		PostCompositionBuffer(TBufferNode* aNode);

    TInt  		PostLegacyBuffer();

    TBool 		PostPending();

    TInt  		CloseMsg();

    TInt  	 	CreateChannelSetup(TInt aUnit);

    TDfcQue*	DfcQ(TInt  aUnit);

public:

	void  VSyncIsr();

	static void VSyncDfcFn(TAny* aChannel);

private:

	TDfcQue* 		iDfcQ;

    //generic  display info

	TVideoInfoV01    	iScreenInfo;

    //Pointer to a buffer in the Pending state

    TBufferNode*     	iPendingBuffer;

     //Pointer to a buffer in the Active state

    TBufferNode*     	iActiveBuffer;

    DChunk * 		 	iChunk;

    TLcdUserCallBack*   iLcdCallback;

 public:

	TDfc 		     	iVSyncDfc;

	};

//

// Add any private functions and data you require

//

NONSHARABLE_CLASS(DLcdPowerHandler) : public DPowerHandler

	{

public:

	DLcdPowerHandler();

	// from DPowerHandler

	void PowerDown(TPowerState);

	void PowerUp();

	void PowerUpDfc();

	void PowerDownDfc();

	TInt Create();

	void DisplayOn();

	void DisplayOff();

	TInt HalFunction(TInt aFunction, TAny* a1, TAny* a2);

	void PowerUpLcd(TBool aSecure);

	void PowerDownLcd();

	void ScreenInfo(TScreenInfoV01& aInfo);

	void WsSwitchOnScreen();

	void WsSwitchOffScreen();

	void HandleMsg(TMessageBase* aMsg);

	void SwitchDisplay(TBool aSecure);

	void SetBacklightState(TBool aState);

	void BacklightOn();

	void BacklightOff();

	TInt SetContrast(TInt aContrast);

	TInt HalSetContrast(TInt aContrast);

	TInt SetBrightness(TInt aBrightness);

	TInt HalSetBrightness(TInt aBrightness);

	void SwitchToSecureDisplay();

	void SwitchFromSecureDisplay();

private:

	TInt SetPaletteEntry(TInt aEntry, TInt aColor);

	TInt GetPaletteEntry(TInt aEntry, TInt* aColor);

	TInt NumberOfPaletteEntries();

	TInt GetCurrentDisplayModeInfo(TVideoInfoV01& aInfo, TBool aSecure);

	TInt GetSpecifiedDisplayModeInfo(TInt aMode, TVideoInfoV01& aInfo);

	TInt SetDisplayMode(TInt aMode);

	void SplashScreen();

	TInt GetDisplayColors(TInt* aColors);

public:

	TInt InitialiseController();

	static void Service(TAny* aPtr);

    IMPORT_C static    TInt    RegisterCallback(TLcdUserCallBack* aCbPtr);

    IMPORT_C static    void    DeRegisterCallback(TLcdUserCallBack* aCbPtr);

private:

	TBool 			iIsPalettized;

	TBool 			iDisplayOn;				// to prevent a race condition with WServer trying to power up/down at the same time

	DPlatChunkHw* 	iChunk;

	DPlatChunkHw* 	iSecureChunk;

	TBool 			iWsSwitchOnScreen;

 	TBool 			iSecureDisplay;

	TDfc 			iPowerUpDfc;

	TDfc 			iPowerDownDfc;

	TVideoInfoV01 	iSecureVideoInfo;

	NFastMutex 		iLock;				// protects against being preempted whilst manipulating iVideoInfo/iSecureVideoInfo

	TPhysAddr 		ivRamPhys;

	TPhysAddr 		iSecurevRamPhys;

	TBool 			iBacklightOn;

	TInt 			iContrast;

	TInt 			iBrightness;

	TUint 			iInitialMode;

	TLcdUserCallBack * iAppCallBk[2];

public:

	TMessageQue 	iMsgQ;

	TDfcQue* 		iDfcQ;

	TVideoInfoV01 	iVideoInfo;

	TInt			iSize;

	TPhysAddr		iCompositionPhysical;

    static   DLcdPowerHandler 	* pLcd;

	};

//#define _GCE_NAVIDISPLAY_DEBUG

#ifdef _GCE_NAVIDISPLAY_DEBUG

#define  __GCE_DEBUG_PRINT(a) 		Kern::Printf(a)

#define  __GCE_DEBUG_PRINT2(a,b) 	Kern::Printf(a,b)

#else

#define  __GCE_DEBUG_PRINT(a)

#define  __GCE_DEBUG_PRINT2(a,b)

#endif

#endif //__LCDGCE_H__