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

// e32/drivers/camerasc/cameraldd.cpp

// 

//

#include <drivers/camerasc.h>

#include <kernel/kern_priv.h>

#include <kernel/cache.h>

//#define __KTRACE_CAM(s) s;

#define __KTRACE_CAM(s)

#define DISCARD_COMPLETED_TO_AVOID_OVERFLOW

static const char KCameraLddPanic[]="CameraSc LDD";

/**

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

in this case, DSoundScLddFactory.

*/

DECLARE_STANDARD_LDD()

	{

	return new DCameraScLddFactory;

	}

/**

Constructor for the camera driver factory class.

*/

DCameraScLddFactory::DCameraScLddFactory()

	{

//	iUnitsOpenMask=0;

	__KTRACE_CAM(Kern::Printf(">DCameraScLddFactory::DCameraScLddFactory"));

	// Set version number for this device.

	iVersion=RDevCameraSc::VersionRequired();

	// Indicate that units / PDD are supported.

	iParseMask=KDeviceAllowUnit|KDeviceAllowPhysicalDevice;

	// Leave the units decision to the PDD

	iUnitsMask=0xffffffff;

	}

/**

Second stage constructor for the camera driver factory class.

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 DCameraScLddFactory::Install()

	{

	return(SetName(&KDevCameraScName));

	}

/**

Return the 'capabilities' of the camera driver in general.

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

@param aDes A user-side descriptor to write the capabilities information into.

*/

