// Copyright (c) 2006-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:
// template\template_variant\camerasc\camerasc.cpp
// Implementation of the template shared chunk camera physical device driver (PDD).
// This file is part of the Template Base port
// 
//
#include "camerasc_plat.h"

_LIT(KCameraScPddName, "CameraSc.TE");
_LIT(KCameraScDfcQueueName, "CameraSc.TE.DfcQ");

/**
Standard export function for PDD factories.  This creates a DPhysicalDevice derived object, in this case,
DTemplateCameraScPddFactory.
*/
DECLARE_STANDARD_PDD()
	{
	return new DTemplateCameraScPddFactory;
	}

/**
Constructor for the shared chunk camera PDD factory class.
*/
DTemplateCameraScPddFactory::DTemplateCameraScPddFactory()
	{
	// We currently support only unit 0
	iUnitsMask = 0x01;

	// Set the version number for this device.  This is used to allow code to specify that it requires a
	// minimum version of the device in order to operate.  If the version requested is less than this then
	// the device is safe to be used
	iVersion = RDevCameraSc::VersionRequired();
	}

/**
Destructor for the shared chunk camera PDD factory class.
*/
DTemplateCameraScPddFactory::~DTemplateCameraScPddFactory()
	{
	}

/**
Second stage constructor for the shared chunk camera PDD factory class.  This must at least set a name for
the driver object.
@return KErrNone if successful, otherwise one of the system wide error codes.
*/
TInt DTemplateCameraScPddFactory::Install()
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPddFactory::Install()"));

	TInt r;

	// Create a DFC queue so that handling of both camera hardware callbacks and requests made to the LDD from
	// user mode can be processed in the same thread, to avoid the use of semaphores
	if ((r = Kern::DynamicDfcQCreate(iDfcQ, 26, KCameraScDfcQueueName)) == KErrNone)
		{
		// All PDD factories must have a unique name
		r = SetName(&KCameraScPddName);
		}

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPddFactory::Install() => Returning %d", r));

	return r;
	}

/**
Returns the PDD's capabilities.  This is not used by the Symbian OS device driver framework
or by the LDD but is here as some LDDs will make use of it.
@param aDes	A descriptor into which to write capability information.
*/
void DTemplateCameraScPddFactory::GetCaps(TDes8& /*aDes*/) const
	{
	}

/**
Called by the kernel's device driver framework to check if this PDD is suitable for use
with 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 aUnit	The unit argument supplied by the client to RBusLogicalChannel::DoCreate()
				This is used to determine which sensor to use.
@param aInfo	The info argument supplied by the client to RBusLogicalChannel::DoCreate().
@param aVer		The version number of the logical channel which will use this physical channel.
@return KErrNone if successful, otherwise one of the system wide error codes.
*/
TInt DTemplateCameraScPddFactory::Validate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& aVer)
	{
	// Check that the version requested is less than or equal to the version of this PDD
	if (!Kern::QueryVersionSupported(RDevCameraSc::VersionRequired(), aVer))
		{
		return KErrNotSupported;
		}

	// Check that the unit number specifies the available sensor
	if ((aUnit < 0) || (aUnit > 0))
		{
		return KErrNotSupported;
		}

	return KErrNone;
	}

/**
Called by the kernel's device driver framework to create a physical channel object.  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 physical channel object.
@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 number of the logical channel which will use this physical channel.
@return KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DTemplateCameraScPddFactory::Create(DBase*& aChannel, TInt aUnit, const TDesC8* /*anInfo*/, const TVersion& /*aVer*/)
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPddFactory::Create()"));

	// Create an instance of the PDD channel object that will work with the Template sensor
	DTemplateCameraScPdd* pD = new DTemplateCameraScPdd;

	aChannel = pD;
	TInt r = KErrNoMemory;

	if (pD)
		{
		r = pD->DoCreate(this, aUnit);
		}

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPddFactory::Create() => Returning %d", r));

	return r;
	}

/**
Called by SetUnitOpen() to see if a particular unit is open.  When called, the
iUnitInfoMutex fast mutex will be taken, ensuring safe access to iUnitsOpenMask.
@param aUnit	The unit number to be checked for being open.
@return ETrue if the unit specified by aUnit is already open, otherwise EFalse.
*/
TBool DTemplateCameraScPddFactory::IsUnitOpen(TInt aUnit)
	{
	return (iUnitsOpenMask & (1 << aUnit));
	}

