1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\e32test\demandpaging\d_pagingexample_2_pre.cpp

    15 // Demand paging migration example device driver d_pagingexample_2_pre: a

    16 // DLogicalChannelBase-dervied driver, pre-migration

    17 // 

    18 //

    19 

    20 #include "d_pagingexample.h"

    21 #include <kernel/kernel.h>

    22 #include <kernel/kern_priv.h>

    23 

    24 const TInt KBufferSize = KMaxTransferSize;

    25 

    26 //

    27 // Logical channel

    28 //

    29 

    30 class DExampleChannel : public DLogicalChannelBase

    31 	{

    32 public:

    33 	typedef RPagingExample::TConfigData TConfigData;

    34 	typedef RPagingExample::TValueStruct TValueStruct;

    35 public:

    36 	DExampleChannel();

    37 	~DExampleChannel();

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

    39 	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);

    40 	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);

    41 	TInt DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2);

    42 	TInt DoCancel(TUint aMask);

    43 private:

    44  	TDfcQue* DfcQ();

    45 	void Shutdown();

    46 	void GetConfig(TConfigData&);

    47 	void SetConfig(const TConfigData&);

    48 	TInt StartNotify(TRequestStatus* aStatus);

    49 	TInt StartAsyncGetValue(TInt* aValue, TRequestStatus* aStatus);

    50 	TInt StartAsyncGetValue2(TInt* aValue1, TInt* aValue2, TRequestStatus* aStatus);

    51 	TInt StartRead(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus);

    52 	TInt StartReadDes(TDes8* aDesOut, TRequestStatus* aStatus);

    53 	TInt StartWrite(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus);

    54 	TInt StartWriteDes(const TDesC8* aDesIn, TRequestStatus* aStatus);

    55 	void ReceiveToReadBuffer();

    56 	void SendFromWriteBuffer();

    57 	static void CancelDfcFunc(TAny* aPtr);

    58 	static void AsyncGetValueCompleteDfcFunc(TAny* aPtr);

    59 	static void AsyncGetValue2CompleteDfcFunc(TAny* aPtr);

    60 	static void ReceiveCompleteDfcFunc(TAny* aPtr);

    61 	static void SendCompleteDfcFunc(TAny* aPtr);

    62 	void CompleteNotify();

    63 	void CompleteAsyncGetValue();

    64 	void CompleteAsyncGetValue2();

    65 	void CompleteRead();

    66 	void CompleteWrite();

    67 	void Cancel();

    68 private:

    69 	NFastMutex iLock;

    70 	TConfigData iConfig;

    71 	DThread* iClient;

    72 	TDfc iCancelDfc;

    73 	

    74 	// Notify

    75 	TRequestStatus* iNotifyStatus;

    76 	

    77 	// Async get value

    78 	TRequestStatus* iAsyncGetValueStatus;

    79 	TInt* iAsyncGetValueDest;

    80 	NTimer iAsyncGetValueTimer;

    81 	TDfc iAsyncGetValueDfc;

    82 

    83 	// Async get value 2

    84 	TRequestStatus* iAsyncGetValue2Status;

    85 	TInt* iAsyncGetValue2Dest1;

    86 	TInt* iAsyncGetValue2Dest2;

    87 	NTimer iAsyncGetValue2Timer;

    88 	TDfc iAsyncGetValue2Dfc;

    89 	

    90 	// Read

    91 	TRequestStatus* iReadStatus;

    92 	NTimer iReadTimer;

    93 	TAny* iReadDest;

    94 	TInt iReadLength;

    95 	TDes8* iReadDes;

    96 	TDfc iCompleteReadDfc;

    97 	

    98 	// Write

    99 	TRequestStatus* iWriteStatus;

   100 	NTimer iWriteTimer;

   101 	TAny* iWriteSrc;

   102 	TInt iWriteLength;

   103 	const TDesC8* iWriteDes;

   104 	TDfc iCompleteWriteDfc;

   105 	TUint8 iBuffer[KBufferSize];

   106 	};

   107 

   108 DExampleChannel::DExampleChannel() :

   109 	iCancelDfc(CancelDfcFunc, this, DfcQ(), 0),

   110 	iAsyncGetValueTimer(NULL, this),

   111 	iAsyncGetValueDfc(AsyncGetValueCompleteDfcFunc, this, DfcQ(), 0),

   112 	iAsyncGetValue2Timer(NULL, this),

   113 	iAsyncGetValue2Dfc(AsyncGetValue2CompleteDfcFunc, this, DfcQ(), 0),

   114 	iReadTimer(NULL, this),

   115 	iCompleteReadDfc(ReceiveCompleteDfcFunc, this, DfcQ(), 0),

   116 	iWriteTimer(NULL, this),

   117 	iCompleteWriteDfc(SendCompleteDfcFunc, this, DfcQ(), 0)

   118 	{

   119 	iClient = &Kern::CurrentThread();

   120 	iClient->Open();

   121 	}

   122 

   123 DExampleChannel::~DExampleChannel()

   124 	{

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

   126 	}

   127 

   128 TDfcQue* DExampleChannel::DfcQ()

   129 	{

   130 	return Kern::DfcQue0();

   131 	}

   132 

   133 TInt DExampleChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

   134 	{

   135 	return KErrNone;

   136 	}

   137 

   138 TInt DExampleChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)

   139 	{

   140 	TInt r = KErrNone;	

   141 	if (&Kern::CurrentThread() != iClient)

   142 		r = KErrAccessDenied;  // we only support one client

   143 	else if (aReqNo==KMaxTInt)

   144 		{

   145 		// DoCancel

   146 		r = DoCancel((TInt)a1);

   147 		}

   148     else if (aReqNo<0)

   149 		{

   150 		// DoRequest

   151 		TRequestStatus* pS=(TRequestStatus*)a1;

   152 		TAny* array[2] = { NULL, NULL };

   153 		kumemget32(array, a2, 2 * sizeof(TAny*));

   154 		r = DoRequest(~aReqNo, pS, array[0], array[1]);

   155 		if(r != KErrNone)

   156 			Kern::RequestComplete(pS, r);

   157 		r = KErrNone;

   158 		}

   159     else

   160 		{

   161 		// DoControl

   162 		r = DoControl(aReqNo, a1, a2);

   163 		}

   164 	return r;

   165 	}

   166 

   167 TInt DExampleChannel::DoControl(TInt aFunction,TAny* a1,TAny* /*a2*/)

   168 	{

   169 	TInt r = KErrNone;

   170 	TConfigData configBuffer;

   171 	switch (aFunction)

   172 		{

   173 		case RPagingExample::EGetConfig:

   174 			GetConfig(configBuffer);

   175 			umemput32(a1, (TAny*)&configBuffer, sizeof(TConfigData));

   176 			break;

   177 

   178 		case RPagingExample::ESetConfig:

   179 			umemget32(&configBuffer, a1, sizeof(TConfigData));

   180 			SetConfig(configBuffer);

   181 			break;

   182 

   183 		default:

   184 			r = KErrNotSupported;

   185 		}

   186 	return r;

   187 	}

   188 

   189 TInt DExampleChannel::DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2)

   190 	{

   191 	TInt r = KErrNotSupported;

   192 	switch (aFunction)

   193 		{

   194 		case RPagingExample::ERequestNotify:

   195 			r = StartNotify(aStatus);

   196 			break;

   197 			

   198 		case RPagingExample::ERequestAsyncGetValue:

   199 			r = StartAsyncGetValue((TInt*)a1, aStatus);

   200 			break;

   201 			

   202 		case RPagingExample::ERequestAsyncGetValue2:

   203 			r = StartAsyncGetValue2((TInt*)a1, (TInt*)a2, aStatus);

   204 			break;

   205 			

   206 		case RPagingExample::ERequestRead:

   207 			r = StartRead(a1, (TInt)a2, aStatus);

   208 			break;

   209 			

   210 		case RPagingExample::ERequestReadDes:

   211 			r = StartReadDes((TDes8*)a1, aStatus);

   212 			break;

   213 

   214 		case RPagingExample::ERequestWrite:

   215 			r = StartWrite(a1, (TInt)a2, aStatus);

   216 			break;

   217 			

   218 		case RPagingExample::ERequestWriteDes:

   219 			r = StartWriteDes((TDes8*)a1, aStatus);

   220 			break;

   221 		}

   222 	return r;

   223 	}

   224 

   225 TInt DExampleChannel::DoCancel(TUint /*aMask*/)

   226 	{

   227 	iCancelDfc.Enque();

   228 	return KErrNone;

   229 	}

   230 

   231 void DExampleChannel::CancelDfcFunc(TAny* aPtr)

   232 	{

   233 	DExampleChannel* self = (DExampleChannel*)aPtr;

   234 	self->Cancel();

   235 	}

   236 

   237 void DExampleChannel::Cancel()

   238 	{

   239 	if (iAsyncGetValueStatus)

   240 		{

   241 		iAsyncGetValueTimer.Cancel();

   242 		iAsyncGetValueDfc.Cancel();

   243 		Kern::RequestComplete(iClient, iAsyncGetValueStatus, KErrCancel);

   244 		}

   245 

   246 	if (iAsyncGetValue2Status)

   247 		{

   248 		iAsyncGetValue2Timer.Cancel();

   249 		iAsyncGetValue2Dfc.Cancel();

   250 		Kern::RequestComplete(iClient, iAsyncGetValue2Status, KErrCancel);

   251 		}

   252 

   253 	if (iReadStatus)

   254 		{

   255 		iReadTimer.Cancel();

   256 		iCompleteReadDfc.Cancel();

   257 		Kern::RequestComplete(iClient, iReadStatus, KErrCancel);

   258 		}

   259 

   260 	if (iWriteStatus)

   261 		{

   262 		iWriteTimer.Cancel();

   263 		iCompleteWriteDfc.Cancel();

   264 		Kern::RequestComplete(iClient, iWriteStatus, KErrCancel);

   265 		}

   266 	}

   267 

   268 void DExampleChannel::Shutdown()

   269 	{

   270 	}

   271 

   272 void DExampleChannel::GetConfig(TConfigData& aConfigOut)

   273 	{

   274 	NKern::FMWait(&iLock);

   275 	aConfigOut = iConfig;

   276 	NKern::FMSignal(&iLock);

   277 	}

   278 

   279 void DExampleChannel::SetConfig(const TConfigData& aNewConfig)

   280 	{

   281 	NKern::FMWait(&iLock);

   282 	iConfig = aNewConfig;

   283 	NKern::FMSignal(&iLock);

   284 	}

   285 

   286 TInt DExampleChannel::StartNotify(TRequestStatus* aStatus)

   287 	{

   288 	iNotifyStatus = aStatus;	

   289 	CompleteNotify(); // example implementation completes the request immediately

   290 	return KErrNone;

   291 	}

   292 

   293 void DExampleChannel::CompleteNotify()

   294 	{

   295 	Kern::RequestComplete(iClient, iNotifyStatus, KErrNone);

   296 	}

   297 

   298 TInt DExampleChannel::StartAsyncGetValue(TInt* aValue, TRequestStatus* aStatus)

   299 	{

   300 	iAsyncGetValueDest = aValue;

   301 	iAsyncGetValueStatus = aStatus;

   302 

   303 	// queue a timer to simulate an asynchronous operation

   304 	iAsyncGetValueTimer.OneShot(KAsyncDelay, iAsyncGetValueDfc);

   305 	return KErrNone;

   306 	}

   307 

   308 void DExampleChannel::AsyncGetValueCompleteDfcFunc(TAny* aPtr)

   309 	{

   310 	DExampleChannel* self = (DExampleChannel*)aPtr;

   311 	self->CompleteAsyncGetValue();

   312 	}

   313 

   314 void DExampleChannel::CompleteAsyncGetValue()

   315 	{

   316 	TValueStruct value;

   317 	value.iValue1 = 1;

   318 	value.iValue2 = _L8("shrt");

   319 	TInt r = Kern::ThreadRawWrite(iClient, iAsyncGetValueDest, (TAny*)&value, sizeof(TValueStruct), iClient);

   320 	Kern::RequestComplete(iClient, iAsyncGetValueStatus, r);

   321 	}

   322 

   323 TInt DExampleChannel::StartAsyncGetValue2(TInt* aValue1, TInt* aValue2, TRequestStatus* aStatus)

   324 	{

   325 	iAsyncGetValue2Dest1 = aValue1;

   326 	iAsyncGetValue2Dest2 = aValue2;

   327 	iAsyncGetValue2Status = aStatus;

   328 

   329 	// queue a timer to simulate an asynchronous operation

   330 	iAsyncGetValue2Timer.OneShot(KAsyncDelay, iAsyncGetValue2Dfc);

   331 	return KErrNone;

   332 	}

   333 

   334 void DExampleChannel::AsyncGetValue2CompleteDfcFunc(TAny* aPtr)

   335 	{

   336 	DExampleChannel* self = (DExampleChannel*)aPtr;

   337 	self->CompleteAsyncGetValue2();

   338 	}

   339 

   340 void DExampleChannel::CompleteAsyncGetValue2()

   341 	{

   342 	TInt value1 = 1;

   343 	TInt value2 = 2;

   344 	TInt r = Kern::ThreadRawWrite(iClient, iAsyncGetValue2Dest1, (TAny*)&value1, sizeof(TInt), iClient);

   345 	if (r == KErrNone)

   346 		r = Kern::ThreadRawWrite(iClient, iAsyncGetValue2Dest2, (TAny*)&value2, sizeof(TInt), iClient);

   347 	Kern::RequestComplete(iClient, iAsyncGetValue2Status, r);

   348 	}

   349 

   350 TInt DExampleChannel::StartRead(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus)

   351 	{

   352 	if (!NKern::CompareAndSwap(*(TAny**)&iReadStatus, NULL, aStatus))

   353 		return KErrInUse;

   354 	if (aLength < 1 || aLength > KBufferSize)

   355 		{

   356 		iReadStatus = NULL;

   357 		return KErrArgument;

   358 		}

   359 	iReadDest = aBuffer;

   360 	iReadLength = aLength;

   361 	ReceiveToReadBuffer();

   362 	return KErrNone;

   363 	}

   364 

   365 TInt DExampleChannel::StartReadDes(TDes8* aDesOut, TRequestStatus* aStatus)

   366 	{

   367 	if (!NKern::CompareAndSwap(*(TAny**)&iReadStatus, NULL, aStatus))

   368 		return KErrInUse;

   369 	TInt r = Kern::ThreadGetDesMaxLength(iClient, aDesOut);

   370 	if (r < 0)

   371 		{

   372 		iReadStatus = NULL;

   373 		return r;

   374 		}

   375 	TInt length = r;

   376 	if (length < 1 || length > KBufferSize)

   377 		{

   378 		iReadStatus = NULL;

   379 		return KErrArgument;

   380 		}

   381 	iReadDes = aDesOut;

   382 	iReadLength = length;

   383 	ReceiveToReadBuffer();

   384 	return KErrNone;

   385 	}

   386 

   387 TInt DExampleChannel::StartWrite(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus)

   388 	{

   389 	if (!NKern::CompareAndSwap(*(TAny**)&iWriteStatus, NULL, aStatus))

   390 		return KErrInUse;

   391 	if (aLength < 1 || aLength > KBufferSize)

   392 		{

   393 		iWriteStatus = NULL;

   394 		return KErrArgument;

   395 		}

   396 	iWriteSrc = aBuffer;

   397 	iWriteLength = aLength;

   398 	SendFromWriteBuffer();

   399 	return KErrNone;

   400 	}

   401 

   402 TInt DExampleChannel::StartWriteDes(const TDesC8* aDesIn, TRequestStatus* aStatus)

   403 	{

   404 	if (!NKern::CompareAndSwap(*(TAny**)&iWriteStatus, NULL, aStatus))

   405 		return KErrInUse;

   406 	TInt r = Kern::ThreadGetDesLength(iClient, aDesIn);

   407 	if (r < 0)

   408 		return r;

   409 	TInt length = r;

   410 	if (length < 1 || length > KBufferSize)

   411 		{

   412 		iWriteStatus = NULL;

   413 		return KErrArgument;

   414 		}

   415 	iWriteLength = length;

   416 	iWriteDes = aDesIn;

   417 	SendFromWriteBuffer();

   418 	return KErrNone;

   419 	}

   420 

   421 void DExampleChannel::ReceiveToReadBuffer()

   422 	{

   423 	// just queue a timer to simulate an asynchronous receive operation

   424 	// actually will return the previous contents of the buffer

   425 	NKern::FMWait(&iLock);

   426 	// The synchonisation is for illustrative purposes only - in a real driver we might make use of

   427 	// the configution here, so this would need to be protected from concurrent modification.

   428 	NKern::FMSignal(&iLock);

   429 	iReadTimer.OneShot(KAsyncDelay, iCompleteReadDfc);

   430 	}

   431 

   432 void DExampleChannel::SendFromWriteBuffer()

   433 	{

   434 	// just queue a timer to simulate an asynchronous send operation

   435 	NKern::FMWait(&iLock);

   436 	// The synchonisation is for illustrative purposes only - in a real driver we might make use of

   437 	// the configution here, so this would need to be protected from concurrent modification.

   438 	NKern::FMSignal(&iLock);

   439 	iWriteTimer.OneShot(KAsyncDelay, iCompleteWriteDfc);

   440 	}

   441 

   442 void DExampleChannel::ReceiveCompleteDfcFunc(TAny* aPtr)

   443 	{

   444 	DExampleChannel* self = (DExampleChannel*)aPtr;

   445 	self->CompleteRead();

   446 	}

   447 

   448 void DExampleChannel::SendCompleteDfcFunc(TAny* aPtr)

   449 	{

   450 	DExampleChannel* self = (DExampleChannel*)aPtr;

   451 	self->CompleteWrite();

   452 	}

   453 

   454 void DExampleChannel::CompleteRead()

   455 	{

   456 	TInt r;

   457 	if (iReadDest)

   458 		{

   459 		r = Kern::ThreadRawWrite(iClient, iReadDest, iBuffer, iReadLength, iClient);

   460 		iReadDest = NULL;

   461 		}

   462 	else

   463 		{

   464 		TPtrC8 des(iBuffer, iReadLength);

   465 		r = Kern::ThreadDesWrite(iClient, iReadDes, des, 0, KChunkShiftBy0, iClient);

   466 		iReadDes = NULL;

   467 		}

   468 	

   469 	iReadLength = 0;

   470 	Kern::RequestComplete(iClient, iReadStatus, r);

   471 	}

   472 

   473 void DExampleChannel::CompleteWrite()

   474 	{

   475 	TInt r;

   476 	if (iWriteSrc)

   477 		{

   478 		r = Kern::ThreadRawRead(iClient, iWriteSrc, iBuffer, iWriteLength);

   479 		iWriteSrc = NULL;

   480 		}

   481 	else

   482 		{

   483 		TPtr8 des(iBuffer, iWriteLength);

   484 		r = Kern::ThreadDesRead(iClient, iWriteDes, des, 0);

   485 		iWriteDes = NULL;

   486 		}

   487 	

   488 	iWriteLength = 0;

   489 	Kern::RequestComplete(iClient, iWriteStatus, r);

   490 	}

   491 

   492 //

   493 // Logical device

   494 //

   495 

   496 class DExampleFactory : public DLogicalDevice

   497 	{

   498 public:

   499 	DExampleFactory();

   500 	virtual TInt Install();

   501 	virtual void GetCaps(TDes8& aDes) const;

   502 	virtual TInt Create(DLogicalChannelBase*& aChannel);

   503 	};

   504 

   505 DExampleFactory::DExampleFactory()

   506 	{

   507 	iParseMask = 0;

   508 	iVersion = TVersion(1, 0, 0);

   509 	}

   510 

   511 TInt DExampleFactory::Install()

   512 	{

   513 	return SetName(&KPagingExample2PreLdd);

   514 	}

   515 

   516 void DExampleFactory::GetCaps(TDes8& /*aDes*/) const

   517 	{

   518 	// not used but required as DLogicalDevice::GetCaps is pure virtual

   519 	}

   520 

   521 TInt DExampleFactory::Create(DLogicalChannelBase*& aChannel)

   522 	{

   523 	aChannel = new DExampleChannel;

   524 	return aChannel ? KErrNone : KErrNoMemory;

   525 	}

   526 

   527 DECLARE_STANDARD_LDD()

   528 	{

   529 	return new DExampleFactory;

   530 	}