void DCameraScLddFactory::GetCaps(TDes8 &aDes) const

	{

	// Create a capabilities object

	TCapsDevCameraV01 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 client thread which requested the creation of a logical

channel - through a call to RBusLogicalChannel::DoCreate().

The thread is in a critical section.

@param aChannel Set by this function to point to the created logical channel.

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

*/

TInt DCameraScLddFactory::Create(DLogicalChannelBase*& aChannel)

	{

	__KTRACE_CAM(Kern::Printf(">DCameraScLddFactory::Create"));

	aChannel=new DCameraScLdd;

	if (!aChannel)

		return(KErrNoMemory);

	return(KErrNone);

	}

/**

Check whether a channel has is currently open on the specified unit.

@param aUnit The number of the unit to be checked.

@return ETrue if a channel is open on the specified channel, EFalse otherwise.

@pre The unit info. mutex must be held.

*/

TBool DCameraScLddFactory::IsUnitOpen(TInt aUnit)

	{

	return(iUnitsOpenMask&(1<<aUnit));

	}

/**

Attempt to change the state of the channel open status for a particular channel.

@param aUnit The number of the unit to be updated.

@param aIsOpenSetting	The required new state for the channel open status: either ETrue to set the status to open or

						EFalse to set the status to closed.

@return KErrNone if the status was updated successfully;

		KErrInUse if an attempt has been made to set the channnel status to open while it is already open.

*/

TInt DCameraScLddFactory::SetUnitOpen(TInt aUnit,TBool aIsOpenSetting)

	{

	NKern::FMWait(&iUnitInfoMutex); // Acquire the unit info. mutex.

	// Fail a request to open an channel that is already open

	if (aIsOpenSetting && IsUnitOpen(aUnit))

		{

		NKern::FMSignal(&iUnitInfoMutex); // Release the unit info. mutex.

		return(KErrInUse);

		}

	// Update the open status as requested

	if (aIsOpenSetting)

		iUnitsOpenMask|=(1<<aUnit);

	else

		iUnitsOpenMask&=~(1<<aUnit);

	NKern::FMSignal(&iUnitInfoMutex); // Release the unit info. mutex.

	return(KErrNone);

	}

/**

Constructor for the camera driver logical channel.

*/

DCameraScLdd::DCameraScLdd()

	:	iRequestQueue(&iMutex),

		iRestartDfc(DCameraScLdd::RestartDfc,this,5),

		iPowerDownDfc(DCameraScLdd::PowerDownDfc,this,3),

		iPowerUpDfc(DCameraScLdd::PowerUpDfc,this,3)

	{

//	iState=EOpen;

//	iCaptureMode=ECaptureModeImage;

//	iFrameHeight=0;

//	iFrameWidth=0;

//	iBufManager=NULL;

//	iPowerHandler=NULL;

//	iImageGatherCount=0;

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DCameraScLdd"));

	iUnit=-1;	// Invalid unit number

	// Get pointer to client thread's DThread object

	iOwningThread=&Kern::CurrentThread();

	// Open a reference on client thread so it's control block can't dissapear until

	// this driver has finished with it. Note, this call to Open() can't fail since

	// it is the thread we are currently running in

	iOwningThread->Open();

	}

/**

Destructor for the camera driver logical channel.

This is called in the context of the client thread once a 'ECloseMsg' message has been

sent to the device driver DFC thread.

*/

DCameraScLdd::~DCameraScLdd()

	{

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::~DCameraScLdd"));

	TInt captureMode;

	// Remove and delete the power handler.

	if (iPowerHandler)

		{

		iPowerHandler->Remove();

		delete iPowerHandler;

		iPowerHandler=NULL;

		}

	if (iCaptureModeConfig)

		{

		// Delete any buffers, the shared chunk we created, and the buffer config struct.

		for (captureMode=0; captureMode < ECamCaptureModeMax; captureMode++)

			{

			if (iCaptureModeConfig[captureMode].iBufManager)

				{

				delete iCaptureModeConfig[captureMode].iBufManager;

				iCaptureModeConfig[captureMode].iBufManager=NULL;

				}

			if (iCaptureModeConfig[captureMode].iBufConfig)

				{

				Kern::Free(iCaptureModeConfig[captureMode].iBufConfig);

				iCaptureModeConfig[captureMode].iBufConfig=NULL;

				}

			}

		delete[] iCaptureModeConfig;

		iCaptureModeConfig=NULL;

		}

	// Close our reference on the client thread

	Kern::SafeClose((DObject*&)iOwningThread,NULL);

	// Clear the 'units open mask' in the LDD factory.

	if (iUnit>=0)

		((DCameraScLddFactory*)iDevice)->SetUnitOpen(iUnit,EFalse);

	}

/**

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

This is called in the context of the client thread 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. This is checked by the PDD and not used here.

@param aInfo The info argument supplied by the client. Always NULL in this case.

@param aVer The version argument supplied by the client.

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

*/

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

	{

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DoCreate"));

	// Check the client has EMultimediaDD capability.

	if (!Kern::CurrentThreadHasCapability(ECapabilityMultimediaDD,__PLATSEC_DIAGNOSTIC_STRING("Checked by ECAMERA.LDD (Camera driver)")))

		return(KErrPermissionDenied);

	// Check that the camera driver version specified by the client is compatible.

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

		return(KErrNotSupported);

	// Check that a channel hasn't already been opened on this unit.

	TInt r=((DCameraScLddFactory*)iDevice)->SetUnitOpen(aUnit,ETrue); // Try to update 'units open mask' in the LDD factory.

	if (r!=KErrNone)

		return(r);

	iUnit=aUnit;

	// Create the power handler

	iPowerHandler=new DCameraScPowerHandler(this);

	if (!iPowerHandler)

		return(KErrNoMemory);

	iPowerHandler->Add();

	// Create the pending capture request list

	r=iRequestQueue.Create(iOwningThread);

	if (r!=KErrNone)

		return(r);

	// Initialise the PDD

	((DCameraScPdd*)iPdd)->iLdd=this;

	// Setup the default camera config

	iCaptureMode=ECamCaptureModeImage;

	iCaptureModeConfig = new TCaptureModeConfig[ECamCaptureModeMax];

	if(!iCaptureModeConfig)

		return KErrNoMemory;

	TInt capsSize = Pdd()->CapsSize();

	TInt captureMode;

	TAny* capsBuf;

	capsBuf = Kern::Alloc(capsSize);

	if(!capsBuf)

		return KErrNoMemory;

	// Query the driver for its capabilities and set a default pixel format

	// and frame size for each available capture mode.

	TPtr8 capsPtr( (TUint8*)capsBuf, capsSize, capsSize );

	Pdd()->Caps(capsPtr);

	TCameraCapsV02* caps = (TCameraCapsV02*) capsPtr.Ptr();

	SDevCamPixelFormat* pixelFormat = (SDevCamPixelFormat*) (caps + 1);

	SDevCamFrameSize* frameSize;

	TAny* frameSizeCapsBuf=0;

	TPtr8 frameSizeCapsPtr(0,0,0);

	for (captureMode=0; captureMode < ECamCaptureModeMax; captureMode++)

		{

		if ((captureMode==ECamCaptureModeImage) && (caps->iNumImagePixelFormats==0))

			continue;

		if ((captureMode==ECamCaptureModeVideo) && (caps->iNumVideoPixelFormats==0))

			continue;

		if ((captureMode==ECamCaptureModeViewFinder) && (caps->iNumViewFinderPixelFormats==0))

			continue;

		iCaptureModeConfig[captureMode].iCamConfig.iPixelFormat=*pixelFormat;

		frameSizeCapsBuf = Kern::Alloc(pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		new (&frameSizeCapsPtr) TPtr8((TUint8*)frameSizeCapsBuf, pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize), pixelFormat->iNumFrameSizes*sizeof(SDevCamFrameSize));

		r=Pdd()->FrameSizeCaps((TDevCamCaptureMode)captureMode, pixelFormat->iPixelFormat, frameSizeCapsPtr);

		if(r!=KErrNone)

			{

			Kern::Free(frameSizeCapsBuf);

			return r;

			}

		frameSize=(SDevCamFrameSize*) frameSizeCapsPtr.Ptr();

		iCaptureModeConfig[captureMode].iCamConfig.iFrameSize=*frameSize;

		Kern::Free(frameSizeCapsBuf);

		iCaptureModeConfig[captureMode].iCamConfig.iFlashMode=ECamFlashNone;

		iCaptureModeConfig[captureMode].iCamConfig.iExposureMode=ECamExposureAuto;

		iCaptureModeConfig[captureMode].iCamConfig.iWhiteBalanceMode=ECamWBAuto;

		iCaptureModeConfig[captureMode].iCamConfig.iZoom=0;

		iCaptureModeConfig[captureMode].iCamConfig.iPixelWidthInBytes=0;

		iCaptureModeConfig[captureMode].iCamConfig.iFrameRate = 0;

		}

	Kern::Free(capsBuf);

	// Setup the default buffer config.

	r=ReAllocBufferConfigInfo(0);	// Zeros the structure

	if (r!=KErrNone)

		return(r);

	for (captureMode=0; captureMode < ECamCaptureModeMax; captureMode++)

		{

		iCaptureModeConfig[captureMode].iBufConfig->iNumBuffers=KDefaultNumClientBuffers;

		}

	// Set up the correct DFC queue and enable the reception of client messages.

	TDfcQue* dfcq=((DCameraScPdd*)iPdd)->DfcQ(aUnit);

	SetDfcQ(dfcq);

	iRestartDfc.SetDfcQ(dfcq);

	iPowerDownDfc.SetDfcQ(dfcq);

	iPowerUpDfc.SetDfcQ(dfcq);

	iMsgQ.Receive();

	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::DoCreate"));

	return(KErrNone);

	}

/**

Shutdown the camera device.

Terminate all device activity and power down the hardware.

*/

void DCameraScLdd::Shutdown()

	{

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::Shutdown"));

	iState=EOpen;

	// Power down the hardware

	Pdd()->PowerDown();

	// Cancel any requests that we may be handling

	DoCancel(RDevCameraSc::EAllRequests);

	// Make sure DFCs are not queued.

	iRestartDfc.Cancel();

	iPowerDownDfc.Cancel();

	iPowerUpDfc.Cancel();

	}

/**

Notification to the driver that a handle to it has been requested by a user thread.

The use of a camera driver channel is restricted here to a single thread (that has

EMultimediaDD capability).

@param aThread A pointer to thread which is requesting the handle.

@param aType Whether the requested handle is thread or process relative.

@return	KErrNone, if the request is for a thread relative handle - originating from

		the same the thread that created the channel object;

		KErrAccessDenied, otherwise.

*/

TInt DCameraScLdd::RequestUserHandle(DThread* aThread, TOwnerType aType)

	{

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::RequestUserHandle"));

	// Ensure that each channel can only be used by a single thread.

	if (aType!=EOwnerThread || aThread!=iOwningThread)

		return(KErrAccessDenied);

	return(KErrNone);

	}

/**

Process a request on this logical channel

Called in the context of the client thread.

@param aReqNo	The request number:

				==KMaxTInt: a 'DoCancel' message;

				>=0: a 'DoControl' message with function number equal to value.

				<0: a 'DoRequest' message with function number equal to ~value.

@param a1 The first request argument. For DoRequest(), this is a pointer to the TRequestStatus.

@param a2 The second request argument. For DoRequest(), this is a pointer to the 2 actual TAny* arguments.

@return The result of the request. This is ignored by device driver framework for DoRequest().

*/

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

	{

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::Request(%d)",aReqNo));

	TInt r;

	if (aReqNo<RDevCameraSc::EMsgControlMax && aReqNo>(~RDevCameraSc::EMsgRequestMax))

		{

		// Implement in the context of the kernel thread - prepare and issue a kernel message.

		r=DLogicalChannel::Request(aReqNo,a1,a2);

		}

	else

		{

		// Implement in the context of the client thread.

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

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

			r=DoControl(aReqNo,a1,a2);		// DoControl - process the request.

		else if (aReqNo==KMaxTInt)

			{

			r=DoCancel((TInt)a1);			// DoCancel - cancel the request.

			}

		else

			{

			// DoRequest

			TInt func=~aReqNo;

			// NotifyNewImage() during image capture mode is another case which must be handled in the kernel thread.

			if (iCaptureMode==ECamCaptureModeImage && func==RDevCameraSc::ERequestNotifyNewImage)

				r=DLogicalChannel::Request(aReqNo,a1,a2);

			else

				{

				// Read the arguments from the client thread and process the request.

				TAny* a[2];

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

				TRequestStatus* status=(TRequestStatus*)a1;

				r=DoRequest(func,status,a[0],a[1]);

				// Complete request if there was an error

				if (r!=KErrNone)

					Kern::RequestComplete(iOwningThread,status,r);

				r=KErrNone;

				}

			}

		}

	__KTRACE_CAM(Kern::Printf("<DCameraScLdd::Request - %d",r));

	return(r);

	}

/**

Process a message for this logical channel.

This function is called in the context of the DFC thread.

@param aMsg The message to process.

			The iValue member of this distinguishes the message type:

			iValue==ECloseMsg, channel close message.

			iValue==KMaxTInt, a 'DoCancel' message.

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

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

*/

void DCameraScLdd::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::HandleMsg(%d)",id));

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

	if (id==(TInt)ECloseMsg)

		{

		// Channel close.

		Shutdown();

		m.Complete(KErrNone,EFalse);

		return;

		}

	else if (id<0)	// The only DoRequest handled in the kernel thread is NotifyNewImage(ECamCaptureModeImage).

		{

		// DoRequest

		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

		TInt r=DoRequest(~id,pS,m.Ptr1(),m.Ptr2());

		if (r!=KErrNone)

			Kern::RequestComplete(iOwningThread,pS,r);

		m.Complete(KErrNone,ETrue);

		}

	else

		{

		// Must be DoControl (Cancel is handled in the client thread).

		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());

		m.Complete(r,ETrue);

		}

	}

