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