|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 #ifndef __T_DMA2_H__ |
|
18 #define __T_DMA2_H__ |
|
19 |
|
20 #include "cap_reqs.h" |
|
21 #include "test_thread.h" |
|
22 #include "d_dma2.h" |
|
23 #include <e32std.h> |
|
24 |
|
25 |
|
26 class TTestCase; |
|
27 // Global array of test cases |
|
28 extern RPointerArray<TTestCase> TestArray; |
|
29 |
|
30 |
|
31 extern TBool gVerboseOutput; // Verbose output control |
|
32 |
|
33 |
|
34 const TInt KParameterTextLenMax = 80; // command-line param length |
|
35 |
|
36 /** |
|
37 This function prints out the PSL test Information |
|
38 */ |
|
39 void Print(const TDmaV2TestInfo& aInfo); |
|
40 |
|
41 /** |
|
42 Runs all framework self tests |
|
43 */ |
|
44 void SelfTests(); |
|
45 |
|
46 void ApiTests(); |
|
47 |
|
48 class CSingleTransferTest; |
|
49 class CIsrRequeTest; |
|
50 class CMultiTransferTest; |
|
51 |
|
52 |
|
53 /** |
|
54 An interface to a classs that sets up the buffers before a test |
|
55 */ |
|
56 //TODO both pre and post transfer checks should perhaps derive from an |
|
57 //abstract visitor base |
|
58 class MPreTransfer |
|
59 { |
|
60 public: |
|
61 virtual ~MPreTransfer() |
|
62 {} |
|
63 virtual void Setup(const CSingleTransferTest& aTest) const = 0; |
|
64 virtual void Setup(const CIsrRequeTest& aTest) const = 0; |
|
65 virtual void Setup(const CMultiTransferTest& aTest) const = 0; |
|
66 }; |
|
67 |
|
68 /** |
|
69 An interface for a check which takes place at the end of a DMA |
|
70 transfer test to verify the transfer was as expected. |
|
71 */ |
|
72 class MPostTransferCheck |
|
73 { |
|
74 public: |
|
75 virtual ~MPostTransferCheck() |
|
76 {} |
|
77 virtual TInt Check(const CSingleTransferTest& aTest) const = 0; |
|
78 virtual TInt Check(const CIsrRequeTest& aTest) const = 0; |
|
79 virtual TInt Check(CMultiTransferTest& aTest) const = 0; |
|
80 }; |
|
81 |
|
82 class TCompare2D : public MPostTransferCheck |
|
83 { |
|
84 public: |
|
85 TCompare2D() |
|
86 {} |
|
87 |
|
88 virtual TInt Check(const CSingleTransferTest& aTest) const; |
|
89 virtual TInt Check(const CIsrRequeTest& aTest) const; |
|
90 virtual TInt Check(CMultiTransferTest& aTest) const; |
|
91 |
|
92 }; |
|
93 |
|
94 class TAlwaysFail : public MPostTransferCheck |
|
95 { |
|
96 public: |
|
97 virtual TInt Check(const CSingleTransferTest& /*aTest*/) const |
|
98 {return KErrUnknown;} |
|
99 virtual TInt Check(const CIsrRequeTest&) const |
|
100 {return KErrUnknown;} |
|
101 virtual TInt Check(CMultiTransferTest&) const |
|
102 {return KErrUnknown;} |
|
103 }; |
|
104 |
|
105 class TAlwaysPass : public MPostTransferCheck |
|
106 { |
|
107 public: |
|
108 virtual TInt Check(const CSingleTransferTest& /*aTest*/) const |
|
109 {return KErrNone;} |
|
110 virtual TInt Check(const CIsrRequeTest&) const |
|
111 {return KErrNone;} |
|
112 virtual TInt Check(CMultiTransferTest&) const |
|
113 {return KErrNone;} |
|
114 }; |
|
115 |
|
116 /** |
|
117 Compare that all the various source buffers of a test match |
|
118 its destination buffers |
|
119 */ |
|
120 class TCompareSrcDst : public MPostTransferCheck |
|
121 { |
|
122 public: |
|
123 TCompareSrcDst() |
|
124 {} |
|
125 |
|
126 virtual TInt Check(const CSingleTransferTest& aTest) const; |
|
127 virtual TInt Check(const CIsrRequeTest& aTest) const; |
|
128 virtual TInt Check(CMultiTransferTest& aTest) const; |
|
129 |
|
130 protected: |
|
131 TInt Check(const TIsrRequeArgsSet& aRequeueArgSet, TUint8* aChunkBase, const TDmaTransferArgs& aTferArgs) const; |
|
132 TInt Check(const TIsrRequeArgs& aRequeueArgs) const; |
|
133 TInt Check(const TDmaTransferArgs& aTransferArgs, TUint8* aChunkBase) const; |
|
134 }; |
|
135 |
|
136 /** |
|
137 Base class for all DMA tests |
|
138 */ |
|
139 class CDmaTest : public CTest |
|
140 { |
|
141 public: |
|
142 CDmaTest(const TDesC& aName, TInt aIterations, const MPreTransfer* aPreTransfer, const MPostTransferCheck* aPostTransfer) |
|
143 : CTest(aName, aIterations), iPreTransfer(aPreTransfer), iPostTransferCheck(aPostTransfer) |
|
144 {} |
|
145 |
|
146 void OpenDmaSession(); |
|
147 void CloseDmaSession(); |
|
148 |
|
149 virtual void PrintTestInfo() const; |
|
150 virtual TBool Result() = 0; |
|
151 |
|
152 const RChunk& Chunk() const |
|
153 {return iChunk;} |
|
154 |
|
155 /** |
|
156 Tells the test which DMA channel it should run on |
|
157 */ |
|
158 void SetChannelCookie(TUint32 aCookie) |
|
159 {iChannelCookie = aCookie;} |
|
160 |
|
161 virtual void PreTransferSetup() =0; |
|
162 virtual TInt DoPostTransferCheck() =0; |
|
163 protected: |
|
164 RDmaSession iDmaSession; |
|
165 RChunk iChunk; |
|
166 |
|
167 /** |
|
168 Identifies the channel to open (as understood by a DMA PSL) |
|
169 */ |
|
170 TUint iChannelCookie; |
|
171 const MPreTransfer* iPreTransfer; |
|
172 |
|
173 const MPostTransferCheck* iPostTransferCheck; //!< Some check to be run after the transfer |
|
174 }; |
|
175 |
|
176 /** |
|
177 Holds return codes for the various functions which must be called |
|
178 to create, fragment, and queue a DMA request |
|
179 */ |
|
180 struct TRequestResults |
|
181 { |
|
182 TRequestResults |
|
183 ( |
|
184 TInt aCreate = KErrNone, |
|
185 TInt aFragmentCount = 0, |
|
186 TInt aFragmentationResult = KErrNone, |
|
187 TInt aQueueResult = KErrNone |
|
188 ) |
|
189 :iCreate(aCreate), iFragmentCount(aFragmentCount), iFragmentationResult(aFragmentationResult), iQueueResult(aQueueResult) |
|
190 {} |
|
191 |
|
192 /** |
|
193 Constructs with error results |
|
194 */ |
|
195 TRequestResults(TFalse) |
|
196 :iCreate(KErrUnknown), iFragmentCount(0), iFragmentationResult(KErrUnknown), iQueueResult(KErrUnknown) |
|
197 {} |
|
198 |
|
199 inline TRequestResults& CreationResult(TInt aErrorCode) {iCreate = aErrorCode; return *this;} |
|
200 inline TRequestResults& FragmentCount(TInt aCount) {iFragmentCount = aCount; return *this;} |
|
201 inline TRequestResults& FragmentationResult(TInt aErrorCode) {iFragmentationResult = aErrorCode; return *this;} |
|
202 inline TRequestResults& QueueResult(TInt aErrorCode) {iQueueResult = aErrorCode; return *this;} |
|
203 |
|
204 TInt iCreate; |
|
205 TInt iFragmentCount; //!< 0 means any result permitted |
|
206 TInt iFragmentationResult; |
|
207 TInt iQueueResult; |
|
208 }; |
|
209 |
|
210 /** |
|
211 Holds all the results for a DMA CSingleTransferTest |
|
212 */ |
|
213 struct TResultSet |
|
214 { |
|
215 /** |
|
216 No errors expected |
|
217 */ |
|
218 TResultSet(TInt aChannelOpenResult = KErrNone, |
|
219 const TRequestResults aRequestResults = TRequestResults(), |
|
220 TInt aPostTransferCheck = KErrNone, |
|
221 const TCallbackRecord aCallbackRecord = TCallbackRecord(TCallbackRecord::EThread,1) |
|
222 ) |
|
223 : |
|
224 iChannelOpenResult(aChannelOpenResult), |
|
225 iRequestResult(aRequestResults), |
|
226 iPostTransferCheck(aPostTransferCheck), |
|
227 iCallbackRecord(aCallbackRecord) |
|
228 {} |
|
229 |
|
230 explicit TResultSet(const TCallbackRecord& aRecord) |
|
231 :iChannelOpenResult(KErrNone), |
|
232 iRequestResult(), |
|
233 iPostTransferCheck(KErrNone), |
|
234 iCallbackRecord(aRecord) |
|
235 {} |
|
236 |
|
237 /** |
|
238 Errors expected |
|
239 */ |
|
240 TResultSet(TFalse) |
|
241 :iChannelOpenResult(KErrUnknown), |
|
242 iRequestResult(EFalse), |
|
243 iPostTransferCheck(KErrUnknown), |
|
244 iCallbackRecord(TCallbackRecord::Empty()) |
|
245 {} |
|
246 |
|
247 void Print() const; |
|
248 TBool operator == (const TResultSet& aOther) const; |
|
249 |
|
250 /** Set channel opening result */ |
|
251 TResultSet& ChannelOpenResult(TInt aResult) {iChannelOpenResult = aResult; return *this;} |
|
252 TResultSet& PostTransferResult(TInt aResult) {iPostTransferCheck = aResult; return *this;} |
|
253 /** Set request results */ |
|
254 TResultSet& RequestResult(const TRequestResults& aResults) {iRequestResult = aResults; return *this;} |
|
255 /** Set Callback record */ |
|
256 TResultSet& CallbackRecord(const TCallbackRecord& aCallbackRecord) {iCallbackRecord = aCallbackRecord; return *this;} |
|
257 |
|
258 TInt iChannelOpenResult; |
|
259 TRequestResults iRequestResult; |
|
260 TInt iPostTransferCheck; |
|
261 TCallbackRecord iCallbackRecord; |
|
262 }; |
|
263 |
|
264 /** |
|
265 Fills each source buffer with an increasing value and clears each destination |
|
266 */ |
|
267 class TPreTransferIncrBytes : public MPreTransfer |
|
268 { |
|
269 public: |
|
270 TPreTransferIncrBytes() |
|
271 {} |
|
272 |
|
273 virtual void Setup(const CSingleTransferTest& aTest) const; |
|
274 virtual void Setup(const CIsrRequeTest& aTest) const; |
|
275 virtual void Setup(const CMultiTransferTest& aTest) const; |
|
276 protected: |
|
277 virtual void Setup(const TAddressParms& aParams) const; |
|
278 TBool CheckBuffers(const CIsrRequeTest& aTest) const; |
|
279 TBool CheckBuffers(const RArray<const TAddressParms> aTransferParams) const; |
|
280 }; |
|
281 |
|
282 const TPreTransferIncrBytes KPreTransferIncrBytes; |
|
283 const TCompareSrcDst KCompareSrcDst; |
|
284 const TCompare2D KCompare2D; |
|
285 |
|
286 |
|
287 /** |
|
288 Iterates over the bytes in buffer, in the order |
|
289 the supllied DMA config would access them |
|
290 */ |
|
291 class TTransferIter |
|
292 { |
|
293 public: |
|
294 TTransferIter() |
|
295 :iCfg(NULL), iPtr(NULL) |
|
296 {} |
|
297 |
|
298 TTransferIter(const TDmaTransferConfig& aCfg, TUint8* aChunkBase=NULL) |
|
299 :iElem(0), iFrame(0), iCfg(&aCfg), iChunkBase(aChunkBase), iPtr(Start()), iBytes(0) |
|
300 {} |
|
301 |
|
302 void operator++ (); |
|
303 TUint8& operator* () |
|
304 { |
|
305 Invariant(); |
|
306 return *iPtr; |
|
307 } |
|
308 |
|
309 TBool operator!= (const TTransferIter& aOther) |
|
310 { |
|
311 return (iPtr != aOther.iPtr); |
|
312 } |
|
313 |
|
314 static void SelfTest(); |
|
315 private: |
|
316 TUint8* Start() const |
|
317 { |
|
318 return iChunkBase + iCfg->iAddr; |
|
319 } |
|
320 |
|
321 void Invariant() const; |
|
322 |
|
323 TUint iElem; //!< The current element |
|
324 TUint iFrame; //!< The current frame |
|
325 |
|
326 const TDmaTransferConfig* const iCfg; |
|
327 TUint8* iChunkBase; |
|
328 |
|
329 TUint8* iPtr; //<! Pointer to the current byte |
|
330 |
|
331 TInt iBytes; //!< The number of bytes traversed |
|
332 }; |
|
333 |
|
334 /** |
|
335 Performs a single DMA transfer using the member TDmaTransferArgs on |
|
336 one channel. At each stage of the transfer results are recorded in a |
|
337 TResultSet struct: at the end these are compared with a set of expected |
|
338 results. |
|
339 */ |
|
340 class CSingleTransferTest : public CDmaTest |
|
341 { |
|
342 public: |
|
343 CSingleTransferTest( |
|
344 const TDesC& aName, TInt aIterations, |
|
345 const TDmaTransferArgs& aArgs, |
|
346 const TResultSet& aExpected, |
|
347 TUint aMaxFragmentSize = 0, |
|
348 const MPostTransferCheck* aPostTferChk = &KCompareSrcDst, |
|
349 const MPreTransfer* aPreTfer = &KPreTransferIncrBytes |
|
350 ) |
|
351 : CDmaTest(aName, aIterations, aPreTfer, aPostTferChk), |
|
352 iTransferArgs(aArgs),iExpected(aExpected),iActual(EFalse), |
|
353 iUseNewRequest(ETrue), |
|
354 iUseNewFragment(ETrue), |
|
355 iMaxFragmentSize(aMaxFragmentSize) |
|
356 {} |
|
357 |
|
358 /** |
|
359 Perform each stage of trasnfer |
|
360 */ |
|
361 virtual void RunTest(); |
|
362 virtual void PrintTestType() const; |
|
363 |
|
364 virtual CTest* Clone() const {return new CSingleTransferTest(*this);} |
|
365 |
|
366 /** |
|
367 Compares the actual vs the exepected results and reports |
|
368 of the test passed |
|
369 @return ETrue for a pass, EFalse for a fail |
|
370 */ |
|
371 virtual TBool Result(); |
|
372 |
|
373 /** |
|
374 An accessor function for the object's TDmaTransferArgs |
|
375 */ |
|
376 const TDmaTransferArgs& TransferArgs() const |
|
377 {return iTransferArgs;} |
|
378 |
|
379 // The below methods are setters, which may be chained together |
|
380 // ie. The Named Parameter Idiom |
|
381 // @see http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.18 |
|
382 inline CSingleTransferTest& UseNewRequest(TBool aFlag) {iUseNewRequest=aFlag; return *this;} |
|
383 inline CSingleTransferTest& UseNewFragment(TBool aFlag) {iUseNewFragment=aFlag; return *this;} |
|
384 inline CSingleTransferTest& UseNewDmaApi(TBool aFlag) {UseNewRequest(aFlag); UseNewFragment(aFlag); return *this;} |
|
385 |
|
386 protected: |
|
387 virtual void OpenChannel(); |
|
388 virtual void PreTransferSetup(); |
|
389 virtual void CreateDmaRequest(); |
|
390 virtual void Fragment(); |
|
391 virtual void Queue(); |
|
392 virtual void PostTransferCheck(); |
|
393 virtual TInt DoPostTransferCheck(); |
|
394 virtual void FreeRequest(); |
|
395 virtual void CloseChannel(); |
|
396 |
|
397 protected: |
|
398 /** |
|
399 A handle to kernel side TDmaChannel object received after a channel is opened. |
|
400 */ |
|
401 TUint iChannelSessionCookie; |
|
402 /** |
|
403 A handle to kernel side DDmaRequest object. |
|
404 */ |
|
405 TUint iRequestSessionCookie; |
|
406 |
|
407 const TDmaTransferArgs& iTransferArgs; |
|
408 |
|
409 /** |
|
410 Expected transfer results |
|
411 */ |
|
412 TResultSet iExpected; |
|
413 |
|
414 /** |
|
415 Filled with actual transfer results |
|
416 */ |
|
417 TResultSet iActual; |
|
418 |
|
419 TBool iUseNewRequest; //!< If true then CSingleTransferTest will create a DDmaRequest with the v2 ctor |
|
420 TBool iUseNewFragment; //!< If true then CSingleTransferTest will use v2 Fragment API |
|
421 const TUint iMaxFragmentSize; |
|
422 }; |
|
423 |
|
424 /** |
|
425 This class will be used for tests which benchmark certain DMA operations |
|
426 */ |
|
427 class CDmaBenchmark : public CSingleTransferTest |
|
428 { |
|
429 public: |
|
430 CDmaBenchmark(const TDesC& aName, TInt aIterations, const TResultSet& aExpectedResults, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize); |
|
431 ~CDmaBenchmark(); |
|
432 |
|
433 virtual TBool Result(); |
|
434 |
|
435 static void SelfTest(); |
|
436 |
|
437 protected: |
|
438 /** |
|
439 @return The mean average of the result array |
|
440 */ |
|
441 TUint64 MeanResult(); |
|
442 |
|
443 //TODO must be included within copy ctor or all instances will |
|
444 //share on result set! |
|
445 RArray<TUint64> iResultArray; |
|
446 |
|
447 }; |
|
448 |
|
449 /** |
|
450 Fragments requests (only) and records duration |
|
451 TODO make sure we are using old style DDmaRequest |
|
452 */ |
|
453 class CDmaBmFragmentation : public CDmaBenchmark |
|
454 { |
|
455 public: |
|
456 CDmaBmFragmentation(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize); |
|
457 virtual CTest* Clone() const {return new CDmaBmFragmentation(*this);} |
|
458 virtual TInt DoPostTransferCheck() |
|
459 {TEST_FAULT; return KErrNotSupported;} |
|
460 |
|
461 virtual void RunTest(); |
|
462 virtual void PrintTestType() const; |
|
463 |
|
464 protected: |
|
465 void Fragment(); |
|
466 static const TResultSet ExpectedResults; |
|
467 }; |
|
468 |
|
469 /** |
|
470 Performs a transfer using an old style DDmaRequest and |
|
471 records the duration |
|
472 */ |
|
473 class CDmaBmTransfer : public CDmaBenchmark |
|
474 { |
|
475 public: |
|
476 CDmaBmTransfer(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize); |
|
477 virtual CTest* Clone() const {return new CDmaBmTransfer(*this);} |
|
478 virtual TInt DoPostTransferCheck() |
|
479 {TEST_FAULT; return KErrNotSupported;} |
|
480 |
|
481 virtual void RunTest(); |
|
482 virtual void PrintTestType() const; |
|
483 |
|
484 inline CDmaBmTransfer& UseNewDmaApi(TBool aFlag) {CSingleTransferTest::UseNewDmaApi(aFlag); return *this;} |
|
485 inline CDmaBmTransfer& ExpectedResults(const TResultSet& aArgs) {iExpected=aArgs; return *this;} |
|
486 protected: |
|
487 void Queue(); |
|
488 }; |
|
489 |
|
490 |
|
491 |
|
492 /** |
|
493 Will create and queue multiple requests |
|
494 |
|
495 Unlike CSingleTransferTest the class does not permit the use of TResultSet to |
|
496 define expected results (for neagative testing) |
|
497 */ |
|
498 class CMultiTransferTest : public CDmaTest |
|
499 { |
|
500 public: |
|
501 CMultiTransferTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs* aTransferArgs, const TResultSet* aResultSets, TInt aCount); |
|
502 CMultiTransferTest(const CMultiTransferTest& aOther); |
|
503 virtual ~CMultiTransferTest(); |
|
504 virtual CTest* Clone() const {return new CMultiTransferTest(*this);} |
|
505 |
|
506 virtual TBool Result(); |
|
507 virtual void RunTest(); |
|
508 virtual void PrintTestType() const; |
|
509 |
|
510 inline CMultiTransferTest& PauseWhileQueuing() {iPauseWhileQueuing = ETrue; return *this;} |
|
511 inline CMultiTransferTest& SetPreTransferTest(const MPreTransfer* aPreTfer) {iPreTransfer = aPreTfer; return *this;} |
|
512 inline CMultiTransferTest& SetPostTransferTest(const MPostTransferCheck* aPostTfer) {iPostTransferCheck = aPostTfer; return *this;} |
|
513 |
|
514 const TDmaTransferArgs& TransferArgs(TInt aIndex) const; |
|
515 inline TInt TransferCount() const {return iTransferArgsCount;} |
|
516 |
|
517 void SetPostTransferResult(TInt aIndex, TInt aErrorCode); |
|
518 protected: |
|
519 void OpenChannel(); |
|
520 TInt CloseChannel(); |
|
521 void CreateDmaRequests(); |
|
522 void Fragment(); |
|
523 void QueueRequests(); |
|
524 |
|
525 virtual void PreTransferSetup(); |
|
526 virtual TInt DoPostTransferCheck(); |
|
527 |
|
528 TBool Result(TInt aTransfer); |
|
529 |
|
530 const TDmaTransferArgs* const iTransferArgs; //pointer to an array of transfer args |
|
531 const TInt iTransferArgsCount; |
|
532 |
|
533 |
|
534 TBool iNewDmaApi; //!< If true then CMultiTransferTest will use new style API |
|
535 |
|
536 /** |
|
537 A handle to kernel side TDmaChannel object received after a channel is opened. |
|
538 */ |
|
539 TUint iChannelSessionCookie; |
|
540 RArray<TUint> iRequestCookies; |
|
541 |
|
542 const TResultSet* const iExpectedArray; // array will be of length iTransferArgsCount |
|
543 RArray<TResultSet> iActualResults; |
|
544 |
|
545 /** |
|
546 If set, the test will pause the channel before queuing requests, and |
|
547 resume once they are all queued |
|
548 */ |
|
549 TBool iPauseWhileQueuing; |
|
550 }; |
|
551 |
|
552 /** |
|
553 Used for testing TDmaChannel::IsrRedoRequest |
|
554 |
|
555 Extends CSingle transfer by adding the capability to queue with |
|
556 additonal transfer parameters (TIsrRequeArgs) which are passed |
|
557 to IsrRedoRequest in ISR callback |
|
558 */ |
|
559 class CIsrRequeTest : public CSingleTransferTest |
|
560 { |
|
561 public: |
|
562 CIsrRequeTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aArgs, |
|
563 TIsrRequeArgs* aRequeueArgs, TInt aCount, |
|
564 const TResultSet& aExpected, const MPreTransfer* aPreTfer, |
|
565 const MPostTransferCheck* aPostTferChk, TUint aMaxFragmentSize=0); |
|
566 |
|
567 virtual void PrintTestType() const; |
|
568 |
|
569 virtual void Queue(); |
|
570 |
|
571 /** |
|
572 Compares the actual vs the exepected results and reports |
|
573 of the test passed |
|
574 @return ETrue for a pass, EFalse for a fail |
|
575 */ |
|
576 //virtual TBool Result(); |
|
577 |
|
578 |
|
579 virtual CTest* Clone() const {return new CIsrRequeTest(*this);} |
|
580 |
|
581 const TIsrRequeArgsSet& GetRequeueArgs() const |
|
582 {return iRequeArgSet;} |
|
583 |
|
584 |
|
585 protected: |
|
586 virtual TInt DoPostTransferCheck(); |
|
587 virtual void PreTransferSetup(); |
|
588 |
|
589 TIsrRequeArgsSet iRequeArgSet; |
|
590 }; |
|
591 |
|
592 /** |
|
593 A channel record collects DMA channel capabilities and other PSL information |
|
594 before running tests. |
|
595 */ |
|
596 class TChannelRecord |
|
597 { |
|
598 public: |
|
599 TChannelRecord(){} |
|
600 ~TChannelRecord(){} |
|
601 |
|
602 /** |
|
603 DMA Channel Cookie |
|
604 */ |
|
605 TUint iCookie; |
|
606 |
|
607 /** |
|
608 DMA Channel Capabilities |
|
609 */ |
|
610 TDmacTestCaps iChannelCaps; |
|
611 }; |
|
612 |
|
613 /** |
|
614 A test case collects together a DMA test (CDmaTest), its hardware prerequisites, |
|
615 and other information about how the test should be run. |
|
616 */ |
|
617 class TTestCase |
|
618 { |
|
619 public: |
|
620 //TODO it might be better to group sets of TDmaCapability |
|
621 //into their own class eg. TDmaCapSet. |
|
622 TTestCase(CDmaTest* aTest, |
|
623 TBool aConcurrent = EFalse, |
|
624 const TDmaCapability = TDmaCapability(), |
|
625 const TDmaCapability = TDmaCapability(), |
|
626 const TDmaCapability = TDmaCapability(), |
|
627 const TDmaCapability = TDmaCapability(), |
|
628 const TDmaCapability = TDmaCapability() |
|
629 ); |
|
630 |
|
631 static void SelfTest(); |
|
632 |
|
633 /** |
|
634 Compares the requirements held in the class |
|
635 against those described in aChannelCaps and makes a decision |
|
636 as to whether this test case should be run, skipped, or failed. |
|
637 */ |
|
638 TResult TestCaseValid(const SDmacCaps& aChannelCaps) const; |
|
639 TResult TestCaseValid(const TDmacTestCaps& aChannelCaps) const; |
|
640 |
|
641 enum {KMaxChannelCaps=5}; |
|
642 TDmaCapability iChannelCaps[KMaxChannelCaps]; |
|
643 TUint iChannelType; |
|
644 TInt iTimeout; |
|
645 CDmaTest* iTest; |
|
646 TBool iConcurrentTest; |
|
647 TBool iDmaV2Only; //!< If true then this test cannot be run on DMA v1 framework |
|
648 }; |
|
649 |
|
650 /** |
|
651 A TestRunner manages the whole testing process.Before running any test cases it will open its own RDmaSession |
|
652 handle, not associated with a DMA channel, so that it can recover the TDmaTestInfo object (as used by the |
|
653 existing DMA framework) which says what channels are available to be tested.It will use TTestThread objects |
|
654 to run tests in new threads.TTestThread contains a number of useful features such as waiting for thread exit |
|
655 and accepting a TFunctor object to be run in a new thread. |
|
656 */ |
|
657 class TTestRunner |
|
658 { |
|
659 public: |
|
660 TTestRunner(); |
|
661 ~TTestRunner(); |
|
662 |
|
663 /** |
|
664 This function will populate TTestRunner with an array of test cases which |
|
665 would be a collection of DMA test,its hardware prerequisites,and other |
|
666 information about how the test |
|
667 |
|
668 @aTTestCases on return, this contains an the DMA test cases |
|
669 */ |
|
670 void AddTestCases(RPointerArray<TTestCase>& aTTestCases); |
|
671 |
|
672 /** |
|
673 This will iterate over all test cases held by the test runner and |
|
674 for each one will judge which DMA channels it can be run on, running |
|
675 the test if possible. |
|
676 */ |
|
677 void RunTests(); |
|
678 |
|
679 private: |
|
680 /** |
|
681 This functions retrieves the PSL cookies from all the DMA channels |
|
682 and stores them in a single array. It will use information from |
|
683 the PslTestInfo. |
|
684 */ |
|
685 void GetPslCookie(); |
|
686 |
|
687 /** |
|
688 This function will generate the DMA channel records.i.e channel cookies,Caps. |
|
689 */ |
|
690 void GenerateChannelRecord(); |
|
691 |
|
692 /** |
|
693 Holds the PslTestInfo |
|
694 */ |
|
695 TDmaV2TestInfo iPslTestInfo; |
|
696 |
|
697 /** |
|
698 A handle to RDmaSession |
|
699 */ |
|
700 RDmaSession iDmaSession; |
|
701 |
|
702 /** |
|
703 Array of DMA test cases |
|
704 */ |
|
705 RPointerArray<TTestCase> iTestCases; |
|
706 |
|
707 /** |
|
708 Array of DMA channel records,channel capabilities and other PSL information |
|
709 */ |
|
710 RArray<TChannelRecord> iChannelRecords; |
|
711 |
|
712 /** |
|
713 Array of DMA channel cookies |
|
714 */ |
|
715 RArray<TUint> iPslCookies; |
|
716 }; |
|
717 |
|
718 |
|
719 #endif // #ifndef __T_DMA2_H__ |