// 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 data converter device driver which uses Shared Chunks in

 @publishedPartner

 @prototype 9.1

*/

#include <kernel/kern_priv.h>

#include <kernel/cache.h>

#include "convert1.h"

#include "convert1_dev.h"

#if 0  // Set true for tracing

#define TRACE(x) x

#else

#define TRACE(x)

#endif

_LIT(KConvert1PanicCategory,"CONVERT1");

//

// DConvert1Factory

//

/**

  Number of hardware 'resources' available to driver.

  E.g. the number of simultaneous channels it can support.

*/

const TInt KTotalConvert1Resources = 4;

/**

  A resource ID representing no resources

*/

const TInt KNullConvert1ResourceId = -1;

/**

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

  in this case, our DConvert1Factory

*/

DECLARE_STANDARD_LDD()

	{

	return new DConvert1Factory;

	}

/**

  Constructor

*/

DConvert1Factory::DConvert1Factory()

	{

	// Set version number for this device

	iVersion=RConvert1::VersionRequired();

	// Indicate that do support units or a PDD

	iParseMask=0;

	// Mark all resources available

	iResourceFlags = (1<<KTotalConvert1Resources)-1;

	}

/**

  Second stage constructor for DConvert1Factory.

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

	{

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

	}

/**

  Destructor

*/

DConvert1Factory::~DConvert1Factory()

	{

	}

/**

  Return the drivers capabilities.

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

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

*/

void DConvert1Factory::GetCaps(TDes8& aDes) const

	{

	// Create a capabilities object

	RConvert1::TCaps caps;

	caps.iVersion = iVersion;

	caps.iMaxChannels = KTotalConvert1Resources;

	// 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 DConvert1Factory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel=new DConvert1Channel(this);

	if(!aChannel)

		return KErrNoMemory;

	return KErrNone;

	}

/**

  Claim a hardware resource. This example driver has KTotalConvert1Resources

  'hardware resources' and returns the ID of the next unallocated one.

*/

TInt DConvert1Factory::ClaimResource(TInt& aResourceId)

	{

	// Wait on mutex protecting resource allocation

	NKern::FMWait(&iResourceMutex);

	// Search for a free resource

	TUint resourceFlags = iResourceFlags;

	TUint mask = 1;

	TInt id = 0;

	do

		{

		if(resourceFlags&mask)

			break;

		mask <<= 1;

		}

	while(++id<KTotalConvert1Resources);

	if(resourceFlags&mask)

		iResourceFlags = resourceFlags&~mask; // Found resource, so mark it in use

	else

		id = KNullConvert1ResourceId; // No resource available

	// Set returned resource id

	aResourceId = id;

	// Release mutex protecting resource allocation

	NKern::FMSignal(&iResourceMutex);

	return id<0 ? KErrInUse : KErrNone;

	}

/**

  Released the hardware resource indicated by the given id

*/

void DConvert1Factory::ReleaseResource(TInt aResourceId)

	{

	// Do nothing if the null id was given

	if(aResourceId==KNullConvert1ResourceId)

		return;

	// Wait on mutex protecting resource allocation

	NKern::FMWait(&iResourceMutex);

	// Check for valid resource and that it is not already free

	__NK_ASSERT_DEBUG(TUint(aResourceId)<TUint(KTotalConvert1Resources));

	__NK_ASSERT_DEBUG((iResourceFlags&(1<<aResourceId))==0);

	// Flag resource free again

	iResourceFlags |= 1<<aResourceId;

	// Release mutex protecting resource allocation

	NKern::FMSignal(&iResourceMutex);

	}

//

// Logical Channel

//

/**

  Default configuration (4k buffer, No Input Chunk, 1MB/sec speed)

*/

static const RConvert1::TConfig DefaultConfig = {4<<10,EFalse,1<<20};

/**

  Constructor

*/

DConvert1Channel::DConvert1Channel(DConvert1Factory* aFactory)

	:	iFactory(aFactory), 

		iResourceId(KNullConvert1ResourceId),

		iConfig(DefaultConfig),

		iConvertTimer(ConvertDfcTrampoline,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 DConvert1Channel::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(RConvert1::VersionRequired(),aVer))

		return KErrNotSupported;

	// Claim ownership of a hardware resource

	TInt r=iFactory->ClaimResource(iResourceId);

	if(r!=KErrNone)

		return r;

	// Set client thread with which channel will be used by

	iClient = &Kern::CurrentThread();

	// Done

	return KErrNone;

	}

/**

  Destructor

*/

DConvert1Channel::~DConvert1Channel()

	{

	// Cancel outsatnding requests

	DoCancel(RConvert1::EAllRequests);

	// Release hardware resource which we own

	iFactory->ReleaseResource(iResourceId);

	}

/**

  Called when a user thread requests a handle to this channel.

*/

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

	{

	// Make sure that only our client can get a handle

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

		return KErrAccessDenied;

	return KErrNone;

	}

