/*

* 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:  

* \hwip_nec_naviengine\naviengine_assp\lcdgce\lcdgce.cpp

* Implementation of an LCD driver with GCE support.

* This file is part of the NE1_TBVariant 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.

*

*/

/**

 @file Implementation of an LCD driver with GCE support.

 @internalTechnology

 @prototype

*/

#include <videodriver.h>

#include "platform.h"

#include <nkern.h>

#include <kernel/kernel.h>

#include <kernel/kern_priv.h>

#include <kernel/kpower.h>

#include <naviengine_priv.h>

#include "lcdgce.h"

#include <naviengine_lcd.h>

#include "powerresources.h"

#include <resourcecontrol.h>

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

const TUint32 KShiftBitsPerByte				= 3;

const TInt	KConfigBitsPerPixel16			= 16;

const TInt	KConfigBitsPerPixel32			= 32;

#define RESOLUTION_AND_CYCLE		DISPLAY_RESOLUTION_AND_CYCLE(Lcd_Mode_Config[iInitialMode].iConfigLcdHeight, Lcd_Mode_Config[iInitialMode].iConfigLcdWidth, Lcd_Mode_Config[iInitialMode].iLinesInFrame, Lcd_Mode_Config[iInitialMode].iPixelsInLine)

#define SCREEN_UNIT					0

#define SCREEN_UNIT_COUNT			1

struct SLcdConfig

	{

	TInt    iOffsetToFirstVideoBuffer;

	TInt    iConfigLcdWidth;    // The width of the physical display

	TInt    iConfigLcdHeight;   // The height of the physical display

	TBool   iIsPalettized;

	TInt    iBitsPerPixel;

	TUint64 iPulseWidth;

	TUint   iLinesInFrame;      // This appears to be a magic number that has no resemblence to the height

	TUint   iPixelsInLine;      // This appears to be a magic number that has no resemblence to the width

	TInt    iReportedLcdWidth;  // The width reported to the higher levels of software

	TInt    iReportedLcdHeight; // The height reported to the higher levels of software

	};

static const SLcdConfig Lcd_Mode_Config[]=

	{

	// 0: DISPLAY_MODE_ANALOG_VGA: No LCD, Landscape VGA 640x480

		{ 0, 640, 480, EFalse, KConfigBitsPerPixel32, KPulseWidthVga,    525, 800,  640, 480, },

	// 1: DISPLAY_MODE_HITACHI_VGA: Hitachi LCD, Portrait VGA 480x640 (for this mode, SW4-1 should be turned OFF on the LCD panel)

		{ 0, 480, 640, EFalse, KConfigBitsPerPixel32, KPulseWidthVgaLCD, 650, 650,  480, 640, },

	// 2: DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE_OLD: No LCD, Landscape QVGA 320x240

		{ 0, 320, 240, EFalse, KConfigBitsPerPixel32, KPulseWidthVga,    525, 800,  320, 240, },

	// 3: DISPLAY_MODE_HITACHI_QVGA: Hitachi LCD, Portrait QVGA 240x320

		{ 0, 240, 320, EFalse, KConfigBitsPerPixel32, KPulseWidth,       525, 800,  240, 320, },

	// 4: DISPLAY_MODE_NEC_WVGA: NEC LCD, Landscape WVGA

		{ 0, 800, 480, EFalse, KConfigBitsPerPixel32, KPulseWidthWvga,   525, 1024, 800, 480, },

	// 5: DISPLAY_MODE_ANALOG_QVGA_PORTRAIT: No LCD, Portrait QVGA 240x320

	// Note! this screen mode reports different dimensions than the real panel size

		{ 0, 640, 480, EFalse, KConfigBitsPerPixel16, KPulseWidthVga,    525, 800,  240, 320, },

	// 6: DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE: No LCD, Landscape QVGA 320x240

		{ 0, 640, 480, EFalse, KConfigBitsPerPixel16, KPulseWidthVga,    525, 800,  320, 240, },

	};

// Hack function to convert pixels to TWIPS

// Twips are screen-independent units to ensure that the proportion of screen elements

// are the same on all display systems. A twip is defined as being 1/20th of a point.

