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

/**
 @file Example Pysical Device Driver
 @publishedPartner
 @released
*/

#include <kernel/kern_priv.h>
#include "driver1.h"
#include "driver1_dev.h"

// Name for PDD, must match LDD name with a '.' and distinguishing name appended
_LIT(KDriver1PddName,"DRIVER1.template");


class DDriver1Device : public DDriver1
	{
public:
	DDriver1Device(DDevice1PddFactory* aFactory);
	~DDriver1Device();
	TInt DoCreate();
	// Inherited from DDriver1. These called by the LDD.
	virtual TInt BufferSize() const;
	virtual TInt Speed() const;
	virtual TInt SetSpeed(TInt aSpeed);
	virtual TInt SendData(const TDesC8& aData);
	virtual void SendDataCancel();
	virtual TInt ReceiveData(TDes8& aBuffer);
	virtual void ReceiveDataCancel();
private:
	static void SendDataTimerCallback(TAny* aPtr);
	void SendDataCallback();
	static void ReceiveDataTimerCallback(TAny* aPtr);
	void ReceiveDataCallback();
private:
	DDevice1PddFactory* iFactory;
	TInt iSpeed;
	NTimer iSendDataTimer;
	NTimer iReceiveDataTimer;
	TBuf8<256> iBuffer;
	TDes8* iReceiveBuffer;
	};



//
// DDevice1PddFactory
//

const TInt KDriver1ThreadPriority = 27;
_LIT(KDriver1Thread,"Driver1Thread");

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

DDevice1PddFactory::DDevice1PddFactory()
	{
	// Set version number for this device
	iVersion=RDriver1::VersionRequired();
	}

/**
  Second stage constructor for DPhysicalDevice derived objects.
  This must at least set a name for the driver object.

  @return KErrNone or standard error code.
*/
TInt DDevice1PddFactory::Install()
	{
	// Allocate a kernel thread to run the DFC 
	TInt r = Kern::DynamicDfcQCreate(iDfcQ, KDriver1ThreadPriority, KDriver1Thread);
	if (r == KErrNone)
		{ 
		r = SetName(&KDriver1PddName);
		} 	
	return r;
	}

/**
  Returns the drivers capabilities. This is not used by the Symbian OS device driver framework
  but may be useful for the LDD to use.

  @param aDes Descriptor to write capabilities information into
*/
void DDevice1PddFactory::GetCaps(TDes8& aDes) const
	{
	// Create a capabilities object
	DDriver1::TCaps caps;
	caps.iVersion = iVersion;
	// Zero the buffer
	TInt maxLen = aDes.MaxLength();
	aDes.FillZ(maxLen);
	// Copy cpabilities
	TInt size=sizeof(caps);
	if(size>maxLen)
		size=maxLen;
	aDes.Copy((TUint8*)&caps,size);
	}

/**
  Called by the kernel's device driver framework to create a Physical 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 Physical Channel
  @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 or standard error code.
*/
TInt DDevice1PddFactory::Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)
	{
	// Ignore the parameters we aren't interested in...
	(void)aUnit;
	(void)aInfo;
	(void)aVer;

	// Create a new physical channel
	DDriver1Device* device=new DDriver1Device(this);
	aChannel=device;
	if (!device)
		return KErrNoMemory;
	return device->DoCreate();
	}

/**
  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 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 number of the Logical Channel which will use this Physical Channel 

  @return KErrNone or standard error code.
*/
TInt DDevice1PddFactory::Validate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)
	{
	// Check version numbers
	if ((!Kern::QueryVersionSupported(iVersion,aVer)) || (!Kern::QueryVersionSupported(aVer,TVersion(EMinimumLddMajorVersion,EMinimumLddMinorVersion,EMinimumLddBuild))))
		return KErrNotSupported;

	// We don't support units
    if (aUnit != -1)
        return KErrNotSupported;

	// Ignore extra info, (this could be used for validation purposes)
	// Note, aInof is a pointer to a descriptor in user memory, therefore safe methods should
	// be used for reading its contents. E.g. using Kern::KUDesGet()
	(void)aInfo;

	// OK
	return KErrNone;
	}