/**
Attempt to change the state of the unit open state for a particular unit.
@param aUnit	The unit number to be set to open or closed state.
@param aIsOpen	The required new state for the unit;  either ETrue to set the state
				to open or EFalse to set the state to closed.
@return KErrNone if the state was updated successfully, otherwise KErrInUse if an attempt
		was made to set the unit status to open while it is already open.
*/
TInt DTemplateCameraScPddFactory::SetUnitOpen(TInt aUnit, TBool aIsOpen)
	{
	// Wait until it is safe to access the unit state mask
	NKern::FMWait(&iUnitInfoMutex);

	// Fail a request to open a unit that is already open
	if (aIsOpen && IsUnitOpen(aUnit))
		{
		__KTRACE_CAM(Kern::Printf("+ DTemplateCameraScPddFactory::SetUnitOpen() => Unit %d is already in use", aUnit));

		// Release the unit state mask mutex
		NKern::FMSignal(&iUnitInfoMutex);

		return KErrInUse;
		}

	// Set or clear the unit's open status bit as required
	if (aIsOpen)
		{
		iUnitsOpenMask |= (1 << aUnit);
		}
	else
		{
		iUnitsOpenMask &= ~(1 << aUnit);
		}

	// Release the unit state mask mutex
	NKern::FMSignal(&iUnitInfoMutex);

	return KErrNone;
	}

/**
Constructor for the shared chunk camera PDD class.
*/
DTemplateCameraScPdd::DTemplateCameraScPdd()
	{
	// Set the unit number to -1 to indicate that this channel has never been registered
	// with the PDD factory
	iUnit = -1;

	// The channel has been created but not yet configured */
	iState = EUnconfigured;
	}

/**
Destructor for the shared chunk camera PDD class.  This is called in the context of the client thread
once an 'ECloseMsg' message has been sent to the device driver DFC thread.
*/
DTemplateCameraScPdd::~DTemplateCameraScPdd()
	{
	delete [] iCapsBuffer;
	delete iSensor;

	// Indicate that a physical channel is no longer open on this unit
	if (iUnit >= 0)
		{
		iPhysicalDevice->SetUnitOpen(iUnit, EFalse);
		}
	}

/**
Second stage constructor for the H4 camera PDD.
@param aPhysicalDevice	A pointer to the factory class that is creating this PDD
@param aUnit			The unit argument supplied by the client to RBusLogicalChannel::DoCreate().
@return KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DTemplateCameraScPdd::DoCreate(DTemplateCameraScPddFactory* aPhysicalDevice, TInt aUnit)
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPdd::DoCreate()"));

	TInt r;

	iPhysicalDevice = aPhysicalDevice;

	// Check that a physical channel hasn't already been opened on this unit
	if ((r = iPhysicalDevice->SetUnitOpen(aUnit, ETrue)) == KErrNone)
		{
		iUnit = aUnit;

		// Create an abstracted sensor interface
		if ((iSensor = new DTemplateSensorIf(*this, DfcQ(aUnit))) != NULL)
			{
			if ((r = iSensor->DoCreate()) == KErrNone)
				{
				// Setup the capabilities of this device for later reference
				if ((r = iSensor->GetCaps(iCaps)) > 0)
					{
					// And save the size as returned from the sensor
					iCapsSize = r;

					// Although iCaps now points to a TCameraCapsV02 structure, it is actually a variable
					// sized structure that was allocated as an array of TUint8 so save it to a TUint8
					// ptr so that it can be deleted properly
					iCapsBuffer = (TUint8*) iCaps;

					// Enable the clocks needed by the camera subsystem and power up the sensor
					r = iSensor->RequestPower();

					// Some sensors power themselves up automatically in their DoCreate() function,
					// so take this into account here
					if (r == KErrAlreadyExists)
						{
						r = KErrNone;
						}
					}
				}
			}
		else
			{
			r = KErrNoMemory;
			}
		}

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPdd::DoCreate() => Returning %d", r));

	return r;
	}

/**
An appropriate DFC queue to use for processing client requests (that is, those that won't be processed
in the context of the client thread), and also for processing image completion requests from the sensor
will have been setup by the PDD factory.  Anything needing to run in this same DFC thread can access the
queue via this function.
@param	aUnit	The unit number for which to get the DFC queue.
@return	The DFC queue to be used.
*/
TDfcQue* DTemplateCameraScPdd::DfcQ(TInt /*aUnit*/)
	{
	return iPhysicalDevice->iDfcQ;
	}