/**

Process a synchronous 'DoControl' request.

This function is called in the context of the DFC thread.

@param aFunction The request number.

@param a1 The first request argument.

@param a2 The second request argument.

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

*/

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

	{

	__KTRACE_CAM(Kern::Printf(">DCameraScLdd::DoControl(%d)",aFunction));

	TInt r=KErrNotSupported;

	switch (aFunction)

		{

		case RDevCameraSc::EControlCaps:

			{

			r = GetSensorCaps(a1);

			break;

			}

		case RDevCameraSc::EControlSetCaptureMode:

			{

			// Change the capture mode.

			r=SetCaptureMode((TInt)a1);

			break;

			}

		case RDevCameraSc::EControlSetCamConfig:

			{

			// Set the new camera configuration.

			NKern::ThreadEnterCS();

			r=SetCamConfig((TInt)a1, (const TDesC8*)a2);

			NKern::ThreadLeaveCS();

			break;

			}

		case RDevCameraSc::EControlGetCamConfig:

			{

			// Write the config to the client.

			TPtrC8 ptr((const TUint8*)&iCaptureModeConfig[(TInt)a1].iCamConfig,sizeof(iCaptureModeConfig[(TInt)a1].iCamConfig));

			Kern::InfoCopy(*((TDes8*)a2),ptr);

			r=KErrNone;

			break;

			}

		case RDevCameraSc::EControlGetBufferConfig:

			if (iCaptureModeConfig[(TInt)a1].iBufConfig)

				{

				// Write the buffer config to the client.

				TPtrC8 ptr((const TUint8*)&(*iCaptureModeConfig[(TInt)a1].iBufConfig),iCaptureModeConfig[(TInt)a1].iBufConfigSize);