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

 // its implementation.

 // 

 //

 /**

  @file Kernel side interfaces to example camera device driver which uses Shared Chunks in

  @publishedPartner

  @prototype 9.1

 */

 #ifndef __CAMERA1_DEV_H__

 #define __CAMERA1_DEV_H__

 /**

   Logical Device (factory class) for 'Camera1'

 */

 class DCamera1Factory : public DLogicalDevice

 	{

 public:

 	DCamera1Factory();

 	~DCamera1Factory();

 	//	Inherited from DLogicalDevice

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 /**

   Class representing a single image buffer

 */

 class DImageBuffer

 	{

 public:

 	DImageBuffer();

 	~DImageBuffer();

 	TInt Create(DChunk* aChunk, TInt aOffset, TInt aSize);

 public:

 	TInt iChunkOffset;			/**< Offset, in bytes, of buffer start within the chunk */

 	TInt iSize;					/**< Size of buffer n bytes */

 	TPhysAddr iPhysicalAddress;	/**< Physical address of buffer. KPhysAddrInvalid if buffer not physically contiguous */

 	TPhysAddr* iPhysicalPages;	/**< List of physical addresses for buffer pages. 0 if buffer is physically contiguous */

 	};

 /**

   Class representing all of the image buffers

 */

 class DCaptureBuffers : public DBase

 	{

 public:

 	static DCaptureBuffers* New(TInt aNumBuffers,TInt aBufferSize);

 	void Open();

 	void Close();

 	void Reset();

 	void Purge(DImageBuffer* aBuffer);

 	DImageBuffer* ImageForClient();

 	DImageBuffer* ImageCaptured();

 	DImageBuffer* ImageRelease(TInt aChunkOffset);

 	DImageBuffer* InUseImage(TInt aChunkOffset);

 private:

 	DCaptureBuffers();

 	~DCaptureBuffers();

 	TInt Create(TInt aNumBuffers,TInt aBufferSize);

 	static DImageBuffer* Remove(DImageBuffer** aList);

 	static DImageBuffer* Add(DImageBuffer** aList,DImageBuffer* aBuffer);

 public:

 	DChunk* iChunk;				/**< The chunk which contains the buffers */

 	TLinAddr iChunkBase;		/**< Linear address in kernel process for the start of the chunk  */

 	TUint32 iChunkMapAttr;		/**< MMU mapping attributes for chunk */

 	TInt iNumBuffers;			/**< Number of buffers */

 	DImageBuffer* iImageBuffer;	/**< Array of iNumBuffers buffer objects */

 	//

 	DImageBuffer* iCurrentBuffer;		/**< The buffer currently being filled by image capture */

 	DImageBuffer* iNextBuffer;			/**< The buffer to use for next image capture */

 	DImageBuffer** iFreeBuffers;		/**< NULL terminated list of free buffers */

 	DImageBuffer** iCompletedBuffers;	/**< NULL terminated list of buffers containing captured images */

 	DImageBuffer** iInUseBuffers;		/**< NULL terminated list of buffers currently being used by client */

 private:

 	TInt iAccessCount;			/**< Access count for this object */

 	TAny* iBufferLists;			/**< Memory holding lists iFreeBuffers, iCompletedBuffers and iInUseBuffers */

 	};

 /**

   Logical Channel class for 'Camera1'

 */

 class DCamera1Channel : public DLogicalChannelBase

 	{

 public:

 	DCamera1Channel();

 	virtual ~DCamera1Channel();

 	// Inherited from DLogicalChannelBase

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

 	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);

 private:

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

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

 	TInt DoRequest(TInt aNotReqNo, TAny* a1, TAny* a2);

 	TInt DoCancel(TUint aMask);

 	// Methods for configuration

 	TInt GetConfig(TDes8* aConfigBuf);

 	TInt SetConfig(const TDesC8* aConfigBuf);

 	// Methods for capturing images

 	TInt StartCapture();

 	TInt EndCapture();

 	void CaptureImage(TRequestStatus* aRequestStatus,TInt aReleaseImage);

 	void CaptureImageCancel();

 	TInt ImageRelease(TInt aChunkOffset);

 	static void CaptureDfcTrampoline(TAny* aSelf);

 	void CaptureDfc();

 	void StateChange(TBool aNewState);

 	static void StateChangeDfcTrampoline(TAny* aSelf);

 	void StateChangeDfc();

 	// Methods which program the camera hardware

 	void DoStartCapture();

 	void DoEndCapture();

 	void DoNextCapture();

 private:

 	NFastMutex iCaptureMutex;	/**< Mutex to protect access to driver state */

 	DCaptureBuffers* iCaptureBuffers;		/**< The image buffers */

 	TRequestStatus* iCaptureRequestStatus;	/**< The request status for client CaptureImage request */

 	DThread* iCaptureRequestThread;			/**< The client thread which issued a CaptureImage request */

 	TDfcQue* iDfcQ;				/**< The DFC queue used for driver functions */

 	TDfc iStateChangeDfc;		/**< DFC queued when Start/EndCapture requests are performed */

 	TBool iNewState;			/**< True if state change DFC should start image capture, false to stop capture */

 	DMutex* iStateChangeMutex;	/**< Mutex which protect Start/EndCapture requests from reenty */

 	NFastSemaphore iStateChangeSemaphore;	/**< Semaphore signaled when state change DFC completes */

 	RCamera1::TConfig iConfig;	/**< The driver configuration information */

 	TBool iCapturing;			/**< Flag which is True when image capture is in progress */

 	TInt iCaptureCounter;		/**< Frame counter incremented on each image captured */

 	NTimer iCaptureTimer;		/**< Timer used to emulate image capture hardware */

 	TInt iCaptureRateTicks;		/**< Number of timer ticks for iCaptureTimer */

 	};

 #endif