// Copyright (c) 1995-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\kernel\device.cpp

// 

//

#include <kernel/kern_priv.h>

#include <e32uid.h>

#include "execs.h"

_LIT(KDotStar,".*");

/********************************************

 * Logical device base class

 ********************************************/

/**	Base class destructor for DLogicalDevice

	This arranges for the code segment to be unloaded when the system next goes

	idle.

	@pre Calling thread must be in a critical section.

	@pre Interrupts must be enabled.

	@pre Kernel must be unlocked.

	@pre No fast mutex can be held.

	@pre Call in a thread context.

 */

EXPORT_C DLogicalDevice::~DLogicalDevice()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DLogicalDevice::~DLogicalDevice");	

	if (iCodeSeg)

		{

		__DEBUG_EVENT(EEventUnloadLdd, iCodeSeg);

		iCodeSeg->ScheduleKernelCleanup(EFalse);

		}

	}

/**	Checks if a specific interface version is supported.

	Default implementation.

	All old versions are supported.

	@param	aVer	The requested interface version

	@return	TRUE if supported, FALSE if not.

 */

EXPORT_C TBool DLogicalDevice::QueryVersionSupported(const TVersion& aVer) const

	{

	return Kern::QueryVersionSupported(iVersion,aVer);

	}

/**	Checks if a specified unit number and additional info and a specific PDD is supported.

	Default implementation.

	@param	aUnit	The requested unit number

	@param	aPdd	The requested PDD name

	@param	aInfo	The additional information

	@return	TRUE if supported, FALSE if not.

 */

EXPORT_C TBool DLogicalDevice::IsAvailable(TInt /*aUnit*/, const TDesC* /*aPdd*/, const TDesC8* /*aInfo*/) const

	{

	return ETrue;

	}

EXPORT_C TInt Kern::InstallLogicalDevice(DLogicalDevice* aDevice)

//

// Must be called in a critical section

//

	{

	aDevice->SetProtection(DObject::EGlobal);

	aDevice->iObjectFlags |= DObject::EObjectExtraReference;

	TInt r=aDevice->Install();

	if (r==KErrNone)

		r=K::AddObject(aDevice,ELogicalDevice); // Mustn't access aDevice after a successful AddObject!

	return r;

	}

TInt DoLogicalDeviceLoad(DCodeSeg* aSeg)

	{

	TLogicalDeviceNew f=(TLogicalDeviceNew)aSeg->Lookup(1);

	if (!f)

		return KErrGeneral;

	// Dispatch event before calling CreateLogicalDevice() so the latter can be debugged.

	__DEBUG_EVENT(EEventLoadLdd, aSeg);

	DLogicalDevice *pD=(*f)();

	TInt r=KErrNoMemory;

	if (pD)

		{

		pD->iCodeSeg = aSeg;

		r=Kern::InstallLogicalDevice(pD);

		if (r==KErrNone)

			{

			// workaround to try and prevent codeseg destruction from happening whilst

			// object destuctor code if it is still executing...

			pD->iObjectFlags |= DObject::EObjectDeferKernelCodesegCleanup;

			}

		else

			{

			// Claim back ownership code seg and close device

			pD->iCodeSeg=0;

			pD->Close(NULL);

			}

		}

	__COND_DEBUG_EVENT(r!=KErrNone, EEventUnloadLdd, aSeg);

	return r;

	}

EXPORT_C TInt Kern::InstallPhysicalDevice(DPhysicalDevice* aDevice)

//

// Must be called in a critical section

//

	{

	aDevice->iObjectFlags |= DObject::EObjectExtraReference;

	TInt r=aDevice->Install();

	if (r==KErrNone)

		r=K::AddObject(aDevice,EPhysicalDevice); // Mustn't access aDevice after a successful AddObject!

	return r;

	}

