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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// omap3530/beagle_drivers/lcd/lcd.cpp

// Implementation of an LCD driver. 

// This file is part of the Beagle Base port

// N.B. This sample code assumes that the display supports setting the backlight on or off, 

// as well as adjusting the contrast and the brightness.

//

#include <videodriver.h>

#include <platform.h>

#include <nkern.h>

#include <kernel.h>

#include <kern_priv.h>

#include <kpower.h>

#include <assp/omap3530_assp/omap3530_assp_priv.h>

#include <assp/omap3530_assp/omap3530_hardware_base.h>

#include <assp/omap3530_assp/omap3530_prcm.h>

#define DSS_SYSCONFIG				0x48050010

#define DISPC_SYSSTATUS				0x48050414

#define DISPC_SYSCONFIG				0x48050410

#define DISPC_CONFIG				0x48050444

#define DISPC_DEFAULT_COLOR0		0x4805044c

#define DISPC_TRANS_COLOR0			0x48050454

#define DISPC_TIMING_H				0x48050464

#define DISPC_TIMING_V				0x48050468

#define DISPC_POL_FREQ				0x4805046c

#define DISPC_DIVISOR				0x48050470

#define DISPC_SIZE_LCD				0x4805047c

#define DISPC_GFX_BA1				0x48050480

#define DISPC_GFX_BA2				0x48050484

#define DISPC_GFX_POSITION			0x48050488

#define DISPC_GFX_SIZE				0x4805048c

#define DISPC_GFX_ATTRIBUTES		0x480504a0

#define DISPC_GFX_FIFO_THRESHOLD	0x480504a4

#define DISPC_GFX_FIFO_SIZE_STATUS	0x480504a8

#define DISPC_GFX_ROW_INC			0x480504ac

#define DISPC_GFX_PIXEL_INC			0x480504b0

#define DISPC_GFX_WINDOW_SKIP		0x480504b4

#define DISPC_GFX_TABLE_BA			0x480504b8

#define DISPC_CONTROL				0x48050440

#define GET_REGISTER(Reg)		*( (TUint *) Omap3530HwBase::TVirtual<Reg>::Value )

#define SET_REGISTER(Reg,Val)	*( (TUint *) Omap3530HwBase::TVirtual<Reg>::Value ) = Val

#define _MODE_1280x1024_

//#define _MODE_1024x768_

#ifdef _MODE_800x600_

// ModeLine       "800x600@60" 40.0 800 840 968 1056 600 601 605 628 +hsync +vsync

// Decoded by: http://www.tkk.fi/Misc/Electronics/faq/vga2rgb/calc.html

#	define PIXEL_CLK	40000

#	define H_DISP		800

#	define H_FPORCH	40

#	define H_SYNC		128

#	define H_BPORCH	88

#	define H_SYNC_POL	1

#	define V_DISP		600

#	define V_FPORCH	1

#	define V_SYNC		4

#	define V_BPORCH	23

#	define V_SYNC_POL	1

#	define INTERLACE_ENABLE	0

#endif

#ifdef _MODE_1024x768_

// ModeLine       "1024x768@60" 65.0 1024 1048 1184 1344 768 771 777 806 -hsync -vsync

// Decoded by: http://www.tkk.fi/Misc/Electronics/faq/vga2rgb/calc.html

#	define PIXEL_CLK	65000

#	define H_DISP		1024

#	define H_FPORCH	24

#	define H_SYNC		136

#	define H_BPORCH	160

#	define H_SYNC_POL	0

#	define V_DISP		768

#	define V_FPORCH	3

#	define V_SYNC		6

#	define V_BPORCH	29

#	define V_SYNC_POL	0

#	define INTERLACE_ENABLE	0

#endif

#ifdef _MODE_1280x1024_

// ModeLine "1280x1024@60" 108.0 1280 1328 1440 1688 1024 1025 1028 1066 +hsync +vsync

// Decoded by: http://www.tkk.fi/Misc/Electronics/faq/vga2rgb/calc.html

#	define PIXEL_CLK	108000

#	define H_DISP		1280

#	define H_FPORCH	48

#	define H_SYNC		112

#	define H_BPORCH	248

#	define H_SYNC_POL	1

#	define V_DISP		1024

#	define V_FPORCH	1

#	define V_SYNC		3