/**
  Destructor
*/
DDevice1PddFactory::~DDevice1PddFactory()
	{
	if (iDfcQ)
		iDfcQ->Destroy();
	}

//
// DDriver1Device
//

DDriver1Device::DDriver1Device(DDevice1PddFactory* aFactory)
	:	iFactory(aFactory),
		iSpeed(100000),  // 100000us (100ms) per byte
		iSendDataTimer(SendDataTimerCallback,this),
		iReceiveDataTimer(ReceiveDataTimerCallback,this)
	{
	}

DDriver1Device::~DDriver1Device()
	{
	// Driver no longer using hardware resources
	__e32_atomic_add_ord32(&iFactory->iHardwareInUse, TUint32(-1));
	}

TInt DDriver1Device::DoCreate()
	{
	// Claim the hardware resources by incrementing iHardwareInUse.
	// Must do this before any other failure can happen in this function so that
	// the destructor can safely decrement iHardwareInUse.
	//
	// This method of ensuring hardware is only in use by one driver at a time
	// wouldn't be needed if the driver claimed real hardware resources which
	// could only be used once. E.g. binding to an interrupt.
	if (__e32_atomic_add_ord32(&iFactory->iHardwareInUse, 1))
		return KErrInUse;

	// Other setup goes here

	return KErrNone;
	}

TInt DDriver1Device::BufferSize() const
	{
	return iBuffer.MaxSize();
	}

TInt DDriver1Device::Speed() const
	{
	return iSpeed;
	}

TInt DDriver1Device::SetSpeed(TInt aSpeed)
	{
	if(aSpeed<=0)
		return KErrArgument;
	iSpeed = aSpeed;
	return KErrNone;
	}

TInt DDriver1Device::SendData(const TDesC8& aData)
	{
	// Save the last part of the data to 'send', we will pretend to 'receive' this later
	iBuffer=aData.Right(iBuffer.MaxSize());
	// Pretend to send the data by waiting for iSpeed micro-seconds per byte...
	iSendDataTimer.OneShot(aData.Size()*iSpeed/NKern::TickPeriod());

	return KErrNone;
	}

void DDriver1Device::SendDataCancel()
	{
	// Stop the timer we were using to pretend we were processing the send
	iSendDataTimer.Cancel();
	}

void DDriver1Device::SendDataTimerCallback(TAny* aPtr)
	{
	// Just forward callback to non-static callback function
	((DDriver1Device*)aPtr)->SendDataCallback();
	}

void DDriver1Device::SendDataCallback()
	{
	// Tell LDD we've done
	iLdd->SendDataComplete(KErrNone);
	}

TInt DDriver1Device::ReceiveData(TDes8& aBuffer)
	{
	// Save a pointer to the buffer we need to put the 'recevied' data in
	iReceiveBuffer=&aBuffer;
	// Pretend to receive the data by waiting for iSpeed micro-seconds per byte...
	iReceiveDataTimer.OneShot(iBuffer.Size()*iSpeed/NKern::TickPeriod());

	return KErrNone;
	}

void DDriver1Device::ReceiveDataCancel()
	{
	// Stop the timer we were using to pretend we were processing the receive
	iReceiveDataTimer.Cancel();
	}

void DDriver1Device::ReceiveDataTimerCallback(TAny* aPtr)
	{
	// Just forward callback to non-static callback function
	((DDriver1Device*)aPtr)->ReceiveDataCallback();
	}

void DDriver1Device::ReceiveDataCallback()
	{
	// Pretend the data we have received is that saved in iBuffer when we last did a send
	*iReceiveBuffer=iBuffer;
	// Tell LDD we've done
	iLdd->ReceiveDataComplete(KErrNone);
	}