// Copyright (c) 1997-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:
// e32test\pccd\d_medch.cpp
// This LDD allow simulation of media change on a peripheral bus controller.
// 
//

#include <kernel/kernel.h>
#include <drivers/pbus.h>
#include "d_medch.h"

const TInt KMajorVersionNumber=1;
const TInt KMinorVersionNumber=0;
const TInt KBuildVersionNumber=1;

_LIT(KDFCThreadName,"D_MEDCH_DFC_THREAD");
const TInt KMedChThreadPriority = 27;

class DLddFactoryMedCh : public DLogicalDevice
	{
public:
	DLddFactoryMedCh();
	virtual TInt Install();
	virtual void GetCaps(TDes8 &aDes) const;
	virtual TInt Create(DLogicalChannelBase*& aChannel);
	};

class DLddMedCh : public DLogicalChannel
	{
public:
	 DLddMedCh();
	~DLddMedCh();
protected:
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual void HandleMsg(class TMessageBase *);
private:
	TInt DoRequest(TInt aReqNo,TAny *a1,TAny *a2);
	TInt DoControl(TInt aFunction,TAny *a1,TAny *a2);
private:
	static void MsCBFunc(TAny* aPtr);
private:	
	DPBusSocket* iSocketP;
	DThread* iClient;
	TRequestStatus* iReqStat;
	TDynamicDfcQue* iDfcQ;
	
	NTimer iMsCallBack;
	TInt iMsInterval;

	DPBusSocket::TPBusSimulateMediaState iDelayedOperation;
	};

DECLARE_STANDARD_LDD()
	{
	return new DLddFactoryMedCh;
	}

DLddFactoryMedCh::DLddFactoryMedCh()
/**
 * Constructor
 */
	{

    iParseMask=KDeviceAllowUnit;
	iUnitsMask=0xffffffff;
	iVersion = TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber);
	}

TInt DLddFactoryMedCh::Install()
/**
 * Install the device driver.
 */
	{

    TPtrC name = _L("MedCh");
	return(SetName(&name));
	}

void DLddFactoryMedCh::GetCaps(TDes8 &aDes) const
/**
 * Return the media change LDD capabilities.
 */
	{

	TCapsMediaChangeV01 caps;
	caps.version = TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber);
    Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));
	}

TInt DLddFactoryMedCh::Create(DLogicalChannelBase*& aChannel)
/**
 * Create a channel on the device.
 */
	{

	aChannel = new DLddMedCh;
	return aChannel ? KErrNone : KErrNoMemory;
	}

DLddMedCh::DLddMedCh()
/**
 * Constructor
 */
	: iMsCallBack(MsCBFunc, this)
	{

	iClient = &Kern::CurrentThread();
	((DObject*)iClient)->Open();
	}

DLddMedCh::~DLddMedCh()
/**
 * Destructor
 */
	{ 
	if(iSocketP)
		(void)iSocketP->ControlIO(DPBusSocket::EControlMediaState, (TAny*)DPBusSocket::EPeriphBusMediaNormal, NULL);

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

	if (iDfcQ)
		iDfcQ->Destroy();
	}

TInt DLddMedCh::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/, const TVersion& aVer)
/**
 * Create channel.
 */
	{

	if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber), aVer))
		return(KErrNotSupported);

	//
	// Obtain the requested socket (as specified by the opened logical unit)
	//
	iSocketP = DPBusSocket::SocketFromId(aUnit);
	if(iSocketP == NULL)
		return(KErrNoMemory);

	if (!iDfcQ)
 			{
 			TInt r = Kern::DynamicDfcQCreate(iDfcQ, KMedChThreadPriority, KDFCThreadName);
			if (r != KErrNone)
 				return r;
#ifdef CPU_AFFINITY_ANY
			NKern::ThreadSetCpuAffinity((NThread*)(iDfcQ->iThread), KCpuAffinityAny);			
#endif

			SetDfcQ(iDfcQ);
 			}	

	iMsgQ.Receive();
	
    return KErrNone;
	}

