diff -r 000000000000 -r a41df078684a kerneltest/e32test/examples/convert1/convert1_ldd.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/examples/convert1/convert1_ldd.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,982 @@
+// 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
+//
+
+/**
+  Process Convert request where the source data is specified by a descriptor
+*/
+void DConvert1Channel::ConvertDes(const TDesC8* aSrc,TRequestStatus* aRequestStatus)
+	{
+	TInt r;
+
+	// Get descriptor info
+	TInt len;
+	TInt maxLen;
+	TAny* uptr = (TAny*)Kern::KUDesInfo(*aSrc,len,maxLen);
+
+	// Check there isn't an outstanding request
+	if(iConvertRequestStatus)
+		Kern::ThreadKill(NULL,EExitPanic,ERequestAlreadyPending,KConvert1PanicCategory);
+
+	// Check output buffer has been created
+	if(!iOutBuffer.iChunk)
+		{
+		r = KErrNotReady;
+		goto done;
+		}
+
+	// Check chunk has been created (TConfig::iCreateInputChunk True when SetConfig was called)
+	if(!iInBuffer.iChunk)
+		{
+		r = KErrNotSupported;
+		goto done;
+		}
+
+	// See if client data is in a shared chunk
+	r = iClientBuffer.Open(uptr,len);
+	if(r==KErrNone)
+		iSource = &iClientBuffer; // use iClientBuffer as input buffer
+	else
+		{
+		// Copy data from client descriptor into our iInBuffer
+		r = iInBuffer.Copy(uptr,len);
+		if(r==KErrNone)
+			iSource = &iInBuffer; // use iInBuffer as input buffer
+		}
+
+	// Start convert if no error
+	if(r==KErrNone)
+		{
+		iConvertRequestStatus = aRequestStatus;
+		DoConvertStart(0,len);
+		}
+done:
+	// Complete request if there was an error
+	if (r!=KErrNone)
+		Kern::RequestComplete(&Kern::CurrentThread(),aRequestStatus,r);
+	}
+
+/**
+  Process Convert request where the source data is specified by a chunk
+*/
+void DConvert1Channel::ConvertChunk(const RConvert1::TConvertArgs* aSrcArgs,TRequestStatus* aRequestStatus)
+	{
+	TInt r;
+
+	// Check there isn't an outstanding request
+	if(iConvertRequestStatus)
+		Kern::ThreadKill(NULL,EExitPanic,ERequestAlreadyPending,KConvert1PanicCategory);
+
+	// Check output buffer has been created
+	if(!iOutBuffer.iChunk)
+		{
+		r = KErrNotReady;
+		goto done;
+		}
+
+	// Unpackage arguments
+	RConvert1::TConvertArgs args;
+	kumemget32(&args,aSrcArgs,sizeof(args));
+
+	// Make buffer by opening chunk
+	r=iClientBuffer.Open(args.iChunkHandle,args.iOffset,args.iSize);
+
+	// Start convert if no error
+	if(r==KErrNone)
+		{
+		iSource = &iClientBuffer;
+		iConvertRequestStatus = aRequestStatus;
+		DoConvertStart(0,args.iSize);
+		}
+done:
+	// Complete request if there was an error
+	if (r!=KErrNone)
+		Kern::RequestComplete(&Kern::CurrentThread(),aRequestStatus,r);
+	}
+
+/**
+  Process Convert request where the source data is contained in the input chunk
+*/
+void DConvert1Channel::ConvertInChunk(TInt aSize,TRequestStatus* aRequestStatus)
+	{
+	TInt r;
+
+	// Check there isn't an outstanding request
+	if(iConvertRequestStatus)
+		Kern::ThreadKill(NULL,EExitPanic,ERequestAlreadyPending,KConvert1PanicCategory);
+
+	// Check output buffer has been created
+	if(!iOutBuffer.iChunk)
+		{
+		r = KErrNotReady;
+		goto done;
+		}
+
+	// Check chunk has been created (TConfig::iCreateInputChunk True when SetConfig was called)
+	if(!iInBuffer.iChunk)
+		{
+		r = KErrNotSupported;
+		goto done;
+		}
+
+	// Check size of data really fits within chunk
+	if(TUint(aSize)>=TUint(iInBuffer.iMaxSize))
+		{
+		r = KErrArgument;
+		goto done;
+		}
+
+	// Start the convert 
+	iSource = &iInBuffer;
+	iConvertRequestStatus = aRequestStatus;
+	DoConvertStart(iInBuffer.iChunkOffset,aSize);
+	r = KErrNone;
+
+done:
+	// Complete request if there was an error
+	if (r!=KErrNone)
+		Kern::RequestComplete(&Kern::CurrentThread(),aRequestStatus,r);
+	}
+
+/**
+  Signal ConvertData request completed
+*/
+void DConvert1Channel::ConvertCancel()
+	{
+	// Tell hardware to stop
+	DoConvertCancel();
+
+	// Complete client request
+	NKern::ThreadEnterCS();
+	ConvertComplete(KErrCancel);
+	NKern::ThreadLeaveCS();
+	}
+
+/**
+  DFC callback called after data has been converted.
+*/
+void DConvert1Channel::ConvertDfcTrampoline(TAny* aSelf)
+	{
+	// Just call non-static method
+	((DConvert1Channel*)aSelf)->ConvertDfc();
+	}
+
+/**
+  DFC callback called after data has been converted
+*/
+void DConvert1Channel::ConvertDfc()
+	{
+	TRACE(Kern::Printf(">DConvert1Channel::ConvertDfc\n");)
+
+	// The result value will be the chunk offset of the data we've converted
+	TInt result = iOutBuffer.iChunkOffset;
+	ConvertComplete(result);
+
+	TRACE(Kern::Printf("<DConvert1Channel::ConvertDfc\n");)
+	}
+
+/**
+  Complete a Convert request
+  @pre In thread critical section or DFC thread
+*/
+void DConvert1Channel::ConvertComplete(TInt aResult)
+	{
+	// Hold mutex to avoid concurrency
+	NKern::FMWait(&iConvertMutex);
+
+	// Claim the client request
+	TRequestStatus* status = iConvertRequestStatus;
+	iConvertRequestStatus = NULL;
+
+	// Claim chunk handle if we need to close it
+	DChunk* chunk = NULL;
+	if(status && iSource==&iClientBuffer)
+		{
+		chunk = iClientBuffer.iChunk;
+		iClientBuffer.iChunk = NULL;
+		}
+
+	// Clear iSource to help show up bugs
+	iSource = NULL;
+
+	// Can release mutex now we own the pointers
+	NKern::FMSignal(&iConvertMutex);
+
+	// Must be in a critical section so we can't die whilst owning 'chunk' and 'status'
+	__ASSERT_CRITICAL;
+
+	// Close chunk if required
+	if(chunk)
+		Kern::ChunkClose(chunk);
+
+	// Complete the request
+	if(status)
+		Kern::RequestComplete(iClient,status,aResult);
+	}
+
+
+//
+// DChunkBuffer
+//
+
+/**
+  Constructor
+*/
+DChunkBuffer::DChunkBuffer()
+	: iChunk(NULL), iPhysicalPages(NULL)
+	{
+	}
+
+/**
+  Create chunk and commit memory for buffer
+*/
+TInt DChunkBuffer::Create(TInt aBufferSize)
+	{
+	// Initialise member data for the size of buffer we want
+	TInt r=SetMaxSize(aBufferSize);
+	if(r!=KErrNone)
+		return r;
+
+	// Create chunk
+	__NK_ASSERT_DEBUG(!iChunk);
+	TChunkCreateInfo info;
+	info.iType = TChunkCreateInfo::ESharedKernelMultiple;
+	info.iMaxSize = (TInt)aBufferSize;
+#ifndef __WINS__
+	info.iMapAttr = EMapAttrCachedMax;
+#else
+	info.iMapAttr = 0;
+#endif
+	info.iOwnsMemory = ETrue;
+	r = Kern::ChunkCreate(info,iChunk,iChunkBase,iChunkMapAttr);
+
+	if(r==KErrNone)
+		{
+		// Commit memory to chunk
+		iChunkOffset = 0;
+		r = Kern::ChunkCommit(iChunk,iChunkOffset,Kern::RoundToPageSize(iMaxSize));
+		if(r==KErrNone)
+			{
+			// Setup physical address info for memory in the buffer
+			r = SetPhysicalAddresses(iMaxSize);
+			}
+		}
+
+	if(r!=KErrNone)
+		Destroy(); // Cleanup
+
+	return r;
+	}
+
+/**
+  Free all resources
+*/
+void DChunkBuffer::Destroy()
+	{
+	delete [] iPhysicalPages;
+	iPhysicalPages = 0;
+	Close();
+	}
+
+/**
+  Destructor
+*/
+DChunkBuffer::~DChunkBuffer()
+	{
+	Destroy();
+	}
+
+/**
+  Set maximum size for buffer.
+  (Allocates heap resources for this max size.)
+*/
+TInt DChunkBuffer::SetMaxSize(TInt aMaxSize)
+	{
+	// Create array to hold address of physical pages
+	__NK_ASSERT_DEBUG(!iPhysicalPages);
+	iPhysicalPages = new TPhysAddr[Kern::RoundToPageSize(aMaxSize)/Kern::RoundToPageSize(1)+1];
+	if(!iPhysicalPages)
+		return KErrNoMemory;
+
+	iMaxSize = aMaxSize;
+	return KErrNone;
+	}
+
+/**
+  Open a shared chunk given an user address and siae
+*/
+TInt DChunkBuffer::Open(TAny* aAddress, TInt aSize, TBool aWrite)
+	{
+	TInt r;
+
+	// Check size
+	if(aSize>iMaxSize)
+		return KErrTooBig;
+
+	NKern::ThreadEnterCS();
+
+	// Attempt to open chunk
+	iChunk = Kern::OpenSharedChunk(NULL,aAddress,aWrite,iChunkOffset);
+	if(!iChunk)
+		r = KErrArgument;
+	else
+		{
+		// Get physical addresses
+		r = SetPhysicalAddresses(aSize);
+		if(r!=KErrNone)
+			Close();
+		}
+
+	NKern::ThreadLeaveCS();
+
+	return r;
+	}
+
+/**
+  Open a specified shared chunk
+*/
+TInt DChunkBuffer::Open(TInt aChunkHandle, TInt aOffset, TInt aSize, TBool aWrite)
+	{
+	TInt r;
+
+	// Check size
+	if(aSize>iMaxSize)
+		return KErrTooBig;
+	iChunkOffset = aOffset;
+
+	NKern::ThreadEnterCS();
+
+	// Attempt to open chunk
+	iChunk = Kern::OpenSharedChunk(NULL,aChunkHandle,aWrite);
+	if(!iChunk)
+		r = KErrArgument;
+	else
+		{
+		// Get physical addresses
+		r = SetPhysicalAddresses(aSize);
+		if(r!=KErrNone)
+			Close();
+		}
+
+	NKern::ThreadLeaveCS();
+
+	return r;
+	}
+
+/**
+  Close chunk
+*/
+void DChunkBuffer::Close()
+	{
+	__ASSERT_CRITICAL;
+	if(iChunk)
+		{
+		Kern::ChunkClose(iChunk);
+		iChunk = NULL;
+		}
+	}
+
+/**
+  Fill buffer by copying data from the given user address
+*/
+TInt DChunkBuffer::Copy(TAny* aAddress, TInt aSize)
+	{
+	// Check size
+	if(aSize>iMaxSize)
+		return KErrTooBig;
+
+	// Copy data
+	kumemget((TAny*)(iChunkBase+iChunkOffset),aAddress,aSize);
+
+	return KErrNone;
+	}
+
+/**
+  Setup physical address info for memory in the buffer
+*/
+TInt DChunkBuffer::SetPhysicalAddresses(TInt aSize)
+	{
+	// Assert that the iPhysicalPages array already allocated will be big enough
+	__NK_ASSERT_DEBUG(aSize<=iMaxSize);
+
+	// Get physical addresses
+	TLinAddr kaddr;
+	TInt r=Kern::ChunkPhysicalAddress(iChunk,iChunkOffset,aSize,kaddr,iChunkMapAttr,iPhysicalAddress,iPhysicalPages);
+	// r = 0 or 1 on success. (1 meaning the physical pages are not contiguous)
+	if(r>=0) 
+		{
+		iChunkBase = kaddr-iChunkOffset; // Calculate start of chunk in kernel process address space
+		r = KErrNone;
+		}
+	return r;
+	}
+
+//
+// Program converter hardware
+//
+
+/**
+  Initialise hardware to start converting data.
+  Input data is in iSource.
+  Output data to be placed in iOutBuffer.
+*/
+void DConvert1Channel::DoConvertStart(TInt aOffset,TInt aSize)
+	{
+	// For this example test...
+	
+	TRACE(Kern::Printf("DConvert1Channel::DoConvertStart\n");)
+
+	// 'Convert' data by xoring with 1
+	TUint8* src = (TUint8*)iSource->iChunkBase+iSource->iChunkOffset+aOffset;
+	TUint8* end = src+aSize;
+	TUint8* dst = (TUint8*)iOutBuffer.iChunkBase+iOutBuffer.iChunkOffset;
+	while(src<end)
+		*dst++ = TUint8(*src++^1);
+
+	// Start the timer
+	TInt ticks = TInt((TInt64)1000000*(TInt64)aSize/(TInt64)iConfig.iSpeed)
+					/NKern::TickPeriod();
+	if(ticks<1)
+		ticks = 1;
+#ifdef _DEBUG
+	TInt r=
+#endif
+		iConvertTimer.OneShot(ticks,ETrue);
+	__NK_ASSERT_DEBUG(r==KErrNone);
+	}
+
+/**
+  Tell hardware to stop converting.
+*/
+void DConvert1Channel::DoConvertCancel()
+	{
+	// For this example test...
+	
+	TRACE(Kern::Printf("DConvert1Channel::DoConvertCancel\n");)
+
+	// Cancel the timer
+	iConvertTimer.Cancel();
+	}