/**
Called by the LDD in order to query the capabilities of the PDD.
@param	aCapsBuf	A reference to a descriptor owned by the LDD, containing a TCameraCapsV02 structure
					for the capabilities.
*/
void DTemplateCameraScPdd::Caps(TDes8& aCapsBuf) const
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPdd::Caps()"));

	// The iCaps structure will already have been created by a call to iSensor->SetCaps() in DoCreate().
	// Simply copy it into the supplied TPckgBuf, taking into account the fact that the TCameraCapsV02
	// buffer is of a variable size *and* may be smaller or larger than the iCaps structure
	TPtrC8 ptr((const TUint8*) iCaps, iCapsSize);
	aCapsBuf.FillZ(aCapsBuf.MaxLength());
	aCapsBuf = ptr.Left(Min(ptr.Length(), aCapsBuf.MaxLength()));

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPdd::Caps()"));
	}

/**
Called by the LDD to setup a new image configuration, including such things as image size, framerate
and pixel format.
@param	aConfigBuf	A reference to a TPckgBuf containing a TCameraConfigV02 configuration structure.
@return KErrNone if successful, otherwise one of the system wide error codes.
*/
TInt DTemplateCameraScPdd::SetConfig(const TDesC8& aConfigBuf)
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPdd::SetConfig()"));

	TInt r;

	// It is only legal to call this if image capture is not already underway, so check for this
	// before doing anything
	if (iState <= EConfigured)
		{
		// Read the new configuration from the LDD into a local copy of the configuration structure,
		// taking into account for compatibility that the TPckgBuf may be smaller or larger than the
		// TCameraConfigV02 structure
		TCameraConfigV02 config;
		TPtr8 ptr((TUint8*) &config, sizeof(config));
		Kern::InfoCopy(ptr, aConfigBuf);

		// Save the new configuration for later and let the sensor also know about it
		iConfig = config;
		iSensor->SetConfig(config);

		// Signal success and set the channel to the configured state
		r = KErrNone;
		iState = EConfigured;
		}
	else
		{
		r = KErrInUse;
		}

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPdd::SetConfig() => Returning %d", r));

	return r;
	}

/**
Begins capture into the address pointed to by aLinAddr and aPhysAddr.  Both of these addresses point to
the same buffer;  The address used by the sensor is hardware dependent.
@param	aCaptureMode	Whether to capture in video, viewfinder or single image mode.
@param	aLinAddr		The virtual address of the buffer into which to capture the image.
@param	aPhysAddr		The physical address of the buffer into which to capture the image.
@return	KErrNone if successful, otherwise one of the other system wide error codes.
@pre	SetConfig() must first have been called.
*/
TInt DTemplateCameraScPdd::Start(TDevCamCaptureMode aCaptureMode, TLinAddr aLinAddr, TPhysAddr aPhysAddr)
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPdd::Start() => Configuring sensor for %d x %d capture", iConfig.iFrameSize.iWidth, iConfig.iFrameSize.iHeight));

	// Ensure the precondition is met
	__ASSERT_DEBUG((iState == EConfigured), Kern::Fault("camerasc", ENotConfigured));

	// Save the capture mode for use when we call back into the LDD with the captured image
	iCaptureMode = aCaptureMode;

	// And start the sensor running
	TInt r = iSensor->Start(aCaptureMode, aLinAddr, aPhysAddr);

	// If everything was ok, set the channel to the capturing state
	if (r == KErrNone)
		{
		iState = ECapturing;
		}

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPdd::Start() => Returning %d", r));

	return r;
	}

/**
Sets the address of the buffer info which the next image will be captured.  Called by the LDD for successive
images that are requested after the initial call to Start().
@param	aLinAddr		The virtual address of the buffer into which to capture the image.
@param	aPhysAddr		The physical address of the buffer into which to capture the image.
@return	KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DTemplateCameraScPdd::CaptureNextImage(TLinAddr aLinAddr, TPhysAddr aPhysAddr)
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPdd::CaptureNextImage()"));

	// Pass the call directly to the sensor abstraction
	TInt r = iSensor->CaptureNextImage(aLinAddr, aPhysAddr);

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPdd::CaptureNextImage()=> Returning %d", r));

	return(r);
	}

/**
Stops any image capturing that is currently underway.  It is safe to call this without having called Start().
@return	KErrNone if successful, otherwise one of the other system wide error codes.
*/
TInt DTemplateCameraScPdd::Stop()
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPdd::Stop()"));

	// Pass the call directly to the sensor abstraction
	iSensor->Stop();

	// Det the channel back to the configured state as it is now safe to call Start() again
	iState = EConfigured;

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPdd::Stop()"));

	return KErrNone;
	}