TInt DoPhysicalDeviceLoad(DCodeSeg* aSeg)

	{

	TPhysicalDeviceNew f=(TPhysicalDeviceNew)aSeg->Lookup(1);

	if (!f)

		return KErrGeneral;

	// Dispatch event before calling CreatePhysicalDevice() so the latter can be debugged.

	__DEBUG_EVENT(EEventLoadPdd, aSeg);

	DPhysicalDevice *pD=(*f)();

	TInt r=KErrNoMemory;

	if (pD)

		{

		pD->iCodeSeg=aSeg;

		r=Kern::InstallPhysicalDevice(pD);

		if (r==KErrNone)

			{

			// workaround to try and prevent codeseg destruction from happening whilst

			// object destuctor code if it is still executing...

			pD->iObjectFlags |= DObject::EObjectDeferKernelCodesegCleanup;

			}

		else

			{

			// Claim back ownership code seg and close device

			pD->iCodeSeg=0;

			pD->Close(NULL);

			}

		}

	__COND_DEBUG_EVENT(r!=KErrNone, EEventUnloadPdd, aSeg);

	return r;

	}

TInt ReopenDriver(TInt aDeviceType,DCodeSeg* aCodeSeg)

	{

	DObject* pClose = NULL;

	TInt objtype = aDeviceType ? EPhysicalDevice : ELogicalDevice;

	DObjectCon& oc = *K::Containers[objtype];

	oc.Wait();

	TInt c = oc.Count();

	TInt r = KErrNotFound;

	for (TInt i=0; i<c; i++)

		{

		DObject* pD = oc[i];

		DCodeSeg* pS = aDeviceType ? ((DPhysicalDevice*)pD)->iCodeSeg

								   : ((DLogicalDevice*)pD)->iCodeSeg;

		if(pS==aCodeSeg)

			{

			// Found the driver so...

			if(pD->Open()!=KErrNone)

				r = KErrDied;  // Failed to Open

			else

				{

				TUint oldFlags = __e32_atomic_ior_ord8(&pD->iObjectFlags, DObject::EObjectExtraReference);

				if(!(oldFlags&DObject::EObjectExtraReference))

					r = KErrNone;  // We succesfully added the 'extra reference'

				else

					{

					// The extra reference was already set.

					r = KErrAlreadyExists;

					pClose = pD;  // need to close again

					}

				}

			break;

			}

		}

	oc.Signal();

	if(pClose)

		pClose->Close(NULL);

	return r;

	}

TInt ExecHandler::DeviceLoad(TAny* aHandle, TInt aDeviceType)

//

// Install a logical or physical device driver

//

	{

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::DeviceLoad type %d",aDeviceType));

	DCodeSeg* pS=DCodeSeg::VerifyCallerAndHandle(aHandle);

	DProcess& kern=*K::TheKernelProcess;

	TUint32 uid2=aDeviceType ? KPhysicalDeviceDriverUidValue : KLogicalDeviceDriverUidValue;

	if (TUint32(pS->iUids.iUid[1].iUid)!=uid2)

		return KErrNotSupported;

	NKern::ThreadEnterCS();

	TInt r;

	// Attempt to reopen the 'extra reference' on the driver...

	r = ReopenDriver(aDeviceType,pS);

	if(r==KErrNotFound)

		{

		// Driver didn't exist, so try and load it...

		// See if Codeseg already exists in the kernel

		SCodeSegEntry find;

		find.iSeg=pS;

		find.iLib=NULL;

		TInt i;

		DCodeSeg::Wait();

		r=kern.iDynamicCode.FindInUnsignedKeyOrder(find,i);

		if(r==KErrNone)

			{

			// The Codeseg already exists but we didn't previousely find the driver.

			// This means that the driver must be in the process of destruction.

			// We can't do anything about this so return an error.

			DCodeSeg::Signal();

			r = KErrDied;

			}

		else

			{

			// Add Codeseg to kernel

			SDblQue cs_list;

			r=kern.AddCodeSeg(pS,NULL,cs_list);

			DCodeSeg::EmptyQueue(cs_list,0);

			DCodeSeg::Signal();

			if (r==KErrNone)

				{

				// Create the driver object

				if (aDeviceType)

					r=DoPhysicalDeviceLoad(pS);

				else

					r=DoLogicalDeviceLoad(pS);

				// If driver create failed, remove the Codeseg we added

				if (r!=KErrNone)

					pS->ScheduleKernelCleanup(ETrue);

				}

			}

		}

	NKern::ThreadLeaveCS();

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::DeviceLoad returns %d",r));

	return r;

	}

