// 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 An example camera device driver which uses Shared Chunks in

 @publishedPartner

 @prototype 9.1

*/

#include <kernel/kern_priv.h>

#include <kernel/cache.h>

#include "camera1.h"

#include "camera1_dev.h"

#if 0  // Set true for tracing

#define TRACE(x) x

#else

#define TRACE(x)

#endif

//

// DCamera1Factory

//

/**

  Standard export function for LDDs. This creates a DLogicalDevice derived object,

  in this case, our DCamera1Factory

*/

DECLARE_STANDARD_LDD()

	{

	return new DCamera1Factory;

	}

/**

  Constructor

*/

DCamera1Factory::DCamera1Factory()

	{

	// Set version number for this device

	iVersion=RCamera1::VersionRequired();

	// Indicate that do support units or a PDD

	iParseMask=0;

	}

/**

  Second stage constructor for DCamera1Factory.

  This must at least set a name for the driver object.

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DCamera1Factory::Install()

	{

	return SetName(&RCamera1::Name());

	}

/**

  Destructor

*/

DCamera1Factory::~DCamera1Factory()

	{

	}

/**

  Return the drivers capabilities.

  Called in the response to an RDevice::GetCaps() request.

  @param aDes User-side descriptor to write capabilities information into

*/

void DCamera1Factory::GetCaps(TDes8& aDes) const

	{

	// Create a capabilities object

	RCamera1::TCaps caps;

	caps.iVersion = iVersion;

	// Write it back to user memory

	Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));

	}

/**

  Called by the kernel's device driver framework to create a Logical Channel.

  This is called in the context of the user thread (client) which requested the creation of a Logical Channel

  (E.g. through a call to RBusLogicalChannel::DoCreate)

  The thread is in a critical section.

  @param aChannel Set to point to the created Logical Channel

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DCamera1Factory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel=new DCamera1Channel;

	if(!aChannel)

		return KErrNoMemory;

	return KErrNone;

	}

//

// Logical Channel

//

/**

  Default configuration for driver (640x480 pixels of 32bits captured at 15 frames/sec)

*/

static const RCamera1::TConfig DefaultConfig = {{640,480},4,15};

/**

  Constructor

*/

DCamera1Channel::DCamera1Channel()

	:	iDfcQ(Kern::TimerDfcQ()),  // This test uses the timer DFC queue for DFCs

		iStateChangeDfc(StateChangeDfcTrampoline,this,1),  // DFC is priority '1'

		iConfig(DefaultConfig),

		iCaptureTimer(CaptureDfcTrampoline,this)

	{

	}

/**

  Second stage constructor called by the kernel's device driver framework.

  This is called in the context of the user thread (client) which requested the creation of a Logical Channel

  (E.g. through a call to RBusLogicalChannel::DoCreate)

  The thread is in a critical section.

  @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate

  @param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DCamera1Channel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

	{

	// Check client has EMultimediaDD capability

	if(!Kern::CurrentThreadHasCapability(ECapabilityMultimediaDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by CAPTURE1")))

		return KErrPermissionDenied;

	// Check version

	if (!Kern::QueryVersionSupported(RCamera1::VersionRequired(),aVer))

		return KErrNotSupported;

	// Setup DFCs

	iStateChangeDfc.SetDfcQ(iDfcQ);

	// Done

	return Kern::MutexCreate(iStateChangeMutex,KNullDesC,KMutexOrdGeneral7);

	}

/**

  Destructor

*/

DCamera1Channel::~DCamera1Channel()

	{

	DoCancel(RCamera1::EAllRequests);

	EndCapture();

	iStateChangeDfc.Cancel();

	if(iStateChangeMutex)

		iStateChangeMutex->Close(0);

	if(iCaptureBuffers)

		iCaptureBuffers->Close();

	}

/**

  Process a request on this logical channel.

  @param aReqNo Request number:

  	            ==KMaxTInt, a 'DoCancel' message

	            >=0, a 'DoControl' message with function number equal to iValue

	            <0, a 'DoRequest' message with function number equal to ~iValue

  @param a1     First argument. For DoRequest requests this is a pointer to the TRequestStatus.

  @param a2     Second argument. For DoRequest this is a pointer to the 2 actual TAny* arguments.

  @return       Result. Ignored by device driver framework for DoRequest requests.

*/

TInt DCamera1Channel::Request(TInt aReqNo, TAny* a1, TAny* a2)

	{

	// Decode the message type and dispatch it to the relevent handler function...

	if ((TUint)aReqNo<(TUint)KMaxTInt)

		return DoControl(aReqNo,a1,a2);

	if(aReqNo==KMaxTInt)

		return DoCancel((TInt)a1);

	return DoRequest(aReqNo,a1,a2);

	}

/**

  Process synchronous 'control' requests

*/