/**
Power down the camera device.  This is called by the LDD when the driver channel is being closed or
when the system is being powered down.  This is always called in the context of the DFC thread.
*/
void DTemplateCameraScPdd::PowerDown()
	{

#ifdef _DEBUG

	// Power off the camera
	TInt r = iSensor->RelinquishPower();

	// Not being able to power down indicates a serious programming error
	__ASSERT_DEBUG((r == KErrNone), Kern::Fault("camerasc", ECannotPowerDown));

#else // ! _DEBUG

	// Power off the camera
	iSensor->RelinquishPower();

#endif // ! _DEBUG

	}

/**
Return the shared chunk creation information to be used by this device.
@param	aChunkCreateInfo	A structure to be filled with the settings required for this device.
*/
void DTemplateCameraScPdd::GetChunkCreateInfo(TChunkCreateInfo& aChunkCreateInfo)
	{
	// Can be opened by any number of user side processes
	aChunkCreateInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;
	// Use both L1 and L2 cache if available.  LDD will take care of pre and post DMA cache handling
#ifdef __WINS__
	aChunkCreateInfo.iMapAttr = 0xFF000;
#else
	aChunkCreateInfo.iMapAttr = EMapAttrCachedMax;
#endif
	// Chunk owns the memory which will be freed when the chunk is destroyed
	aChunkCreateInfo.iOwnsMemory = ETrue;
	// Don't queue the chunk's destruction on an DFC
	aChunkCreateInfo.iDestroyedDfc = NULL;
	}

/**
Returns the size of the variable sized capabilities structure in bytes.  The buffer passed into
DTemplateCameraScPdd::GetCaps() must be at least this large to hold the fixed portion of the TCameraCapsV02
structure, as well as the array of SDevCamPixelFormat structures that follows it.
@return	The size in bytes of the variable sized capabilities structure.
*/
TInt DTemplateCameraScPdd::CapsSize()
	{
	return iCapsSize;
	}

/**
Obtains information regarding the frame sizes and frame rates supported for a given combination of capture mode
and pixel format.
@param	aCaptureMode		The capture mode for which to obtain the information.
@param	aUidPixelFormat		The pixel format for which to obtain the information.
@param	aFrameSizeCapsBuf	A reference to an array of packaged SDevCamFrameSize structures, owned by the LDD, into
							which to place the information.
@@return	KErrNone if successful, else one of the other system wide error codes.
*/
TInt DTemplateCameraScPdd::FrameSizeCaps(TDevCamCaptureMode aCaptureMode, TUidPixelFormat aUidPixelFormat, TDes8& aFrameSizeCapsBuf)
	{
	return iSensor->FrameSizeCaps(aCaptureMode, aUidPixelFormat, aFrameSizeCapsBuf);
	}

/**
Called by the sensor abstraction when an image is available.
@param	aResult	KErrNone if successful, otherwise one of the system wide error codes.
@param	aLinAddr		The virtual address of the buffer into which to capture the image.
@param	aPhysAddr		The physical address of the buffer into which to capture the image.
*/
TInt DTemplateCameraScPdd::NotifyImageCaptureEvent(TInt aResult, TLinAddr& aLinAddr, TPhysAddr& aPhysAddr)
	{
	__KTRACE_CAM(Kern::Printf("> DTemplateCameraScPdd::NotifyImageCaptureEvent() => aResult = %d", aResult));

	// Inform the LDD that a new image has been received
	TInt r = iLdd->ImageCaptureCallback(iCaptureMode, aResult, &aLinAddr, &aPhysAddr);

	// If the LDD has returned KErrAbort then something has gone wrong, and if it has returned KErrNotReady
	// then it has no more frames available, so call Stop()
	if (r != KErrNone)
		{
		Stop();
		}

	__KTRACE_CAM(Kern::Printf("< DTemplateCameraScPdd::NotifyImageCaptureEvent() => Returning %d", r));

	return r;
	}

TInt DTemplateCameraScPdd::SetBrightness(TUint /*aBrightness*/)
	{
	return KErrNone;
	}

TInt DTemplateCameraScPdd::SetContrast(TUint /*aContrast*/)
	{
	return KErrNone;
	}

TInt DTemplateCameraScPdd::SetColorEffect(TUint /*aColorEffect*/)
	{
	return KErrNone;
	}