#	define V_BPORCH	38

#	define V_SYNC_POL	1

#	define INTERLACE_ENABLE	0

#endif

// TO DO: (mandatory)

// If the display supports Contrast and/or Brightness control then supply the following defines:

// This is only example code... you may need to modify it for your hardware

const TInt KConfigInitialDisplayContrast	= 128;

const TInt KConfigLcdMinDisplayContrast		= 1;

const TInt KConfigLcdMaxDisplayContrast		= 255;

const TInt KConfigInitialDisplayBrightness	= 128;

const TInt KConfigLcdMinDisplayBrightness	= 1;

const TInt KConfigLcdMaxDisplayBrightness	= 255;

// TO DO: (mandatory)

// define a macro to calculate the screen buffer size

// This is only example code... you may need to modify it for your hardware

// aBpp is the number of bits-per-pixel, aPpl is the number of pixels per line and 

// aLpp number of lines per panel

#define FRAME_BUFFER_SIZE(aBpp,aPpl,aLpp)	(aBpp*aPpl*aLpp)/8	

// TO DO: (mandatory)

// define the physical screen dimensions

// This is only example code... you need to modify it for your hardware

const TUint	KConfigLcdWidth					= 360;//640;		// 640 pixels per line

const TUint	KConfigLcdHeight				= 640;//480;		// 480 lines per panel

// TO DO: (mandatory)

// define the characteristics of the LCD display

// This is only example code... you need to modify it for your hardware

const TBool	KConfigLcdIsMono				= EFalse;

const TBool	KConfigLcdPixelOrderLandscape	= ETrue;

const TBool	KConfigLcdPixelOrderRGB			= ETrue;

const TInt	KConfigLcdMaxDisplayColors		= 65536;	//24bit: 16777216;

// TO DO: (mandatory)

// define the display dimensions in TWIPs

// A TWIP is a 20th of a point.  A point is a 72nd of an inch

// Therefore a TWIP is a 1440th of an inch

// This is only example code... you need to modify it for your hardware

// TO DO: (mandatory)

// define the available display modes

// This is only example code... you need to modify it for your hardware

const TInt  KConfigLcdNumberOfDisplayModes	= 1;

const TInt  KConfigLcdInitialDisplayMode	= 0;

struct SLcdConfig

	{

	TInt iMode;

	TInt iOffsetToFirstVideoBuffer;

	TInt iLenghtOfVideoBufferInBytes;

	TInt iOffsetBetweenLines;

	TBool iIsPalettized;

	TInt iBitsPerPixel;

	};

static const SLcdConfig Lcd_Mode_Config[KConfigLcdNumberOfDisplayModes]=

	{

		{

		0,								// iMode

		0,								// iOffsetToFirstVideoBuffer

		FRAME_BUFFER_SIZE(16, KConfigLcdWidth, KConfigLcdHeight),	// iLenghtOfVideoBufferInBytes

		KConfigLcdWidth*2,				// iOffsetBetweenLines

		EFalse,							// iIsPalettized

		16								// iBitsPerPixel

		}

	};	

_LIT(KLitLcd,"LCD");

//

// TO DO: (optional)

//

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

	void SwitchDisplay(TBool aSecure);

	void SetBacklightState(TBool aState);

	void BacklightOn();

	void BacklightOff();

	TInt SetContrast(TInt aContrast);

	TInt SetBrightness(TInt aBrightness);

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

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;

	TDfcQue* iDfcQ;

	TMessageQue iMsgQ;

	TDfc iPowerUpDfc;

	TDfc iPowerDownDfc;	

	TVideoInfoV01 iVideoInfo;

	TVideoInfoV01 iSecureVideoInfo;

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

	TPhysAddr ivRamPhys;

	TPhysAddr iSecurevRamPhys;

	TBool iBacklightOn;

	TInt iContrast;

	TInt iBrightness;

	};

/**

HAL handler function

@param	aPtr a pointer to an instance of DLcdPowerHandler

@param	aFunction the function number

@param	a1 an arbitrary parameter

@param	a2 an arbitrary parameter

*/

LOCAL_C TInt halFunction(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2)

	{

	DLcdPowerHandler* pH=(DLcdPowerHandler*)aPtr;

	return pH->HalFunction(aFunction,a1,a2);

	}