/**

  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 DConvert1Channel::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 DConvert1Channel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

	{

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

	TInt r = KErrNotSupported;

	switch (aFunction)

		{

		case RConvert1::EGetConfig:

			r = GetConfig((TDes8*)a1);

			break;

		case RConvert1::ESetConfig:

			r = SetConfig((const TDesC8*)a1,(RConvert1::TBufferInfo*)a2);

			break;

		case RConvert1::EConvertDes:

			ConvertDes((const TDesC8*)a1,(TRequestStatus*)a2);

			break;

		case RConvert1::EConvertChunk:

			ConvertChunk((const RConvert1::TConvertArgs*)a1,(TRequestStatus*)a2);

			break;

		case RConvert1::EConvertInChunk:

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

			break;

		}

	TRACE(Kern::Printf("<DConvert1Channel::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 DConvert1Channel::DoRequest(TInt aNotReqNo, TAny* a1, TAny* a2)

	{

	TRACE(Kern::Printf(">DConvert1Channel::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 RConvert1::EConvertDes:

		case RConvert1::EConvertChunk:

		case RConvert1::EConvertInChunk:

			// Not used because we do these asyncronous request 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("<DConvert1Channel::DoRequest result=%d\n",r);)

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

	}

/**

  Process cancelling of asynchronous requests.

*/

TInt DConvert1Channel::DoCancel(TUint aMask)

	{

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

	if(aMask&( (1<<RConvert1::EConvertDes) | (1<<RConvert1::EConvertChunk) | (1<<RConvert1::EConvertInChunk) ) )

		ConvertCancel();

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

	return KErrNone;

	}

//

// Methods for processing configuration control messages

//

/**

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

  RConvert1::TConfigBuf supplied by the client.

*/

TInt DConvert1Channel::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

  RConvert1::TConfigBuf supplied by the client.

*/

TInt DConvert1Channel::SetConfig(const TDesC8* aConfigBuf,RConvert1::TBufferInfo* aBufferInfo)

	{

	// Create a config structure.

	RConvert1::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);

	// 'info' is the data we will return to client at the end

	RConvert1::TBufferInfo info;

	memclr(&info,sizeof(info));

	TInt r;

	// Need to be in critical section whilst allocating objects

	NKern::ThreadEnterCS();

	// Check we aren't in the middle of converting data

	if(iConvertRequestStatus)

		{

		r = KErrInUse;

		goto done;

		}

	// Note: The above check is enough to ensure we have exclusive access

	// to this channels buffer and hardware resources because:

	// 1. The covert DFC can't run because we haven't started converting yet.

	// 2. No other request can come in because the channel only allows one

	//    client thread to use it. See DConvert1Channel::Request()

	// 3. The channel destructor can't be called whilst we are processing a request.

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

	if(!config.iBufferSize)

		config.iBufferSize = DefaultConfig.iBufferSize;

	if(!config.iSpeed)

		config.iSpeed = DefaultConfig.iSpeed;

	// Validate configuration

	if(config.iBufferSize<=0)

		{

		r = KErrArgument;

		goto done;

		}

	if(config.iSpeed<=0)

		{

		r = KErrArgument;

		goto done;

		}

	// Change the config

	iConfig = config; 

	{

	// Calculate buffer size

	TInt bufferSize = Kern::RoundToPageSize(config.iBufferSize);

	// Destroy old buffers

	iClientBuffer.Destroy();

	iInBuffer.Destroy();

	iOutBuffer.Destroy();

	// Setup iClientBuffer

	r = iClientBuffer.SetMaxSize(bufferSize);

	if(r!=KErrNone)

		goto done;

	// Create output buffer

	r = iOutBuffer.Create(bufferSize);

	if(r!=KErrNone)

		goto done;

	// Make handle for output buffer

	r = Kern::MakeHandleAndOpen(NULL, iOutBuffer.iChunk);

	if(r<0) // -ve value is error, +ve value is a handle

		goto done;

	info.iOutChunkHandle = r;

	r = KErrNone;

	// Create input buffer if requested

	if(iConfig.iCreateInputChunk)

		{

		r = iInBuffer.Create(bufferSize);

		if(r!=KErrNone)

			goto done;

		// Make handle for input buffer

		r = Kern::MakeHandleAndOpen(NULL, iInBuffer.iChunk);

		if(r<0) // -ve value is error, +ve value is a handle

			goto done;

		info.iInChunkHandle = r;

		r = KErrNone;

		// Set info about input buffer

		//

		// Note we don't set iInBufferPtr because this is the address in

		// client process which it must set for itself

		info.iInBufferOffset = iInBuffer.iChunkOffset;

		info.iInBufferSize = iInBuffer.iMaxSize;

		}

	}

done:

	// Cleanup if there was an error

	if(r!=KErrNone)

		{

		iClientBuffer.Destroy();

		iInBuffer.Destroy();

		iOutBuffer.Destroy();

		if(info.iOutChunkHandle)

			Kern::CloseHandle(NULL,info.iOutChunkHandle);

		if(info.iInChunkHandle)

			Kern::CloseHandle(NULL,info.iInChunkHandle);

		memclr(&info,sizeof(info));

		}

	NKern::ThreadLeaveCS();

	// Write chunk handles and other info back to client memory

	kumemput32(aBufferInfo,&info,sizeof(info));

	return r;

	}

//

// Methods for processing Convert requests

//

/**