TInt DCamera1Channel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

	{

	TRACE(Kern::Printf(">DCamera1Channel::DoControl fn=%d\n",aFunction);)

	(void)a2;   // a2 not used in this example

	TInt r = KErrNotSupported;

	switch (aFunction)

		{

		case RCamera1::EGetConfig:

			r = GetConfig((TDes8*)a1);

			break;

		case RCamera1::ESetConfig:

			r = SetConfig((const TDesC8*)a1);

			break;

		case RCamera1::EStartCapture:

			r = StartCapture();

			break;

		case RCamera1::EEndCapture:

			r = EndCapture();

			break;

		case RCamera1::EReleaseImage:

			r = ImageRelease((TInt)a1);

			break;

		case RCamera1::ECaptureImage:

			CaptureImage((TRequestStatus*)a1,(TInt)a2);

			break;

		}

	TRACE(Kern::Printf("<DCamera1Channel::DoControl result=%d\n",r);)

	return r;

	}

/**

  Process asynchronous requests.

  This driver doesn't have any 'DoRequest' requests because we handle asyncronous

  requests using 'DoControl' for performance reasons. I.e. to avoid having to read

  the arguments with kumemget()

*/

TInt DCamera1Channel::DoRequest(TInt aNotReqNo, TAny* a1, TAny* a2)

	{

	TRACE(Kern::Printf(">DCamera1Channel::DoRequest req=%d\n",aNotReqNo);)

	// Get arguments

	TAny* a[2];

	kumemget32(a,a2,sizeof(a)); 

	TRequestStatus* status=(TRequestStatus*)a1;

	TInt reqNo = ~aNotReqNo;

	// Do the request

	TInt r;

	switch(reqNo)

		{

		case RCamera1::ECaptureImage:

			// Not used because we do 'ECaptureImage' as a DoControl rather than

			// a DoRequest for performance reasons

		default:

			r = KErrNotSupported;

			break;

		}

	// Complete request if there was an error

	if (r!=KErrNone)

		Kern::RequestComplete(&Kern::CurrentThread(),status,r);

	TRACE(Kern::Printf("<DCamera1Channel::DoRequest result=%d\n",r);)

	return KErrNone;  // Result is ignored by device driver framework for DoRequest requests

	}

/**

  Process cancelling of asynchronous requests.

*/

TInt DCamera1Channel::DoCancel(TUint aMask)

	{

	TRACE(Kern::Printf(">DCamera1Channel::DoCancel mask=%08x\n",aMask);)

	if(aMask&(1<<RCamera1::ECaptureImage))

		CaptureImageCancel();

	TRACE(Kern::Printf("<DCamera1Channel::DoCancel\n");)

	return KErrNone;

	}

//

// Methods for processing configuration control messages

//

/**

  Process a GetConfig control message. This writes the current driver configuration to a

  RCamera1::TConfigBuf supplied by the client.

*/

TInt DCamera1Channel::GetConfig(TDes8* aConfigBuf)

	{

	// Write the config to the client

	Kern::InfoCopy(*aConfigBuf,(const TUint8*)&iConfig,sizeof(iConfig));

	return KErrNone;

	}

/**

  Process a SetConfig control message. This sets the driver configuration using a

  RCamera1::TConfigBuf supplied by the client.

*/

TInt DCamera1Channel::SetConfig(const TDesC8* aConfigBuf)

	{

	// Create a config structure.

	RCamera1::TConfig config(DefaultConfig);

	// Note: We have constructed a config using DefaultConfig, this is to allow

	// backwards compatibility when a client gives us an old (and shorter) version

	// of the config structure.

	// Read the config structure from client

	TPtr8 ptr((TUint8*)&config,sizeof(config));

	Kern::KUDesGet(ptr,*aConfigBuf);

	// For some settings we allow zero to mean default...

	if(!config.iImageSize.iWidth)

		config.iImageSize.iWidth = DefaultConfig.iImageSize.iWidth;

	if(!config.iImageSize.iHeight)

		config.iImageSize.iHeight = DefaultConfig.iImageSize.iHeight;

	if(!config.iImageBytesPerPixel)

		config.iImageBytesPerPixel = DefaultConfig.iImageBytesPerPixel;

	// Validate configuration

	TInt scale = DefaultConfig.iImageSize.iWidth/config.iImageSize.iWidth;

	if(scale*config.iImageSize.iWidth != DefaultConfig.iImageSize.iWidth)

		return KErrArgument;

	if(scale*config.iImageSize.iHeight != DefaultConfig.iImageSize.iHeight)

		return KErrArgument;

	if(config.iImageBytesPerPixel<=0 || config.iImageBytesPerPixel>4)

		return KErrArgument;

	if(config.iFrameRate<0)

		return KErrArgument;

	if(config.iNumImageBuffers<1)

		return KErrArgument;

	TInt imageSize;

	DCaptureBuffers* buffers;

	TInt r;

	// Need to be in critical section whilst holding a DMutex

	NKern::ThreadEnterCS();

	// Claim state change mutex. Note, the return value is ignored because a Wait

	// can only fail if the mutex is destroyed whilst waiting for it, this can't 

	// happen in our driver.

	Kern::MutexWait(*iStateChangeMutex);

	// Check we aren't in the middle of capturing images

	if(iCapturing)

		{

		r = KErrInUse;

		goto done;

		}

	// Change the config

	iConfig = config; 

	iCaptureRateTicks = config.iFrameRate ? 1000000/config.iFrameRate/NKern::TickPeriod() : KMaxTInt;

	if(iCaptureRateTicks<1)

		iCaptureRateTicks = 1;

	// Claim ownership of old buffers

	NKern::FMWait(&iCaptureMutex);

	buffers = iCaptureBuffers;

	iCaptureBuffers = NULL;

	NKern::FMSignal(&iCaptureMutex);

	// Delete old buffers

	if(buffers)

		buffers->Close();

	// Contruct new buffer object

	imageSize = iConfig.iImageSize.iWidth*iConfig.iImageSize.iHeight*iConfig.iImageBytesPerPixel;

	buffers = DCaptureBuffers::New(2+iConfig.iNumImageBuffers,imageSize);

	if(!buffers)

		{

		r = KErrNoMemory;

		goto done;

		}

	// Use the new buffers if another thread didn't create them first

	NKern::FMWait(&iCaptureMutex);

	iCaptureBuffers = buffers;

	NKern::FMSignal(&iCaptureMutex);

	// Create handle for chunk

	r = Kern::MakeHandleAndOpen(NULL, iCaptureBuffers->iChunk);

done:

	// Release state change mutex

	Kern::MutexSignal(*iStateChangeMutex);

	NKern::ThreadLeaveCS();

	return r;

	}

