|
1 // Copyright (c) 2002-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 "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 // e32test\dmav2\d_dma2.h |
|
15 // User-side API for LDD used to test DMAv2 framework. |
|
16 // |
|
17 // |
|
18 |
|
19 #ifndef __D_DMA2_H__ |
|
20 #define __D_DMA2_H__ |
|
21 |
|
22 #include <e32cmn.h> |
|
23 #include <drivers/dmadefs.h> |
|
24 |
|
25 |
|
26 #define ARRAY_LENGTH(ARRAY) sizeof(ARRAY)/sizeof(ARRAY[0]) |
|
27 |
|
28 #ifdef __KERNEL_MODE__ |
|
29 #include <nkern.h> |
|
30 #include <kernel.h> |
|
31 #define TEST_FAULT FAULT(); |
|
32 #define PRINT(N) Kern::Printf("%s = 0x%08x (%d)", #N, (N), (N)) |
|
33 #else |
|
34 #include <e32std.h> |
|
35 #include <e32debug.h> |
|
36 #define TEST_FAULT RDebug::Printf("Assertion failure in %s, %d", __FILE__, __LINE__); User::Invariant() |
|
37 #define PRINT(N) RDebug::Printf("%s = 0x%08x (%d)", #N, (N), (N)) |
|
38 #endif |
|
39 |
|
40 #define TEST_ASSERT(C) if(!(C)) {TEST_FAULT;} |
|
41 |
|
42 const TUint KPhysAddrInvalidUser=0xFFFFFFFFu; // KPhysAddrInvalid is not defined on the user side |
|
43 #ifdef __KERNEL_MODE__ |
|
44 //if this fails then KPhysAddrInvalidUser must be updated to match |
|
45 //KPhysAddrInvalid |
|
46 __ASSERT_COMPILE(KPhysAddrInvalidUser == KPhysAddrInvalid); |
|
47 #endif |
|
48 |
|
49 |
|
50 _LIT(KTestDmaLddName, "TestDmaV2"); |
|
51 |
|
52 inline TVersion TestDmaLddVersion() { return TVersion(1, 0, 1); } |
|
53 |
|
54 TInt Log2(TInt aNum); |
|
55 |
|
56 /** |
|
57 Indicates the number of each type of call back received |
|
58 and their context |
|
59 |
|
60 TODO as yet, it does not indicate the context of each callback, only |
|
61 the final one |
|
62 */ |
|
63 const TInt KNumberOfCallbacks = 12; |
|
64 |
|
65 class TCallbackRecord |
|
66 { |
|
67 public: |
|
68 enum TCbContext |
|
69 { EInvalid, EThread, EIsr }; |
|
70 |
|
71 TCallbackRecord( |
|
72 TCbContext aContext = EThread, |
|
73 TInt aReq = 0, |
|
74 TInt aReqSrc = 0, |
|
75 TInt aReqDst = 0, |
|
76 |
|
77 TInt aDes = 0, |
|
78 TInt aDesSrc = 0, |
|
79 TInt aDesDst = 0, |
|
80 |
|
81 TInt aFrame = 0, |
|
82 TInt aFrameSrc = 0, |
|
83 TInt aFrameDst = 0, |
|
84 |
|
85 TInt aPause = 0, |
|
86 TInt aPauseSrc = 0, |
|
87 TInt aPauseDst = 0, |
|
88 TDmaResult aResult = EDmaResultOK |
|
89 ); |
|
90 |
|
91 static TCallbackRecord Empty(); |
|
92 |
|
93 void Reset(); |
|
94 |
|
95 /** |
|
96 Allows 2 callback records to be compared |
|
97 */ |
|
98 TBool operator == (const TCallbackRecord aOther) const; |
|
99 void Print() const; |
|
100 |
|
101 /** |
|
102 Get the number of callbacks for callback aCbType |
|
103 */ |
|
104 TInt GetCount(TDmaCallbackType aCbType) const; |
|
105 |
|
106 void SetCount(TDmaCallbackType aCbType, TInt aCount); |
|
107 |
|
108 /** |
|
109 Set the result (expected or actual) from |
|
110 TDmaChannel::IsrRedoRequest |
|
111 */ |
|
112 inline TCallbackRecord& IsrRedoResult(TInt aResult) {iIsrRedoRequestResult = aResult; return *this;} |
|
113 |
|
114 /** |
|
115 Reports the context in which the callback occurred. |
|
116 */ |
|
117 inline TCbContext GetContext() |
|
118 {return iContext;} |
|
119 |
|
120 /** |
|
121 Updates data based on callback mask aCallbackMask |
|
122 @param aCallbackMask Bitmask of callback events @see TDmaCallbackType |
|
123 @oaram aResult The result reported by the current callback |
|
124 */ |
|
125 void ProcessCallback(TUint aCallbackMask, TDmaResult aResultaContext); |
|
126 |
|
127 static void SelfTest(); |
|
128 |
|
129 // The below methods are setters, which may be chained together |
|
130 // ie. The Named Parameter Idiom |
|
131 // @see http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.18 |
|
132 TCallbackRecord& Context(TCbContext aContext) {iContext = aContext; return *this;} |
|
133 |
|
134 private: |
|
135 TInt BitToIndex(TDmaCallbackType aCbType) const; |
|
136 |
|
137 TCbContext CurrentContext() const; |
|
138 |
|
139 TInt iCallbackLog[KNumberOfCallbacks]; |
|
140 |
|
141 TDmaResult iResult; |
|
142 TCbContext iContext; |
|
143 /** Result of the most recent redo request call */ |
|
144 TInt iIsrRedoRequestResult; |
|
145 }; |
|
146 |
|
147 /** |
|
148 Extends SDmacCaps to contain the DMA PIL |
|
149 version being used |
|
150 */ |
|
151 struct TDmacTestCaps : public SDmacCaps |
|
152 { |
|
153 TDmacTestCaps(); |
|
154 TDmacTestCaps(const SDmacCaps& aDmacCaps, TInt aVersion = 2); |
|
155 |
|
156 TInt iPILVersion; |
|
157 }; |
|
158 |
|
159 |
|
160 class TDmaChannel; |
|
161 |
|
162 struct TAddrRange |
|
163 { |
|
164 TAddrRange(TUint aStart, TUint aLength); |
|
165 inline TUint End() const {return (iStart + iLength -1);} |
|
166 inline TUint Start() const {return iStart;} |
|
167 |
|
168 inline TBool Contains(TUint aValue) const {return Rng(iStart, aValue, End());} |
|
169 TBool Contains(TAddrRange aRange) const; |
|
170 |
|
171 TBool Overlaps(const TAddrRange& aRange) const; |
|
172 static void SelfTest(); |
|
173 |
|
174 private: |
|
175 TUint iStart; |
|
176 TUint iLength; |
|
177 }; |
|
178 |
|
179 |
|
180 struct TAddressParms |
|
181 { |
|
182 TAddressParms(TUint32 aSrcAddr=0, TUint32 aDstAddr=0, TUint aTransferCount=0) |
|
183 :iSrcAddr(aSrcAddr), iDstAddr(aDstAddr), iTransferCount(aTransferCount) |
|
184 {} |
|
185 |
|
186 TAddressParms(const TDmaTransferArgs& aArgs) |
|
187 :iSrcAddr(aArgs.iSrcConfig.iAddr), |
|
188 iDstAddr(aArgs.iDstConfig.iAddr), |
|
189 iTransferCount(aArgs.iTransferCount) |
|
190 {} |
|
191 |
|
192 /** |
|
193 If any src, dst, or transfer count are zero, substitute the values from |
|
194 aTransferArgs in their place |
|
195 */ |
|
196 void Substitute(const TDmaTransferArgs& aTransferArgs); |
|
197 |
|
198 /** |
|
199 When recieved by the test driver, src and dst |
|
200 addresses will be offsets from the dma test session's |
|
201 chunk base. They must be converted to absolute, *physical* addresses |
|
202 */ |
|
203 void Fixup(TLinAddr aChunkBase); |
|
204 |
|
205 /** |
|
206 Check that both the src and destination lie within the area |
|
207 defined by aStart and aSize |
|
208 */ |
|
209 TBool CheckRange(TLinAddr aStart, TUint aSize); |
|
210 |
|
211 TAddrRange SourceRange() const; |
|
212 TAddrRange DestRange() const; |
|
213 |
|
214 TBool Overlaps(const TAddrRange aRange) const; |
|
215 TBool Overlaps(const TAddressParms aParm) const; |
|
216 |
|
217 TBool operator==(const TAddressParms& aOther) const; |
|
218 |
|
219 static void SelfTest(); |
|
220 |
|
221 TUint32 iSrcAddr; |
|
222 TUint32 iDstAddr; |
|
223 TUint iTransferCount; |
|
224 }; |
|
225 |
|
226 // These functions can be used for accessing TDmaTransferArgs in |
|
227 // terms of TAddressParms. (TAddressParms would be a natural base |
|
228 // class for TDmaTransferArgs but changing the production code |
|
229 // is undesirable) |
|
230 TAddressParms GetAddrParms(const TDmaTransferArgs&); |
|
231 void SetAddrParms(TDmaTransferArgs&, const TAddressParms&); |
|
232 |
|
233 /** |
|
234 This struct holds the arguments which can be used with TDmaChannel::IsrRedoRequest |
|
235 */ |
|
236 struct TIsrRequeArgs : public TAddressParms |
|
237 { |
|
238 TIsrRequeArgs(TUint32 aSrcAddr=KPhysAddrInvalidUser, TUint32 aDstAddr=KPhysAddrInvalidUser, |
|
239 TUint aTransferCount=0, TUint32 aPslRequestInfo=0, |
|
240 TBool aIsrCb=ETrue) |
|
241 : TAddressParms(aSrcAddr, aDstAddr, aTransferCount), iPslRequestInfo(aPslRequestInfo), iIsrCb(aIsrCb) |
|
242 {} |
|
243 |
|
244 |
|
245 TInt Call(TDmaChannel& aChannel); |
|
246 |
|
247 TBool CheckRange(TLinAddr aStart, TUint aSize) const; |
|
248 |
|
249 TUint32 iPslRequestInfo; |
|
250 TBool iIsrCb; |
|
251 }; |
|
252 class CISrRequeTest; |
|
253 /** |
|
254 A collection of TIsrRequeArgs |
|
255 */ |
|
256 struct TIsrRequeArgsSet |
|
257 { |
|
258 |
|
259 friend class CIsrRequeTest; //TODO see line 394 t_dma2.cpp |
|
260 TIsrRequeArgsSet(TIsrRequeArgs* aRequeueArgs=NULL, TInt aCount =0) |
|
261 :iCount(aCount), iIndex(0) |
|
262 { |
|
263 TEST_ASSERT(iCount <= MaxCount); |
|
264 for(TInt i=0; i<iCount; i++) |
|
265 { |
|
266 iRequeArgs[i] = aRequeueArgs[i]; |
|
267 } |
|
268 |
|
269 } |
|
270 |
|
271 TBool IsEmpty() const |
|
272 {return iCount == 0;} |
|
273 |
|
274 TIsrRequeArgs GetArgs(); |
|
275 |
|
276 void Substitute(const TDmaTransferArgs& aTransferArgs); |
|
277 void Fixup(TLinAddr aChunkBase); |
|
278 TBool CheckRange(TLinAddr aAddr, TUint aSize) const; |
|
279 |
|
280 private: |
|
281 enum {MaxCount=6}; |
|
282 TInt iCount; |
|
283 TInt iIndex; |
|
284 TIsrRequeArgs iRequeArgs[MaxCount]; |
|
285 }; |
|
286 |
|
287 class DDmaTestSession; |
|
288 class RDmaSession : public RBusLogicalChannel |
|
289 { |
|
290 friend class DDmaTestSession; |
|
291 public: |
|
292 #ifndef __KERNEL_MODE__ |
|
293 TInt ChannelIsQueueEmpty(TUint aDriverCookie,TBool& aQueueEmpty) |
|
294 { |
|
295 return DoControl(EIsQueueEmpty, reinterpret_cast<TAny*>(aDriverCookie), &aQueueEmpty); |
|
296 } |
|
297 |
|
298 TInt ChannelIsOpened(TUint aDriverCookie,TBool &aChannelOpen) |
|
299 { |
|
300 return DoControl(EIsOpened, reinterpret_cast<TAny*>(aDriverCookie), &aChannelOpen); |
|
301 } |
|
302 |
|
303 TInt ChannelIsrRedoRequest(TUint aDriverCookie,TUint32 aSrcAddr,TUint32 aDstAddr,TInt aTransferCount,TUint32 aPslRequestInfo,TBool aIsrCb) |
|
304 { |
|
305 TIsrRedoReqArgs args(aDriverCookie,aSrcAddr,aDstAddr,aTransferCount,aPslRequestInfo,aIsrCb); |
|
306 TPckgC<TIsrRedoReqArgs> package(args); |
|
307 return DoControl(EIsrRedoRequest,&package); |
|
308 } |
|
309 |
|
310 TInt ChannelCancelAll(TUint aDriverCookie) |
|
311 { |
|
312 return DoControl(ECancelAllChannel, reinterpret_cast<TAny*>(aDriverCookie)); |
|
313 } |
|
314 |
|
315 TInt ChannelOpen(TUint aPslCookie, TUint& aDriverCookie) |
|
316 { |
|
317 return DoControl(EOpenChannel, reinterpret_cast<TAny*>(aPslCookie), &aDriverCookie); |
|
318 } |
|
319 |
|
320 TInt ChannelClose(TUint aDriverCookie) |
|
321 { |
|
322 return DoControl(ECloseChannel, reinterpret_cast<TAny*>(aDriverCookie)); |
|
323 } |
|
324 |
|
325 TInt ChannelPause(TUint aDriverCookie) |
|
326 { |
|
327 return DoControl(EPauseChannel, reinterpret_cast<TAny*>(aDriverCookie)); |
|
328 } |
|
329 |
|
330 TInt ChannelResume(TUint aDriverCookie) |
|
331 { |
|
332 return DoControl(EResumeChannel, reinterpret_cast<TAny*>(aDriverCookie)); |
|
333 } |
|
334 |
|
335 TInt ChannelCaps(TUint aDriverCookie, SDmacCaps& aChannelCaps) |
|
336 { |
|
337 TDmacTestCaps caps; |
|
338 TInt r = ChannelCaps(aDriverCookie, caps); |
|
339 aChannelCaps = caps; |
|
340 return r; |
|
341 } |
|
342 |
|
343 TInt ChannelCaps(TUint aDriverCookie, TDmacTestCaps& aChannelCaps) |
|
344 { |
|
345 TPckg<TDmacTestCaps> package(aChannelCaps); |
|
346 return DoControl(EChannelCaps, reinterpret_cast<TAny*>(aDriverCookie), &package); |
|
347 } |
|
348 |
|
349 TInt Open() |
|
350 {// TO DO: Add Info , this class is just to test the opening of channels |
|
351 //TPckgBuf<TOpenInfo> infoBuf; |
|
352 //infoBuf().iWhat = TOpenInfo::EOpen; |
|
353 //infoBuf().U.iOpen.iId = aId; |
|
354 //infoBuf().U.iOpen.iDesCount = aDesCount; |
|
355 //infoBuf().U.iOpen.iMaxTransferSize = aMaxTransferSize; |
|
356 return DoCreate(KTestDmaLddName,TestDmaLddVersion(), 0, NULL, NULL, EOwnerThread); |
|
357 } |
|
358 |
|
359 //TODO rename this (append "old") |
|
360 TInt RequestCreate(TUint aChannelCookie, TUint& aRequestCookie, TUint aMaxTransferSize=0) |
|
361 { |
|
362 return DoRequestCreate(aChannelCookie, EFalse, aMaxTransferSize, aRequestCookie); |
|
363 } |
|
364 |
|
365 //TODO rename this (get rid of "new" |
|
366 TInt RequestCreateNew(TUint aChannelCookie, TUint& aRequestCookie, TUint aMaxTransferSize=0) |
|
367 { |
|
368 return DoRequestCreate(aChannelCookie, ETrue, aMaxTransferSize, aRequestCookie); |
|
369 } |
|
370 |
|
371 TInt RequestDestroy(TUint aRequestCookie) |
|
372 { |
|
373 return DoControl(ERequestClose, reinterpret_cast<TAny*>(aRequestCookie)); |
|
374 } |
|
375 |
|
376 TInt RequestFragmentCount(TUint aRequestCookie) |
|
377 { |
|
378 return DoControl(EFragmentCount, reinterpret_cast<TAny*>(aRequestCookie)); |
|
379 } |
|
380 |
|
381 /** |
|
382 Will fragment a DMA request using the legacy API |
|
383 */ |
|
384 TInt FragmentRequestOld(TUint aRequestCookie, const TDmaTransferArgs& aTransferArgs, TUint64* aDurationMicroSecs=NULL) |
|
385 { |
|
386 const TFragmentArgs args(aRequestCookie, aTransferArgs, aDurationMicroSecs); |
|
387 TPckgC<TFragmentArgs> package(args); |
|
388 return DoControl(EFragmentLegacy, &package); |
|
389 } |
|
390 |
|
391 /** |
|
392 Will fragment a DMA request using the new API |
|
393 */ |
|
394 TInt FragmentRequest(TUint aRequestCookie, const TDmaTransferArgs& aTransferArgs, TUint64* aDurationMicroSecs=NULL) |
|
395 { |
|
396 const TFragmentArgs args(aRequestCookie, aTransferArgs, aDurationMicroSecs); |
|
397 TPckgC<TFragmentArgs> package(args); |
|
398 return DoControl(EFragment, &package); |
|
399 } |
|
400 |
|
401 TInt QueueRequest(TUint aRequestCookie, TRequestStatus& aStatus, TCallbackRecord* aRecord = NULL, TUint64* aDurationMicroSecs=NULL) |
|
402 { |
|
403 //These dummy values can accept the writeback from the driver |
|
404 //if the client does not want them. |
|
405 //(TClientDataRequest can not be programmed with a NULL to |
|
406 //indicate that an argument is unwanted) |
|
407 TCallbackRecord dummyRec; |
|
408 TUint64 dummyTime=0; |
|
409 |
|
410 TQueueArgs args(aRequestCookie, &aStatus, aRecord ? aRecord : &dummyRec, aDurationMicroSecs ? aDurationMicroSecs : &dummyTime); |
|
411 TPckgC<TQueueArgs> package(args); |
|
412 return DoControl(EQueueRequest, &package); |
|
413 } |
|
414 |
|
415 /** |
|
416 Synchronous version of QueueRequest |
|
417 */ |
|
418 TInt QueueRequest(TUint aRequestCookie, TCallbackRecord* aRecord = NULL, TUint64* aDurationMicroSecs=NULL) |
|
419 { |
|
420 TRequestStatus status; |
|
421 TInt r = QueueRequest(aRequestCookie, status, aRecord, aDurationMicroSecs); |
|
422 User::WaitForRequest(status); |
|
423 return r; |
|
424 } |
|
425 |
|
426 /** |
|
427 Queue a previously fragmented request. |
|
428 Additional request parameters are included in iRequeueArgs, these will be |
|
429 transferred from ISR context callback using the TDmaChannel::IsrRedoRequest function |
|
430 |
|
431 @pre Isr callback for completion must have been requested at request fragmentation time |
|
432 */ |
|
433 TInt QueueRequestWithRequeue(TUint aRequestCookie, TIsrRequeArgs* aRequeueArgs, TInt aCount, TRequestStatus& aStatus, TCallbackRecord* aRecord = NULL, TUint64* aDurationMicroSecs=NULL) |
|
434 { |
|
435 //These dummy values can accept the writeback from the driver |
|
436 //if the client does not want them. |
|
437 //(TClientDataRequest can not be programmed with a NULL to |
|
438 //indicate that an argument is unwanted) |
|
439 TCallbackRecord dummyRec; |
|
440 TUint64 dummyTime=0; |
|
441 |
|
442 TQueueArgsWithReque args(aRequeueArgs, aCount, aRequestCookie, &aStatus, aRecord ? aRecord : &dummyRec, aDurationMicroSecs ? aDurationMicroSecs : &dummyTime); |
|
443 TPckgC<TQueueArgsWithReque> package(args); |
|
444 return DoControl(EQueueRequestWithReque, &package); |
|
445 } |
|
446 |
|
447 /** |
|
448 Synchronous version of QueueRequestWithRequeue |
|
449 */ |
|
450 TInt QueueRequestWithRequeue(TUint aRequestCookie, TIsrRequeArgs* aRequeueArgs, TInt aCount, TCallbackRecord* aRecord = NULL, TUint64* aDurationMicroSecs=NULL) |
|
451 { |
|
452 TRequestStatus status; |
|
453 TInt r = QueueRequestWithRequeue(aRequestCookie, aRequeueArgs, aCount, status, aRecord, aDurationMicroSecs); |
|
454 User::WaitForRequest(status); |
|
455 return r; |
|
456 } |
|
457 |
|
458 TInt OpenSharedChunk(RChunk& aChunk) |
|
459 { |
|
460 TUint chunkHandle = DoControl(EOpenSharedChunk); |
|
461 return aChunk.SetReturnedHandle(chunkHandle); |
|
462 } |
|
463 |
|
464 TInt GetTestInfo(TDmaV2TestInfo& aInfo) |
|
465 { |
|
466 TPckg<TDmaV2TestInfo> package(aInfo); |
|
467 return DoControl(EGetTestInfo, &package); |
|
468 } |
|
469 |
|
470 static void SelfTest(); |
|
471 |
|
472 static void ApiTest(); |
|
473 #endif // __KERNEL_MODE__ |
|
474 |
|
475 private: |
|
476 |
|
477 TInt DoRequestCreate(TUint aChannelCookie, TBool aNewStyle, TUint aMaxTransferSize, TUint& aRequestCookie) |
|
478 { |
|
479 TRequestCreateArgs args(aChannelCookie, aNewStyle, aMaxTransferSize); |
|
480 TPckgC<TRequestCreateArgs> package(args); |
|
481 return DoControl(ERequestOpen, &package, &aRequestCookie); |
|
482 } |
|
483 |
|
484 |
|
485 struct TRequestCreateArgs |
|
486 { |
|
487 TRequestCreateArgs(TUint aChannelCookie, TBool aNewStyle, TUint aMaxFragmentSize) |
|
488 :iChannelCookie(aChannelCookie), iNewStyle(aNewStyle), iMaxFragmentSize(aMaxFragmentSize) |
|
489 {} |
|
490 |
|
491 TUint iChannelCookie; |
|
492 TBool iNewStyle; |
|
493 TUint iMaxFragmentSize; |
|
494 }; |
|
495 |
|
496 struct TFragmentArgs |
|
497 { |
|
498 TFragmentArgs() |
|
499 :iRequestCookie(0), iTransferArgs(), iDurationMicroSecs(NULL) |
|
500 {} |
|
501 TFragmentArgs(TUint aRequestCookie, const TDmaTransferArgs& aTransferArgs, TUint64* aDurationMicroSecs = NULL) |
|
502 :iRequestCookie(aRequestCookie), iTransferArgs(aTransferArgs), iDurationMicroSecs(aDurationMicroSecs) |
|
503 {} |
|
504 |
|
505 const TUint iRequestCookie; |
|
506 const TDmaTransferArgs iTransferArgs; |
|
507 TUint64* const iDurationMicroSecs; |
|
508 }; |
|
509 |
|
510 struct TQueueArgs |
|
511 { |
|
512 TQueueArgs(TUint aRequestCookie=0, TRequestStatus* aStatus=NULL, TCallbackRecord* aCallbackRecord=NULL, TUint64* aDurationMicroSecs=NULL) |
|
513 :iRequestCookie(aRequestCookie), iStatus(aStatus), iCallbackRecord(aCallbackRecord), iDurationMicroSecs(aDurationMicroSecs) |
|
514 {} |
|
515 TUint iRequestCookie; |
|
516 TRequestStatus* iStatus; |
|
517 TCallbackRecord* iCallbackRecord; |
|
518 TUint64* iDurationMicroSecs; |
|
519 }; |
|
520 |
|
521 struct TIsrRedoReqArgs |
|
522 { |
|
523 TIsrRedoReqArgs(TUint aDriverCookie=0,TUint32 aSrcAddr=0, TUint32 aDstAddr=0, TInt aTransferCount=0, TUint32 aPslRequestInfo=0,TBool aIsrCb=ETrue) |
|
524 :iDriverCookie(aDriverCookie),iSrcAddr(aSrcAddr),iDstAddr(aDstAddr),iTransferCount(aTransferCount),iPslRequestInfo(aPslRequestInfo),iIsrCb(aIsrCb) |
|
525 {} |
|
526 TUint iDriverCookie; |
|
527 TUint32 iSrcAddr; |
|
528 TUint32 iDstAddr; |
|
529 TInt iTransferCount; |
|
530 TUint32 iPslRequestInfo; |
|
531 TBool iIsrCb; |
|
532 }; |
|
533 |
|
534 /** |
|
535 This struct is used for queing and including a set of transfers |
|
536 to be setup from ISR context callback |
|
537 */ |
|
538 struct TQueueArgsWithReque : public TQueueArgs |
|
539 { |
|
540 TQueueArgsWithReque(TIsrRequeArgs* aRequeueArgs=NULL, TInt aCount=0, |
|
541 TUint aRequestCookie=0, TRequestStatus* aStatus=NULL, TCallbackRecord* aCallbackRecord=NULL, TUint64* aDurationMicroSecs=NULL) |
|
542 :TQueueArgs(aRequestCookie, aStatus, aCallbackRecord, aDurationMicroSecs), iRequeSet(aRequeueArgs, aCount) |
|
543 { |
|
544 } |
|
545 |
|
546 TIsrRequeArgsSet iRequeSet; |
|
547 }; |
|
548 |
|
549 |
|
550 enum TControl |
|
551 { |
|
552 EOpenChannel, |
|
553 ECloseChannel, |
|
554 EPauseChannel, |
|
555 EResumeChannel, |
|
556 EChannelCaps, |
|
557 ERequestOpen, |
|
558 ERequestClose, |
|
559 EOpenSharedChunk, |
|
560 EFragmentLegacy, |
|
561 EFragment, |
|
562 EFragmentCount, |
|
563 EQueueRequest, |
|
564 EGetTestInfo, |
|
565 EIsQueueEmpty, |
|
566 EIsOpened, |
|
567 EIsrRedoRequest, |
|
568 ECancelAllChannel, |
|
569 EQueueRequestWithReque |
|
570 }; |
|
571 }; |
|
572 #endif // __D_DMA2_H__ |