inline TInt PixelsToTwips(TInt aPixels)

	{

	return (119*aPixels)/10;

	}

DLcdPowerHandler	*  DLcdPowerHandler::pLcd			= NULL;

const TInt   KDisplay0ThreadPriority					= 26;

const TInt   KVSyncDfcPriority							= 7 ;   //priority of DFC within the queue (0 to 7, where 7 is highest)

_LIT(KLitLcd,"LCD");

_LIT(KDisplay0DfcThread,"Display0DfcThread-");

TInt vsync_irq_callback(TUint a, TAny* b);

#ifdef __SMP__

static TSpinLock callbackLock = TSpinLock(TSpinLock::EOrderGenericIrqHigh0);

#endif

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

*    Class DDisplayPddNaviEng

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

void DDisplayPddNaviEng::VSyncDfcFn(TAny* aChannel)

	{

	DDisplayPddNaviEng * channel =(DDisplayPddNaviEng*)aChannel;

	if (channel->iPostFlag)

		{

		 channel->iPostFlag = EFalse;

		if (channel->iActiveBuffer)

			{					 		 	 		 		

	 		//When a User buffer is registered its iFree member becomes EFalse and Deregister sets it 

	 		//back to ETrue. Composition and Legacy buffers are not free when they are in the pending or 

	 		//active state. 		

			if (channel->iActiveBuffer->iType == EBufferTypeUser)

				{

				//If a subsequent PostUserRequest has occured,so there is a pending user buffer which has 

				//cancelled the previous post( the one that  queued the current active buffer), calling 

				//RequestComplete would mistakenly complete the latest PostUserRequest. 

				if (!(channel->iPendingBuffer && channel->iPendingBuffer->iType == EBufferTypeUser) )

					{	

					channel->RequestComplete(RDisplayChannel::EReqPostUserBuffer, KErrNone);	

					}

				}

			else

				{

				channel->iActiveBuffer->iFree	= ETrue;

				}

			channel->iActiveBuffer->iState		= EBufferFree;

			if (channel->iActiveBuffer->iType == EBufferTypeComposition)

				{

				//If no buffer was available during a call to GetCompositionBuffer the active buffer has  

				//been returned as the next available one, so we must set the buffer to the proper state before we 

				//send the notification.

				TInt pendingIndex = channel->iLdd->iPendingIndex[RDisplayChannel::EReqGetCompositionBuffer];

				if( channel->iLdd->iPendingReq[RDisplayChannel::EReqGetCompositionBuffer][pendingIndex].iTClientReq)

					{

					if(channel->iLdd->iPendingReq[RDisplayChannel::EReqGetCompositionBuffer][pendingIndex].iTClientReq->IsReady() )

						{

						channel->iActiveBuffer->iState	= EBufferCompose;

						channel->RequestComplete(RDisplayChannel::EReqGetCompositionBuffer, KErrNone);

						}

					}			

				}

			channel->iActiveBuffer				= NULL;            							

			}					

		if (channel->iPendingBuffer)

			{

			__GCE_DEBUG_PRINT2("DDisplayPddNaviEng::VSyncDfcFn moving pending buffer at address %08x to the active state\n", channel->iPendingBuffer->iAddress);		

			channel->iActiveBuffer			= channel->iPendingBuffer;

			channel->iActiveBuffer->iState	= EBufferActive;

			channel->iPendingBuffer			= NULL; 

			channel->RequestComplete(RDisplayChannel::EReqWaitForPost,  KErrNone);

			}

		}

	}

/**

	Constructor

*/

DDisplayPddNaviEng::DDisplayPddNaviEng():

	iPendingBuffer(NULL),

	iActiveBuffer(NULL),

	iChunk(NULL),

	iLcdCallback(NULL),

	iVSyncDfc(&VSyncDfcFn, this, KVSyncDfcPriority)

	{

	__GCE_DEBUG_PRINT("DDisplayPddNaviEng::DDisplayPddNaviEng\n");

	iPostFlag = EFalse;

	}

/**

	Destructor

*/

