1
2
3
4
5
6
7
8#include <common.h>
9
10#include <MCD_dma.h>
11#include <MCD_tasksInit.h>
12#include <MCD_progCheck.h>
13
14
15
16dmaRegs *MCD_dmaBar;
17
18
19
20
21
22extern TaskTableEntry MCD_realTaskTableSrc[NCHANNELS];
23extern TaskTableEntry MCD_modelTaskTableSrc[NUMOFVARIANTS];
24
25
26
27
28
29volatile TaskTableEntry *MCD_taskTable;
30TaskTableEntry *MCD_modelTaskTable;
31
32
33
34
35
36
37static int MCD_chStatus[NCHANNELS] = {
38 MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA,
39 MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA,
40 MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA,
41 MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA, MCD_NO_DMA
42};
43
44
45static void MCD_memcpy(int *dest, int *src, u32 size);
46static void MCD_resmActions(int channel);
47
48
49
50
51
52
53#ifdef MCD_INCLUDE_EU
54extern MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
55#else
56MCD_bufDesc MCD_singleBufDescs[NCHANNELS];
57#endif
58MCD_bufDesc *MCD_relocBuffDesc;
59
60
61#define DBG_CTL_COMP1_TASK (0x00002000)
62#define DBG_CTL_ENABLE (DBG_CTL_AUTO_ARM | \
63 DBG_CTL_BREAK | \
64 DBG_CTL_INT_BREAK | \
65 DBG_CTL_COMP1_TASK)
66#define DBG_CTL_DISABLE (DBG_CTL_AUTO_ARM | \
67 DBG_CTL_INT_BREAK | \
68 DBG_CTL_COMP1_TASK)
69#define DBG_KILL_ALL_STAT (0xFFFFFFFF)
70
71
72#define CSAVE_OFFSET 10
73
74
75#define MCD_BYTE_SWAP_KILLER 0xFFF8888F
76#define MCD_NO_BYTE_SWAP_ATALL 0x00040000
77
78
79#define MAC 0
80#define LUAC 1
81#define CRC 2
82#define LURC 3
83
84
85#define TASK_CHAINNOEU 0
86#define TASK_SINGLENOEU 1
87#ifdef MCD_INCLUDE_EU
88#define TASK_CHAINEU 2
89#define TASK_SINGLEEU 3
90#define TASK_FECRX 4
91#define TASK_FECTX 5
92#else
93#define TASK_CHAINEU 0
94#define TASK_SINGLEEU 1
95#define TASK_FECRX 2
96#define TASK_FECTX 3
97#endif
98
99
100
101
102
103typedef struct MCD_remVariants_struct MCD_remVariant;
104struct MCD_remVariants_struct {
105 int remDestRsdIncr[NCHANNELS];
106 int remSrcRsdIncr[NCHANNELS];
107 s16 remDestIncr[NCHANNELS];
108 s16 remSrcIncr[NCHANNELS];
109 u32 remXferSize[NCHANNELS];
110};
111
112
113MCD_remVariant MCD_remVariants;
114
115
116
117
118
119
120
121
122
123
124
125
126
127extern u32 MCD_funcDescTab0[];
128
129int MCD_initDma(dmaRegs * dmaBarAddr, void *taskTableDest, u32 flags)
130{
131 int i;
132 TaskTableEntry *entryPtr;
133
134
135 MCD_dmaBar = dmaBarAddr;
136
137
138 if ((flags & MCD_RELOC_TASKS) != 0) {
139 int fixedSize;
140 u32 *fixedPtr;
141
142 int varTabsOffset, funcDescTabsOffset, contextSavesOffset;
143 int taskDescTabsOffset;
144 int taskTableSize, varTabsSize, funcDescTabsSize,
145 contextSavesSize;
146 int taskDescTabSize;
147
148 int i;
149
150
151 if (((u32) taskTableDest & 0x000001ff) != 0)
152 return (MCD_TABLE_UNALIGNED);
153
154
155 MCD_taskTable = taskTableDest;
156
157
158
159
160
161
162
163
164
165
166 taskTableSize = NCHANNELS * sizeof(TaskTableEntry);
167
168 varTabsOffset = taskTableSize + (u32) taskTableDest;
169 if ((varTabsOffset & (VAR_TAB_SIZE - 1)) != 0)
170 varTabsOffset =
171 (varTabsOffset + VAR_TAB_SIZE) & (~VAR_TAB_SIZE);
172
173 varTabsSize = NCHANNELS * VAR_TAB_SIZE;
174 funcDescTabsOffset = varTabsOffset + varTabsSize;
175
176 if ((funcDescTabsOffset & (FUNCDESC_TAB_SIZE - 1)) != 0)
177 funcDescTabsOffset =
178 (funcDescTabsOffset +
179 FUNCDESC_TAB_SIZE) & (~FUNCDESC_TAB_SIZE);
180
181 funcDescTabsSize = FUNCDESC_TAB_NUM * FUNCDESC_TAB_SIZE;
182 contextSavesOffset = funcDescTabsOffset + funcDescTabsSize;
183 contextSavesSize = (NCHANNELS * CONTEXT_SAVE_SIZE);
184 fixedSize =
185 taskTableSize + varTabsSize + funcDescTabsSize +
186 contextSavesSize;
187
188
189 fixedPtr = (u32 *) taskTableDest;
190 for (i = 0; i < (fixedSize / 4); i++)
191 fixedPtr[i] = 0;
192
193 entryPtr = (TaskTableEntry *) MCD_taskTable;
194
195 for (i = 0; i < NCHANNELS; i++) {
196
197 entryPtr[i].varTab = (u32) varTabsOffset;
198 entryPtr[i].FDTandFlags =
199 (u32) funcDescTabsOffset | MCD_TT_FLAGS_DEF;
200 entryPtr[i].contextSaveSpace = (u32) contextSavesOffset;
201 varTabsOffset += VAR_TAB_SIZE;
202#ifdef MCD_INCLUDE_EU
203
204
205 funcDescTabsOffset += FUNCDESC_TAB_SIZE;
206#endif
207 contextSavesOffset += CONTEXT_SAVE_SIZE;
208 }
209
210 for (i = 0; i < FUNCDESC_TAB_NUM; i++) {
211 MCD_memcpy((void *)(entryPtr[i].
212 FDTandFlags & ~MCD_TT_FLAGS_MASK),
213 (void *)MCD_funcDescTab0, FUNCDESC_TAB_SIZE);
214 }
215
216
217
218 MCD_modelTaskTable = (TaskTableEntry *) contextSavesOffset;
219
220 MCD_memcpy((void *)MCD_modelTaskTable,
221 (void *)MCD_modelTaskTableSrc,
222 NUMOFVARIANTS * sizeof(TaskTableEntry));
223
224
225 entryPtr = MCD_modelTaskTable;
226 taskDescTabsOffset = (u32) MCD_modelTaskTable +
227 (NUMOFVARIANTS * sizeof(TaskTableEntry));
228
229
230
231 for (i = 0; i < NUMOFVARIANTS; i++) {
232 taskDescTabSize =
233 entryPtr[i].TDTend - entryPtr[i].TDTstart + 4;
234 MCD_memcpy((void *)taskDescTabsOffset,
235 (void *)entryPtr[i].TDTstart,
236 taskDescTabSize);
237 entryPtr[i].TDTstart = (u32) taskDescTabsOffset;
238 taskDescTabsOffset += taskDescTabSize;
239 entryPtr[i].TDTend = (u32) taskDescTabsOffset - 4;
240 }
241#ifdef MCD_INCLUDE_EU
242
243
244 MCD_relocBuffDesc =
245 (MCD_bufDesc *) (entryPtr[NUMOFVARIANTS - 1].TDTend + 4);
246#else
247
248
249 MCD_relocBuffDesc = MCD_singleBufDescs;
250#endif
251 } else {
252
253
254
255 if (((u32) MCD_realTaskTableSrc & 0x000001ff) != 0)
256 return (MCD_TABLE_UNALIGNED);
257
258
259
260
261
262 entryPtr = MCD_realTaskTableSrc;
263 for (i = 0; i < NCHANNELS; i++) {
264 if (((entryPtr[i].varTab & (VAR_TAB_SIZE - 1)) != 0) ||
265 ((entryPtr[i].
266 FDTandFlags & (FUNCDESC_TAB_SIZE - 1)) != 0))
267 return (MCD_TABLE_UNALIGNED);
268 }
269
270 MCD_taskTable = MCD_realTaskTableSrc;
271 MCD_modelTaskTable = MCD_modelTaskTableSrc;
272 MCD_relocBuffDesc = MCD_singleBufDescs;
273 }
274
275
276
277 MCD_dmaBar->taskbar = (u32) MCD_taskTable;
278 for (i = 0; i < NCHANNELS; i++) {
279 MCD_dmaBar->taskControl[i] = 0x0;
280 MCD_chStatus[i] = MCD_NO_DMA;
281 }
282
283
284
285 MCD_dmaBar->debugComp1 = 0;
286 MCD_dmaBar->debugComp2 = 0;
287 MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
288 MCD_dmaBar->debugStatus = DBG_KILL_ALL_STAT;
289
290
291
292 if ((flags & MCD_COMM_PREFETCH_EN) != 0)
293 MCD_dmaBar->ptdControl &= ~PTD_CTL_COMM_PREFETCH;
294 else
295 MCD_dmaBar->ptdControl |= PTD_CTL_COMM_PREFETCH;
296
297 return (MCD_OK);
298}
299
300
301
302
303
304
305
306
307
308int MCD_dmaStatus(int channel)
309{
310 u16 tcrValue;
311
312 if ((channel < 0) || (channel >= NCHANNELS))
313 return (MCD_CHANNEL_INVALID);
314
315 tcrValue = MCD_dmaBar->taskControl[channel];
316 if ((tcrValue & TASK_CTL_EN) == 0) {
317
318 if (MCD_chStatus[channel] == MCD_RUNNING
319 || MCD_chStatus[channel] == MCD_IDLE)
320 MCD_chStatus[channel] = MCD_DONE;
321 } else {
322
323
324 if (MCD_chStatus[channel] == MCD_RUNNING
325 || MCD_chStatus[channel] == MCD_IDLE) {
326 MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
327
328
329 if ((MCD_dmaBar->ptdDebug >> channel) & 0x1)
330 MCD_chStatus[channel] = MCD_RUNNING;
331 else
332 MCD_chStatus[channel] = MCD_IDLE;
333
334 }
335 }
336 return MCD_chStatus[channel];
337}
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359int MCD_startDma(int channel, s8 * srcAddr, s16 srcIncr, s8 * destAddr,
360 s16 destIncr, u32 dmaSize, u32 xferSize, u32 initiator,
361 int priority, u32 flags, u32 funcDesc
362#ifdef MCD_NEED_ADDR_TRANS
363 s8 * srcAddrVirt
364#endif
365 )
366{
367 int srcRsdIncr, destRsdIncr;
368 int *cSave;
369 short xferSizeIncr;
370 int tcrCount = 0;
371#ifdef MCD_INCLUDE_EU
372 u32 *realFuncArray;
373#endif
374
375 if ((channel < 0) || (channel >= NCHANNELS))
376 return (MCD_CHANNEL_INVALID);
377
378
379
380
381#ifndef MCD_INCLUDE_EU
382 funcDesc = MCD_FUNC_NOEU1;
383#endif
384
385#ifdef MCD_DEBUG
386 printf("startDma:Setting up params\n");
387#endif
388
389
390
391
392
393
394 MCD_dmaBar->ptdControl |= (u16) 0x8000;
395
396
397#if 1
398
399 srcRsdIncr = srcIncr < 0 ? -1 : (srcIncr > 0 ? 1 : 0);
400 destRsdIncr = destIncr < 0 ? -1 : (destIncr > 0 ? 1 : 0);
401
402 xferSizeIncr = (xferSize & 0xffff) | 0x20000000;
403
404
405 MCD_remVariants.remSrcRsdIncr[channel] = srcRsdIncr;
406 MCD_remVariants.remDestRsdIncr[channel] = destRsdIncr;
407 MCD_remVariants.remDestIncr[channel] = destIncr;
408 MCD_remVariants.remSrcIncr[channel] = srcIncr;
409 MCD_remVariants.remXferSize[channel] = xferSize;
410#endif
411
412 cSave =
413 (int *)(MCD_taskTable[channel].contextSaveSpace) + CSAVE_OFFSET +
414 CURRBD;
415
416#ifdef MCD_INCLUDE_EU
417
418 realFuncArray =
419 (u32 *) (MCD_taskTable[channel].FDTandFlags & 0xffffff00);
420
421
422 realFuncArray[(LURC * 16)] = xferSize == 4 ?
423 funcDesc : xferSize == 2 ?
424 funcDesc & 0xfffff00f : funcDesc & 0xffff000f;
425 realFuncArray[(LURC * 16 + 1)] =
426 (funcDesc & MCD_BYTE_SWAP_KILLER) | MCD_NO_BYTE_SWAP_ATALL;
427#endif
428
429
430
431
432
433 MCD_dmaBar->taskControl[channel] =
434 (initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM;
435
436 while (((MCD_dmaBar->taskControl[channel] & 0x1fff) !=
437 ((initiator << 8) | TASK_CTL_HIPRITSKEN | TASK_CTL_HLDINITNUM))
438 && (tcrCount < 1000)) {
439 tcrCount++;
440
441 MCD_dmaBar->taskControl[channel] =
442 (initiator << 8) | TASK_CTL_HIPRITSKEN |
443 TASK_CTL_HLDINITNUM;
444 }
445
446 MCD_dmaBar->priority[channel] = (u8) priority & PRIORITY_PRI_MASK;
447
448
449 if (channel < 8 && channel >= 0) {
450 MCD_dmaBar->taskSize0 &= ~(0xf << (7 - channel) * 4);
451 MCD_dmaBar->taskSize0 |=
452 (xferSize & 3) << (((7 - channel) * 4) + 2);
453 MCD_dmaBar->taskSize0 |= (xferSize & 3) << ((7 - channel) * 4);
454 } else {
455 MCD_dmaBar->taskSize1 &= ~(0xf << (15 - channel) * 4);
456 MCD_dmaBar->taskSize1 |=
457 (xferSize & 3) << (((15 - channel) * 4) + 2);
458 MCD_dmaBar->taskSize1 |= (xferSize & 3) << ((15 - channel) * 4);
459 }
460
461
462
463 MCD_taskTable[channel].FDTandFlags &= ~MCD_TT_FLAGS_MASK;
464 MCD_taskTable[channel].FDTandFlags |= (MCD_TT_FLAGS_MASK & flags);
465
466 if (flags & MCD_FECTX_DMA) {
467
468 MCD_taskTable[channel].TDTstart =
469 MCD_modelTaskTable[TASK_FECTX].TDTstart;
470 MCD_taskTable[channel].TDTend =
471 MCD_modelTaskTable[TASK_FECTX].TDTend;
472 MCD_startDmaENetXmit((char *)srcAddr, (char *)srcAddr,
473 (char *)destAddr, MCD_taskTable,
474 channel);
475 } else if (flags & MCD_FECRX_DMA) {
476
477 MCD_taskTable[channel].TDTstart =
478 MCD_modelTaskTable[TASK_FECRX].TDTstart;
479 MCD_taskTable[channel].TDTend =
480 MCD_modelTaskTable[TASK_FECRX].TDTend;
481 MCD_startDmaENetRcv((char *)srcAddr, (char *)srcAddr,
482 (char *)destAddr, MCD_taskTable,
483 channel);
484 } else if (flags & MCD_SINGLE_DMA) {
485
486
487
488
489
490 MCD_relocBuffDesc[channel].srcAddr = srcAddr;
491 MCD_relocBuffDesc[channel].destAddr = destAddr;
492
493
494 MCD_relocBuffDesc[channel].lastDestAddr = destAddr;
495
496 MCD_relocBuffDesc[channel].dmaSize = dmaSize;
497 MCD_relocBuffDesc[channel].flags = 0;
498 MCD_relocBuffDesc[channel].csumResult = 0;
499 MCD_relocBuffDesc[channel].next = 0;
500
501
502
503 ((volatile int *)MCD_taskTable[channel].
504 contextSaveSpace)[SRCPTR + CSAVE_OFFSET] = (int)srcAddr;
505 ((volatile int *)MCD_taskTable[channel].
506 contextSaveSpace)[DESTPTR + CSAVE_OFFSET] = (int)destAddr;
507 ((volatile int *)MCD_taskTable[channel].
508 contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
509 ((volatile int *)MCD_taskTable[channel].
510 contextSaveSpace)[CURRBD + CSAVE_OFFSET] =
511(u32) & (MCD_relocBuffDesc[channel]);
512
513
514 if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) {
515
516 MCD_taskTable[channel].TDTstart =
517 MCD_modelTaskTable[TASK_SINGLENOEU].TDTstart;
518 MCD_taskTable[channel].TDTend =
519 MCD_modelTaskTable[TASK_SINGLENOEU].TDTend;
520 MCD_startDmaSingleNoEu((char *)srcAddr, srcIncr,
521 (char *)destAddr, destIncr,
522 (int)dmaSize, xferSizeIncr,
523 flags, (int *)
524 &(MCD_relocBuffDesc[channel]),
525 cSave, MCD_taskTable, channel);
526 } else {
527
528 MCD_taskTable[channel].TDTstart =
529 MCD_modelTaskTable[TASK_SINGLEEU].TDTstart;
530 MCD_taskTable[channel].TDTend =
531 MCD_modelTaskTable[TASK_SINGLEEU].TDTend;
532 MCD_startDmaSingleEu((char *)srcAddr, srcIncr,
533 (char *)destAddr, destIncr,
534 (int)dmaSize, xferSizeIncr,
535 flags, (int *)
536 &(MCD_relocBuffDesc[channel]),
537 cSave, MCD_taskTable, channel);
538 }
539 } else {
540
541
542#if 1
543
544 ((volatile int *)MCD_taskTable[channel].
545 contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
546 = (int)((MCD_bufDesc *) srcAddr)->srcAddr;
547 ((volatile int *)MCD_taskTable[channel].
548 contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
549 = (int)((MCD_bufDesc *) srcAddr)->destAddr;
550#else
551
552
553 ((volatile int *)MCD_taskTable[channel].
554 contextSaveSpace)[SRCPTR + CSAVE_OFFSET]
555 = (int)((MCD_bufDesc *) srcAddrVirt)->srcAddr;
556 ((volatile int *)MCD_taskTable[channel].
557 contextSaveSpace)[DESTPTR + CSAVE_OFFSET]
558 = (int)((MCD_bufDesc *) srcAddrVirt)->destAddr;
559#endif
560 ((volatile int *)MCD_taskTable[channel].
561 contextSaveSpace)[DCOUNT + CSAVE_OFFSET] = 0;
562 ((volatile int *)MCD_taskTable[channel].
563 contextSaveSpace)[CURRBD + CSAVE_OFFSET] = (u32) srcAddr;
564
565 if (funcDesc == MCD_FUNC_NOEU1 || funcDesc == MCD_FUNC_NOEU2) {
566
567 MCD_taskTable[channel].TDTstart =
568 MCD_modelTaskTable[TASK_CHAINNOEU].TDTstart;
569 MCD_taskTable[channel].TDTend =
570 MCD_modelTaskTable[TASK_CHAINNOEU].TDTend;
571 MCD_startDmaChainNoEu((int *)srcAddr, srcIncr,
572 destIncr, xferSize,
573 xferSizeIncr, cSave,
574 MCD_taskTable, channel);
575 } else {
576
577 MCD_taskTable[channel].TDTstart =
578 MCD_modelTaskTable[TASK_CHAINEU].TDTstart;
579 MCD_taskTable[channel].TDTend =
580 MCD_modelTaskTable[TASK_CHAINEU].TDTend;
581 MCD_startDmaChainEu((int *)srcAddr, srcIncr, destIncr,
582 xferSize, xferSizeIncr, cSave,
583 MCD_taskTable, channel);
584 }
585 }
586 MCD_chStatus[channel] = MCD_IDLE;
587 return (MCD_OK);
588}
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620#define STABTIME 0
621
622int MCD_XferProgrQuery(int channel, MCD_XferProg * progRep)
623{
624 MCD_XferProg prevRep;
625 int again;
626
627 int i;
628 int destDiffBytes;
629
630 int numIterations;
631 int bytesNotXfered;
632 s8 *LWAlignedInitDestAddr, *LWAlignedCurrDestAddr;
633 int subModVal, addModVal;
634
635
636 if ((channel < 0) || (channel >= NCHANNELS))
637 return (MCD_CHANNEL_INVALID);
638
639
640 prevRep.lastSrcAddr =
641 (s8 *) ((volatile int *)MCD_taskTable[channel].
642 contextSaveSpace)[SRCPTR + CSAVE_OFFSET];
643 prevRep.lastDestAddr =
644 (s8 *) ((volatile int *)MCD_taskTable[channel].
645 contextSaveSpace)[DESTPTR + CSAVE_OFFSET];
646 prevRep.dmaSize =
647 ((volatile int *)MCD_taskTable[channel].contextSaveSpace)[DCOUNT +
648 CSAVE_OFFSET];
649 prevRep.currBufDesc =
650 (MCD_bufDesc *) ((volatile int *)MCD_taskTable[channel].
651 contextSaveSpace)[CURRBD + CSAVE_OFFSET];
652
653 do {
654
655 for (i = 0; i < STABTIME; i++) {
656
657
658 i += i >> 2;
659 }
660
661 progRep->lastSrcAddr =
662 (s8 *) ((volatile int *)MCD_taskTable[channel].
663 contextSaveSpace)[SRCPTR + CSAVE_OFFSET];
664 progRep->lastDestAddr =
665 (s8 *) ((volatile int *)MCD_taskTable[channel].
666 contextSaveSpace)[DESTPTR + CSAVE_OFFSET];
667 progRep->dmaSize =
668 ((volatile int *)MCD_taskTable[channel].
669 contextSaveSpace)[DCOUNT + CSAVE_OFFSET];
670 progRep->currBufDesc =
671 (MCD_bufDesc *) ((volatile int *)MCD_taskTable[channel].
672 contextSaveSpace)[CURRBD + CSAVE_OFFSET];
673
674 if (prevRep.lastSrcAddr != progRep->lastSrcAddr
675 || prevRep.lastDestAddr != progRep->lastDestAddr
676 || prevRep.dmaSize != progRep->dmaSize
677 || prevRep.currBufDesc != progRep->currBufDesc) {
678
679
680 prevRep.lastSrcAddr = progRep->lastSrcAddr;
681 prevRep.lastDestAddr = progRep->lastDestAddr;
682 prevRep.dmaSize = progRep->dmaSize;
683 prevRep.currBufDesc = progRep->currBufDesc;
684 again = MCD_TRUE;
685 } else
686 again = MCD_FALSE;
687 } while (again == MCD_TRUE);
688
689
690
691
692 switch (MCD_remVariants.remDestRsdIncr[channel]) {
693 case MINUS1:
694 subModVal =
695 ((int)progRep->
696 lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) -
697 1);
698 addModVal =
699 ((int)progRep->currBufDesc->
700 destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
701 LWAlignedInitDestAddr =
702 (progRep->currBufDesc->destAddr) - addModVal;
703 LWAlignedCurrDestAddr = (progRep->lastDestAddr) - subModVal;
704 destDiffBytes = LWAlignedInitDestAddr - LWAlignedCurrDestAddr;
705 bytesNotXfered =
706 (destDiffBytes / MCD_remVariants.remDestIncr[channel]) *
707 (MCD_remVariants.remDestIncr[channel]
708 + MCD_remVariants.remXferSize[channel]);
709 progRep->dmaSize =
710 destDiffBytes - bytesNotXfered + addModVal - subModVal;
711 break;
712 case ZERO:
713 progRep->lastDestAddr = progRep->currBufDesc->destAddr;
714 break;
715 case PLUS1:
716
717
718 subModVal =
719 ((int)progRep->currBufDesc->
720 destAddr) & ((MCD_remVariants.remXferSize[channel]) - 1);
721
722 addModVal =
723 ((int)progRep->
724 lastDestAddr) & ((MCD_remVariants.remXferSize[channel]) -
725 1);
726 LWAlignedInitDestAddr =
727 (progRep->currBufDesc->destAddr) - subModVal;
728 LWAlignedCurrDestAddr = (progRep->lastDestAddr) - addModVal;
729 destDiffBytes = (progRep->lastDestAddr - LWAlignedInitDestAddr);
730 numIterations =
731 (LWAlignedCurrDestAddr -
732 LWAlignedInitDestAddr) /
733 MCD_remVariants.remDestIncr[channel];
734 bytesNotXfered =
735 numIterations * (MCD_remVariants.remDestIncr[channel]
736 - MCD_remVariants.remXferSize[channel]);
737 progRep->dmaSize = destDiffBytes - bytesNotXfered - subModVal;
738 break;
739 default:
740 break;
741 }
742
743
744 switch (MCD_remVariants.remSrcRsdIncr[channel]) {
745 case MINUS1:
746 progRep->lastSrcAddr =
747 progRep->currBufDesc->srcAddr +
748 (MCD_remVariants.remSrcIncr[channel] *
749 (progRep->dmaSize / MCD_remVariants.remXferSize[channel]));
750 break;
751 case ZERO:
752 progRep->lastSrcAddr = progRep->currBufDesc->srcAddr;
753 break;
754 case PLUS1:
755 progRep->lastSrcAddr =
756 progRep->currBufDesc->srcAddr +
757 (MCD_remVariants.remSrcIncr[channel] *
758 (progRep->dmaSize / MCD_remVariants.remXferSize[channel]));
759 break;
760 default:
761 break;
762 }
763
764 return (MCD_OK);
765}
766
767
768
769
770
771
772
773
774
775
776static void MCD_resmActions(int channel)
777{
778 MCD_dmaBar->debugControl = DBG_CTL_DISABLE;
779 MCD_dmaBar->debugStatus = MCD_dmaBar->debugStatus;
780
781
782 MCD_dmaBar->ptdDebug = PTD_DBG_TSK_VLD_INIT;
783
784 if ((MCD_dmaBar->ptdDebug >> channel) & 0x1)
785 MCD_chStatus[channel] = MCD_RUNNING;
786 else
787 MCD_chStatus[channel] = MCD_IDLE;
788}
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804int MCD_killDma(int channel)
805{
806
807
808 if ((channel < 0) || (channel >= NCHANNELS))
809 return (MCD_CHANNEL_INVALID);
810
811 MCD_dmaBar->taskControl[channel] = 0x0;
812 MCD_resumeDma(channel);
813
814
815
816
817
818
819 MCD_chStatus[channel] = MCD_HALTED;
820
821
822
823
824
825
826
827 return (MCD_OK);
828}
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843int MCD_continDma(int channel)
844{
845 if ((channel < 0) || (channel >= NCHANNELS))
846 return (MCD_CHANNEL_INVALID);
847
848 MCD_dmaBar->taskControl[channel] |= TASK_CTL_EN;
849 MCD_chStatus[channel] = MCD_RUNNING;
850
851 return (MCD_OK);
852}
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895int MCD_pauseDma(int channel)
896{
897
898
899 if ((channel < 0) || (channel >= NCHANNELS))
900 return (MCD_CHANNEL_INVALID);
901
902 if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN) {
903 MCD_dmaBar->debugComp1 = channel;
904 MCD_dmaBar->debugControl =
905 DBG_CTL_ENABLE | (1 << (channel + 16));
906 MCD_chStatus[channel] = MCD_PAUSED;
907
908
909
910
911
912
913
914 }
915 return (MCD_OK);
916}
917
918
919
920
921
922
923
924
925
926
927int MCD_resumeDma(int channel)
928{
929 if ((channel < 0) || (channel >= NCHANNELS))
930 return (MCD_CHANNEL_INVALID);
931
932 if (MCD_dmaBar->taskControl[channel] & TASK_CTL_EN)
933 MCD_resmActions(channel);
934
935 return (MCD_OK);
936}
937
938
939
940
941
942
943
944
945
946
947
948
949
950int MCD_csumQuery(int channel, u32 * csum)
951{
952#ifdef MCD_INCLUDE_EU
953 if ((channel < 0) || (channel >= NCHANNELS))
954 return (MCD_CHANNEL_INVALID);
955
956 *csum = MCD_relocBuffDesc[channel].csumResult;
957 return (MCD_OK);
958#else
959 return (MCD_ERROR);
960#endif
961}
962
963
964
965
966
967
968
969
970int MCD_getCodeSize(void)
971{
972#ifdef MCD_INCLUDE_EU
973 return (0x2b5c);
974#else
975 return (0x173c);
976#endif
977}
978
979
980
981
982
983
984
985
986
987
988char MCD_versionString[] = "Multi-channel DMA API Alpha v0.3 (2004-04-26)";
989#define MCD_REV_MAJOR 0x00
990#define MCD_REV_MINOR 0x03
991
992int MCD_getVersion(char **longVersion)
993{
994 *longVersion = MCD_versionString;
995 return ((MCD_REV_MAJOR << 8) | MCD_REV_MINOR);
996}
997
998
999
1000
1001
1002
1003
1004static void MCD_memcpy(int *dest, int *src, u32 size)
1005{
1006 u32 i;
1007
1008 for (i = 0; i < size; i += sizeof(int), dest++, src++)
1009 *dest = *src;
1010}
1011