// Copyright (c) 1998-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:

 // os\kernelhwsrv\kernel\eka\include\drivers\display.h 

 // Interface to LDD of the Display GCE driver

 // Kernel side definitions for the GCE driver

 //

 /**

  @file

  @internalTechnology

  @prototype

 */

 #ifndef __DISPLAY_H__

 #define __DISPLAY_H__

 #include <videodriver.h>

 #include <dispchannel.h>

 #include <platform.h>

 #include <pixelformats.h>

 const TInt KDisplayLBMax = 2;

 const TInt KDisplayCBMax = 2;

 const TInt KDisplayUBMax = 8;

 const TInt KPendingReqArraySize  = RDisplayChannel::EReqWaitForPost +1;

 const TInt KMaxQueuedRequests 	 = 3;

 class DDisplayChannel;

 enum TBufferType

 {

     	EBufferTypeLegacy = 0,

     	EBufferTypeComposition,

     	EBufferTypeUser,

 };

 enum TBufferState

 {

    		EBufferFree = 0,

    		EBufferCompose,

    		EBufferPending,

    		EBufferActive

 };

 typedef struct

 {

     	TInt    		iType;

     	TInt    		iBufferId;

 	    TBool   		iFree;

 	    TInt    		iHandle;

 	    TInt    		iSize;

 	    TUint32 		iAddress;

 	    TUint32  		iPhysicalAddress; 

 	    TInt    		iOffset ;

 	    DChunk * 		iChunk ;

 	    TBufferState 	iState;

 	    TRequestStatus* iPendingRequest;

 } TBufferNode;

 /**

 An object encapsulating a request from the client(iOwningThread) to the GCE driver. 

 */ 

 typedef struct

 {

 	  /** The TClientRequest object associated with the request - used to signal completion of the request and pass back a

 	   completion code. */

 	  TClientRequest*   iTClientReq;

 	  /** The thread which issued the request and which supplied the request status. */

 	  DThread* 			iOwningThread;

 } TRequestNode;

 class DDisplayPdd; 

 /**

   Logical Channel factory class for 'Display Channel LDD'

 */

 class DDisplayLddFactory : public DLogicalDevice

 	{

 public:

     static DDisplayLddFactory* CreateInstance();

 	~DDisplayLddFactory();

 	//	Inherited from DLogicalDevice

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	TBool 	IsUnitOpen(TInt aUnit);

 	TInt 	SetUnitOpen(TInt aUnit,TBool aIsOpenSetting);

 private:

 	DDisplayLddFactory();

 private:

 	/** Mask to keep track of which units have a channel open on them. */

 	TUint iUnitsOpenMask;				

 	/** A mutex to protect access to the unit info mask. */

 	NFastMutex iUnitInfoMutex;	

 	};

 /**

   Logical Channel class for 'Display Channel LDD'

 */

 class DDisplayLdd : public DLogicalChannel 

 	{

 public:

     // create one instance of this object

 	static DDisplayLdd* CreateInstance();

 	virtual ~DDisplayLdd();

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

     virtual void HandleMsg(TMessageBase* aMsg);

 private:

 	DDisplayLdd();

 private:

 	// Implementation for the differnt kinds of messages sent through RBusLogicalChannel

 	TInt  			DoControl(TInt aFunction, TAny* a1, TAny* a2, DThread* aClient);

 	TInt  			DoRequest(TInt aReqNo, TAny* a1, TAny* a2,  TInt index, DThread* aClient);

 	void  			DoCancel(TUint aMask);

 	TInt 		    SendRequest(TMessageBase* aMsg);

 	TInt 		    SendControl(TMessageBase* aMsg);

 	TInt 		    SendMsg(TMessageBase* aMsg);	 

     TBufferNode*  	FindUserBufferNode(TInt aBufferId);  

     TInt 			CheckAndOpenUserBuffer(TBufferNode* aNode, TInt aHandle, TInt aOffset, DThread* aClient);         

     TInt  			FreeUserBufferNode(TBufferNode* aNode);

     void 			CompleteRequest(DThread* aThread, TClientRequest*& aTClientReq, TInt aReason);

     DDisplayPdd * 	Pdd();  

 public: 	

  	virtual TInt 	RequestComplete(TInt aRequest, TInt );

 public:

     // display info

     RDisplayChannel::TDisplayInfo 	iLegacyInfo;

     RDisplayChannel::TDisplayInfo 	iDisplayInfo;

         // post counters

     RDisplayChannel::TPostCount   	iCurrentPostCount;

     RDisplayChannel::TPostCount   	iRequestedPostCount;

     DThread*    	iClient;	

 	TInt        	iUnit;      

     // frame buffer nodes

     TBufferNode 	iLegacyBuffer[KDisplayLBMax];

     TBufferNode 	iCompositionBuffer[KDisplayCBMax];

     TBufferNode 	iUserBuffer[KDisplayUBMax];

     //pending queue for asynchronous requests

     TRequestNode 	iPendingReq[KPendingReqArraySize][KMaxQueuedRequests];

     //Queue of TClientRequest objects, one for each type of asynchronous request.

     TClientRequest* iClientRequest[KPendingReqArraySize][KMaxQueuedRequests];

 	//The index in structures iPendingReq and iClientRequest that identifies the active TClientRequest object.

 	//For each type of asynchronous request, iPendingIndex is the index of the active TClientRequest object 

 	//in iPendingReq

 	TInt			iPendingIndex[KPendingReqArraySize];

     // Protect access of iClientRequest

     DMutex * 		 iClientRequestMutex;

     // current index

     TInt    		iLegacyBuffIdx;

 	TInt    		iCompositionBuffIdx;

     TInt    		iUserBuffIdx;

     RDisplayChannel::TDisplayRotation 	iLegacyRotation;

     RDisplayChannel::TDisplayRotation   iCurrentRotation;

     TBool    		iReady;  

     /** Used in debug builds to track that all calls to DThread::Open() are balanced with a close before the driver closes. */

 	TInt iThreadOpenCount; 

 	/** Used in debug builds to track the number of asynchronous requests that are queued is equal to the number of 

 	requests that are completed, before the driver closes.*/

 	TInt iAsyncReqCount; 

 	/** Chunk used in UDEB only for testing user buffers. */

 	DChunk*	iChunk;

 	};

  /**

     Display PDD base class with GCE support.

    */

 class DDisplayPdd : public DBase

 	{

 	public:

   	/**  

     Called by the LDD to handle the device specific part of switching to Legacy mode.

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

     */    

     virtual TInt  SetLegacyMode()=0;

      /**

      Called by the LDD to handle the device specific part of switching to GCE mode.

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

      */       

     virtual TInt  SetGceMode()=0;

      /**

      Called by the LDD to handle the device specific part of setting the rotation.

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

      */       

     virtual TInt  SetRotation(RDisplayChannel::TDisplayRotation aRotation)=0;

      /**

      Called by the LDD to handle the device specific part of posting a User Buffer.

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

      */ 	

 	virtual TInt  PostUserBuffer(TBufferNode* aNode)=0;

      /**

      Called by the LDD to handle the device specific part of posting a Composition Buffer

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

      */ 		

 	virtual TInt  PostCompositionBuffer(TBufferNode* aNode)=0;

      /**

      Called by the LDD to handle the device specific part of posting the Legacy Buffuer

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

      */   

     virtual TInt  PostLegacyBuffer()=0;

     /**

      Called by the LDD to handle device specific cleanup operations when a channel is closed.

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

      */  

     virtual TInt  CloseMsg()=0;

      /**

      Called by the LDD to handle device specific initialisation tasks when a channel is opened.

      @param aUnit The screen/hardware unit number.

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

      */    

     virtual TInt  CreateChannelSetup(TInt aUnit)=0;

      /**

      Called by the LDD in order to detect whether a post operation is pending. This type of 

      information is specific to the actual physical device.

      @return ETrue if a Post operation is pending otherwise EFalse.

      */       

    	virtual TBool  PostPending()=0;

     /**

      Called by the LDD to retrieve the DFC Queue created in the PDD.      

      @param aUnit The screen/hardware unit number.

      @return A pointer to the TDfcQue object created in the PDD.

      */    

     virtual TDfcQue* DfcQ(TInt  aUnit)=0;    

      /**

      Called by the PDD when an asynchronous request should be completed with a specific reason.

      (Just calls the LDD's RequestComplete method)

       @param aRequest Any value from the RDisplayChannel::TRequest enumeration.

       @param aReason  Any valid error reason.

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

      */

     inline TInt RequestComplete(TInt aRequest, TInt aReason );

 public:        

   	/**

     A pointer to the logical device driver's channel that owns this device.

     */        

     DDisplayLdd *iLdd;

     /**

 	Every post operation sets this flag to true in order to identify when

 	the previsouly posted buffer is no longer in use by the display hardware. 

     */ 

 	TBool		 iPostFlag;

 	};

 inline DDisplayPdd * DDisplayLdd::Pdd()

     { return (DDisplayPdd*) iPdd; }

 inline TInt DDisplayPdd::RequestComplete(TInt aRequest, TInt aReason)

 	{ return iLdd->RequestComplete(aRequest,aReason); }

 //#define _GCE_DISPLAY_DEBUG

 #ifdef _GCE_DISPLAY_DEBUG

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

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

 #define  __DEBUG_PRINT3(a,b,c) 		Kern::Printf(a,b,c)

 #define  __DEBUG_PRINT4(a,b,c,d) 	Kern::Printf(a,b,c,d)

 #define  __DEBUG_PRINT5(a,b,c,d,e) 	Kern::Printf(a,b,c,d,e)

 #else

 #define  __DEBUG_PRINT(a)

 #define  __DEBUG_PRINT2(a,b)

 #define  __DEBUG_PRINT3(a,b,c)

 #define  __DEBUG_PRINT4(a,b,c,d) 

 #define  __DEBUG_PRINT5(a,b,c,d,e)

 #endif

 #endif	// __DISPLAY_H__