/**

DFC for receiving messages from the power handler

@param	aPtr a pointer to an instance of DLcdPowerHandler

*/

void rxMsg(TAny* aPtr)

	{

	DLcdPowerHandler& h=*(DLcdPowerHandler*)aPtr;

	h.HandleMsg();

	}

/**

DFC for powering up the device

@param aPtr	aPtr a pointer to an instance of DLcdPowerHandler

*/

void power_up_dfc(TAny* aPtr)

	{

	((DLcdPowerHandler*)aPtr)->PowerUpDfc();

	}

/**

DFC for powering down the device

@param aPtr	aPtr a pointer to an instance of DLcdPowerHandler

*/

void power_down_dfc(TAny* aPtr)

	{

	((DLcdPowerHandler*)aPtr)->PowerDownDfc();

	}

/**

Default constructor

*/

DLcdPowerHandler::DLcdPowerHandler() :

		DPowerHandler(KLitLcd),

		iMsgQ(rxMsg,this,NULL,1),

		iPowerUpDfc(&power_up_dfc,this,6),

		iPowerDownDfc(&power_down_dfc,this,7),

		iBacklightOn(EFalse),

		iContrast(KConfigInitialDisplayContrast),

		iBrightness(KConfigInitialDisplayBrightness)

	{

	}

/**

Second-phase constructor 

Called by factory function at ordinal 0

*/

TInt DLcdPowerHandler::Create()

	{

	iDfcQ=Kern::DfcQue0();	// use low priority DFC queue for this driver 

	// map the video RAM

	//TPhysAddr videoRamPhys;

	TInt vSize = Lcd_Mode_Config[KConfigLcdInitialDisplayMode].iLenghtOfVideoBufferInBytes; //KConfigLcdWidth*KConfigLcdHeight*3; //VideoRamSize();

	TInt r = Epoc::AllocPhysicalRam( 2*vSize, ivRamPhys );

	if ( r!=KErrNone )

		{

		Kern::Fault( "AllocVRam", r );

		}

	//TInt vSize = ((Omap3530BoardAssp*)Arch::TheAsic())->VideoRamSize();

	//ivRamPhys = TOmap3530Assp::VideoRamPhys();				// EXAMPLE ONLY: assume TOmap3530Assp interface class

	r = DPlatChunkHw::New(iChunk,ivRamPhys,vSize,EMapAttrUserRw|EMapAttrBufferedC);

	if (r != KErrNone)

		return r;	

	//create "secure" screen immediately after normal one

	iSecurevRamPhys =  ivRamPhys + vSize;

	TInt r2 = DPlatChunkHw::New(iSecureChunk,iSecurevRamPhys,vSize,EMapAttrUserRw|EMapAttrBufferedC);

	if (r2 != KErrNone)

		return r2;

	TUint* pV=(TUint*)iChunk->LinearAddress();	

	__KTRACE_OPT(KEXTENSION,Kern::Printf("DLcdPowerHandler::Create: VideoRamSize=%x, VideoRamPhys=%08x, VideoRamLin=%08x",vSize,ivRamPhys,pV));

	// TO DO: (mandatory)

	// initialise the palette for the initial display mode

	// NOTE: the palette could either be a buffer allocated in system RAM (usually contiguous to Video buffer)

	//		 or could be offered as part of the hardware block that implemenst the lcd control

	//

	TUint* pV2=(TUint*)iSecureChunk->LinearAddress();

	__KTRACE_OPT(KEXTENSION,Kern::Printf("DLcdPowerHandler::Create: Secure display VideoRamSize=%x, VideoRamPhys=%08x, VideoRamLin=%08x",vSize,iSecurevRamPhys,pV2));

	// TO DO: (mandatory)

	// initialise the secure screen's palette for the initial display mode

	//

	// setup the video info structure, this'll be used to remember the video settings

	iVideoInfo.iDisplayMode = KConfigLcdInitialDisplayMode;

	iVideoInfo.iOffsetToFirstPixel = Lcd_Mode_Config[KConfigLcdInitialDisplayMode].iOffsetToFirstVideoBuffer;

	iVideoInfo.iIsPalettized = Lcd_Mode_Config[KConfigLcdInitialDisplayMode].iIsPalettized;

	iVideoInfo.iOffsetBetweenLines = Lcd_Mode_Config[KConfigLcdInitialDisplayMode].iOffsetBetweenLines;

	iVideoInfo.iBitsPerPixel = Lcd_Mode_Config[KConfigLcdInitialDisplayMode].iBitsPerPixel;

	iVideoInfo.iSizeInPixels.iWidth = KConfigLcdWidth;

	iVideoInfo.iSizeInPixels.iHeight = KConfigLcdHeight;

	iVideoInfo.iSizeInTwips.iWidth = KConfigLcdWidthInTwips;

	iVideoInfo.iSizeInTwips.iHeight = KConfigLcdHeightInTwips;

	iVideoInfo.iIsMono = KConfigLcdIsMono;

	iVideoInfo.iVideoAddress=(TInt)pV;

	iVideoInfo.iIsPixelOrderLandscape = KConfigLcdPixelOrderLandscape;

	iVideoInfo.iIsPixelOrderRGB = KConfigLcdPixelOrderRGB;

	iSecureVideoInfo = iVideoInfo;

	iSecureVideoInfo.iVideoAddress = (TInt)pV2;

	iDisplayOn = EFalse;

	iSecureDisplay = EFalse;

	// install the HAL function

	r=Kern::AddHalEntry(EHalGroupDisplay, halFunction, this);

	if (r!=KErrNone)

		return r;

	iPowerUpDfc.SetDfcQ(iDfcQ);

	iPowerDownDfc.SetDfcQ(iDfcQ);

	iMsgQ.SetDfcQ(iDfcQ);

	iMsgQ.Receive();

	// install the power handler

	// power up the screen

	Add();

	DisplayOn();

	SplashScreen();

	return KErrNone;

	}