DDisplayPddNaviEng::~DDisplayPddNaviEng()

	{

	__GCE_DEBUG_PRINT("DDisplayPddNaviEng::~DDisplayPddNaviEng()  \n");

	if(iLcdCallback)

		{

		DLcdPowerHandler::pLcd->DeRegisterCallback(iLcdCallback) ;

		delete iLcdCallback;

		iLcdCallback = NULL;

		}

	//The DFC Queue is owned by DLcdPowerHandler so we shouldn't call Destroy() at this point.

	if (iDfcQ)

		{

		iDfcQ=NULL;

		}

	DChunk* chunk = (DChunk*) __e32_atomic_swp_ord_ptr(&iChunk, 0);

	if(chunk)

		{

		Kern::ChunkClose(chunk);

		}

	}

/**

    Called by the LDD's DoCreate function to handle the device specific part of opening the channel.

    (DoCreate is called by RDisplayChannel::Open)

	@param aUnit	The screen unit

    @return KErrNone if successful; or one of the other system wide error codes.

*/

TInt DDisplayPddNaviEng::CreateChannelSetup(TInt aUnit)

	{

	__GCE_DEBUG_PRINT("DDisplayPddNaviEng::CreateChannelSetup\n");

	iScreenInfo = DLcdPowerHandler::pLcd->iVideoInfo;

	iLdd->iUnit = aUnit;

	iLdd->iDisplayInfo.iAvailableRotations			= RDisplayChannel::ERotationNormal;

	iLdd->iDisplayInfo.iNormal.iOffsetBetweenLines	= iScreenInfo.iOffsetBetweenLines;

	iLdd->iDisplayInfo.iNormal.iHeight				= iScreenInfo.iSizeInPixels.iHeight;

	iLdd->iDisplayInfo.iNormal.iWidth				= iScreenInfo.iSizeInPixels.iWidth;

	iLdd->iDisplayInfo.iNumCompositionBuffers		= KDisplayCBMax;

	iLdd->iDisplayInfo.iBitsPerPixel				= iScreenInfo.iBitsPerPixel;

    iLdd->iDisplayInfo.iRefreshRateHz = 60;

	switch (iScreenInfo.iBitsPerPixel)

		{

		case 16:

			iLdd->iDisplayInfo.iPixelFormat = EUidPixelFormatRGB_565;

			break;

		case 24:

			iLdd->iDisplayInfo.iPixelFormat = EUidPixelFormatRGB_888;

			break;

		case 32:

			iLdd->iDisplayInfo.iPixelFormat = EUidPixelFormatARGB_8888;

			break;

		default:

			iLdd->iDisplayInfo.iPixelFormat = EUidPixelFormatUnknown;

			break;

		}

	iLdd->iCurrentRotation = RDisplayChannel::ERotationNormal;

	// Open shared chunk to the composition framebuffer

	DChunk* chunk = 0;

	TLinAddr chunkKernelAddr  = 0;

	TUint32 chunkMapAttr = 0;

	// round to twice the page size

	TUint round  =  Kern::RoundToPageSize(2*DLcdPowerHandler::pLcd->iSize);

	__GCE_DEBUG_PRINT2("DDisplayPddNaviEng::CreateChannelSetup DLcdPowerHandler::pLcd->iSize  = %d\n", DLcdPowerHandler::pLcd->iSize );

	TChunkCreateInfo info;

	info.iType					 = TChunkCreateInfo::ESharedKernelMultiple;

	info.iMaxSize				 = round;

	info.iMapAttr				 = EMapAttrFullyBlocking;

	info.iOwnsMemory			 = EFalse;

	info.iDestroyedDfc			 = 0;

	TInt r = Kern::ChunkCreate(info, chunk, chunkKernelAddr, chunkMapAttr);

	__GCE_DEBUG_PRINT2("CreateChannelSetup:ChunkCreate called for composition chunk. Set iChunkKernelAddr  = %08x\n", chunkKernelAddr );

	if( r == KErrNone)

		{

		// map our chunk

		r = Kern::ChunkCommitPhysical(chunk, 0,round , DLcdPowerHandler::pLcd->iCompositionPhysical);

		if(r != KErrNone)

			{

			Kern::ChunkClose(chunk);

			}

		}

	if ( r!= KErrNone)

		{

		return r;

		}

	iChunk	= chunk;

	// init CB 0

	iLdd->iCompositionBuffer[0].iType			= EBufferTypeComposition;

	iLdd->iCompositionBuffer[0].iBufferId		= 0;

	iLdd->iCompositionBuffer[0].iFree			= ETrue;

	iLdd->iCompositionBuffer[0].iState			= EBufferFree;

	iLdd->iCompositionBuffer[0].iAddress		= chunkKernelAddr;

	iLdd->iCompositionBuffer[0].iChunk			= chunk;

	iLdd->iCompositionBuffer[0].iHandle			= 0;

	iLdd->iCompositionBuffer[0].iOffset			= 0;

	iLdd->iCompositionBuffer[0].iSize			= DLcdPowerHandler::pLcd->iSize;

	iLdd->iCompositionBuffer[0].iPendingRequest = 0;

	// init CB 1

	iLdd->iCompositionBuffer[1].iType			= EBufferTypeComposition;

	iLdd->iCompositionBuffer[1].iBufferId		= 1;

	iLdd->iCompositionBuffer[1].iFree			= ETrue;

	iLdd->iCompositionBuffer[1].iState			= EBufferFree;

	iLdd->iCompositionBuffer[1].iAddress		= chunkKernelAddr + DLcdPowerHandler::pLcd->iSize;

	iLdd->iCompositionBuffer[1].iChunk			= chunk;

	iLdd->iCompositionBuffer[1].iHandle			= 0;

	iLdd->iCompositionBuffer[1].iOffset			= DLcdPowerHandler::pLcd->iSize;

	iLdd->iCompositionBuffer[1].iSize			= DLcdPowerHandler::pLcd->iSize;

	iLdd->iCompositionBuffer[1].iPendingRequest = 0;

	iLdd->iCompositionBuffIdx					= 0;

	TUint64 reg64 = AsspRegister::Read64(KHwDisplayMemoryFrameAddress);

	//set up Start address for frames 0 and 1 (The actual Physical addresses must be passed)

	AsspRegister::Write64(KHwDisplayMemoryFrameAddress , ( (TUint64)DLcdPowerHandler::pLcd->iCompositionPhysical<<32  | reg64 ) );

	//set up layer 2

    TUint64 layer2Physical =  DLcdPowerHandler::pLcd->iCompositionPhysical+ DLcdPowerHandler::pLcd->iSize ;

    AsspRegister::Write64(KHwDisplayMemoryFrameAddress + KHex8,layer2Physical ) ;

	//Use the same DFC queue created by the DLcdPowerHandler so all hardware accesses are executed under the same DFC thread.

	iDfcQ= DLcdPowerHandler::pLcd->iDfcQ;

	// Set the Post DFC.

	iVSyncDfc.SetDfcQ(iDfcQ);

	//Register callback function. The function will be called when V Sync is triggered

	iLcdCallback = new TLcdUserCallBack(vsync_irq_callback, (TAny*)this);

	r = KErrNoMemory;

	if (iLcdCallback)

		{

		r = DLcdPowerHandler::pLcd->RegisterCallback(iLcdCallback) ;

		}

	if( r!= KErrNone)

		{

		delete iLcdCallback ;

		iLcdCallback = NULL ;

		return r;

		}

	return KErrNone;

	}