TInt ExecHandler::DeviceFree(const TDesC8& aName, TInt aDeviceType)

	{

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::DeviceFree type %d",aDeviceType));

	TKName devname;

	Kern::KUDesGet(devname, aName);

	__KTRACE_OPT(KDEVICE,Kern::Printf("Name %S",&devname));

	TInt r = Kern::ValidateName(devname);

	if (r<0)

		return r;

	TFindHandle h;

	TKName name;

	TInt objtype = aDeviceType ? EPhysicalDevice : ELogicalDevice;

	DObjectCon& oc = *K::Containers[objtype];

	NKern::ThreadEnterCS();

	oc.Wait();

	r = oc.FindByName(h, devname, name);

	if (r==KErrNone)

		{

		DObject* pO = oc.At(h);

		TUint oldFlags = __e32_atomic_and_ord8(&pO->iObjectFlags, (TUint8)~DObject::EObjectExtraReference);

		oc.Signal();

		r = KErrInUse;  // start of by assuming device will not deleted

		if (oldFlags&DObject::EObjectExtraReference)

			{

			DCodeSeg::DeferKernelCleanup(); // ensure device codeseg doen't get unloaded until after Close() returns

			if (pO->Close(NULL)&DObject::EObjectDeleted)

				r = KErrNone;  // We closed the 'extra reference' and the object was deleted

			DCodeSeg::EndDeferKernelCleanup();

			}

		}

	else

		{

		oc.Signal();

		r = KErrNone;  // Treat 'not found' as a successfull DeviceFree

		}

	NKern::ThreadLeaveCS();

	return r;

	}

void ExecHandler::LogicalDeviceGetCaps(DLogicalDevice* aDevice, TDes8& aDes)

	{

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::LogicalDeviceGetCaps %O",aDevice));

	aDevice->CheckedOpen();

	DThread& t=*TheCurrentThread;

	t.iTempObj=aDevice;

	NKern::UnlockSystem();

	Kern::InfoCopy(aDes,0,0); // intialise to empty - and will also safely panic if aDes is bad

	aDevice->GetCaps(aDes);

	NKern::ThreadEnterCS();

	t.iTempObj=NULL;

	aDevice->Close(NULL);

	NKern::ThreadLeaveCS();

	}

TBool ExecHandler::LogicalDeviceQueryVersionSupported(DLogicalDevice* aDevice, const TVersion& aVer)

	{

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::LogicalDeviceQueryVersionSupported %O",aDevice));

	aDevice->CheckedOpen();

	DThread& t=*TheCurrentThread;

	t.iTempObj=aDevice;

	NKern::UnlockSystem();

	TVersion v;

	kumemget32(&v,&aVer,sizeof(v));

	TBool r=aDevice->QueryVersionSupported(v);

	NKern::ThreadEnterCS();

	t.iTempObj=NULL;

	aDevice->Close(NULL);

	NKern::ThreadLeaveCS();

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::LogicalDeviceQueryVersionSupported ret %d",r));

	return r;

	}

TBool ExecHandler::LogicalDeviceIsAvailable(DLogicalDevice* aDevice, TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* aInfo)

	{

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::LogicalDeviceIsAvailable %O",aDevice));

	aDevice->CheckedOpen();

	DThread& t=*TheCurrentThread;

	t.iTempObj=aDevice;

	NKern::UnlockSystem();

	TBool r=aDevice->IsAvailable(aUnit,aPhysicalDevice,aInfo);

	NKern::ThreadEnterCS();

	t.iTempObj=NULL;

	aDevice->Close(NULL);

	NKern::ThreadLeaveCS();

	__KTRACE_OPT(KDEVICE,Kern::Printf("Exec::LogicalDeviceIsAvailable ret %d",r));

	return r;

	}

/********************************************

 * Physical device base class

 ********************************************/

/**	Base class destructor for DLogicalDevice.

	This arranges for the code segment to be unloaded when the system next goes

	idle.

	@pre Calling thread must be in a critical section.

	@pre No fast mutex can be held.

	@pre Kernel must be unlocked

	@pre Call in a thread context

	@pre interrupts enabled

 */

EXPORT_C DPhysicalDevice::~DPhysicalDevice()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DPhysicalDevice::~DPhysicalDevice");	

	if (iCodeSeg)

		{

		__DEBUG_EVENT(EEventUnloadPdd, iCodeSeg);

		iCodeSeg->ScheduleKernelCleanup(EFalse);

		}

	}

