// 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:

 // e32test\multimedia\d_mmcsc.cpp

 // The interface to a device driver which creates a shared chunk - for use with the multimedia driver tests.

 // This driver uses only generic kernel APIs and so need not be built from each variant.

 // 

 //

 /**

  @file

  @internalComponent

  @test

 */

 #include <kernel/kern_priv.h>

 #include "d_mmcsc.h"

 //#define __KTRACE_MMD(s) s;

 #define __KTRACE_MMD(s)

 class DMmCreateScFactory : public DLogicalDevice

 	{

 public:

 	DMmCreateScFactory();

 	virtual TInt Install();

 	virtual void GetCaps(TDes8 &aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 class DMmCreateSc : public DLogicalChannel

 	{

 public:

 	DMmCreateSc();

 	~DMmCreateSc();

 protected:

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

 	virtual void HandleMsg(TMessageBase* aMsg);

 	TInt DoControl(TInt aId, TAny* a1, TAny* a2);

 private:

 	TInt CreateChunk(TInt aNumBuffers,TInt aBufferSize);

 	void CloseChunk();

 	TInt MakeChunkHandle(DThread* aThread);

 private:

 	DThread* iClient;

 	TMmSharedChunkBufConfig iBufferConfig;

 	DChunk* iChunk;

 	};

 DECLARE_STANDARD_LDD()

 	{

 	return new DMmCreateScFactory;

 	}

 DMmCreateScFactory::DMmCreateScFactory()

 	{

 	// Set version number for this device

 	iVersion=TVersion(0,1,1);

 	// Indicate we do support units or a PDD

 	iParseMask=0;

 	}

 TInt DMmCreateScFactory::Install()

 	{

 	return(SetName(&KDevMmCScName));

 	}

 void DMmCreateScFactory::GetCaps(TDes8& aDes) const

 	{

 	// Create a capabilities object

 	TCapsMmCScV01 caps;

 	caps.iVersion=iVersion;

 	// Write it back to user memory

 	Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));

 	}

 TInt DMmCreateScFactory::Create(DLogicalChannelBase*& aChannel)

 	{

 	aChannel=new DMmCreateSc;

 	if (!aChannel)

 		return(KErrNoMemory);

 	return(KErrNone);

 	}

 DMmCreateSc::DMmCreateSc()

 	{

 //	iChunk=NULL;

 	iClient=&Kern::CurrentThread();

 	((DObject*)iClient)->Open();

 	}

 DMmCreateSc::~DMmCreateSc()

 	{

 	CloseChunk();

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

 	}

 TInt DMmCreateSc::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& /*aVer*/)

 	{

 	__KTRACE_MMD(Kern::Printf("DMmCreateSc:DoCreate"));

 	SetDfcQ(Kern::DfcQue0());

 	iMsgQ.Receive();

 	TInt r;

 	r=CreateChunk(KMmCScNumBuffers,KMmCScBufSize);	// Contains two 150K buffers

 	return(r);

 	}

 void DMmCreateSc::HandleMsg(TMessageBase* aMsg)

 	{

 	TThreadMessage& m=*(TThreadMessage*)aMsg;

 	TInt id=m.iValue;

 	if (id==(TInt)ECloseMsg)

 		{

 		m.Complete(KErrNone, EFalse);

 		return;

 		}

 	else if (id==KMaxTInt)

 		{

 		m.Complete(KErrNone,ETrue);	// DoCancel

 		return;

 		}

 	if (id<0)

 		{

 		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();	// DoRequest

 		Kern::RequestComplete(iClient,pS,KErrNotSupported);

 		m.Complete(KErrNone,ETrue);

 		}

 	else

 		{

 		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());	// DoControl

 		m.Complete(r,ETrue);

 		}

 	}

 TInt DMmCreateSc::DoControl(TInt aId, TAny* a1, TAny* /*a2*/)

 	{

 	__KTRACE_MMD(Kern::Printf("DMmCreateSc:DoControl %x",aId));

 	TInt r=KErrNone;

 	switch (aId)

 		{

 		case RMmCreateSc::EGetChunkHandle:

 			{

 			r=MakeChunkHandle(iClient);

 			break;

 			}

 		case RMmCreateSc::EGetBufInfo:

 			{

 			TPtrC8 ptr((const TUint8*)&iBufferConfig,sizeof(iBufferConfig));

 			r=Kern::ThreadDesWrite(iClient,a1,ptr,0,KTruncateToMaxLength,NULL);

 			break;

 			}

 		default:

 			r=KErrNotSupported;

 		}

 	return(r);

 	}

 TInt DMmCreateSc::CreateChunk(TInt aNumBuffers,TInt aBufferSize)

 	{

 	TInt bufferSize=Kern::RoundToPageSize(aBufferSize);

 	TInt chunkSz=(aNumBuffers*bufferSize);

 	__KTRACE_MMD(Kern::Printf("DMmCreateSc:CreateChunk %d",chunkSz));

 	// Thread must be in critical section to create chunks

 	NKern::ThreadEnterCS();

 	// Create the shared chunk.

 	TChunkCreateInfo info;

 	info.iType = TChunkCreateInfo::ESharedKernelMultiple;

 	info.iMaxSize = chunkSz;

 #if !defined(__WINS__)

 	info.iMapAttr=EMapAttrFullyBlocking;	// No caching

 #else

 	info.iMapAttr=0;

 #endif

 	info.iOwnsMemory = ETrue; 				// Using RAM pages

 	info.iDestroyedDfc = NULL;				// No chunk destroy DFC

 	DChunk* chunk;

 	TLinAddr chunkKernelAddr;

 	TUint32 mapAttr;

 	TInt r = Kern::ChunkCreate(info,chunk,chunkKernelAddr,mapAttr);

 	if (r!=KErrNone)

 		{

 		NKern::ThreadLeaveCS();

 		return(r);

 		}

 	// Map the three buffers into the chunk - each containing	physically contiguous RAM pages.

 	TInt bufOffset=0;

 	TUint32 pa;

 	r=Kern::ChunkCommitContiguous(chunk,bufOffset,bufferSize,pa);

 	if (r==KErrNone)

 		{

 		bufOffset+=bufferSize;

 		r=Kern::ChunkCommitContiguous(chunk,bufOffset,bufferSize,pa);

 		}

 	if (r==KErrNone)

 		{

 		bufOffset+=bufferSize;

 		r=Kern::ChunkCommitContiguous(chunk,bufOffset,bufferSize,pa);

 		}

 	if (r!=KErrNone)

 		Kern::ChunkClose(chunk); // Commit failed - tidy-up.

 	else

 		iChunk=chunk;

 	NKern::ThreadLeaveCS();

 	// Update our buffer info. structure to reflect the chunk we have just created.

 	iBufferConfig.iNumBuffers=aNumBuffers;

 	iBufferConfig.iBufferSizeInBytes=aBufferSize;

 	iBufferConfig.iFlags|=KScFlagBufOffsetListInUse;

 	iBufferConfig.iSpec[0].iBufferOffset=0;

 	iBufferConfig.iSpec[0].iBufferId=0;

 	iBufferConfig.iSpec[1].iBufferOffset=bufferSize;

 	iBufferConfig.iSpec[1].iBufferId=1;

 	__KTRACE_MMD(Kern::Printf("ChunkCommit %d",r));

 	return(r);

 	}

 void DMmCreateSc::CloseChunk()

 	{

 	__KTRACE_MMD(Kern::Printf("DMmCreateSc:CloseChunk"));

 	// Thread must be in critical section to close a chunk

 	NKern::ThreadEnterCS();

 	// Close chunk

 	if (iChunk)

 		Kern::ChunkClose(iChunk);

 	// Can leave critical section now

 	NKern::ThreadLeaveCS();

 	}

 TInt DMmCreateSc::MakeChunkHandle(DThread* aThread)

 	{

 	TInt r;

 	// Thread must be in critical section to make a handle

 	NKern::ThreadEnterCS();

 	if (iChunk)

 		r=Kern::MakeHandleAndOpen(aThread,iChunk);

 	else

 		r=KErrNotFound;

 	NKern::ThreadLeaveCS();

 	__KTRACE_MMD(Kern::Printf("DMmCreateSc:MakeChunkHandle %x %d",aThread,r));

 	return(r);

 	}