|
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_1_pre.cpp |
|
15 // Demand paging migration example device driver d_pagingexample_1_pre: a DLogicalChannel-dervied |
|
16 // 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 KDfcQThreadPriority = 25; |
|
25 const TInt KBufferSize = KMaxTransferSize; |
|
26 |
|
27 // |
|
28 // Logical channel |
|
29 // |
|
30 |
|
31 class DExampleChannel : public DLogicalChannel |
|
32 { |
|
33 public: |
|
34 typedef RPagingExample::TConfigData TConfigData; |
|
35 typedef RPagingExample::TValueStruct TValueStruct; |
|
36 public: |
|
37 DExampleChannel(); |
|
38 ~DExampleChannel(); |
|
39 virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer); |
|
40 virtual void HandleMsg(TMessageBase* aMsg); |
|
41 TInt DoControl(TInt aFunction, TAny* a1, TAny* a2); |
|
42 TInt DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2); |
|
43 TInt DoCancel(TUint aMask); |
|
44 private: |
|
45 TDfcQue* DfcQ(); |
|
46 void Shutdown(); |
|
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 AsyncGetValueCompleteDfcFunc(TAny* aPtr); |
|
58 static void AsyncGetValue2CompleteDfcFunc(TAny* aPtr); |
|
59 static void ReceiveCompleteDfcFunc(TAny* aPtr); |
|
60 static void SendCompleteDfcFunc(TAny* aPtr); |
|
61 void CompleteNotify(); |
|
62 void CompleteAsyncGetValue(); |
|
63 void CompleteAsyncGetValue2(); |
|
64 void CompleteRead(); |
|
65 void CompleteWrite(); |
|
66 private: |
|
67 TDynamicDfcQue* iDynamicDfcQ; |
|
68 TConfigData iConfig; |
|
69 DThread* iClient; |
|
70 |
|
71 // Notify |
|
72 TRequestStatus* iNotifyStatus; |
|
73 |
|
74 // Async get value |
|
75 TRequestStatus* iAsyncGetValueStatus; |
|
76 TInt* iAsyncGetValueDest; |
|
77 NTimer iAsyncGetValueTimer; |
|
78 TDfc iAsyncGetValueDfc; |
|
79 |
|
80 // Async get value 2 |
|
81 TRequestStatus* iAsyncGetValue2Status; |
|
82 TInt* iAsyncGetValue2Dest1; |
|
83 TInt* iAsyncGetValue2Dest2; |
|
84 NTimer iAsyncGetValue2Timer; |
|
85 TDfc iAsyncGetValue2Dfc; |
|
86 |
|
87 // Read |
|
88 TRequestStatus* iReadStatus; |
|
89 NTimer iReadTimer; |
|
90 TAny* iReadDest; |
|
91 TInt iReadLength; |
|
92 TDes8* iReadDes; |
|
93 TDfc iCompleteReadDfc; |
|
94 |
|
95 // Write |
|
96 TRequestStatus* iWriteStatus; |
|
97 NTimer iWriteTimer; |
|
98 TAny* iWriteSrc; |
|
99 TInt iWriteLength; |
|
100 const TDesC8* iWriteDes; |
|
101 TDfc iCompleteWriteDfc; |
|
102 TUint8 iBuffer[KBufferSize]; |
|
103 }; |
|
104 |
|
105 DExampleChannel::DExampleChannel() : |
|
106 iAsyncGetValueTimer(NULL, this), |
|
107 iAsyncGetValueDfc(AsyncGetValueCompleteDfcFunc, this, 0), |
|
108 iAsyncGetValue2Timer(NULL, this), |
|
109 iAsyncGetValue2Dfc(AsyncGetValue2CompleteDfcFunc, this, 0), |
|
110 iReadTimer(NULL, this), |
|
111 iCompleteReadDfc(ReceiveCompleteDfcFunc, this, 0), |
|
112 iWriteTimer(NULL, this), |
|
113 iCompleteWriteDfc(SendCompleteDfcFunc, this, 0) |
|
114 { |
|
115 iClient = &Kern::CurrentThread(); |
|
116 iClient->Open(); |
|
117 } |
|
118 |
|
119 DExampleChannel::~DExampleChannel() |
|
120 { |
|
121 Kern::SafeClose((DObject*&)iClient, NULL); |
|
122 if (iDynamicDfcQ) |
|
123 iDynamicDfcQ->Destroy(); |
|
124 } |
|
125 |
|
126 TDfcQue* DExampleChannel::DfcQ() |
|
127 { |
|
128 return iDynamicDfcQ; |
|
129 } |
|
130 |
|
131 TInt DExampleChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/) |
|
132 { |
|
133 // Existing drivers may use the kernel global DFC queue, but for testing purposes we actually |
|
134 // allocate our own so we can control its realtime state. |
|
135 TInt r = Kern::DynamicDfcQCreate(iDynamicDfcQ, KDfcQThreadPriority, KPagingExample1PreLdd); |
|
136 if (r != KErrNone) |
|
137 return r; |
|
138 iDynamicDfcQ->SetRealtimeState(ERealtimeStateWarn); |
|
139 |
|
140 SetDfcQ(DfcQ()); |
|
141 iAsyncGetValueDfc.SetDfcQ(DfcQ()); |
|
142 iAsyncGetValue2Dfc.SetDfcQ(DfcQ()); |
|
143 iCompleteReadDfc.SetDfcQ(DfcQ()); |
|
144 iCompleteWriteDfc.SetDfcQ(DfcQ()); |
|
145 iMsgQ.Receive(); |
|
146 return KErrNone; |
|
147 } |
|
148 |
|
149 void DExampleChannel::HandleMsg(TMessageBase* aMsg) |
|
150 { |
|
151 TThreadMessage& m=*(TThreadMessage*)aMsg; |
|
152 TInt id=m.iValue; |
|
153 |
|
154 if (id==(TInt)ECloseMsg) |
|
155 { |
|
156 Shutdown(); |
|
157 m.Complete(KErrNone,EFalse); |
|
158 return; |
|
159 } |
|
160 |
|
161 // we only support one client |
|
162 if (m.Client() != iClient) |
|
163 { |
|
164 m.Complete(KErrAccessDenied,ETrue); |
|
165 return; |
|
166 } |
|
167 |
|
168 if (id==KMaxTInt) |
|
169 { |
|
170 // DoCancel |
|
171 DoCancel(m.Int0()); |
|
172 m.Complete(KErrNone,ETrue); |
|
173 return; |
|
174 } |
|
175 else if (id<0) |
|
176 { |
|
177 // DoRequest |
|
178 TRequestStatus* pS=(TRequestStatus*)m.Ptr0(); |
|
179 TInt r=DoRequest(~id,pS,m.Ptr1(),m.Ptr2()); |
|
180 if (r!=KErrNone) |
|
181 Kern::RequestComplete(m.Client(),pS,r); |
|
182 m.Complete(KErrNone,ETrue); |
|
183 } |
|
184 else |
|
185 { |
|
186 // DoControl |
|
187 TInt r=DoControl(id,m.Ptr0(),m.Ptr1()); |
|
188 m.Complete(r,ETrue); |
|
189 } |
|
190 } |
|
191 |
|
192 TInt DExampleChannel::DoControl(TInt aFunction,TAny* a1,TAny* /*a2*/) |
|
193 { |
|
194 TInt r = KErrNone; |
|
195 switch (aFunction) |
|
196 { |
|
197 case RPagingExample::ESetRealtimeState: |
|
198 iDynamicDfcQ->SetRealtimeState(a1 ? ERealtimeStateOn : ERealtimeStateWarn); |
|
199 break; |
|
200 |
|
201 case RPagingExample::EGetConfig: |
|
202 r = Kern::ThreadRawWrite(iClient, a1, (TAny*)&iConfig, sizeof(TConfigData), iClient); |
|
203 break; |
|
204 |
|
205 case RPagingExample::ESetConfig: |
|
206 { |
|
207 TConfigData newConfig; |
|
208 r = Kern::ThreadRawRead(iClient, a1, &newConfig, sizeof(TConfigData)); |
|
209 if (r == KErrNone) |
|
210 SetConfig(newConfig); |
|
211 } |
|
212 break; |
|
213 |
|
214 default: |
|
215 r = KErrNotSupported; |
|
216 } |
|
217 return r; |
|
218 } |
|
219 |
|
220 TInt DExampleChannel::DoRequest(TInt aFunction, TRequestStatus* aStatus, TAny* a1, TAny* a2) |
|
221 { |
|
222 TInt r = KErrNotSupported; |
|
223 switch (aFunction) |
|
224 { |
|
225 case RPagingExample::ERequestNotify: |
|
226 r = StartNotify(aStatus); |
|
227 break; |
|
228 |
|
229 case RPagingExample::ERequestAsyncGetValue: |
|
230 r = StartAsyncGetValue((TInt*)a1, aStatus); |
|
231 break; |
|
232 |
|
233 case RPagingExample::ERequestAsyncGetValue2: |
|
234 r = StartAsyncGetValue2((TInt*)a1, (TInt*)a2, aStatus); |
|
235 break; |
|
236 |
|
237 case RPagingExample::ERequestRead: |
|
238 r = StartRead(a1, (TInt)a2, aStatus); |
|
239 break; |
|
240 |
|
241 case RPagingExample::ERequestReadDes: |
|
242 r = StartReadDes((TDes8*)a1, aStatus); |
|
243 break; |
|
244 |
|
245 case RPagingExample::ERequestWrite: |
|
246 r = StartWrite(a1, (TInt)a2, aStatus); |
|
247 break; |
|
248 |
|
249 case RPagingExample::ERequestWriteDes: |
|
250 r = StartWriteDes((TDes8*)a1, aStatus); |
|
251 break; |
|
252 } |
|
253 return r; |
|
254 } |
|
255 |
|
256 TInt DExampleChannel::DoCancel(TUint /*aMask*/) |
|
257 { |
|
258 if (iAsyncGetValueStatus) |
|
259 { |
|
260 iAsyncGetValueTimer.Cancel(); |
|
261 iAsyncGetValueDfc.Cancel(); |
|
262 Kern::RequestComplete(iClient, iAsyncGetValueStatus, KErrCancel); |
|
263 } |
|
264 |
|
265 if (iAsyncGetValue2Status) |
|
266 { |
|
267 iAsyncGetValue2Timer.Cancel(); |
|
268 iAsyncGetValue2Dfc.Cancel(); |
|
269 Kern::RequestComplete(iClient, iAsyncGetValue2Status, KErrCancel); |
|
270 } |
|
271 |
|
272 if (iReadStatus) |
|
273 { |
|
274 iReadTimer.Cancel(); |
|
275 iCompleteReadDfc.Cancel(); |
|
276 Kern::RequestComplete(iClient, iReadStatus, KErrCancel); |
|
277 } |
|
278 |
|
279 if (iWriteStatus) |
|
280 { |
|
281 iWriteTimer.Cancel(); |
|
282 iCompleteWriteDfc.Cancel(); |
|
283 Kern::RequestComplete(iClient, iWriteStatus, KErrCancel); |
|
284 } |
|
285 |
|
286 return KErrNone; |
|
287 } |
|
288 |
|
289 void DExampleChannel::Shutdown() |
|
290 { |
|
291 } |
|
292 |
|
293 void DExampleChannel::SetConfig(const TConfigData& aNewConfig) |
|
294 { |
|
295 iConfig = aNewConfig; |
|
296 } |
|
297 |
|
298 TInt DExampleChannel::StartNotify(TRequestStatus* aStatus) |
|
299 { |
|
300 iNotifyStatus = aStatus; |
|
301 CompleteNotify(); // example implementation completes the request immediately |
|
302 return KErrNone; |
|
303 } |
|
304 |
|
305 void DExampleChannel::CompleteNotify() |
|
306 { |
|
307 Kern::RequestComplete(iClient, iNotifyStatus, KErrNone); |
|
308 } |
|
309 |
|
310 TInt DExampleChannel::StartAsyncGetValue(TInt* aValue, TRequestStatus* aStatus) |
|
311 { |
|
312 iAsyncGetValueDest = aValue; |
|
313 iAsyncGetValueStatus = aStatus; |
|
314 |
|
315 // queue a timer to simulate an asynchronous operation |
|
316 iAsyncGetValueTimer.OneShot(KAsyncDelay, iAsyncGetValueDfc); |
|
317 return KErrNone; |
|
318 } |
|
319 |
|
320 void DExampleChannel::AsyncGetValueCompleteDfcFunc(TAny* aPtr) |
|
321 { |
|
322 DExampleChannel* self = (DExampleChannel*)aPtr; |
|
323 self->CompleteAsyncGetValue(); |
|
324 } |
|
325 |
|
326 void DExampleChannel::CompleteAsyncGetValue() |
|
327 { |
|
328 TValueStruct value; |
|
329 value.iValue1 = 1; |
|
330 value.iValue2 = _L8("shrt"); |
|
331 TInt r = Kern::ThreadRawWrite(iClient, iAsyncGetValueDest, (TAny*)&value, sizeof(TValueStruct), iClient); |
|
332 Kern::RequestComplete(iClient, iAsyncGetValueStatus, r); |
|
333 } |
|
334 |
|
335 TInt DExampleChannel::StartAsyncGetValue2(TInt* aValue1, TInt* aValue2, TRequestStatus* aStatus) |
|
336 { |
|
337 iAsyncGetValue2Dest1 = aValue1; |
|
338 iAsyncGetValue2Dest2 = aValue2; |
|
339 iAsyncGetValue2Status = aStatus; |
|
340 |
|
341 // queue a timer to simulate an asynchronous operation |
|
342 iAsyncGetValue2Timer.OneShot(KAsyncDelay, iAsyncGetValue2Dfc); |
|
343 return KErrNone; |
|
344 } |
|
345 |
|
346 void DExampleChannel::AsyncGetValue2CompleteDfcFunc(TAny* aPtr) |
|
347 { |
|
348 DExampleChannel* self = (DExampleChannel*)aPtr; |
|
349 self->CompleteAsyncGetValue2(); |
|
350 } |
|
351 |
|
352 void DExampleChannel::CompleteAsyncGetValue2() |
|
353 { |
|
354 TInt value1 = 1; |
|
355 TInt value2 = 2; |
|
356 TInt r = Kern::ThreadRawWrite(iClient, iAsyncGetValue2Dest1, (TAny*)&value1, sizeof(TInt), iClient); |
|
357 if (r == KErrNone) |
|
358 r = Kern::ThreadRawWrite(iClient, iAsyncGetValue2Dest2, (TAny*)&value2, sizeof(TInt), iClient); |
|
359 Kern::RequestComplete(iClient, iAsyncGetValue2Status, r); |
|
360 } |
|
361 |
|
362 TInt DExampleChannel::StartRead(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus) |
|
363 { |
|
364 if (iReadStatus) |
|
365 return KErrInUse; |
|
366 if (aLength < 1 || aLength > KBufferSize) |
|
367 return KErrArgument; |
|
368 iReadStatus = aStatus; |
|
369 iReadDest = aBuffer; |
|
370 iReadLength = aLength; |
|
371 ReceiveToReadBuffer(); |
|
372 return KErrNone; |
|
373 } |
|
374 |
|
375 TInt DExampleChannel::StartReadDes(TDes8* aDesOut, TRequestStatus* aStatus) |
|
376 { |
|
377 if (iReadStatus) |
|
378 return KErrInUse; |
|
379 TInt r = Kern::ThreadGetDesMaxLength(iClient, aDesOut); |
|
380 if (r < 0) |
|
381 return r; |
|
382 TInt length = r; |
|
383 if (length < 1 || length > KBufferSize) |
|
384 return KErrArgument; |
|
385 iReadStatus = aStatus; |
|
386 iReadDes = aDesOut; |
|
387 iReadLength = length; |
|
388 ReceiveToReadBuffer(); |
|
389 return KErrNone; |
|
390 } |
|
391 |
|
392 TInt DExampleChannel::StartWrite(TAny* aBuffer, TInt aLength, TRequestStatus* aStatus) |
|
393 { |
|
394 if (iWriteStatus) |
|
395 return KErrInUse; |
|
396 if (aLength < 1 || aLength > KBufferSize) |
|
397 return KErrArgument; |
|
398 iWriteStatus = aStatus; |
|
399 iWriteSrc = aBuffer; |
|
400 iWriteLength = aLength; |
|
401 SendFromWriteBuffer(); |
|
402 return KErrNone; |
|
403 } |
|
404 |
|
405 TInt DExampleChannel::StartWriteDes(const TDesC8* aDesIn, TRequestStatus* aStatus) |
|
406 { |
|
407 if (iWriteStatus) |
|
408 return KErrInUse; |
|
409 TInt r = Kern::ThreadGetDesLength(iClient, aDesIn); |
|
410 if (r < 0) |
|
411 return r; |
|
412 TInt length = r; |
|
413 if (length < 1 || length > KBufferSize) |
|
414 return KErrArgument; |
|
415 iWriteStatus = aStatus; |
|
416 iWriteLength = length; |
|
417 iWriteDes = aDesIn; |
|
418 SendFromWriteBuffer(); |
|
419 return KErrNone; |
|
420 } |
|
421 |
|
422 void DExampleChannel::ReceiveToReadBuffer() |
|
423 { |
|
424 // just queue a timer to simulate an asynchronous receive operation |
|
425 // actually will return the previous contents of the buffer |
|
426 iReadTimer.OneShot(KAsyncDelay, iCompleteReadDfc); |
|
427 } |
|
428 |
|
429 void DExampleChannel::SendFromWriteBuffer() |
|
430 { |
|
431 // just queue a timer to simulate an asynchronous send operation |
|
432 iWriteTimer.OneShot(KAsyncDelay, iCompleteWriteDfc); |
|
433 } |
|
434 |
|
435 void DExampleChannel::ReceiveCompleteDfcFunc(TAny* aPtr) |
|
436 { |
|
437 DExampleChannel* self = (DExampleChannel*)aPtr; |
|
438 self->CompleteRead(); |
|
439 } |
|
440 |
|
441 void DExampleChannel::SendCompleteDfcFunc(TAny* aPtr) |
|
442 { |
|
443 DExampleChannel* self = (DExampleChannel*)aPtr; |
|
444 self->CompleteWrite(); |
|
445 } |
|
446 |
|
447 void DExampleChannel::CompleteRead() |
|
448 { |
|
449 TInt r; |
|
450 if (iReadDest) |
|
451 { |
|
452 r = Kern::ThreadRawWrite(iClient, iReadDest, iBuffer, iReadLength, iClient); |
|
453 iReadDest = NULL; |
|
454 } |
|
455 else |
|
456 { |
|
457 TPtrC8 des(iBuffer, iReadLength); |
|
458 r = Kern::ThreadDesWrite(iClient, iReadDes, des, 0, KChunkShiftBy0, iClient); |
|
459 iReadDes = NULL; |
|
460 } |
|
461 |
|
462 iReadLength = 0; |
|
463 Kern::RequestComplete(iClient, iReadStatus, r); |
|
464 } |
|
465 |
|
466 void DExampleChannel::CompleteWrite() |
|
467 { |
|
468 TInt r; |
|
469 if (iWriteSrc) |
|
470 { |
|
471 r = Kern::ThreadRawRead(iClient, iWriteSrc, iBuffer, iWriteLength); |
|
472 iWriteSrc = NULL; |
|
473 } |
|
474 else |
|
475 { |
|
476 TPtr8 des(iBuffer, iWriteLength); |
|
477 r = Kern::ThreadDesRead(iClient, iWriteDes, des, 0); |
|
478 iWriteDes = NULL; |
|
479 } |
|
480 |
|
481 iWriteLength = 0; |
|
482 Kern::RequestComplete(iClient, iWriteStatus, r); |
|
483 } |
|
484 |
|
485 // |
|
486 // Logical device |
|
487 // |
|
488 |
|
489 class DExampleFactory : public DLogicalDevice |
|
490 { |
|
491 public: |
|
492 DExampleFactory(); |
|
493 virtual TInt Install(); |
|
494 virtual void GetCaps(TDes8& aDes) const; |
|
495 virtual TInt Create(DLogicalChannelBase*& aChannel); |
|
496 }; |
|
497 |
|
498 DExampleFactory::DExampleFactory() |
|
499 { |
|
500 iParseMask = 0; |
|
501 iVersion = TVersion(1, 0, 0); |
|
502 } |
|
503 |
|
504 TInt DExampleFactory::Install() |
|
505 { |
|
506 return SetName(&KPagingExample1PreLdd); |
|
507 } |
|
508 |
|
509 void DExampleFactory::GetCaps(TDes8& /*aDes*/) const |
|
510 { |
|
511 // not used but required as DLogicalDevice::GetCaps is pure virtual |
|
512 } |
|
513 |
|
514 TInt DExampleFactory::Create(DLogicalChannelBase*& aChannel) |
|
515 { |
|
516 aChannel = new DExampleChannel; |
|
517 return aChannel ? KErrNone : KErrNoMemory; |
|
518 } |
|
519 |
|
520 DECLARE_STANDARD_LDD() |
|
521 { |
|
522 return new DExampleFactory; |
|
523 } |