/**

	Called by the Vsync callback method and queues the corresponding DFC.

 */

void DDisplayPddNaviEng::VSyncIsr()

	{

	iVSyncDfc.Add();

	}

/**

	Return the DFC queue to be used for this device.

 */

TDfcQue * DDisplayPddNaviEng:: DfcQ(TInt aUnit)

	{

	return iDfcQ;

	}

/**

    Handles device specific operations when a close message has been sent to the Logical Channel.

*/

TInt DDisplayPddNaviEng::CloseMsg()

	{

	__GCE_DEBUG_PRINT("DDisplayPddNaviEng::CloseMsg()\n");

	iPendingBuffer  = NULL;

	iActiveBuffer	= NULL;

	iVSyncDfc.Cancel();

    return KErrNone;

	}

/**

    Set the GCE mode by posting a composition buffer.

*/

TInt DDisplayPddNaviEng::SetGceMode()

	{

	__GCE_DEBUG_PRINT("DDisplayPddNaviEng::SetGceMode()\n");

    PostCompositionBuffer(&iLdd->iCompositionBuffer[0]);

    return KErrNone;

	}

/**

    Set the Legacy Mode by setting the appropriate Frame control value.

*/

TInt DDisplayPddNaviEng::SetLegacyMode()

	{

	__GCE_DEBUG_PRINT("DDisplayPddNaviEng::SetLegacyMode()\n");

	//Set the default frame 0 which corresponds to the Legacy Buffer.

	AsspRegister::Write64(KHwDisplayDisplayFrameControl, KDisplayFrameControlValue);

    return KErrNone;

	}