/**	Checks if a specific interface version is supported.

	Default implementation.

	All old versions are supported.

	@param	aVer	The requested interface version

	@return	TRUE if supported, FALSE if not.

 */

EXPORT_C TBool DPhysicalDevice::QueryVersionSupported(const TVersion& aVer) const

	{

	return Kern::QueryVersionSupported(iVersion,aVer);

	}

/**	Checks if a specified unit number and additional info is supported.

    Default implementation.

	@param	aUnit	The requested unit number

	@param	aInfo	The additional information

	@return	TRUE if supported, FALSE if not.

 */

EXPORT_C TBool DPhysicalDevice::IsAvailable(TInt /*aUnit*/, const TDesC8* /*aInfo*/) const

	{

	return ETrue;

	}

/** Gets additional device specific or device class specific information about

	this driver.

	Currently used only for driver priorities in conjunction with the

	RPhysicalDeviceArray class which is used to find media drivers.

	@param	aFunction	The piece of information being requested

	@param	a1			Arbitrary additional parameter(s)

	@return	The requested information.

	@see RPhysicalDeviceArray

 */

EXPORT_C TInt DPhysicalDevice::Info(TInt aFunction, TAny* /*a1*/)

	{

	if (aFunction==EPriority)

		return 0;

	return KErrNotSupported;

	}

// Utility for finding PDDs in priority order

/**	Constructor for physical device array.

 */

EXPORT_C RPhysicalDeviceArray::RPhysicalDeviceArray()

	: RArray<SPhysicalDeviceEntry>(8,_FOFF(SPhysicalDeviceEntry,iPriority))

	{}

/** Frees all resources held by this array.

	This closes any devices held in the array before freeing memory used by

	the array itself.

	@pre Call in a thread context.

	@pre Calling thread must be in a critical section.

	@pre No fast mutex can be held.

	@pre Kernel must be unlocked.

	@pre interrupts enabled

 */

EXPORT_C void RPhysicalDeviceArray::Close()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"RPhysicalDeviceArray::Close");	

	TInt i;

	TInt c=Count();

	for (i=0; i<c; i++)

		{

		SPhysicalDeviceEntry& e=operator[](i);

		Kern::SafeClose((DObject*&)e.iPhysicalDevice,NULL);

		}

	RArray<SPhysicalDeviceEntry>::Reset();

	}

/**	Populates the array with a list of PDDs meeting certain criteria.

	@param	aMatch	Descriptor which the PDD's name must match

	@param	aUnit	Unit number which the PDD must support

	@param	aInfo	Additional information about what the PDD must support

	@param	aVer	Interface version which the PDD must support

	@return	KErrNone, if at least one PDD matched the criteria.

	        KErrNotFound, if no PDD matched the criteria;

	        KErrNoMemory, if the array could not be expanded at some point.

	@pre Call in a thread context.

	@pre Calling thread must be in a critical section.

	@pre No fast mutex can be held.

	@pre Kernel must be unlocked.

	@pre interrupts enabled

	@post	The array is populated with pointers to DPhysicalDevice objects

			matching the requested criteria, along with the priorities of those

			PDDs. The pointers are reference counted. The array is sorted in

			ascending order of driver priority.

			If an OOM occurred the list will be empty.

 */

EXPORT_C TInt RPhysicalDeviceArray::GetDriverList(const TDesC& aMatch, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"RPhysicalDeviceArray::GetDriverList");	

	Reset();

	TInt r=KErrNone;

	DObjectCon& pdev=*K::Containers[EPhysicalDevice];

	pdev.Wait();

	TFindHandle h;

	TKName name;

	FOREVER

		{

		TInt s=pdev.FindByName(h,aMatch,name);

		if (s!=KErrNone)

			break;

		DPhysicalDevice* pD=(DPhysicalDevice*)pdev.At(h);

		s=pD->Open();

		if (s==KErrNone)

			{

			s=pD->Validate(aUnit,aInfo,aVer);

			if (s!=KErrNone)

				pD->Close(NULL);

			else

				{

				SPhysicalDeviceEntry e;

				e.iPriority=pD->Info(DPhysicalDevice::EPriority,NULL);

				e.iPhysicalDevice=pD;

				r=InsertInSignedKeyOrderAllowRepeats(e);

				if (r!=KErrNone)

					{

					// we are out of memory

					pD->Close(NULL);

					break;