void DLddMedCh::HandleMsg(TMessageBase* aMsg)
/**
 * Message Handler
 */
    {

    TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt id=m.iValue;
    
	if (id == (TInt)ECloseMsg)
		{
		iMsCallBack.Cancel();
		(void)iSocketP->ControlIO(DPBusSocket::EControlMediaState, (TAny*)DPBusSocket::EPeriphBusMediaNormal, NULL);
		m.Complete(KErrNone, EFalse);
		return;
		}
    else if (id == KMaxTInt)
		{
		// DoCancel
		m.Complete(KErrNone, ETrue);
		return;
		}

    if (id < 0)
		{
		// DoRequest
		TRequestStatus* pS = (TRequestStatus*)m.Ptr0();
		iReqStat = pS;
		TInt r = DoRequest(~id, m.Ptr1(), m.Ptr2());
		if (r != KErrNone)
	    	Kern::RequestComplete(iClient, pS, r);
		m.Complete(KErrNone, ETrue);
		}
    else
		{
		// DoControl
		TInt r = DoControl(id, m.Ptr0(), m.Ptr1());
		if(r != KErrCompletion)
			{
			m.Complete(r, ETrue);
			}
		}
	}

TInt DLddMedCh::DoRequest(TInt aFunction, TAny* a1, TAny* a2)
/**
 * Asynchronous requests
 */
	{

	TInt err = KErrNotSupported;
	
	switch (aFunction)
		{
		case RMedCh::EDelayedDoorOpen:
			{
			const TInt KMsInterval = (TInt)a1;
			iDelayedOperation = DPBusSocket::EPeriphBusDoorOpen;
			err = iMsCallBack.OneShot(NKern::TimerTicks(KMsInterval), ETrue);
			break;
			}
		
		case RMedCh::EDelayedDoorClose:
			{
			const TInt KMsInterval = (TInt)a1;
			const TBool KMediaPresent = (TBool)a2;
			iDelayedOperation = KMediaPresent ? DPBusSocket::EPeriphBusMediaPresent : DPBusSocket::EPeriphBusMediaRemoved;
			err = iMsCallBack.OneShot(NKern::TimerTicks(KMsInterval), ETrue);
			break;
			}
				
		default:
			{
			err = KErrNotSupported;
			break;
			}
		}
	
	return err;
	}

TInt DLddMedCh::DoControl(TInt aFunction,TAny* a1, TAny* /*a2*/)
/**
 * Synchronous requests
 */
	{

	TInt err = KErrNotSupported;
	
	switch (aFunction)
		{
		case RMedCh::EDoorOpen:
			{
			err = iSocketP->ControlIO(DPBusSocket::EControlMediaState, (TAny*)DPBusSocket::EPeriphBusDoorOpen, NULL);
			break;
			}

		case RMedCh::EDoorClose:
			{
			const TBool KMediaPresent = (TBool)a1;

			err = iSocketP->ControlIO(DPBusSocket::EControlMediaState, 
									  (TAny*)(KMediaPresent ? DPBusSocket::EPeriphBusMediaPresent : DPBusSocket::EPeriphBusMediaRemoved),
									  NULL);
			break;
			}

		case RMedCh::EDoorNormal:
			{
			err = iSocketP->ControlIO(DPBusSocket::EControlMediaState, (TAny*)DPBusSocket::EPeriphBusMediaNormal, NULL);
			break;
			}

		case RMedCh::EDoubleDoorOpen:
			{
			err = iSocketP->ControlIO(DPBusSocket::EControlMediaState, (TAny*)DPBusSocket::EPeriphBusMediaDoubleDoorOpen, NULL);
			break;
			}

		default:
			{
			err = KErrNotSupported;
			break;
			}
		}
	
	return err;
	}

void DLddMedCh::MsCBFunc(TAny* aPtr)
/**
 * Delayed Open/Close timer callback
 */
	{
	DLddMedCh& mcldd=*(DLddMedCh*)aPtr;
	TInt err = mcldd.iSocketP->ControlIO(DPBusSocket::EControlMediaState, (TAny*)mcldd.iDelayedOperation, NULL);
   	Kern::RequestComplete(mcldd.iClient, mcldd.iReqStat, err);
	}