/**

	If the specified rotation is supported set it as the current rotation.  The NaviEngine

	version supports only the RDisplayChannel::ERotationNormal rotation.

	@param  aDegOfRot The requested rotation to be set.

	@return KErrNone if the rotation is supported else KErrArgument.

*/

TInt DDisplayPddNaviEng::SetRotation(RDisplayChannel::TDisplayRotation aDegOfRot)

	{

	TInt r;

	switch (aDegOfRot)

		{

		case RDisplayChannel::ERotationNormal:

			r = KErrNone;

			break;

		default:

			r = KErrArgument;

		}

	return r;

	}

/**

    Remove any previous post operations, set the appropriate layer as the next layer to be displayed( This value is updated in synchronization

    with V Sync so it will take affect in the next V Sync after that) and also set the buffer provided as the buffer to

    be posted next. Layer 3 is associated with user buffers.

	@param	aNode  Pointer to the User buffer to post.

*/

TInt DDisplayPddNaviEng::PostUserBuffer(TBufferNode* aNode)

	{

	__GCE_DEBUG_PRINT2("PostUserBuffer :  aNode->iAddress = %08x\n", aNode->iAddress);

	if(iPendingBuffer)

		{

		iPendingBuffer->iState = EBufferFree;

		if (!(iPendingBuffer->iType == EBufferTypeUser) )

			{

			iPendingBuffer->iFree  = ETrue;

			}

		}

	//Set the Physical address for layer3 and then set layer3 as the frame to be displayed.

	AsspRegister::Write64(KHwDisplayMemoryFrameAddress + KHex8 ,(TUint64)aNode->iPhysicalAddress<<32 );

	AsspRegister::Write64(KHwDisplayDisplayFrameControl, KDisplayFrame3ControlValue);

	aNode->iState   = EBufferPending;

	iPendingBuffer	= aNode;

	iPostFlag		= ETrue;

	TUint64 reg64 = AsspRegister::Read64(KHwDisplayInterruptEnable);

	reg64 |= KVSyncEnable;

	AsspRegister::Write64(KHwDisplayInterruptEnable , reg64 ); //Enable Vsync

	return KErrNone;

	}

/**

    Remove any previous post operations, set the appropriate layer as the next layer to be displayed( This value is updated in synchronization

    with V Sync so it will take affect in the next V Sync after that) and also set the buffer provided as the buffer to

    be posted next. Layer 1 and 2 are associated with composition buffers 0 and 1 respectively.

	@param	aNode  Pointer to the Composition buffer to post.

*/

TInt DDisplayPddNaviEng::PostCompositionBuffer(TBufferNode* aNode)

	{

	__GCE_DEBUG_PRINT2("PostCompositionBuffer :  aNode->iAddress = %08x\n", aNode->iAddress);

	if(iPendingBuffer)

		{

		iPendingBuffer->iState = EBufferFree;

		if (iPendingBuffer->iType == EBufferTypeUser)

			{

			RequestComplete(RDisplayChannel::EReqPostUserBuffer, KErrCancel);

			}

		else

			{

			iPendingBuffer->iFree  = ETrue;

			}

		}

	if ( aNode->iBufferId == 0)

		{

		// Display frame control registers	(Layer 1)

		AsspRegister::Write64(KHwDisplayDisplayFrameControl , KDisplayFrame1ControlValue );

		}