//

// Methods for processing start/end capture

//

/**

   Start image capturing

*/

TInt DCamera1Channel::StartCapture()

	{

	// Need to be in critical section whilst holding a DMutex

	NKern::ThreadEnterCS();

	// Claim state change mutex. Note, the return value is ignored because a Wait

	// can only fail if the mutex is destroyed whilst waiting for it, this can't 

	// happen in our driver.

	Kern::MutexWait(*iStateChangeMutex);

	NKern::FMWait(&iCaptureMutex);

	TInt r;

	if(!iCaptureBuffers)

		r = KErrNotReady;  // SetConfig not yet been called

	else if(iCapturing)

		r = KErrInUse;     // StartCapture has already been called

	else

		{

		// Initialise image buffer state for capturing images

		iCaptureBuffers->Reset();

		// Flag capturing started

		iCapturing = ETrue;

		r = KErrNone;

		}

	NKern::FMSignal(&iCaptureMutex);

	// Get state change DFC to initialise camera hardware for capture

	if(r==KErrNone)

		StateChange(ETrue);

	// Release state change mutex

	Kern::MutexSignal(*iStateChangeMutex);

	NKern::ThreadLeaveCS();

	return r;

	}

/**

   End image capturing

*/

TInt DCamera1Channel::EndCapture()

	{

	// Need to be in critical section whilst holding a DMutex

	NKern::ThreadEnterCS();

	// Claim state change mutex. Note, the return value is ignored because a Wait

	// can only fail if the mutex is destroyed whilst waiting for it, this can't 

	// happen in our driver.

	Kern::MutexWait(*iStateChangeMutex);

	if(iCapturing)

		{

		// Get state change DFC to reset camera hardware

		StateChange(EFalse);

		// Flag capture ended

		NKern::FMWait(&iCaptureMutex);

		iCapturing = EFalse;

		NKern::FMSignal(&iCaptureMutex);

		// Cancel any pending caoture request

		CaptureImageCancel();

		}

	// Release state change mutex

	Kern::MutexSignal(*iStateChangeMutex);

	NKern::ThreadLeaveCS();

	return KErrNone;

	}

/**

  Performs state change on Start/EndCapture by calling state change DFC

  Call with iStateChangeMutex held.

  @param aNewState True to start image capture, false to stop image capture.

*/

void DCamera1Channel::StateChange(TBool aNewState)

	{

	iNewState = aNewState;

	NKern::FSSetOwner(&iStateChangeSemaphore,NULL);

	iStateChangeDfc.Enque();

	NKern::FSWait(&iStateChangeSemaphore);

	}

/**

  DFC callback called when Start/EndCapture requests are made.

*/

void DCamera1Channel::StateChangeDfcTrampoline(TAny* aSelf)

	{

	// Just call non-static method

	((DCamera1Channel*)aSelf)->StateChangeDfc();

	}

/**

  DFC callback called when Start/EndCapture requests are made.

*/

void DCamera1Channel::StateChangeDfc()

	{

	TRACE(Kern::Printf(">DCamera1Channel::StateChangeDfc\n");)

	// Call relevent state change function

	if(iNewState)

		DoStartCapture();

	else

		DoEndCapture();

	// Signal completion

	NKern::FSSignal(&iStateChangeSemaphore);

	TRACE(Kern::Printf("<DCamera1Channel::StateChangeDfc\n");)