/**

Turn the display on

May be called as a result of a power transition or from the HAL

If called from HAL, then the display may be already be on (iDisplayOn == ETrue)

*/

void DLcdPowerHandler::DisplayOn()

	{

	__KTRACE_OPT(KBOOT, Kern::Printf("DisplayOn %d", iDisplayOn));

	if (!iDisplayOn)				// may have been powered up already

		{

		iDisplayOn = ETrue;

		PowerUpLcd(iSecureDisplay);

		SetContrast(iContrast);

		SetBrightness(iBrightness);

		}

	}

/**

Turn the display off

May be called as a result of a power transition or from the HAL

If called from Power Manager, then the display may be already be off (iDisplayOn == EFalse)

if the platform is in silent running mode

*/

void DLcdPowerHandler::DisplayOff()

	{

	__KTRACE_OPT(KBOOT, Kern::Printf("DisplayOff %d", iDisplayOn));

	if (iDisplayOn)

		{

		iDisplayOn = EFalse;

		PowerDownLcd();

		}

	}

/**

Switch between secure and non-secure displays

@param aSecure ETrue if switching to secure display

*/

void DLcdPowerHandler::SwitchDisplay(TBool aSecure)

 	{

 	if (aSecure)

 		{

 		if (!iSecureDisplay)

 			{

 			//switch to secure display

 			DisplayOff();

 			iSecureDisplay = ETrue;

 			DisplayOn();

 			}

 		}

 	else

 		{

 		if (iSecureDisplay)

 			{

 			//switch from secure display

 			DisplayOff();

 			iSecureDisplay = EFalse;

 			DisplayOn();

 			}

 		}

 	}

/**

DFC to power up the display

*/

void DLcdPowerHandler::PowerUpDfc()

	{

	__KTRACE_OPT(KPOWER, Kern::Printf("PowerUpDfc"));

	DisplayOn();

	PowerUpDone();				// must be called from a different thread than PowerUp()

	}

/**

DFC to power down the display

*/

void DLcdPowerHandler::PowerDownDfc()

	{

	__KTRACE_OPT(KPOWER, Kern::Printf("PowerDownDfc"));

	DisplayOff();

	PowerDownDone();			// must be called from a different thread than PowerUp()

	}

/**

Schedule the power-down DFC

*/

void DLcdPowerHandler::PowerDown(TPowerState)

	{

	iPowerDownDfc.Enque();		// schedules DFC to execute on this driver's thread

	}

/**

Schedule the power-up DFC

*/

void DLcdPowerHandler::PowerUp()

	{

	iPowerUpDfc.Enque();		// schedules DFC to execute on this driver's thread

	}

/**